Blame - coders/tiff.c - platform/external/ImageMagick

blob: 3f773833c5ac635440b8744cc2309600241ff01f [file] [log] [blame]

cristy	3ed852e	2009-09-05 21:47:34 +0000	[diff] [blame]	1	/*
				2	%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
				3	% %
				4	% %
				5	% %
				6	% TTTTT IIIII FFFFF FFFFF %
				7	% T I F F %
				8	% T I FFF FFF %
				9	% T I F F %
				10	% T IIIII F F %
				11	% %
				12	% %
				13	% Read/Write TIFF Image Format %
				14	% %
				15	% Software Design %
				16	% John Cristy %
				17	% July 1992 %
				18	% %
				19	% %
				20	% Copyright 1999-2009 ImageMagick Studio LLC, a non-profit organization %
				21	% dedicated to making software imaging solutions freely available. %
				22	% %
				23	% You may not use this file except in compliance with the License. You may %
				24	% obtain a copy of the License at %
				25	% %
				26	% http://www.imagemagick.org/script/license.php %
				27	% %
				28	% Unless required by applicable law or agreed to in writing, software %
				29	% distributed under the License is distributed on an "AS IS" BASIS, %
				30	% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. %
				31	% See the License for the specific language governing permissions and %
				32	% limitations under the License. %
				33	% %
				34	%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
				35	%
				36	%
				37	*/
				38
				39	/*
				40	Include declarations.
				41	*/
				42	#include "magick/studio.h"
cristy	5a2ca48	2009-10-14 18:24:56 +0000	[diff] [blame]	43	#include "magick/attribute.h"
cristy	3ed852e	2009-09-05 21:47:34 +0000	[diff] [blame]	44	#include "magick/blob.h"
				45	#include "magick/blob-private.h"
				46	#include "magick/cache.h"
				47	#include "magick/color.h"
				48	#include "magick/color-private.h"
				49	#include "magick/colorspace.h"
				50	#include "magick/constitute.h"
				51	#include "magick/enhance.h"
				52	#include "magick/exception.h"
				53	#include "magick/exception-private.h"
				54	#include "magick/geometry.h"
				55	#include "magick/image.h"
				56	#include "magick/image-private.h"
				57	#include "magick/list.h"
				58	#include "magick/log.h"
				59	#include "magick/magick.h"
				60	#include "magick/memory_.h"
				61	#include "magick/module.h"
				62	#include "magick/monitor.h"
				63	#include "magick/monitor-private.h"
				64	#include "magick/option.h"
				65	#include "magick/property.h"
				66	#include "magick/quantum.h"
				67	#include "magick/quantum-private.h"
				68	#include "magick/profile.h"
				69	#include "magick/resize.h"
cristy	3d7f806	2009-09-24 20:45:35 +0000	[diff] [blame]	70	#include "magick/resource_.h"
cristy	3ed852e	2009-09-05 21:47:34 +0000	[diff] [blame]	71	#include "magick/semaphore.h"
				72	#include "magick/splay-tree.h"
				73	#include "magick/static.h"
				74	#include "magick/statistic.h"
				75	#include "magick/string_.h"
				76	#include "magick/thread_.h"
				77	#include "magick/utility.h"
				78	#include "magick/module.h"
				79	#if defined(MAGICKCORE_TIFF_DELEGATE)
				80	# if defined(MAGICKCORE_HAVE_TIFFCONF_H)
				81	# include "tiffconf.h"
				82	#endif
				83	# include "tiff.h"
				84	# include "tiffio.h"
				85	# if !defined(COMPRESSION_ADOBE_DEFLATE)
				86	# define COMPRESSION_ADOBE_DEFLATE 8
				87	# endif
				88
				89	/*
				90	Typedef declarations.
				91	*/
				92	#if defined(MAGICKCORE_HAVE_TIFFREADEXIFDIRECTORY)
				93	typedef struct _ExifInfo
				94	{
				95	unsigned int
				96	tag,
				97	type;
				98
				99	const char
				100	*property;
				101	} ExifInfo;
				102
				103	static const ExifInfo
				104	exif_info[] = {
				105	{ EXIFTAG_EXPOSURETIME, TIFF_RATIONAL, "exif:ExposureTime" },
				106	{ EXIFTAG_FNUMBER, TIFF_RATIONAL, "exif:FNumber" },
				107	{ EXIFTAG_EXPOSUREPROGRAM, TIFF_SHORT, "exif:ExposureProgram" },
				108	{ EXIFTAG_SPECTRALSENSITIVITY, TIFF_ASCII, "exif:SpectralSensitivity" },
cristy	0accf6e	2009-10-01 13:14:28 +0000	[diff] [blame]	109	{ EXIFTAG_ISOSPEEDRATINGS, TIFF_SHORT, "exif:ISOSpeedRatings" },
cristy	3ed852e	2009-09-05 21:47:34 +0000	[diff] [blame]	110	{ EXIFTAG_OECF, TIFF_UNDEFINED, "exif:OptoelectricConversionFactor" },
				111	{ EXIFTAG_EXIFVERSION, TIFF_UNDEFINED, "exif:ExifVersion" },
				112	{ EXIFTAG_DATETIMEORIGINAL, TIFF_ASCII, "exif:DateTimeOriginal" },
				113	{ EXIFTAG_DATETIMEDIGITIZED, TIFF_ASCII, "exif:DateTimeDigitized" },
				114	{ EXIFTAG_COMPONENTSCONFIGURATION, TIFF_UNDEFINED, "exif:ComponentsConfiguration" },
				115	{ EXIFTAG_COMPRESSEDBITSPERPIXEL, TIFF_RATIONAL, "exif:CompressedBitsPerPixel" },
				116	{ EXIFTAG_SHUTTERSPEEDVALUE, TIFF_SRATIONAL, "exif:ShutterSpeedValue" },
				117	{ EXIFTAG_APERTUREVALUE, TIFF_RATIONAL, "exif:ApertureValue" },
				118	{ EXIFTAG_BRIGHTNESSVALUE, TIFF_SRATIONAL, "exif:BrightnessValue" },
				119	{ EXIFTAG_EXPOSUREBIASVALUE, TIFF_SRATIONAL, "exif:ExposureBiasValue" },
				120	{ EXIFTAG_MAXAPERTUREVALUE, TIFF_RATIONAL, "exif:MaxApertureValue" },
				121	{ EXIFTAG_SUBJECTDISTANCE, TIFF_RATIONAL, "exif:SubjectDistance" },
				122	{ EXIFTAG_METERINGMODE, TIFF_SHORT, "exif:MeteringMode" },
				123	{ EXIFTAG_LIGHTSOURCE, TIFF_SHORT, "exif:LightSource" },
				124	{ EXIFTAG_FLASH, TIFF_SHORT, "exif:Flash" },
				125	{ EXIFTAG_FOCALLENGTH, TIFF_RATIONAL, "exif:FocalLength" },
				126	/* { EXIFTAG_SUBJECTAREA, TIFF_SHORT, "exif:SubjectArea" }, */
				127	{ EXIFTAG_MAKERNOTE, TIFF_UNDEFINED, "exif:MakerNote" },
				128	{ EXIFTAG_USERCOMMENT, TIFF_UNDEFINED, "exif:UserComment" },
				129	{ EXIFTAG_SUBSECTIME, TIFF_ASCII, "exif:SubSecTime" },
				130	{ EXIFTAG_SUBSECTIMEORIGINAL, TIFF_ASCII, "exif:SubSecTimeOriginal" },
				131	{ EXIFTAG_SUBSECTIMEDIGITIZED, TIFF_ASCII, "exif:SubSecTimeDigitized" },
				132	{ EXIFTAG_FLASHPIXVERSION, TIFF_UNDEFINED, "exif:FlashpixVersion" },
				133	{ EXIFTAG_PIXELXDIMENSION, TIFF_LONG, "exif:PixelXDimension" },
				134	{ EXIFTAG_PIXELXDIMENSION, TIFF_SHORT, "exif:PixelXDimension" },
				135	{ EXIFTAG_PIXELYDIMENSION, TIFF_LONG, "exif:PixelYDimension" },
				136	{ EXIFTAG_PIXELYDIMENSION, TIFF_SHORT, "exif:PixelYDimension" },
				137	{ EXIFTAG_RELATEDSOUNDFILE, TIFF_ASCII, "exif:RelatedSoundFile" },
				138	{ EXIFTAG_FLASHENERGY, TIFF_RATIONAL, "exif:FlashEnergy" },
				139	{ EXIFTAG_SPATIALFREQUENCYRESPONSE, TIFF_UNDEFINED, "exif:SpatialFrequencyResponse" },
				140	{ EXIFTAG_FOCALPLANEXRESOLUTION, TIFF_RATIONAL, "exif:FocalPlaneXResolution" },
				141	{ EXIFTAG_FOCALPLANEYRESOLUTION, TIFF_RATIONAL, "exif:FocalPlaneYResolution" },
				142	{ EXIFTAG_FOCALPLANERESOLUTIONUNIT, TIFF_SHORT, "exif:FocalPlaneResolutionUnit" },
				143	{ EXIFTAG_SUBJECTLOCATION, TIFF_SHORT, "exif:SubjectLocation" },
				144	{ EXIFTAG_EXPOSUREINDEX, TIFF_RATIONAL, "exif:ExposureIndex" },
				145	{ EXIFTAG_SENSINGMETHOD, TIFF_SHORT, "exif:SensingMethod" },
				146	{ EXIFTAG_FILESOURCE, TIFF_UNDEFINED, "exif:FileSource" },
				147	{ EXIFTAG_SCENETYPE, TIFF_UNDEFINED, "exif:SceneType" },
				148	{ EXIFTAG_CFAPATTERN, TIFF_UNDEFINED, "exif:CFAPattern" },
				149	{ EXIFTAG_CUSTOMRENDERED, TIFF_SHORT, "exif:CustomRendered" },
				150	{ EXIFTAG_EXPOSUREMODE, TIFF_SHORT, "exif:ExposureMode" },
				151	{ EXIFTAG_WHITEBALANCE, TIFF_SHORT, "exif:WhiteBalance" },
				152	{ EXIFTAG_DIGITALZOOMRATIO, TIFF_RATIONAL, "exif:DigitalZoomRatio" },
				153	{ EXIFTAG_FOCALLENGTHIN35MMFILM, TIFF_SHORT, "exif:FocalLengthIn35mmFilm" },
				154	{ EXIFTAG_SCENECAPTURETYPE, TIFF_SHORT, "exif:SceneCaptureType" },
				155	{ EXIFTAG_GAINCONTROL, TIFF_RATIONAL, "exif:GainControl" },
				156	{ EXIFTAG_CONTRAST, TIFF_SHORT, "exif:Contrast" },
				157	{ EXIFTAG_SATURATION, TIFF_SHORT, "exif:Saturation" },
				158	{ EXIFTAG_SHARPNESS, TIFF_SHORT, "exif:Sharpness" },
				159	{ EXIFTAG_DEVICESETTINGDESCRIPTION, TIFF_UNDEFINED, "exif:DeviceSettingDescription" },
				160	{ EXIFTAG_SUBJECTDISTANCERANGE, TIFF_SHORT, "exif:SubjectDistanceRange" },
				161	{ EXIFTAG_IMAGEUNIQUEID, TIFF_ASCII, "exif:ImageUniqueID" },
				162	{ 0, 0, (char *) NULL }
				163	};
				164	#endif
				165
				166	/*
				167	Global declarations.
				168	*/
				169	static MagickThreadKey
				170	tiff_exception;
				171
				172	static SemaphoreInfo
				173	tiff_semaphore = (SemaphoreInfo ) NULL;
				174
				175	static volatile MagickBooleanType
				176	instantiate_key = MagickFalse;
				177	#endif
				178
				179	/*
				180	Forward declarations.
				181	*/
				182	#if defined(MAGICKCORE_TIFF_DELEGATE)
cristy	3d7f806	2009-09-24 20:45:35 +0000	[diff] [blame]	183	static Image *
				184	ReadTIFFImage(const ImageInfo ,ExceptionInfo );
				185
cristy	3ed852e	2009-09-05 21:47:34 +0000	[diff] [blame]	186	static MagickBooleanType
cristy	3d7f806	2009-09-24 20:45:35 +0000	[diff] [blame]	187	WriteGROUP4Image(const ImageInfo ,Image ),
cristy	3ed852e	2009-09-05 21:47:34 +0000	[diff] [blame]	188	WritePTIFImage(const ImageInfo ,Image ),
				189	WriteTIFFImage(const ImageInfo ,Image );
				190	#endif
				191
				192	/*
				193	%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
				194	% %
				195	% %
				196	% %
				197	% I s T I F F %
				198	% %
				199	% %
				200	% %
				201	%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
				202	%
				203	% IsTIFF() returns MagickTrue if the image format type, identified by the
				204	% magick string, is TIFF.
				205	%
				206	% The format of the IsTIFF method is:
				207	%
				208	% MagickBooleanType IsTIFF(const unsigned char *magick,const size_t length)
				209	%
				210	% A description of each parameter follows:
				211	%
				212	% o magick: compare image format pattern against these bytes.
				213	%
				214	% o length: Specifies the length of the magick string.
				215	%
				216	*/
				217	static MagickBooleanType IsTIFF(const unsigned char *magick,const size_t length)
				218	{
				219	if (length < 4)
				220	return(MagickFalse);
				221	if (memcmp(magick,"\115\115\000\052",4) == 0)
				222	return(MagickTrue);
				223	if (memcmp(magick,"\111\111\052\000",4) == 0)
				224	return(MagickTrue);
				225	#if defined(TIFF_VERSION_BIG)
				226	if (length < 8)
				227	return(MagickFalse);
				228	if (memcmp(magick,"\115\115\000\053\000\010\000\000",8) == 0)
				229	return(MagickTrue);
				230	if (memcmp(magick,"\111\111\053\000\010\000\000\000",8) == 0)
				231	return(MagickTrue);
				232	#endif
				233	return(MagickFalse);
				234	}
				235
				236	#if defined(MAGICKCORE_TIFF_DELEGATE)
				237	/*
				238	%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
				239	% %
				240	% %
				241	% %
cristy	3d7f806	2009-09-24 20:45:35 +0000	[diff] [blame]	242	% R e a d G R O U P 4 I m a g e %
				243	% %
				244	% %
				245	% %
				246	%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
				247	%
				248	% ReadGROUP4Image() reads a raw CCITT Group 4 image file and returns it. It
				249	% allocates the memory necessary for the new Image structure and returns a
				250	% pointer to the new image.
				251	%
				252	% The format of the ReadGROUP4Image method is:
				253	%
				254	% Image ReadGROUP4Image(const ImageInfo image_info,
				255	% ExceptionInfo *exception)
				256	%
				257	% A description of each parameter follows:
				258	%
				259	% o image_info: the image info.
				260	%
				261	% o exception: return any errors or warnings in this structure.
				262	%
				263	*/
				264
				265	static inline size_t WriteLSBLong(FILE *file,const unsigned int value)
				266	{
				267	unsigned char
				268	buffer[4];
				269
				270	buffer[0]=(unsigned char) value;
				271	buffer[1]=(unsigned char) (value >> 8);
				272	buffer[2]=(unsigned char) (value >> 16);
				273	buffer[3]=(unsigned char) (value >> 24);
				274	return(fwrite(buffer,1,4,file));
				275	}
				276
				277	static Image ReadGROUP4Image(const ImageInfo image_info,
				278	ExceptionInfo *exception)
				279	{
				280	char
				281	filename[MaxTextExtent];
				282
				283	FILE
				284	*file;
				285
				286	Image
				287	*image;
				288
				289	ImageInfo
				290	*read_info;
				291
				292	int
				293	c,
				294	unique_file;
				295
				296	MagickBooleanType
				297	status;
				298
				299	size_t
				300	length;
				301
				302	ssize_t
				303	offset,
				304	strip_offset;
				305
				306	/*
				307	Open image file.
				308	*/
				309	assert(image_info != (const ImageInfo *) NULL);
				310	assert(image_info->signature == MagickSignature);
				311	if (image_info->debug != MagickFalse)
				312	(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
				313	image_info->filename);
				314	assert(exception != (ExceptionInfo *) NULL);
				315	assert(exception->signature == MagickSignature);
				316	image=AcquireImage(image_info);
				317	status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
				318	if (status == MagickFalse)
				319	{
				320	image=DestroyImageList(image);
				321	return((Image *) NULL);
				322	}
				323	/*
				324	Write raw CCITT Group 4 wrapped as a TIFF image file.
				325	*/
				326	file=(FILE *) NULL;
				327	unique_file=AcquireUniqueFileResource(filename);
				328	if (unique_file != -1)
				329	file=fdopen(unique_file,"wb");
				330	if ((unique_file == -1) \|\| (file == (FILE *) NULL))
				331	ThrowImageException(FileOpenError,"UnableToCreateTemporaryFile");
				332	length=fwrite("\111\111\052\000\010\000\000\000\016\000",1,10,file);
				333	length=fwrite("\376\000\003\000\001\000\000\000\000\000\000\000",1,12,file);
				334	length=fwrite("\000\001\004\000\001\000\000\000",1,8,file);
				335	length=WriteLSBLong(file,image->columns);
				336	length=fwrite("\001\001\004\000\001\000\000\000",1,8,file);
				337	length=WriteLSBLong(file,image->rows);
				338	length=fwrite("\002\001\003\000\001\000\000\000\001\000\000\000",1,12,file);
				339	length=fwrite("\003\001\003\000\001\000\000\000\004\000\000\000",1,12,file);
				340	length=fwrite("\006\001\003\000\001\000\000\000\000\000\000\000",1,12,file);
				341	length=fwrite("\021\001\003\000\001\000\000\000",1,8,file);
				342	strip_offset=10+(12*14)+4+8;
				343	length=WriteLSBLong(file,(unsigned long) strip_offset);
				344	length=fwrite("\022\001\003\000\001\000\000\000",1,8,file);
cristy	2d6ccc3	2009-09-25 03:18:25 +0000	[diff] [blame]	345	length=WriteLSBLong(file,(unsigned long) image_info->orientation);
cristy	3d7f806	2009-09-24 20:45:35 +0000	[diff] [blame]	346	length=fwrite("\025\001\003\000\001\000\000\000\001\000\000\000",1,12,file);
				347	length=fwrite("\026\001\004\000\001\000\000\000",1,8,file);
cristy	94c8fe4	2009-10-06 01:57:36 +0000	[diff] [blame]	348	length=WriteLSBLong(file,image->rows);
cristy	3d7f806	2009-09-24 20:45:35 +0000	[diff] [blame]	349	length=fwrite("\027\001\004\000\001\000\000\000\000\000\000\000",1,12,file);
				350	offset=(ssize_t) ftell(file)-4;
				351	length=fwrite("\032\001\005\000\001\000\000\000",1,8,file);
				352	length=WriteLSBLong(file,(unsigned long) (strip_offset-8));
				353	length=fwrite("\033\001\005\000\001\000\000\000",1,8,file);
				354	length=WriteLSBLong(file,(unsigned long) (strip_offset-8));
				355	length=fwrite("\050\001\003\000\001\000\000\000\002\000\000\000",1,12,file);
				356	length=fwrite("\000\000\000\000",1,4,file);
				357	length=WriteLSBLong(file,image->x_resolution);
				358	length=WriteLSBLong(file,1);
				359	for (length=0; (c=ReadBlobByte(image)) != EOF; length++)
				360	(void) fputc(c,file);
				361	offset=(ssize_t) fseek(file,(long) offset,SEEK_SET);
				362	length=WriteLSBLong(file,(unsigned int) length);
				363	(void) fclose(file);
				364	(void) CloseBlob(image);
				365	image=DestroyImage(image);
				366	/*
				367	Read TIFF image.
				368	*/
cristy	14efd99	2009-09-26 23:46:03 +0000	[diff] [blame]	369	read_info=CloneImageInfo((ImageInfo *) NULL);
cristy	3d7f806	2009-09-24 20:45:35 +0000	[diff] [blame]	370	(void) FormatMagickString(read_info->filename,MaxTextExtent,"%.1024s",
				371	filename);
				372	image=ReadTIFFImage(read_info,exception);
				373	read_info=DestroyImageInfo(read_info);
				374	if (image != (Image *) NULL)
				375	{
				376	(void) CopyMagickString(image->filename,image_info->filename,
				377	MaxTextExtent);
				378	(void) CopyMagickString(image->magick_filename,image_info->filename,
				379	MaxTextExtent);
				380	(void) CopyMagickString(image->magick,"GROUP4",MaxTextExtent);
				381	}
				382	(void) RelinquishUniqueFileResource(filename);
				383	return(image);
				384	}
				385	#endif
				386
				387	#if defined(MAGICKCORE_TIFF_DELEGATE)
				388	/*
				389	%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
				390	% %
				391	% %
				392	% %
cristy	3ed852e	2009-09-05 21:47:34 +0000	[diff] [blame]	393	% R e a d T I F F I m a g e %
				394	% %
				395	% %
				396	% %
				397	%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
				398	%
				399	% ReadTIFFImage() reads a Tagged image file and returns it. It allocates the
				400	% memory necessary for the new Image structure and returns a pointer to the
				401	% new image.
				402	%
				403	% The format of the ReadTIFFImage method is:
				404	%
				405	% Image ReadTIFFImage(const ImageInfo image_info,
				406	% ExceptionInfo *exception)
				407	%
				408	% A description of each parameter follows:
				409	%
				410	% o image_info: the image info.
				411	%
				412	% o exception: return any errors or warnings in this structure.
				413	%
				414	*/
				415
				416	static inline size_t MagickMax(const size_t x,const size_t y)
				417	{
				418	if (x > y)
				419	return(x);
				420	return(y);
				421	}
				422
				423	static inline long MagickMin(const long x,const long y)
				424	{
				425	if (x < y)
				426	return(x);
				427	return(y);
				428	}
				429
				430	static MagickBooleanType ReadProfile(Image image,const char name,
				431	unsigned char *datum,long length)
				432	{
				433	MagickBooleanType
				434	status;
				435
				436	register long
				437	i;
				438
				439	StringInfo
				440	*profile;
				441
				442	if (length < 4)
				443	return(MagickFalse);
				444	i=0;
				445	if ((LocaleCompare(name,"icc") != 0) && (LocaleCompare(name,"xmp") != 0))
				446	{
				447	for (i=0; i < (length-4); i+=2)
				448	if (LocaleNCompare((char *) (datum+i),"8BIM",4) == 0)
				449	break;
				450	if (i == length)
				451	length-=i;
				452	else
				453	i=0;
				454	if (length < 4)
				455	return(MagickFalse);
				456	}
				457	profile=AcquireStringInfo((size_t) length);
				458	SetStringInfoDatum(profile,datum+i);
				459	status=SetImageProfile(image,name,profile);
				460	profile=DestroyStringInfo(profile);
				461	if (status == MagickFalse)
				462	ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
				463	image->filename);
				464	return(MagickTrue);
				465	}
				466
				467	#if defined(__cplusplus) \|\| defined(c_plusplus)
				468	extern "C" {
				469	#endif
				470
				471	static int TIFFCloseBlob(thandle_t image)
				472	{
				473	(void) CloseBlob((Image *) image);
				474	return(0);
				475	}
				476
				477	static void TIFFErrors(const char module,const char format,va_list error)
				478	{
				479	char
				480	message[MaxTextExtent];
				481
				482	ExceptionInfo
				483	*exception;
				484
				485	#if defined(MAGICKCORE_HAVE_VSNPRINTF)
				486	(void) vsnprintf(message,MaxTextExtent,format,error);
				487	#else
				488	(void) vsprintf(message,format,error);
				489	#endif
				490	(void) ConcatenateMagickString(message,".",MaxTextExtent);
				491	exception=(ExceptionInfo *) MagickGetThreadValue(tiff_exception);
				492	if (exception != (ExceptionInfo *) NULL)
				493	(void) ThrowMagickException(exception,GetMagickModule(),CoderWarning,
				494	message,"`%s'",module);
				495	}
				496
				497	static void TIFFGetProfiles(TIFF tiff,Image image)
				498	{
				499	uint32
				500	length;
				501
				502	unsigned char
				503	*profile;
				504
				505	#if defined(TIFFTAG_ICCPROFILE)
				506	length=0;
				507	if (TIFFGetField(tiff,TIFFTAG_ICCPROFILE,&length,&profile) == 1)
				508	(void) ReadProfile(image,"icc",profile,(long) length);
				509	#endif
				510	#if defined(TIFFTAG_PHOTOSHOP)
				511	length=0;
				512	if (TIFFGetField(tiff,TIFFTAG_PHOTOSHOP,&length,&profile) == 1)
				513	(void) ReadProfile(image,"8bim",profile,(long) length);
				514	#endif
				515	#if defined(TIFFTAG_RICHTIFFIPTC)
				516	length=0;
				517	if (TIFFGetField(tiff,TIFFTAG_RICHTIFFIPTC,&length,&profile) == 1)
				518	{
				519	if (TIFFIsByteSwapped(tiff) != 0)
				520	TIFFSwabArrayOfLong((uint32 *) profile,(unsigned long) length);
				521	(void) ReadProfile(image,"iptc",profile,4L*length);
				522	}
				523	#endif
				524	#if defined(TIFFTAG_XMLPACKET)
				525	length=0;
				526	if (TIFFGetField(tiff,TIFFTAG_XMLPACKET,&length,&profile) == 1)
				527	(void) ReadProfile(image,"xmp",profile,(long) length);
				528	#endif
				529	length=0;
				530	if (TIFFGetField(tiff,37724,&length,&profile) == 1)
				531	(void) ReadProfile(image,"tiff:37724",profile,(long) length);
				532	}
				533
				534	static void TIFFGetProperties(TIFF tiff,Image image)
				535	{
				536	char
				537	*text;
				538
				539	if (TIFFGetField(tiff,TIFFTAG_ARTIST,&text) == 1)
				540	(void) SetImageProperty(image,"tiff:artist",text);
				541	if (TIFFGetField(tiff,TIFFTAG_DATETIME,&text) == 1)
				542	(void) SetImageProperty(image,"tiff:timestamp",text);
				543	if (TIFFGetField(tiff,TIFFTAG_SOFTWARE,&text) == 1)
				544	(void) SetImageProperty(image,"tiff:software",text);
				545	if (TIFFGetField(tiff,TIFFTAG_HOSTCOMPUTER,&text) == 1)
				546	(void) SetImageProperty(image,"tiff:hostcomputer",text);
				547	if (TIFFGetField(tiff,TIFFTAG_DOCUMENTNAME,&text) == 1)
				548	(void) SetImageProperty(image,"tiff:document",text);
				549	if (TIFFGetField(tiff,TIFFTAG_MAKE,&text) == 1)
				550	(void) SetImageProperty(image,"tiff:make",text);
				551	if (TIFFGetField(tiff,TIFFTAG_MODEL,&text) == 1)
				552	(void) SetImageProperty(image,"tiff:model",text);
				553	if (TIFFGetField(tiff,33432,&text) == 1)
				554	(void) SetImageProperty(image,"tiff:copyright",text);
				555	if (TIFFGetField(tiff,TIFFTAG_PAGENAME,&text) == 1)
				556	(void) SetImageProperty(image,"label",text);
				557	if (TIFFGetField(tiff,TIFFTAG_IMAGEDESCRIPTION,&text) == 1)
				558	(void) SetImageProperty(image,"comment",text);
				559	}
				560
				561	static void TIFFGetEXIFProperties(TIFF tiff,Image image)
				562	{
				563	#if defined(MAGICKCORE_HAVE_TIFFREADEXIFDIRECTORY)
				564	char
				565	value[MaxTextExtent];
				566
				567	register long
				568	i;
				569
				570	tdir_t
				571	directory;
				572
				573	uint32
				574	offset;
				575
				576	/*
				577	Read EXIF properties.
				578	*/
				579	if (TIFFGetField(tiff,TIFFTAG_EXIFIFD,&offset) == 0)
				580	return;
				581	directory=TIFFCurrentDirectory(tiff);
				582	if (TIFFReadEXIFDirectory(tiff,offset) == 0)
				583	return;
				584	for (i=0; exif_info[i].tag != 0; i++)
				585	{
				586	*value='\0';
				587	switch (exif_info[i].type)
				588	{
				589	case TIFF_ASCII:
				590	{
				591	char
				592	*ascii;
				593
				594	if (TIFFGetField(tiff,exif_info[i].tag,&ascii) != 0)
				595	(void) CopyMagickMemory(value,ascii,MaxTextExtent);
				596	break;
				597	}
				598	case TIFF_SHORT:
				599	{
				600	uint16
				601	shorty;
				602
				603	if (TIFFGetField(tiff,exif_info[i].tag,&shorty) != 0)
				604	(void) FormatMagickString(value,MaxTextExtent,"%d",shorty);
				605	break;
				606	}
				607	case TIFF_LONG:
				608	{
				609	uint32
				610	longy;
				611
				612	if (TIFFGetField(tiff,exif_info[i].tag,&longy) != 0)
				613	(void) FormatMagickString(value,MaxTextExtent,"%d",longy);
				614	break;
				615	}
				616	case TIFF_RATIONAL:
				617	case TIFF_SRATIONAL:
				618	{
				619	float
				620	rational;
				621
				622	if (TIFFGetField(tiff,exif_info[i].tag,&rational) != 0)
				623	(void) FormatMagickString(value,MaxTextExtent,"%g",rational);
				624	break;
				625	}
				626	default:
				627	break;
				628	}
				629	if (*value != '\0')
				630	(void) SetImageProperty(image,exif_info[i].property,value);
				631	}
				632	TIFFSetDirectory(tiff,directory);
				633	#else
				634	(void) tiff;
				635	(void) image;
				636	#endif
				637	}
				638
				639	static int TIFFMapBlob(thandle_t image,tdata_t base,toff_t size)
				640	{
				641	base=(tdata_t ) GetBlobStreamData((Image *) image);
				642	if (base != (tdata_t ) NULL)
				643	size=(toff_t) GetBlobSize((Image ) image);
				644	if (base != (tdata_t ) NULL)
				645	return(1);
				646	return(0);
				647	}
				648
				649	static tsize_t TIFFReadBlob(thandle_t image,tdata_t data,tsize_t size)
				650	{
				651	tsize_t
				652	count;
				653
				654	count=(tsize_t) ReadBlob((Image *) image,(size_t) size,
				655	(unsigned char *) data);
				656	return(count);
				657	}
				658
				659	static int32 TIFFReadPixels(TIFF *tiff,unsigned long bits_per_sample,
				660	tsample_t sample,long row,tdata_t scanline)
				661	{
				662	int32
				663	status;
				664
				665	(void) bits_per_sample;
				666	status=TIFFReadScanline(tiff,scanline,(uint32) row,sample);
				667	return(status);
				668	}
				669
				670	static toff_t TIFFSeekBlob(thandle_t image,toff_t offset,int whence)
				671	{
				672	return((toff_t) SeekBlob((Image *) image,(MagickOffsetType) offset,whence));
				673	}
				674
				675	static toff_t TIFFGetBlobSize(thandle_t image)
				676	{
				677	return((toff_t) GetBlobSize((Image *) image));
				678	}
				679
				680	static void TIFFUnmapBlob(thandle_t image,tdata_t base,toff_t size)
				681	{
				682	(void) image;
				683	(void) base;
				684	(void) size;
				685	}
				686
				687	static void TIFFWarnings(const char module,const char format,va_list warning)
				688	{
				689	char
				690	message[MaxTextExtent];
				691
				692	ExceptionInfo
				693	*exception;
				694
				695	#if defined(MAGICKCORE_HAVE_VSNPRINTF)
				696	(void) vsnprintf(message,MaxTextExtent,format,warning);
				697	#else
				698	(void) vsprintf(message,format,warning);
				699	#endif
				700	(void) ConcatenateMagickString(message,".",MaxTextExtent);
				701	exception=(ExceptionInfo *) MagickGetThreadValue(tiff_exception);
				702	if (exception != (ExceptionInfo *) NULL)
				703	(void) ThrowMagickException(exception,GetMagickModule(),CoderWarning,
				704	message,"`%s'",module);
				705	}
				706
				707	static tsize_t TIFFWriteBlob(thandle_t image,tdata_t data,tsize_t size)
				708	{
				709	tsize_t
				710	count;
				711
				712	count=(tsize_t) WriteBlob((Image *) image,(size_t) size,
				713	(unsigned char *) data);
				714	return(count);
				715	}
				716
				717	#if defined(__cplusplus) \|\| defined(c_plusplus)
				718	}
				719	#endif
				720
				721	static Image ReadTIFFImage(const ImageInfo image_info,
				722	ExceptionInfo *exception)
				723	{
				724	typedef enum
				725	{
				726	ReadSingleSampleMethod,
				727	ReadRGBAMethod,
				728	ReadCMYKAMethod,
				729	ReadStripMethod,
				730	ReadTileMethod,
				731	ReadGenericMethod
				732	} TIFFMethodType;
				733
				734	const char
				735	*option;
				736
				737	float
				738	*chromaticity,
				739	x_position,
				740	y_position,
				741	x_resolution,
				742	y_resolution;
				743
				744	Image
				745	*image;
				746
				747	long
				748	y;
				749
				750	MagickBooleanType
				751	associated_alpha,
				752	debug,
				753	status;
				754
				755	MagickSizeType
				756	number_pixels;
				757
				758	QuantumInfo
				759	*quantum_info;
				760
				761	QuantumType
				762	quantum_type;
				763
				764	register long
				765	i;
				766
				767	size_t
				768	length,
				769	pad;
				770
				771	TIFF
				772	*tiff;
				773
				774	TIFFErrorHandler
				775	error_handler,
				776	warning_handler;
				777
				778	TIFFMethodType
				779	method;
				780
				781	uint16
				782	compress_tag,
				783	bits_per_sample,
				784	endian,
				785	extra_samples,
				786	interlace,
				787	max_sample_value,
				788	min_sample_value,
				789	orientation,
				790	pages,
				791	photometric,
				792	*sample_info,
				793	sample_format,
				794	samples_per_pixel,
				795	units,
				796	value;
				797
				798	uint32
				799	height,
				800	rows_per_strip,
				801	width;
				802
				803	unsigned char
				804	*pixels;
				805
				806	unsigned long
				807	lsb_first;
				808
				809	/*
				810	Open image.
				811	*/
				812	assert(image_info != (const ImageInfo *) NULL);
				813	assert(image_info->signature == MagickSignature);
				814	if (image_info->debug != MagickFalse)
				815	(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
				816	image_info->filename);
				817	assert(exception != (ExceptionInfo *) NULL);
				818	assert(exception->signature == MagickSignature);
				819	image=AcquireImage(image_info);
				820	status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
				821	if (status == MagickFalse)
				822	{
				823	image=DestroyImageList(image);
				824	return((Image *) NULL);
				825	}
				826	(void) MagickSetThreadValue(tiff_exception,exception);
				827	error_handler=TIFFSetErrorHandler(TIFFErrors);
				828	warning_handler=TIFFSetWarningHandler(TIFFWarnings);
				829	tiff=TIFFClientOpen(image->filename,"r",(thandle_t) image,TIFFReadBlob,
				830	TIFFWriteBlob,TIFFSeekBlob,TIFFCloseBlob,TIFFGetBlobSize,TIFFMapBlob,
				831	TIFFUnmapBlob);
				832	if (tiff == (TIFF *) NULL)
				833	{
				834	(void) TIFFSetWarningHandler(warning_handler);
				835	(void) TIFFSetErrorHandler(error_handler);
				836	image=DestroyImageList(image);
				837	return((Image *) NULL);
				838	}
				839	debug=IsEventLogging();
				840	if (image_info->number_scenes != 0)
				841	{
				842	/*
				843	Generate blank images for subimage specification (e.g. image.tif[4].
				844	*/
				845	for (i=0; i < (long) image_info->scene; i++)
				846	{
				847	(void) TIFFReadDirectory(tiff);
				848	AcquireNextImage(image_info,image);
				849	if (GetNextImageInList(image) == (Image *) NULL)
				850	{
				851	image=DestroyImageList(image);
				852	return((Image *) NULL);
				853	}
				854	image=SyncNextImageInList(image);
				855	}
				856	}
				857	do
				858	{
				859	if (0 && (image_info->verbose != MagickFalse))
				860	TIFFPrintDirectory(tiff,stdout,MagickFalse);
				861	(void) TIFFGetFieldDefaulted(tiff,TIFFTAG_COMPRESSION,&compress_tag);
				862	(void) TIFFGetFieldDefaulted(tiff,TIFFTAG_ORIENTATION,&orientation);
				863	(void) TIFFGetFieldDefaulted(tiff,TIFFTAG_IMAGEWIDTH,&width);
				864	(void) TIFFGetFieldDefaulted(tiff,TIFFTAG_IMAGELENGTH,&height);
				865	(void) TIFFGetFieldDefaulted(tiff,TIFFTAG_FILLORDER,&endian);
				866	(void) TIFFGetFieldDefaulted(tiff,TIFFTAG_PLANARCONFIG,&interlace);
				867	(void) TIFFGetFieldDefaulted(tiff,TIFFTAG_BITSPERSAMPLE,&bits_per_sample);
				868	(void) TIFFGetFieldDefaulted(tiff,TIFFTAG_SAMPLEFORMAT,&sample_format);
				869	(void) TIFFGetFieldDefaulted(tiff,TIFFTAG_MINSAMPLEVALUE,&min_sample_value);
				870	(void) TIFFGetFieldDefaulted(tiff,TIFFTAG_MAXSAMPLEVALUE,&max_sample_value);
				871	(void) TIFFGetFieldDefaulted(tiff,TIFFTAG_PHOTOMETRIC,&photometric);
				872	switch (photometric)
				873	{
				874	case PHOTOMETRIC_MINISBLACK:
				875	{
				876	(void) SetImageProperty(image,"tiff:photometric","min-is-black");
				877	break;
				878	}
				879	case PHOTOMETRIC_MINISWHITE:
				880	{
				881	(void) SetImageProperty(image,"tiff:photometric","min-is-white");
				882	break;
				883	}
				884	case PHOTOMETRIC_PALETTE:
				885	{
				886	(void) SetImageProperty(image,"tiff:photometric","palette");
				887	break;
				888	}
				889	case PHOTOMETRIC_RGB:
				890	{
				891	(void) SetImageProperty(image,"tiff:photometric","RGB");
				892	break;
				893	}
				894	case PHOTOMETRIC_CIELAB:
				895	{
				896	(void) SetImageProperty(image,"tiff:photometric","CIELAB");
				897	break;
				898	}
				899	case PHOTOMETRIC_SEPARATED:
				900	{
				901	(void) SetImageProperty(image,"tiff:photometric","separated");
				902	break;
				903	}
				904	default:
				905	{
				906	(void) SetImageProperty(image,"tiff:photometric","unknown");
				907	break;
				908	}
				909	}
				910	if (image->debug != MagickFalse)
				911	{
				912	(void) LogMagickEvent(CoderEvent,GetMagickModule(),"Geometry: %ux%u",
				913	(unsigned int) width,(unsigned int) height);
				914	(void) LogMagickEvent(CoderEvent,GetMagickModule(),"Interlace: %u",
				915	interlace);
				916	(void) LogMagickEvent(CoderEvent,GetMagickModule(),
				917	"Bits per sample: %u",bits_per_sample);
				918	(void) LogMagickEvent(CoderEvent,GetMagickModule(),
				919	"Min sample value: %u",min_sample_value);
				920	(void) LogMagickEvent(CoderEvent,GetMagickModule(),
				921	"Max sample value: %u",max_sample_value);
				922	(void) LogMagickEvent(CoderEvent,GetMagickModule(),"Photometric "
				923	"interpretation: %s",GetImageProperty(image,"tiff:photometric"));
				924	}
				925	image->columns=(unsigned long) width;
				926	image->rows=(unsigned long) height;
				927	image->depth=(unsigned long) bits_per_sample;
				928	if (image->debug != MagickFalse)
				929	(void) LogMagickEvent(CoderEvent,GetMagickModule(),"Image depth: %lu",
				930	image->depth);
				931	lsb_first=1;
				932	image->endian=MSBEndian;
				933	if ((int) ((char ) &lsb_first) != 0)
				934	image->endian=LSBEndian;
				935	if (photometric == PHOTOMETRIC_SEPARATED)
				936	image->colorspace=CMYKColorspace;
				937	if (photometric == PHOTOMETRIC_CIELAB)
				938	image->colorspace=LabColorspace;
				939	(void) TIFFGetFieldDefaulted(tiff,TIFFTAG_SAMPLESPERPIXEL,
				940	&samples_per_pixel);
				941	(void) TIFFGetFieldDefaulted(tiff,TIFFTAG_RESOLUTIONUNIT,&units);
				942	x_resolution=(float) image->x_resolution;
				943	y_resolution=(float) image->y_resolution;
				944	(void) TIFFGetFieldDefaulted(tiff,TIFFTAG_XRESOLUTION,&x_resolution);
				945	(void) TIFFGetFieldDefaulted(tiff,TIFFTAG_YRESOLUTION,&y_resolution);
				946	image->x_resolution=x_resolution;
				947	image->y_resolution=y_resolution;
				948	x_position=(float) image->page.x/x_resolution;
				949	y_position=(float) image->page.y/y_resolution;
				950	(void) TIFFGetFieldDefaulted(tiff,TIFFTAG_XPOSITION,&x_position);
				951	(void) TIFFGetFieldDefaulted(tiff,TIFFTAG_YPOSITION,&y_position);
				952	image->page.x=(long) (x_position*x_resolution+0.5);
				953	image->page.y=(long) (y_position*y_resolution+0.5);
				954	image->orientation=(OrientationType) orientation;
				955	chromaticity=(float *) NULL;
				956	(void) TIFFGetField(tiff,TIFFTAG_WHITEPOINT,&chromaticity);
				957	if (chromaticity != (float *) NULL)
				958	{
				959	image->chromaticity.white_point.x=chromaticity[0];
				960	image->chromaticity.white_point.y=chromaticity[1];
				961	}
				962	chromaticity=(float *) NULL;
				963	(void) TIFFGetField(tiff,TIFFTAG_PRIMARYCHROMATICITIES,&chromaticity);
				964	if (chromaticity != (float *) NULL)
				965	{
				966	image->chromaticity.red_primary.x=chromaticity[0];
				967	image->chromaticity.red_primary.y=chromaticity[1];
				968	image->chromaticity.green_primary.x=chromaticity[2];
				969	image->chromaticity.green_primary.y=chromaticity[3];
				970	image->chromaticity.blue_primary.x=chromaticity[4];
				971	image->chromaticity.blue_primary.y=chromaticity[5];
				972	}
				973	TIFFGetProperties(tiff,image);
				974	option=GetImageOption(image_info,"tiff:exif");
				975	if ((option != (const char *) NULL) &&
				976	(IsMagickTrue(option) != MagickFalse))
				977	TIFFGetEXIFProperties(tiff,image);
				978	TIFFGetProfiles(tiff,image);
				979	/*
				980	Allocate memory for the image and pixel buffer.
				981	*/
				982	#if defined(MAGICKCORE_HAVE_TIFFISCODECCONFIGURED) \|\| (TIFFLIB_VERSION > 20040919)
				983	if ((compress_tag != COMPRESSION_NONE) &&
				984	(TIFFIsCODECConfigured(compress_tag) == 0))
				985	{
				986	TIFFClose(tiff);
				987	ThrowReaderException(CoderError,"CompressNotSupported");
				988	}
				989	#endif
				990	switch (compress_tag)
				991	{
				992	case COMPRESSION_NONE: image->compression=NoCompression; break;
				993	case COMPRESSION_CCITTFAX3: image->compression=FaxCompression; break;
				994	case COMPRESSION_CCITTFAX4: image->compression=Group4Compression; break;
				995	case COMPRESSION_JPEG:
				996	{
				997	image->compression=JPEGCompression;
				998	#if defined(JPEG_SUPPORT)
				999	{
				1000	char
				1001	sampling_factor[MaxTextExtent];
				1002
				1003	uint16
				1004	horizontal,
				1005	vertical;
				1006
				1007	(void) TIFFGetFieldDefaulted(tiff,TIFFTAG_YCBCRSUBSAMPLING,
				1008	&horizontal,&vertical);
				1009	(void) FormatMagickString(sampling_factor,MaxTextExtent,"%dx%d",
				1010	horizontal,vertical);
				1011	(void) SetImageProperty(image,"jpeg:sampling-factor",
				1012	sampling_factor);
				1013	(void) LogMagickEvent(CoderEvent,GetMagickModule(),
				1014	"Sampling Factors: %s",sampling_factor);
				1015	if ((samples_per_pixel > 1) && (photometric == PHOTOMETRIC_YCBCR))
				1016	{
				1017	(void) TIFFSetField(tiff,TIFFTAG_JPEGCOLORMODE,
				1018	JPEGCOLORMODE_RGB);
				1019	photometric=PHOTOMETRIC_RGB;
				1020	}
				1021	}
				1022	#endif
				1023	break;
				1024	}
				1025	case COMPRESSION_OJPEG: image->compression=JPEGCompression; break;
				1026	case COMPRESSION_LZW: image->compression=LZWCompression; break;
				1027	case COMPRESSION_DEFLATE: image->compression=ZipCompression; break;
				1028	case COMPRESSION_ADOBE_DEFLATE: image->compression=ZipCompression; break;
				1029	default: image->compression=RLECompression; break;
				1030	}
				1031	quantum_info=AcquireQuantumInfo(image_info,image);
				1032	if (quantum_info == (QuantumInfo *) NULL)
				1033	ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
				1034	if (sample_format == SAMPLEFORMAT_UINT)
				1035	status=SetQuantumFormat(image,quantum_info,UnsignedQuantumFormat);
				1036	if (sample_format == SAMPLEFORMAT_INT)
				1037	status=SetQuantumFormat(image,quantum_info,SignedQuantumFormat);
				1038	if (sample_format == SAMPLEFORMAT_IEEEFP)
				1039	status=SetQuantumFormat(image,quantum_info,FloatingPointQuantumFormat);
				1040	if (status == MagickFalse)
				1041	ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
				1042	status=MagickTrue;
				1043	switch (photometric)
				1044	{
				1045	case PHOTOMETRIC_MINISBLACK:
				1046	{
				1047	quantum_info->min_is_white=MagickFalse;
				1048	break;
				1049	}
				1050	case PHOTOMETRIC_MINISWHITE:
				1051	{
				1052	quantum_info->min_is_white=MagickTrue;
				1053	break;
				1054	}
				1055	default:
				1056	break;
				1057	}
				1058	associated_alpha=MagickFalse;
				1059	extra_samples=0;
				1060	(void) TIFFGetFieldDefaulted(tiff,TIFFTAG_EXTRASAMPLES,&extra_samples,
				1061	&sample_info);
				1062	if (extra_samples == 0)
				1063	{
				1064	if ((samples_per_pixel == 4) && (photometric == PHOTOMETRIC_RGB))
				1065	image->matte=MagickTrue;
				1066	}
				1067	else
				1068	{
				1069	if (samples_per_pixel > 3)
				1070	{
				1071	image->matte=MagickTrue;
				1072	associated_alpha=MagickFalse;
				1073	}
				1074	if (sample_info[0] == EXTRASAMPLE_UNASSALPHA)
				1075	{
				1076	image->matte=MagickTrue;
				1077	associated_alpha=MagickFalse;
				1078	}
				1079	if (sample_info[0] == EXTRASAMPLE_ASSOCALPHA)
				1080	{
				1081	image->matte=MagickTrue;
				1082	associated_alpha=MagickTrue;
				1083	SetQuantumAlphaType(quantum_info,DisassociatedQuantumAlpha);
				1084	}
				1085	}
				1086	option=GetImageOption(image_info,"tiff:alpha");
				1087	if (option != (const char *) NULL)
				1088	associated_alpha=LocaleCompare(option,"associated") == 0 ? MagickTrue :
				1089	MagickFalse;
				1090	if (image->matte != MagickFalse)
				1091	(void) SetImageProperty(image,"tiff:alpha",
				1092	associated_alpha != MagickFalse ? "associated" : "unassociated");
				1093	if ((photometric == PHOTOMETRIC_PALETTE) &&
				1094	(pow(2.0,1.0*bits_per_sample) <= MaxColormapSize))
				1095	{
				1096	unsigned long
				1097	colors;
				1098
				1099	colors=(unsigned long) GetQuantumRange(bits_per_sample)+1;
				1100	if (AcquireImageColormap(image,colors) == MagickFalse)
				1101	{
				1102	TIFFClose(tiff);
				1103	ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
				1104	}
				1105	}
				1106	if (units == RESUNIT_INCH)
				1107	image->units=PixelsPerInchResolution;
				1108	if (units == RESUNIT_CENTIMETER)
				1109	image->units=PixelsPerCentimeterResolution;
				1110	value=(unsigned short) image->scene;
				1111	(void) TIFFGetFieldDefaulted(tiff,TIFFTAG_PAGENUMBER,&value,&pages);
				1112	image->scene=value;
				1113	if (image_info->ping != MagickFalse)
				1114	{
				1115	if (image_info->number_scenes != 0)
				1116	if (image->scene >= (image_info->scene+image_info->number_scenes-1))
				1117	break;
				1118	goto next_tiff_frame;
				1119	}
				1120	method=ReadGenericMethod;
				1121	if (TIFFGetField(tiff,TIFFTAG_ROWSPERSTRIP,&rows_per_strip) != 0)
				1122	{
				1123	char
				1124	value[MaxTextExtent];
				1125
				1126	method=ReadStripMethod;
				1127	(void) FormatMagickString(value,MaxTextExtent,"%u",
				1128	(unsigned int) rows_per_strip);
				1129	(void) SetImageProperty(image,"tiff:rows-per-strip",value);
				1130	}
				1131	if ((samples_per_pixel >= 2) && (interlace == PLANARCONFIG_CONTIG))
				1132	method=ReadRGBAMethod;
				1133	if ((samples_per_pixel >= 2) && (interlace == PLANARCONFIG_SEPARATE))
				1134	method=ReadCMYKAMethod;
				1135	if ((photometric != PHOTOMETRIC_RGB) &&
				1136	(photometric != PHOTOMETRIC_CIELAB) &&
				1137	(photometric != PHOTOMETRIC_SEPARATED))
				1138	method=ReadGenericMethod;
				1139	if (image->storage_class == PseudoClass)
				1140	method=ReadSingleSampleMethod;
				1141	if ((photometric == PHOTOMETRIC_MINISBLACK) \|\|
				1142	(photometric == PHOTOMETRIC_MINISWHITE))
				1143	method=ReadSingleSampleMethod;
				1144	if ((photometric != PHOTOMETRIC_SEPARATED) &&
				1145	(interlace == PLANARCONFIG_SEPARATE))
				1146	method=ReadGenericMethod;
				1147	if (TIFFIsTiled(tiff) != MagickFalse)
				1148	method=ReadTileMethod;
				1149	quantum_type=RGBQuantum;
				1150	pixels=GetQuantumPixels(quantum_info);
				1151	switch (method)
				1152	{
				1153	case ReadSingleSampleMethod:
				1154	{
				1155	/*
				1156	Convert TIFF image to PseudoClass MIFF image.
				1157	*/
				1158	if ((image->storage_class == PseudoClass) &&
				1159	(photometric == PHOTOMETRIC_PALETTE))
				1160	{
				1161	unsigned long
				1162	range;
				1163
				1164	uint16
				1165	*blue_colormap,
				1166	*green_colormap,
				1167	*red_colormap;
				1168
				1169	/*
				1170	Initialize colormap.
				1171	*/
				1172	(void) TIFFGetField(tiff,TIFFTAG_COLORMAP,&red_colormap,
				1173	&green_colormap,&blue_colormap);
				1174	range=255; /* might be old style 8-bit colormap */
				1175	for (i=0; i < (long) image->colors; i++)
				1176	if ((red_colormap[i] >= 256) \|\| (green_colormap[i] >= 256) \|\|
				1177	(blue_colormap[i] >= 256))
				1178	{
				1179	range=65535;
				1180	break;
				1181	}
				1182	for (i=0; i < (long) image->colors; i++)
				1183	{
				1184	image->colormap[i].red=RoundToQuantum(((double) QuantumRange*
				1185	red_colormap[i])/range);
				1186	image->colormap[i].green=RoundToQuantum(((double) QuantumRange*
				1187	green_colormap[i])/range);
				1188	image->colormap[i].blue=RoundToQuantum(((double) QuantumRange*
				1189	blue_colormap[i])/range);
				1190	}
				1191	}
				1192	quantum_type=IndexQuantum;
				1193	pad=(size_t) MagickMax((size_t) samples_per_pixel-1,0);
				1194	if (image->matte != MagickFalse)
				1195	{
				1196	if (image->storage_class != PseudoClass)
				1197	{
				1198	quantum_type=samples_per_pixel == 1 ? AlphaQuantum :
				1199	GrayAlphaQuantum;
				1200	pad=(size_t) MagickMax((size_t) samples_per_pixel-2,0);
				1201	}
				1202	else
				1203	{
				1204	quantum_type=IndexAlphaQuantum;
				1205	pad=(size_t) MagickMax((size_t) samples_per_pixel-2,0);
				1206	}
				1207	}
				1208	else
				1209	if (image->storage_class != PseudoClass)
				1210	{
				1211	quantum_type=GrayQuantum;
				1212	pad=(size_t) MagickMax((size_t) samples_per_pixel-1,0);
				1213	}
				1214	status=SetQuantumPad(image,quantum_info,pad*((bits_per_sample+7) >> 3));
				1215	if (status == MagickFalse)
				1216	ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
				1217	pixels=GetQuantumPixels(quantum_info);
				1218	for (y=0; y < (long) image->rows; y++)
				1219	{
				1220	int
				1221	status;
				1222
				1223	register PixelPacket
				1224	*__restrict q;
				1225
				1226	status=TIFFReadPixels(tiff,bits_per_sample,0,y,(char *) pixels);
				1227	if (status == -1)
				1228	break;
				1229	q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
				1230	if (q == (PixelPacket *) NULL)
				1231	break;
				1232	length=ImportQuantumPixels(image,(CacheView *) NULL,quantum_info,
				1233	quantum_type,pixels,exception);
				1234	if (SyncAuthenticPixels(image,exception) == MagickFalse)
				1235	break;
				1236	if (image->previous == (Image *) NULL)
				1237	{
				1238	status=SetImageProgress(image,LoadImageTag,y,image->rows);
				1239	if (status == MagickFalse)
				1240	break;
				1241	}
				1242	}
				1243	break;
				1244	}
				1245	case ReadRGBAMethod:
				1246	{
				1247	/*
				1248	Convert TIFF image to DirectClass MIFF image.
				1249	*/
				1250	pad=(size_t) MagickMax((size_t) samples_per_pixel-3,0);
				1251	quantum_type=RGBQuantum;
				1252	if (image->matte != MagickFalse)
				1253	{
				1254	quantum_type=RGBAQuantum;
				1255	pad=(size_t) MagickMax((size_t) samples_per_pixel-4,0);
				1256	}
				1257	if (image->colorspace == CMYKColorspace)
				1258	{
				1259	pad=(size_t) MagickMax((size_t) samples_per_pixel-4,0);
				1260	quantum_type=CMYKQuantum;
				1261	if (image->matte != MagickFalse)
				1262	{
				1263	quantum_type=CMYKAQuantum;
				1264	pad=(size_t) MagickMax((size_t) samples_per_pixel-5,0);
				1265	}
				1266	}
				1267	status=SetQuantumPad(image,quantum_info,pad*((bits_per_sample+7) >> 3));
				1268	if (status == MagickFalse)
				1269	ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
				1270	pixels=GetQuantumPixels(quantum_info);
				1271	for (y=0; y < (long) image->rows; y++)
				1272	{
				1273	int
				1274	status;
				1275
				1276	register PixelPacket
				1277	*__restrict q;
				1278
				1279	status=TIFFReadPixels(tiff,bits_per_sample,0,y,(char *) pixels);
				1280	if (status == -1)
				1281	break;
				1282	q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
				1283	if (q == (PixelPacket *) NULL)
				1284	break;
				1285	length=ImportQuantumPixels(image,(CacheView *) NULL,quantum_info,
				1286	quantum_type,pixels,exception);
				1287	if (SyncAuthenticPixels(image,exception) == MagickFalse)
				1288	break;
				1289	if (image->previous == (Image *) NULL)
				1290	{
				1291	status=SetImageProgress(image,LoadImageTag,y,image->rows);
				1292	if (status == MagickFalse)
				1293	break;
				1294	}
				1295	}
				1296	break;
				1297	}
				1298	case ReadCMYKAMethod:
				1299	{
				1300	/*
				1301	Convert TIFF image to DirectClass MIFF image.
				1302	*/
				1303	for (y=0; y < (long) image->rows; y++)
				1304	{
				1305	register PixelPacket
				1306	*__restrict q;
				1307
				1308	for (i=0; i < (long) samples_per_pixel; i++)
				1309	{
				1310	int
				1311	status;
				1312
				1313	status=TIFFReadPixels(tiff,bits_per_sample,(tsample_t) i,y,(char *)
				1314	pixels);
				1315	if (status == -1)
				1316	break;
				1317	q=GetAuthenticPixels(image,0,y,image->columns,1,exception);
				1318	if (q == (PixelPacket *) NULL)
				1319	break;
				1320	if (image->colorspace != CMYKColorspace)
				1321	switch (i)
				1322	{
				1323	case 0: quantum_type=RedQuantum; break;
				1324	case 1: quantum_type=GreenQuantum; break;
				1325	case 2: quantum_type=BlueQuantum; break;
				1326	case 3: quantum_type=AlphaQuantum; break;
				1327	default: quantum_type=UndefinedQuantum; break;
				1328	}
				1329	else
				1330	switch (i)
				1331	{
				1332	case 0: quantum_type=CyanQuantum; break;
				1333	case 1: quantum_type=MagentaQuantum; break;
				1334	case 2: quantum_type=YellowQuantum; break;
				1335	case 3: quantum_type=BlackQuantum; break;
				1336	case 4: quantum_type=AlphaQuantum; break;
				1337	default: quantum_type=UndefinedQuantum; break;
				1338	}
				1339	length=ImportQuantumPixels(image,(CacheView *) NULL,quantum_info,
				1340	quantum_type,pixels,exception);
				1341	if (SyncAuthenticPixels(image,exception) == MagickFalse)
				1342	break;
				1343	}
				1344	if (image->previous == (Image *) NULL)
				1345	{
				1346	status=SetImageProgress(image,LoadImageTag,y,image->rows);
				1347	if (status == MagickFalse)
				1348	break;
				1349	}
				1350	}
				1351	break;
				1352	}
				1353	case ReadStripMethod:
				1354	{
				1355	register unsigned char
				1356	*p;
				1357
				1358	/*
				1359	Convert stripped TIFF image to DirectClass MIFF image.
				1360	*/
				1361	i=0;
				1362	p=(unsigned char *) NULL;
				1363	for (y=0; y < (long) image->rows; y++)
				1364	{
				1365	register long
				1366	x;
				1367
				1368	register PixelPacket
				1369	*__restrict q;
				1370
				1371	q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
				1372	if (q == (PixelPacket *) NULL)
				1373	break;
				1374	if (i == 0)
				1375	{
				1376	if (TIFFReadRGBAStrip(tiff,(tstrip_t) y,(uint32 *) pixels) == 0)
				1377	break;
				1378	i=(long) MagickMin((long) rows_per_strip,(long) image->rows-y);
				1379	}
				1380	i--;
				1381	p=pixels+image->columns*i;
				1382	for (x=0; x < (long) image->columns; x++)
				1383	{
				1384	q->red=ScaleCharToQuantum((unsigned char) (TIFFGetR(*p)));
				1385	q->green=ScaleCharToQuantum((unsigned char) (TIFFGetG(*p)));
				1386	q->blue=ScaleCharToQuantum((unsigned char) (TIFFGetB(*p)));
				1387	if (image->matte != MagickFalse)
				1388	q->opacity=ScaleCharToQuantum((unsigned char) (TIFFGetA(*p)));
				1389	p++;
				1390	q++;
				1391	}
				1392	if (SyncAuthenticPixels(image,exception) == MagickFalse)
				1393	break;
				1394	if (image->previous == (Image *) NULL)
				1395	{
				1396	status=SetImageProgress(image,LoadImageTag,y,image->rows);
				1397	if (status == MagickFalse)
				1398	break;
				1399	}
				1400	}
				1401	break;
				1402	}
				1403	case ReadTileMethod:
				1404	{
				1405	register uint32
				1406	*p;
				1407
				1408	uint32
				1409	*tile_pixels,
				1410	columns,
				1411	rows;
				1412
				1413	unsigned long
				1414	number_pixels;
				1415
				1416	/*
				1417	Convert tiled TIFF image to DirectClass MIFF image.
				1418	*/
				1419	if ((TIFFGetField(tiff,TIFFTAG_TILEWIDTH,&columns) == 0) \|\|
				1420	(TIFFGetField(tiff,TIFFTAG_TILELENGTH,&rows) == 0))
				1421	{
				1422	TIFFClose(tiff);
				1423	ThrowReaderException(CoderError,"ImageIsNotTiled");
				1424	}
				1425	(void) SetImageStorageClass(image,DirectClass);
				1426	number_pixels=columns*rows;
				1427	tile_pixels=(uint32 ) AcquireQuantumMemory((size_t) columnsrows,
				1428	sizeof(*tile_pixels));
				1429	if (tile_pixels == (uint32 *) NULL)
				1430	{
				1431	TIFFClose(tiff);
				1432	ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
				1433	}
				1434	for (y=0; y < (long) image->rows; y+=rows)
				1435	{
				1436	PixelPacket
				1437	*tile;
				1438
				1439	register long
				1440	x;
				1441
				1442	register PixelPacket
				1443	*__restrict q;
				1444
				1445	unsigned long
				1446	columns_remaining,
				1447	rows_remaining;
				1448
				1449	rows_remaining=image->rows-y;
				1450	if ((long) (y+rows) < (long) image->rows)
				1451	rows_remaining=rows;
				1452	tile=QueueAuthenticPixels(image,0,y,image->columns,rows_remaining,
				1453	exception);
				1454	if (tile == (PixelPacket *) NULL)
				1455	break;
				1456	for (x=0; x < (long) image->columns; x+=columns)
				1457	{
				1458	unsigned long
				1459	column,
				1460	row;
				1461
				1462	if (TIFFReadRGBATile(tiff,(uint32) x,(uint32) y,tile_pixels) == 0)
				1463	break;
				1464	columns_remaining=image->columns-x;
				1465	if ((long) (x+columns) < (long) image->columns)
				1466	columns_remaining=columns;
				1467	p=tile_pixels+(rows-rows_remaining)*columns;
				1468	q=tile+(image->columns*(rows_remaining-1)+x);
				1469	for (row=rows_remaining; row > 0; row--)
				1470	{
				1471	if (image->matte != MagickFalse)
				1472	for (column=columns_remaining; column > 0; column--)
				1473	{
				1474	q->red=ScaleCharToQuantum((unsigned char) TIFFGetR(*p));
				1475	q->green=ScaleCharToQuantum((unsigned char) TIFFGetG(*p));
				1476	q->blue=ScaleCharToQuantum((unsigned char) TIFFGetB(*p));
				1477	q->opacity=(Quantum) (QuantumRange-ScaleCharToQuantum(
				1478	(unsigned char) TIFFGetA(*p)));
				1479	q++;
				1480	p++;
				1481	}
				1482	else
				1483	for (column=columns_remaining; column > 0; column--)
				1484	{
				1485	q->red=ScaleCharToQuantum((unsigned char) TIFFGetR(*p));
				1486	q->green=ScaleCharToQuantum((unsigned char) TIFFGetG(*p));
				1487	q->blue=ScaleCharToQuantum((unsigned char) TIFFGetB(*p));
				1488	q++;
				1489	p++;
				1490	}
				1491	p+=columns-columns_remaining;
				1492	q-=(image->columns+columns_remaining);
				1493	}
				1494	}
				1495	if (SyncAuthenticPixels(image,exception) == MagickFalse)
				1496	break;
				1497	if (image->previous == (Image *) NULL)
				1498	{
				1499	status=SetImageProgress(image,LoadImageTag,y,image->rows);
				1500	if (status == MagickFalse)
				1501	break;
				1502	}
				1503	}
				1504	tile_pixels=(uint32 *) RelinquishMagickMemory(tile_pixels);
				1505	break;
				1506	}
				1507	case ReadGenericMethod:
				1508	default:
				1509	{
				1510	register uint32
				1511	*p;
				1512
				1513	uint32
				1514	*pixels;
				1515
				1516	/*
				1517	Convert TIFF image to DirectClass MIFF image.
				1518	*/
				1519	number_pixels=(MagickSizeType) image->columns*image->rows;
				1520	if ((number_pixels*sizeof(uint32)) != (MagickSizeType) ((size_t)
				1521	(number_pixels*sizeof(uint32))))
				1522	{
				1523	TIFFClose(tiff);
				1524	ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
				1525	}
				1526	pixels=(uint32 ) AcquireQuantumMemory(image->columns,image->rows
				1527	sizeof(uint32));
				1528	if (pixels == (uint32 *) NULL)
				1529	{
				1530	TIFFClose(tiff);
				1531	ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
				1532	}
				1533	(void) TIFFReadRGBAImage(tiff,(uint32) image->columns,
				1534	(uint32) image->rows,(uint32 *) pixels,0);
				1535	/*
				1536	Convert image to DirectClass pixel packets.
				1537	*/
				1538	p=pixels+number_pixels-1;
				1539	for (y=0; y < (long) image->rows; y++)
				1540	{
				1541	register long
				1542	x;
				1543
				1544	register PixelPacket
				1545	*__restrict q;
				1546
				1547	q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
				1548	if (q == (PixelPacket *) NULL)
				1549	break;
				1550	q+=image->columns-1;
				1551	for (x=0; x < (long) image->columns; x++)
				1552	{
				1553	q->red=ScaleCharToQuantum((unsigned char) TIFFGetR(*p));
				1554	q->green=ScaleCharToQuantum((unsigned char) TIFFGetG(*p));
				1555	q->blue=ScaleCharToQuantum((unsigned char) TIFFGetB(*p));
				1556	if (image->matte != MagickFalse)
				1557	q->opacity=ScaleCharToQuantum((unsigned char) TIFFGetA(*p));
				1558	p--;
				1559	q--;
				1560	}
				1561	if (SyncAuthenticPixels(image,exception) == MagickFalse)
				1562	break;
				1563	if (image->previous == (Image *) NULL)
				1564	{
				1565	status=SetImageProgress(image,LoadImageTag,y,image->rows);
				1566	if (status == MagickFalse)
				1567	break;
				1568	}
				1569	}
				1570	pixels=(uint32 *) RelinquishMagickMemory(pixels);
				1571	break;
				1572	}
				1573	}
				1574	SetQuantumImageType(image,quantum_type);
				1575	next_tiff_frame:
				1576	if ((photometric == PHOTOMETRIC_LOGL) \|\|
				1577	(photometric == PHOTOMETRIC_MINISBLACK) \|\|
				1578	(photometric == PHOTOMETRIC_MINISWHITE))
				1579	{
				1580	image->type=GrayscaleType;
				1581	if (bits_per_sample == 1)
				1582	image->type=BilevelType;
				1583	}
				1584	if (image->storage_class == PseudoClass)
				1585	image->depth=GetImageDepth(image,exception);
				1586	image->endian=MSBEndian;
				1587	if (endian == FILLORDER_LSB2MSB)
				1588	image->endian=LSBEndian;
				1589	if ((photometric == PHOTOMETRIC_LOGL) \|\|
				1590	(photometric == PHOTOMETRIC_MINISBLACK) \|\|
				1591	(photometric == PHOTOMETRIC_MINISWHITE))
				1592	{
				1593	image->type=GrayscaleType;
				1594	if (bits_per_sample == 1)
				1595	image->type=BilevelType;
				1596	}
				1597	/*
				1598	Proceed to next image.
				1599	*/
				1600	if (image_info->number_scenes != 0)
				1601	if (image->scene >= (image_info->scene+image_info->number_scenes-1))
				1602	break;
				1603	status=TIFFReadDirectory(tiff) != 0 ? MagickTrue : MagickFalse;
				1604	if (status == MagickTrue)
				1605	{
				1606	/*
				1607	Allocate next image structure.
				1608	*/
				1609	AcquireNextImage(image_info,image);
				1610	if (GetNextImageInList(image) == (Image *) NULL)
				1611	{
				1612	image=DestroyImageList(image);
				1613	return((Image *) NULL);
				1614	}
				1615	image=SyncNextImageInList(image);
				1616	status=SetImageProgress(image,LoadImagesTag,image->scene-1,
				1617	image->scene);
				1618	if (status == MagickFalse)
				1619	break;
				1620	}
				1621	quantum_info=DestroyQuantumInfo(quantum_info);
				1622	} while (status == MagickTrue);
				1623	(void) TIFFSetWarningHandler(warning_handler);
				1624	(void) TIFFSetErrorHandler(error_handler);
				1625	TIFFClose(tiff);
				1626	return(GetFirstImageInList(image));
				1627	}
				1628	#endif
				1629
				1630	/*
				1631	%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
				1632	% %
				1633	% %
				1634	% %
				1635	% R e g i s t e r T I F F I m a g e %
				1636	% %
				1637	% %
				1638	% %
				1639	%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
				1640	%
				1641	% RegisterTIFFImage() adds properties for the TIFF image format to
				1642	% the list of supported formats. The properties include the image format
				1643	% tag, a method to read and/or write the format, whether the format
				1644	% supports the saving of more than one frame to the same file or blob,
				1645	% whether the format supports native in-memory I/O, and a brief
				1646	% description of the format.
				1647	%
				1648	% The format of the RegisterTIFFImage method is:
				1649	%
				1650	% unsigned long RegisterTIFFImage(void)
				1651	%
				1652	*/
				1653	ModuleExport unsigned long RegisterTIFFImage(void)
				1654	{
				1655	#define TIFFDescription "Tagged Image File Format"
				1656
				1657	char
				1658	version[MaxTextExtent];
				1659
				1660	MagickInfo
				1661	*entry;
cristy	18b1744	2009-10-25 18:36:48 +0000	[diff] [blame]	1662
				1663	if (tiff_semaphore == (SemaphoreInfo *) NULL)
				1664	tiff_semaphore=AllocateSemaphoreInfo();
cristy	a45da9d	2009-10-25 21:29:37 +0000	[diff] [blame^]	1665	(void) LockSemaphoreInfo(tiff_semaphore);
cristy	3ed852e	2009-09-05 21:47:34 +0000	[diff] [blame]	1666	if (instantiate_key == MagickFalse)
				1667	{
				1668	if (MagickCreateThreadKey(&tiff_exception) == MagickFalse)
				1669	ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
				1670	instantiate_key=MagickTrue;
				1671	}
cristy	a45da9d	2009-10-25 21:29:37 +0000	[diff] [blame^]	1672	(void) UnlockSemaphoreInfo(tiff_semaphore);
cristy	3ed852e	2009-09-05 21:47:34 +0000	[diff] [blame]	1673	*version='\0';
				1674	#if defined(TIFF_VERSION)
				1675	(void) FormatMagickString(version,MaxTextExtent,"%d",TIFF_VERSION);
				1676	#endif
				1677	#if defined(MAGICKCORE_TIFF_DELEGATE)
				1678	{
				1679	const char
				1680	*p;
				1681
				1682	register long int
				1683	i;
				1684
				1685	p=TIFFGetVersion();
				1686	for (i=0; (i < (MaxTextExtent-1)) && (p != 0) && (p != '\n'); i++)
				1687	version[i]=(*p++);
				1688	version[i]='\0';
				1689	}
				1690	#endif
				1691
cristy	3d7f806	2009-09-24 20:45:35 +0000	[diff] [blame]	1692	entry=SetMagickInfo("GROUP4");
				1693	#if defined(MAGICKCORE_TIFF_DELEGATE)
				1694	entry->decoder=(DecodeImageHandler *) ReadGROUP4Image;
				1695	entry->encoder=(EncodeImageHandler *) WriteGROUP4Image;
				1696	#endif
				1697	entry->raw=MagickTrue;
				1698	entry->endian_support=MagickTrue;
cristy	2d6ccc3	2009-09-25 03:18:25 +0000	[diff] [blame]	1699	entry->adjoin=MagickFalse;
cristy	3d7f806	2009-09-24 20:45:35 +0000	[diff] [blame]	1700	entry->seekable_stream=MagickTrue;
				1701	entry->thread_support=NoThreadSupport;
				1702	entry->description=ConstantString("Raw CCITT Group4");
				1703	entry->module=ConstantString("TIFF");
				1704	(void) RegisterMagickInfo(entry);
cristy	3ed852e	2009-09-05 21:47:34 +0000	[diff] [blame]	1705	entry=SetMagickInfo("PTIF");
				1706	#if defined(MAGICKCORE_TIFF_DELEGATE)
				1707	entry->decoder=(DecodeImageHandler *) ReadTIFFImage;
				1708	entry->encoder=(EncodeImageHandler *) WritePTIFImage;
				1709	#endif
				1710	entry->endian_support=MagickTrue;
				1711	entry->seekable_stream=MagickTrue;
				1712	entry->thread_support=NoThreadSupport;
				1713	entry->description=ConstantString("Pyramid encoded TIFF");
				1714	entry->module=ConstantString("TIFF");
				1715	(void) RegisterMagickInfo(entry);
				1716	entry=SetMagickInfo("TIF");
				1717	#if defined(MAGICKCORE_TIFF_DELEGATE)
				1718	entry->decoder=(DecodeImageHandler *) ReadTIFFImage;
				1719	entry->encoder=(EncodeImageHandler *) WriteTIFFImage;
				1720	#endif
				1721	entry->endian_support=MagickTrue;
				1722	entry->seekable_stream=MagickTrue;
				1723	entry->stealth=MagickTrue;
				1724	entry->thread_support=NoThreadSupport;
				1725	entry->description=ConstantString(TIFFDescription);
				1726	if (*version != '\0')
				1727	entry->version=ConstantString(version);
				1728	entry->module=ConstantString("TIFF");
				1729	(void) RegisterMagickInfo(entry);
				1730	entry=SetMagickInfo("TIFF");
				1731	#if defined(MAGICKCORE_TIFF_DELEGATE)
				1732	entry->decoder=(DecodeImageHandler *) ReadTIFFImage;
				1733	entry->encoder=(EncodeImageHandler *) WriteTIFFImage;
				1734	#endif
				1735	entry->magick=(IsImageFormatHandler *) IsTIFF;
				1736	entry->endian_support=MagickTrue;
				1737	entry->seekable_stream=MagickTrue;
				1738	entry->thread_support=NoThreadSupport;
				1739	entry->description=ConstantString(TIFFDescription);
				1740	if (*version != '\0')
				1741	entry->version=ConstantString(version);
				1742	entry->module=ConstantString("TIFF");
				1743	(void) RegisterMagickInfo(entry);
				1744	entry=SetMagickInfo("TIFF64");
				1745	#if defined(TIFF_VERSION_BIG)
				1746	entry->decoder=(DecodeImageHandler *) ReadTIFFImage;
				1747	entry->encoder=(EncodeImageHandler *) WritePTIFImage;
				1748	#endif
				1749	entry->adjoin=MagickFalse;
				1750	entry->endian_support=MagickTrue;
				1751	entry->seekable_stream=MagickTrue;
				1752	entry->thread_support=NoThreadSupport;
				1753	entry->description=ConstantString("Tagged Image File Format (64-bit)");
				1754	if (*version != '\0')
				1755	entry->version=ConstantString(version);
				1756	entry->module=ConstantString("TIFF");
				1757	(void) RegisterMagickInfo(entry);
				1758	return(MagickImageCoderSignature);
				1759	}
				1760
				1761	/*
				1762	%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
				1763	% %
				1764	% %
				1765	% %
				1766	% U n r e g i s t e r T I F F I m a g e %
				1767	% %
				1768	% %
				1769	% %
				1770	%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
				1771	%
				1772	% UnregisterTIFFImage() removes format registrations made by the TIFF module
				1773	% from the list of supported formats.
				1774	%
				1775	% The format of the UnregisterTIFFImage method is:
				1776	%
				1777	% UnregisterTIFFImage(void)
				1778	%
				1779	*/
				1780	ModuleExport void UnregisterTIFFImage(void)
				1781	{
cristy	3d7f806	2009-09-24 20:45:35 +0000	[diff] [blame]	1782	(void) UnregisterMagickInfo("RAWGROUP4");
cristy	3ed852e	2009-09-05 21:47:34 +0000	[diff] [blame]	1783	(void) UnregisterMagickInfo("PTIF");
				1784	(void) UnregisterMagickInfo("TIF");
				1785	(void) UnregisterMagickInfo("TIFF");
				1786	(void) UnregisterMagickInfo("TIFF64");
cristy	a45da9d	2009-10-25 21:29:37 +0000	[diff] [blame^]	1787	(void) LockSemaphoreInfo(tiff_semaphore);
cristy	3ed852e	2009-09-05 21:47:34 +0000	[diff] [blame]	1788	if (instantiate_key != MagickFalse)
				1789	if (MagickDeleteThreadKey(tiff_exception) == MagickFalse)
				1790	ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
				1791	instantiate_key=MagickFalse;
cristy	a45da9d	2009-10-25 21:29:37 +0000	[diff] [blame^]	1792	(void) UnlockSemaphoreInfo(tiff_semaphore);
cristy	3ed852e	2009-09-05 21:47:34 +0000	[diff] [blame]	1793	DestroySemaphoreInfo(&tiff_semaphore);
				1794	}
				1795
				1796	#if defined(MAGICKCORE_TIFF_DELEGATE)
				1797	/*
				1798	%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
				1799	% %
				1800	% %
				1801	% %
cristy	3d7f806	2009-09-24 20:45:35 +0000	[diff] [blame]	1802	% W r i t e G R O U P 4 I m a g e %
				1803	% %
				1804	% %
				1805	% %
				1806	%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
				1807	%
				1808	% WriteGROUP4Image() writes an image in the raw CCITT Group 4 image format.
				1809	%
				1810	% The format of the WriteGROUP4Image method is:
				1811	%
				1812	% MagickBooleanType WriteGROUP4Image(const ImageInfo *image_info,
				1813	% Image *image)
				1814	%
				1815	% A description of each parameter follows:
				1816	%
				1817	% o image_info: the image info.
				1818	%
				1819	% o image: The image.
				1820	%
				1821	*/
				1822	static MagickBooleanType WriteGROUP4Image(const ImageInfo *image_info,
				1823	Image *image)
				1824	{
				1825	char
				1826	filename[MaxTextExtent];
				1827
				1828	FILE
				1829	*file;
				1830
				1831	Image
				1832	*huffman_image;
				1833
				1834	ImageInfo
				1835	*write_info;
				1836
				1837	int
				1838	unique_file;
				1839
				1840	MagickBooleanType
				1841	status;
				1842
				1843	register long
				1844	i;
				1845
				1846	ssize_t
				1847	count;
				1848
				1849	TIFF
				1850	*tiff;
				1851
cristy	94c8fe4	2009-10-06 01:57:36 +0000	[diff] [blame]	1852	toff_t
cristy	3d7f806	2009-09-24 20:45:35 +0000	[diff] [blame]	1853	*byte_count,
				1854	strip_size;
				1855
				1856	unsigned char
				1857	*buffer;
				1858
				1859	/*
				1860	Write image as CCITT Group4 TIFF image to a temporary file.
				1861	*/
				1862	assert(image_info != (const ImageInfo *) NULL);
				1863	assert(image_info->signature == MagickSignature);
				1864	assert(image != (Image *) NULL);
				1865	assert(image->signature == MagickSignature);
				1866	if (image->debug != MagickFalse)
				1867	(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
				1868	status=OpenBlob(image_info,image,WriteBinaryBlobMode,&image->exception);
				1869	if (status == MagickFalse)
				1870	return(status);
				1871	huffman_image=CloneImage(image,0,0,MagickTrue,&image->exception);
				1872	if (huffman_image == (Image *) NULL)
				1873	{
				1874	(void) CloseBlob(image);
				1875	return(MagickFalse);
				1876	}
cristy	94c8fe4	2009-10-06 01:57:36 +0000	[diff] [blame]	1877	huffman_image->endian=MSBEndian;
cristy	3d7f806	2009-09-24 20:45:35 +0000	[diff] [blame]	1878	file=(FILE *) NULL;
				1879	unique_file=AcquireUniqueFileResource(filename);
				1880	if (unique_file != -1)
cristy	0accf6e	2009-10-01 13:14:28 +0000	[diff] [blame]	1881	file=fdopen(unique_file,"wb");
cristy	3d7f806	2009-09-24 20:45:35 +0000	[diff] [blame]	1882	if ((unique_file == -1) \|\| (file == (FILE *) NULL))
				1883	{
				1884	ThrowFileException(&image->exception,FileOpenError,
				1885	"UnableToCreateTemporaryFile",filename);
				1886	return(MagickFalse);
				1887	}
				1888	(void) FormatMagickString(huffman_image->filename,MaxTextExtent,"tiff:%s",
				1889	filename);
				1890	(void) SetImageType(huffman_image,BilevelType);
cristy	14efd99	2009-09-26 23:46:03 +0000	[diff] [blame]	1891	write_info=CloneImageInfo((ImageInfo *) NULL);
cristy	3d7f806	2009-09-24 20:45:35 +0000	[diff] [blame]	1892	SetImageInfoFile(write_info,file);
				1893	write_info->compression=Group4Compression;
				1894	write_info->type=BilevelType;
				1895	(void) SetImageOption(write_info,"quantum:polarity","min-is-white");
				1896	status=WriteTIFFImage(write_info,huffman_image);
				1897	(void) fflush(file);
				1898	write_info=DestroyImageInfo(write_info);
				1899	if (status == MagickFalse)
				1900	{
				1901	InheritException(&image->exception,&huffman_image->exception);
				1902	huffman_image=DestroyImage(huffman_image);
				1903	(void) fclose(file);
				1904	(void) RelinquishUniqueFileResource(filename);
				1905	return(MagickFalse);
				1906	}
				1907	tiff=TIFFOpen(filename,"rb");
				1908	if (tiff == (TIFF *) NULL)
				1909	{
				1910	huffman_image=DestroyImage(huffman_image);
				1911	(void) fclose(file);
				1912	(void) RelinquishUniqueFileResource(filename);
				1913	ThrowFileException(&image->exception,FileOpenError,"UnableToOpenFile",
				1914	image_info->filename);
				1915	return(MagickFalse);
				1916	}
				1917	/*
				1918	Allocate raw strip buffer.
				1919	*/
cristy	94c8fe4	2009-10-06 01:57:36 +0000	[diff] [blame]	1920	if (TIFFGetField(tiff,TIFFTAG_STRIPBYTECOUNTS,&byte_count) != 1)
				1921	{
				1922	TIFFClose(tiff);
				1923	huffman_image=DestroyImage(huffman_image);
				1924	(void) fclose(file);
				1925	(void) RelinquishUniqueFileResource(filename);
				1926	return(MagickFalse);
				1927	}
cristy	3d7f806	2009-09-24 20:45:35 +0000	[diff] [blame]	1928	strip_size=byte_count[0];
				1929	for (i=1; i < (long) TIFFNumberOfStrips(tiff); i++)
				1930	if (byte_count[i] > strip_size)
				1931	strip_size=byte_count[i];
				1932	buffer=(unsigned char *) AcquireQuantumMemory((size_t) strip_size,
				1933	sizeof(*buffer));
				1934	if (buffer == (unsigned char *) NULL)
				1935	{
				1936	TIFFClose(tiff);
				1937	huffman_image=DestroyImage(huffman_image);
				1938	(void) fclose(file);
				1939	(void) RelinquishUniqueFileResource(filename);
				1940	ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
				1941	image_info->filename);
				1942	}
				1943	/*
				1944	Compress runlength encoded to 2D Huffman pixels.
				1945	*/
cristy	3d7f806	2009-09-24 20:45:35 +0000	[diff] [blame]	1946	for (i=0; i < (long) TIFFNumberOfStrips(tiff); i++)
				1947	{
cristy	94c8fe4	2009-10-06 01:57:36 +0000	[diff] [blame]	1948	count=(ssize_t) TIFFReadRawStrip(tiff,(uint32) i,buffer,strip_size);
cristy	3d7f806	2009-09-24 20:45:35 +0000	[diff] [blame]	1949	if (WriteBlob(image,(size_t) count,buffer) != count)
				1950	status=MagickFalse;
				1951	}
				1952	buffer=(unsigned char *) RelinquishMagickMemory(buffer);
				1953	TIFFClose(tiff);
				1954	huffman_image=DestroyImage(huffman_image);
				1955	(void) fclose(file);
				1956	(void) RelinquishUniqueFileResource(filename);
				1957	(void) CloseBlob(image);
				1958	return(status);
				1959	}
				1960	#endif
				1961
				1962	#if defined(MAGICKCORE_TIFF_DELEGATE)
				1963	/*
				1964	%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
				1965	% %
				1966	% %
				1967	% %
cristy	3ed852e	2009-09-05 21:47:34 +0000	[diff] [blame]	1968	% W r i t e P T I F I m a g e %
				1969	% %
				1970	% %
				1971	% %
				1972	%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
				1973	%
				1974	% WritePTIFImage() writes an image in the pyrimid-encoded Tagged image file
				1975	% format.
				1976	%
				1977	% The format of the WritePTIFImage method is:
				1978	%
				1979	% MagickBooleanType WritePTIFImage(const ImageInfo *image_info,
				1980	% Image *image)
				1981	%
				1982	% A description of each parameter follows:
				1983	%
				1984	% o image_info: the image info.
				1985	%
				1986	% o image: The image.
				1987	%
				1988	*/
				1989	static MagickBooleanType WritePTIFImage(const ImageInfo *image_info,
				1990	Image *image)
				1991	{
				1992	Image
				1993	*images,
				1994	*next,
				1995	*pyramid_image;
				1996
				1997	ImageInfo
				1998	*write_info;
				1999
				2000	MagickBooleanType
				2001	status;
				2002
				2003	unsigned long
				2004	columns,
				2005	rows;
				2006
				2007	/*
				2008	Create pyramid-encoded TIFF image.
				2009	*/
				2010	images=NewImageList();
				2011	for (next=image; next != (Image *) NULL; next=GetNextImageInList(next))
				2012	{
				2013	AppendImageToList(&images,CloneImage(next,0,0,MagickFalse,
				2014	&image->exception));
				2015	columns=next->columns;
				2016	rows=next->rows;
				2017	while ((columns > 64) && (rows > 64))
				2018	{
				2019	columns/=2;
				2020	rows/=2;
				2021	pyramid_image=ResizeImage(next,columns,rows,UndefinedFilter,image->blur,
				2022	&image->exception);
				2023	AppendImageToList(&images,pyramid_image);
				2024	}
				2025	}
				2026	/*
				2027	Write pyramid-encoded TIFF image.
				2028	*/
cristy	5856753	2009-09-26 01:13:32 +0000	[diff] [blame]	2029	write_info=CloneImageInfo(image_info);
cristy	3ed852e	2009-09-05 21:47:34 +0000	[diff] [blame]	2030	*write_info->magick='\0';
				2031	write_info->adjoin=MagickTrue;
				2032	status=WriteTIFFImage(write_info,GetFirstImageInList(images));
				2033	images=DestroyImageList(images);
				2034	write_info=DestroyImageInfo(write_info);
				2035	return(status);
				2036	}
				2037	#endif
				2038
				2039	#if defined(MAGICKCORE_TIFF_DELEGATE)
				2040	/*
				2041	%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
				2042	% %
				2043	% %
				2044	% W r i t e T I F F I m a g e %
				2045	% %
				2046	% %
				2047	% %
				2048	%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
				2049	%
				2050	% WriteTIFFImage() writes an image in the Tagged image file format.
				2051	%
				2052	% The format of the WriteTIFFImage method is:
				2053	%
				2054	% MagickBooleanType WriteTIFFImage(const ImageInfo *image_info,
				2055	% Image *image)
				2056	%
				2057	% A description of each parameter follows:
				2058	%
				2059	% o image_info: the image info.
				2060	%
				2061	% o image: The image.
				2062	%
				2063	*/
				2064
				2065	typedef struct _TIFFInfo
				2066	{
				2067	RectangleInfo
				2068	tile_geometry;
				2069
				2070	unsigned char
				2071	*scanline,
				2072	*scanlines,
				2073	*pixels;
				2074	} TIFFInfo;
				2075
				2076	static void DestroyTIFFInfo(TIFFInfo *tiff_info)
				2077	{
				2078	assert(tiff_info != (TIFFInfo *) NULL);
				2079	if (tiff_info->scanlines != (unsigned char *) NULL)
				2080	tiff_info->scanlines=(unsigned char *) RelinquishMagickMemory(
				2081	tiff_info->scanlines);
				2082	if (tiff_info->pixels != (unsigned char *) NULL)
				2083	tiff_info->pixels=(unsigned char *) RelinquishMagickMemory(
				2084	tiff_info->pixels);
				2085	}
				2086
				2087	static MagickBooleanType GetTIFFInfo(const ImageInfo image_info,TIFF tiff,
				2088	TIFFInfo *tiff_info)
				2089	{
				2090	const char
				2091	*option;
				2092
				2093	MagickStatusType
				2094	flags;
				2095
				2096	assert(tiff_info != (TIFFInfo *) NULL);
				2097	(void) ResetMagickMemory(tiff_info,0,sizeof(*tiff_info));
				2098	option=GetImageOption(image_info,"tiff:tile-geometry");
				2099	if (option == (const char *) NULL)
				2100	return(MagickTrue);
				2101	flags=ParseAbsoluteGeometry(option,&tiff_info->tile_geometry);
				2102	if ((flags & HeightValue) == 0)
				2103	tiff_info->tile_geometry.height=tiff_info->tile_geometry.width;
				2104	(void) TIFFSetField(tiff,TIFFTAG_TILEWIDTH,(uint32)
				2105	tiff_info->tile_geometry.width);
				2106	(void) TIFFSetField(tiff,TIFFTAG_TILELENGTH,(uint32)
				2107	tiff_info->tile_geometry.height);
				2108	tiff_info->scanlines=(unsigned char *) AcquireQuantumMemory((size_t)
				2109	tiff_info->tile_geometry.height*TIFFScanlineSize(tiff),
				2110	sizeof(*tiff_info->scanlines));
				2111	tiff_info->pixels=(unsigned char *) AcquireQuantumMemory((size_t)
				2112	TIFFTileSize(tiff),sizeof(*tiff_info->scanlines));
				2113	if ((tiff_info->scanlines == (unsigned char *) NULL) \|\|
				2114	(tiff_info->pixels == (unsigned char *) NULL))
				2115	{
				2116	DestroyTIFFInfo(tiff_info);
				2117	return(MagickFalse);
				2118	}
				2119	return(MagickTrue);
				2120	}
				2121
				2122	static int32 TIFFWritePixels(TIFF tiff,TIFFInfo tiff_info,long row,
				2123	tsample_t sample,Image *image)
				2124	{
				2125	int32
				2126	status;
				2127
				2128	long
				2129	bytes_per_pixel,
				2130	j,
				2131	k,
				2132	l;
				2133
				2134	register long
				2135	i;
				2136
				2137	register unsigned char
				2138	*p,
				2139	*q;
				2140
				2141	unsigned long
				2142	number_tiles,
				2143	tile_width;
				2144
				2145	if (TIFFIsTiled(tiff) == 0)
				2146	return(TIFFWriteScanline(tiff,tiff_info->scanline,(uint32) row,sample));
				2147	/*
				2148	Fill scanlines to tile height.
				2149	*/
				2150	i=(long) (row % tiff_info->tile_geometry.height)*TIFFScanlineSize(tiff);
				2151	(void) CopyMagickMemory(tiff_info->scanlines+i,(char *) tiff_info->scanline,
				2152	(size_t) TIFFScanlineSize(tiff));
				2153	if (((unsigned long) (row % tiff_info->tile_geometry.height) !=
				2154	(tiff_info->tile_geometry.height-1)) && (row != (long) (image->rows-1)))
				2155	return(0);
				2156	/*
				2157	Write tile to TIFF image.
				2158	*/
				2159	status=0;
				2160	bytes_per_pixel=TIFFTileSize(tiff)/(long) (tiff_info->tile_geometry.height*
				2161	tiff_info->tile_geometry.width);
				2162	number_tiles=(image->columns+tiff_info->tile_geometry.width)/
				2163	tiff_info->tile_geometry.width;
				2164	for (i=0; i < (long) number_tiles; i++)
				2165	{
				2166	tile_width=(i == (long) (number_tiles-1)) ? image->columns-(i*
				2167	tiff_info->tile_geometry.width) : tiff_info->tile_geometry.width;
				2168	for (j=0; j < (long) ((row % tiff_info->tile_geometry.height)+1); j++)
				2169	for (k=0; k < (long) tile_width; k++)
				2170	{
				2171	if (bytes_per_pixel == 0)
				2172	{
				2173	p=tiff_info->scanlines+(jTIFFScanlineSize(tiff)+(i
				2174	tiff_info->tile_geometry.width+k)/8);
				2175	q=tiff_info->pixels+(j*TIFFTileRowSize(tiff)+k/8);
				2176	q++=(p++);
				2177	continue;
				2178	}
				2179	p=tiff_info->scanlines+(jTIFFScanlineSize(tiff)+(i
				2180	tiff_info->tile_geometry.width+k)*bytes_per_pixel);
				2181	q=tiff_info->pixels+(jTIFFTileRowSize(tiff)+kbytes_per_pixel);
				2182	for (l=0; l < bytes_per_pixel; l++)
				2183	q++=(p++);
				2184	}
				2185	status=TIFFWriteTile(tiff,tiff_info->pixels,(uint32) (i*
				2186	tiff_info->tile_geometry.width),(uint32) ((row/
				2187	tiff_info->tile_geometry.height)*tiff_info->tile_geometry.height),0,
				2188	sample);
				2189	if (status < 0)
				2190	break;
				2191	}
				2192	return(status);
				2193	}
				2194
				2195	static void TIFFSetProfiles(TIFF tiff,Image image)
				2196	{
				2197	const char
				2198	*name;
				2199
				2200	const StringInfo
				2201	*profile;
				2202
				2203	if (image->profiles == (void *) NULL)
				2204	return;
				2205	ResetImageProfileIterator(image);
				2206	for (name=GetNextImageProfile(image); name != (const char *) NULL; )
				2207	{
				2208	profile=GetImageProfile(image,name);
				2209	#if defined(TIFFTAG_XMLPACKET)
				2210	if (LocaleCompare(name,"xmp") == 0)
				2211	(void) TIFFSetField(tiff,TIFFTAG_XMLPACKET,(uint32) GetStringInfoLength(
				2212	profile),GetStringInfoDatum(profile));
				2213	#endif
				2214	#if defined(TIFFTAG_ICCPROFILE)
				2215	if (LocaleCompare(name,"icc") == 0)
				2216	(void) TIFFSetField(tiff,TIFFTAG_ICCPROFILE,(uint32) GetStringInfoLength(
				2217	profile),GetStringInfoDatum(profile));
				2218	#endif
				2219	if (LocaleCompare(name,"iptc") == 0)
				2220	{
				2221	size_t
				2222	length;
				2223
				2224	StringInfo
				2225	*iptc_profile;
				2226
				2227	iptc_profile=CloneStringInfo(profile);
				2228	length=GetStringInfoLength(profile)+4-(GetStringInfoLength(profile) &
				2229	0x03);
				2230	SetStringInfoLength(iptc_profile,length);
				2231	if (TIFFIsByteSwapped(tiff))
				2232	TIFFSwabArrayOfLong((uint32 *) GetStringInfoDatum(iptc_profile),
				2233	(unsigned long) (length/4));
				2234	(void) TIFFSetField(tiff,TIFFTAG_RICHTIFFIPTC,(uint32)
				2235	GetStringInfoLength(iptc_profile)/4,GetStringInfoDatum(iptc_profile));
				2236	iptc_profile=DestroyStringInfo(iptc_profile);
				2237	}
				2238	#if defined(TIFFTAG_PHOTOSHOP)
				2239	if (LocaleCompare(name,"8bim") == 0)
				2240	(void) TIFFSetField(tiff,TIFFTAG_PHOTOSHOP,(uint32)
				2241	GetStringInfoLength(profile),GetStringInfoDatum(profile));
				2242	#endif
				2243	if (LocaleCompare(name,"tiff:37724") == 0)
				2244	(void) TIFFSetField(tiff,37724,(uint32)GetStringInfoLength(profile),
				2245	GetStringInfoDatum(profile));
				2246	name=GetNextImageProfile(image);
				2247	}
				2248	}
				2249
				2250	static void TIFFSetProperties(TIFF tiff,Image image)
				2251	{
				2252	const char
				2253	*value;
				2254
				2255	value=GetImageProperty(image,"tiff:hostcomputer");
				2256	if (value != (const char *) NULL)
				2257	(void) TIFFSetField(tiff,TIFFTAG_HOSTCOMPUTER,value);
				2258	value=GetImageProperty(image,"tiff:artist");
				2259	if (value != (const char *) NULL)
				2260	(void) TIFFSetField(tiff,TIFFTAG_ARTIST,value);
				2261	value=GetImageProperty(image,"tiff:timestamp");
				2262	if (value != (const char *) NULL)
				2263	(void) TIFFSetField(tiff,TIFFTAG_DATETIME,value);
				2264	value=GetImageProperty(image,"tiff:make");
				2265	if (value != (const char *) NULL)
				2266	(void) TIFFSetField(tiff,TIFFTAG_MAKE,value);
				2267	value=GetImageProperty(image,"tiff:model");
				2268	if (value != (const char *) NULL)
				2269	(void) TIFFSetField(tiff,TIFFTAG_MODEL,value);
				2270	(void) TIFFSetField(tiff,TIFFTAG_SOFTWARE,
				2271	GetMagickVersion((unsigned long *) NULL));
				2272	(void) TIFFSetField(tiff,TIFFTAG_DOCUMENTNAME,image->filename);
				2273	value=GetImageProperty(image,"tiff:copyright");
				2274	if (value != (const char *) NULL)
				2275	(void) TIFFSetField(tiff,33432,value);
				2276	value=GetImageProperty(image,"kodak-33423");
				2277	if (value != (const char *) NULL)
				2278	(void) TIFFSetField(tiff,33423,value);
				2279	value=GetImageProperty(image,"kodak-36867");
				2280	if (value != (const char *) NULL)
				2281	(void) TIFFSetField(tiff,36867,value);
				2282	value=GetImageProperty(image,"label");
				2283	if (value != (const char *) NULL)
				2284	(void) TIFFSetField(tiff,TIFFTAG_PAGENAME,value);
				2285	value=GetImageProperty(image,"comment");
				2286	if (value != (const char *) NULL)
				2287	(void) TIFFSetField(tiff,TIFFTAG_IMAGEDESCRIPTION,value);
				2288	}
				2289
				2290	static void TIFFSetEXIFProperties(TIFF tiff,Image image)
				2291	{
				2292	#if defined(MAGICKCORE_HAVE_TIFFREADEXIFDIRECTORY)
				2293	const char
				2294	*value;
				2295
				2296	register long
				2297	i;
				2298
				2299	uint32
				2300	offset;
				2301
				2302	/*
				2303	Write EXIF properties.
				2304	*/
				2305	offset=0;
				2306	(void) TIFFSetField(tiff,TIFFTAG_SUBIFD,1,&offset);
				2307	for (i=0; exif_info[i].tag != 0; i++)
				2308	{
				2309	value=GetImageProperty(image,exif_info[i].property);
				2310	if (value == (const char *) NULL)
				2311	continue;
				2312	switch (exif_info[i].type)
				2313	{
				2314	case TIFF_ASCII:
				2315	{
				2316	(void) TIFFSetField(tiff,exif_info[i].tag,value);
				2317	break;
				2318	}
				2319	case TIFF_SHORT:
				2320	{
				2321	uint16
				2322	shorty;
				2323
				2324	shorty=(uint16) atoi(value);
				2325	(void) TIFFSetField(tiff,exif_info[i].tag,shorty);
				2326	break;
				2327	}
				2328	case TIFF_LONG:
				2329	{
				2330	uint16
				2331	longy;
				2332
				2333	longy=(uint16) atol(value);
				2334	(void) TIFFSetField(tiff,exif_info[i].tag,longy);
				2335	break;
				2336	}
				2337	case TIFF_RATIONAL:
				2338	case TIFF_SRATIONAL:
				2339	{
				2340	float
				2341	rational;
				2342
				2343	rational=atof(value);
				2344	(void) TIFFSetField(tiff,exif_info[i].tag,rational);
				2345	break;
				2346	}
				2347	default:
				2348	break;
				2349	}
				2350	}
				2351	/* (void) TIFFSetField(tiff,TIFFTAG_EXIFIFD,offset); */
				2352	#else
				2353	(void) tiff;
				2354	(void) image;
				2355	#endif
				2356	}
				2357
				2358	static MagickBooleanType WriteTIFFImage(const ImageInfo *image_info,
				2359	Image *image)
				2360	{
				2361	#if !defined(TIFFDefaultStripSize)
				2362	#define TIFFDefaultStripSize(tiff,request) (8192UL/TIFFScanlineSize(tiff))
				2363	#endif
				2364
				2365	const char
				2366	*mode,
				2367	*option;
				2368
				2369	const char
				2370	*value;
				2371
				2372	CompressionType
				2373	compression;
				2374
				2375	long
				2376	y;
				2377
				2378	MagickBooleanType
				2379	debug,
				2380	status;
				2381
				2382	MagickOffsetType
				2383	scene;
				2384
				2385	QuantumInfo
				2386	*quantum_info;
				2387
				2388	QuantumType
				2389	quantum_type;
				2390
				2391	register long
				2392	i;
				2393
				2394	size_t
				2395	length;
				2396
				2397	TIFF
				2398	*tiff;
				2399
				2400	TIFFErrorHandler
				2401	error_handler,
				2402	warning_handler;
				2403
				2404	TIFFInfo
				2405	tiff_info;
				2406
				2407	uint16
				2408	bits_per_sample,
				2409	compress_tag,
				2410	endian,
				2411	photometric;
				2412
				2413	uint32
				2414	rows_per_strip;
				2415
				2416	unsigned char
				2417	*pixels;
				2418
				2419	unsigned long
				2420	lsb_first;
				2421
				2422	/*
				2423	Open TIFF file.
				2424	*/
				2425	assert(image_info != (const ImageInfo *) NULL);
				2426	assert(image_info->signature == MagickSignature);
				2427	assert(image != (Image *) NULL);
				2428	assert(image->signature == MagickSignature);
				2429	if (image->debug != MagickFalse)
				2430	(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
				2431	status=OpenBlob(image_info,image,WriteBinaryBlobMode,&image->exception);
				2432	if (status == MagickFalse)
				2433	return(status);
				2434	(void) MagickSetThreadValue(tiff_exception,&image->exception);
				2435	error_handler=TIFFSetErrorHandler((TIFFErrorHandler) TIFFErrors);
				2436	warning_handler=TIFFSetWarningHandler((TIFFErrorHandler) TIFFWarnings);
				2437	switch (image_info->endian)
				2438	{
				2439	case LSBEndian: mode="wl"; break;
				2440	case MSBEndian: mode="wb"; break;
				2441	default: mode="w"; break;
				2442	}
				2443	#if defined(TIFF_VERSION_BIG)
				2444	if (LocaleCompare(image_info->magick,"TIFF64") == 0)
				2445	switch (image_info->endian)
				2446	{
				2447	case LSBEndian: mode="wl8"; break;
				2448	case MSBEndian: mode="wb8"; break;
				2449	default: mode="w8"; break;
				2450	}
				2451	#endif
				2452	tiff=TIFFClientOpen(image->filename,mode,(thandle_t) image,TIFFReadBlob,
				2453	TIFFWriteBlob,TIFFSeekBlob,TIFFCloseBlob,TIFFGetBlobSize,TIFFMapBlob,
				2454	TIFFUnmapBlob);
				2455	if (tiff == (TIFF *) NULL)
				2456	{
				2457	(void) TIFFSetWarningHandler(warning_handler);
				2458	(void) TIFFSetErrorHandler(error_handler);
				2459	return(MagickFalse);
				2460	}
				2461	scene=0;
				2462	debug=IsEventLogging();
				2463	do
				2464	{
				2465	/*
				2466	Initialize TIFF fields.
				2467	*/
				2468	if ((image_info->type != UndefinedType) &&
				2469	(image_info->type != OptimizeType))
				2470	(void) SetImageType(image,image_info->type);
				2471	quantum_info=AcquireQuantumInfo(image_info,image);
				2472	if (quantum_info == (QuantumInfo *) NULL)
				2473	ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
				2474	if ((image->storage_class != PseudoClass) && (image->depth >= 32) &&
				2475	(quantum_info->format == UndefinedQuantumFormat) &&
				2476	(IsHighDynamicRangeImage(image,&image->exception) != MagickFalse))
				2477	{
				2478	status=SetQuantumFormat(image,quantum_info,FloatingPointQuantumFormat);
				2479	if (status == MagickFalse)
				2480	ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
				2481	}
				2482	if ((LocaleCompare(image_info->magick,"PTIF") == 0) &&
				2483	(GetPreviousImageInList(image) != (Image *) NULL))
				2484	(void) TIFFSetField(tiff,TIFFTAG_SUBFILETYPE,FILETYPE_REDUCEDIMAGE);
				2485	if ((image->columns != (uint32) image->columns) \|\|
				2486	(image->rows != (uint32) image->rows))
				2487	ThrowWriterException(ImageError,"WidthOrHeightExceedsLimit");
				2488	(void) TIFFSetField(tiff,TIFFTAG_IMAGELENGTH,(uint32) image->rows);
				2489	(void) TIFFSetField(tiff,TIFFTAG_IMAGEWIDTH,(uint32) image->columns);
				2490	compression=image->compression;
				2491	if (image_info->compression != UndefinedCompression)
				2492	compression=image_info->compression;
				2493	switch (compression)
				2494	{
				2495	case FaxCompression:
				2496	{
				2497	compress_tag=COMPRESSION_CCITTFAX3;
				2498	SetQuantumMinIsWhite(quantum_info,MagickTrue);
				2499	break;
				2500	}
				2501	case Group4Compression:
				2502	{
				2503	compress_tag=COMPRESSION_CCITTFAX4;
				2504	SetQuantumMinIsWhite(quantum_info,MagickTrue);
				2505	break;
				2506	}
				2507	case JPEGCompression:
				2508	{
				2509	compress_tag=COMPRESSION_JPEG;
				2510	break;
				2511	}
				2512	case LZWCompression:
				2513	{
				2514	compress_tag=COMPRESSION_LZW;
				2515	break;
				2516	}
				2517	case RLECompression:
				2518	{
				2519	compress_tag=COMPRESSION_PACKBITS;
				2520	break;
				2521	}
				2522	case ZipCompression:
				2523	{
				2524	compress_tag=COMPRESSION_ADOBE_DEFLATE;
				2525	break;
				2526	}
				2527	case NoCompression:
				2528	default:
				2529	{
				2530	compress_tag=COMPRESSION_NONE;
				2531	break;
				2532	}
				2533	}
cristy	5b67587	2009-10-21 13:12:00 +0000	[diff] [blame]	2534	#if defined(MAGICKCORE_HAVE_TIFFISCODECCONFIGURED) \|\| (TIFFLIB_VERSION > 20040919)
				2535	if ((compress_tag != COMPRESSION_NONE) &&
				2536	(TIFFIsCODECConfigured(compress_tag) == 0))
cristy	3ed852e	2009-09-05 21:47:34 +0000	[diff] [blame]	2537	{
cristy	5b67587	2009-10-21 13:12:00 +0000	[diff] [blame]	2538	(void) ThrowMagickException(&image->exception,GetMagickModule(),
				2539	CoderError,"CompressionNotSupported","`%s'",MagickOptionToMnemonic(
				2540	MagickCompressOptions,(long) compression));
				2541	compress_tag=COMPRESSION_NONE;
				2542	compression=NoCompression;
cristy	3ed852e	2009-09-05 21:47:34 +0000	[diff] [blame]	2543	}
				2544	#else
				2545	switch (compress_tag)
				2546	{
				2547	#if defined(CCITT_SUPPORT)
				2548	case COMPRESSION_CCITTFAX3:
				2549	case COMPRESSION_CCITTFAX4:
				2550	#endif
				2551	#if defined(YCBCR_SUPPORT) && defined(JPEG_SUPPORT)
				2552	case COMPRESSION_JPEG:
				2553	#endif
				2554	#if defined(LZW_SUPPORT)
				2555	case COMPRESSION_LZW:
				2556	#endif
				2557	#if defined(PACKBITS_SUPPORT)
				2558	case COMPRESSION_PACKBITS:
				2559	#endif
				2560	#if defined(ZIP_SUPPORT)
				2561	case COMPRESSION_ADOBE_DEFLATE:
				2562	#endif
				2563	case COMPRESSION_NONE:
				2564	break;
				2565	default:
				2566	{
				2567	(void) ThrowMagickException(&image->exception,GetMagickModule(),
				2568	CoderError,"CompressionNotSupported","`%s'",MagickOptionToMnemonic(
				2569	MagickCompressOptions,(long) compression));
				2570	compress_tag=COMPRESSION_NONE;
				2571	compression=NoCompression;
				2572	break;
				2573	}
				2574	}
				2575	#endif
				2576	switch (compression)
				2577	{
				2578	case FaxCompression:
				2579	case Group4Compression:
				2580	{
				2581	(void) SetImageType(image,BilevelType);
				2582	break;
				2583	}
				2584	case JPEGCompression:
				2585	{
				2586	(void) SetImageStorageClass(image,DirectClass);
				2587	(void) SetImageDepth(image,8);
				2588	break;
				2589	}
				2590	default:
				2591	break;
				2592	}
cristy	3ed852e	2009-09-05 21:47:34 +0000	[diff] [blame]	2593	if (image->colorspace == CMYKColorspace)
				2594	{
				2595	photometric=PHOTOMETRIC_SEPARATED;
				2596	(void) TIFFSetField(tiff,TIFFTAG_SAMPLESPERPIXEL,4);
				2597	(void) TIFFSetField(tiff,TIFFTAG_INKSET,INKSET_CMYK);
				2598	}
				2599	else
				2600	{
				2601	/*
				2602	Full color TIFF raster.
				2603	*/
				2604	if (image->colorspace == LabColorspace)
				2605	photometric=PHOTOMETRIC_CIELAB;
				2606	else
				2607	if (image->colorspace == YCbCrColorspace)
				2608	{
				2609	photometric=PHOTOMETRIC_YCBCR;
				2610	(void) TIFFSetField(tiff,TIFFTAG_YCBCRSUBSAMPLING,1,1);
				2611	(void) SetImageDepth(image,8);
				2612	}
				2613	else
				2614	{
				2615	if (image->colorspace != RGBColorspace)
				2616	(void) TransformImageColorspace(image,RGBColorspace);
				2617	photometric=PHOTOMETRIC_RGB;
				2618	}
				2619	(void) TIFFSetField(tiff,TIFFTAG_SAMPLESPERPIXEL,3);
				2620	if ((image_info->type != TrueColorType) &&
				2621	(image_info->type != TrueColorMatteType))
				2622	{
cristy	94c8fe4	2009-10-06 01:57:36 +0000	[diff] [blame]	2623	if ((image_info->type != PaletteType) &&
				2624	(IsGrayImage(image,&image->exception) != MagickFalse))
cristy	3ed852e	2009-09-05 21:47:34 +0000	[diff] [blame]	2625	{
cristy	94c8fe4	2009-10-06 01:57:36 +0000	[diff] [blame]	2626	photometric=(uint16) (quantum_info->min_is_white !=
				2627	MagickFalse ? PHOTOMETRIC_MINISWHITE :
				2628	PHOTOMETRIC_MINISBLACK);
cristy	3ed852e	2009-09-05 21:47:34 +0000	[diff] [blame]	2629	(void) TIFFSetField(tiff,TIFFTAG_SAMPLESPERPIXEL,1);
cristy	94c8fe4	2009-10-06 01:57:36 +0000	[diff] [blame]	2630	if ((image_info->depth == 0) &&
				2631	(IsMonochromeImage(image,&image->exception) != MagickFalse))
				2632	{
				2633	status=SetQuantumDepth(image,quantum_info,1);
				2634	if (status == MagickFalse)
				2635	ThrowWriterException(ResourceLimitError,
				2636	"MemoryAllocationFailed");
				2637	}
cristy	3ed852e	2009-09-05 21:47:34 +0000	[diff] [blame]	2638	}
				2639	else
cristy	94c8fe4	2009-10-06 01:57:36 +0000	[diff] [blame]	2640	if (image->storage_class == PseudoClass)
cristy	3ed852e	2009-09-05 21:47:34 +0000	[diff] [blame]	2641	{
cristy	94c8fe4	2009-10-06 01:57:36 +0000	[diff] [blame]	2642	unsigned long
				2643	depth;
				2644
				2645	/*
				2646	Colormapped TIFF raster.
				2647	*/
cristy	3ed852e	2009-09-05 21:47:34 +0000	[diff] [blame]	2648	(void) TIFFSetField(tiff,TIFFTAG_SAMPLESPERPIXEL,1);
cristy	94c8fe4	2009-10-06 01:57:36 +0000	[diff] [blame]	2649	photometric=PHOTOMETRIC_PALETTE;
				2650	depth=1;
				2651	while ((GetQuantumRange(depth)+1) < image->colors)
				2652	depth<<=1;
				2653	status=SetQuantumDepth(image,quantum_info,depth);
				2654	if (status == MagickFalse)
				2655	ThrowWriterException(ResourceLimitError,
				2656	"MemoryAllocationFailed");
cristy	3ed852e	2009-09-05 21:47:34 +0000	[diff] [blame]	2657	}
				2658	}
				2659	}
cristy	0accf6e	2009-10-01 13:14:28 +0000	[diff] [blame]	2660	switch (image->endian)
				2661	{
				2662	case LSBEndian:
				2663	{
				2664	endian=FILLORDER_LSB2MSB;
				2665	break;
				2666	}
				2667	case MSBEndian:
				2668	{
				2669	endian=FILLORDER_MSB2LSB;
				2670	break;
				2671	}
				2672	case UndefinedEndian:
				2673	default:
				2674	{
				2675	(void) TIFFGetFieldDefaulted(tiff,TIFFTAG_FILLORDER,&endian);
				2676	break;
				2677	}
				2678	}
				2679	lsb_first=1;
				2680	image->endian=MSBEndian;
				2681	if ((int) ((char ) &lsb_first) != 0)
				2682	image->endian=LSBEndian;
				2683	if ((compress_tag == COMPRESSION_JPEG) && (photometric != PHOTOMETRIC_RGB))
				2684	compress_tag=COMPRESSION_NONE;
				2685	else
				2686	if ((compress_tag == COMPRESSION_CCITTFAX3) &&
				2687	(photometric != PHOTOMETRIC_MINISWHITE))
				2688	{
				2689	compress_tag=COMPRESSION_NONE;
				2690	endian=FILLORDER_MSB2LSB;
				2691	}
				2692	else
				2693	if ((compress_tag == COMPRESSION_CCITTFAX4) &&
				2694	(photometric != PHOTOMETRIC_MINISWHITE))
				2695	{
				2696	compress_tag=COMPRESSION_NONE;
				2697	endian=FILLORDER_MSB2LSB;
				2698	}
				2699	(void) TIFFSetField(tiff,TIFFTAG_COMPRESSION,compress_tag);
				2700	(void) TIFFSetField(tiff,TIFFTAG_FILLORDER,endian);
cristy	3ed852e	2009-09-05 21:47:34 +0000	[diff] [blame]	2701	(void) TIFFSetField(tiff,TIFFTAG_BITSPERSAMPLE,quantum_info->depth);
				2702	if (image->matte != MagickFalse)
				2703	{
				2704	uint16
				2705	extra_samples,
				2706	sample_info[1],
				2707	samples_per_pixel;
				2708
				2709	/*
				2710	TIFF has a matte channel.
				2711	*/
				2712	extra_samples=1;
				2713	sample_info[0]=EXTRASAMPLE_UNASSALPHA;
				2714	option=GetImageProperty(image,"tiff:alpha");
				2715	if ((option != (const char *) NULL) &&
				2716	(LocaleCompare(option,"associated") == 0))
				2717	sample_info[0]=EXTRASAMPLE_ASSOCALPHA;
				2718	(void) TIFFGetFieldDefaulted(tiff,TIFFTAG_SAMPLESPERPIXEL,
				2719	&samples_per_pixel);
				2720	(void) TIFFSetField(tiff,TIFFTAG_SAMPLESPERPIXEL,samples_per_pixel+1);
				2721	(void) TIFFSetField(tiff,TIFFTAG_EXTRASAMPLES,extra_samples,
				2722	&sample_info);
				2723	if (sample_info[0] == EXTRASAMPLE_ASSOCALPHA)
				2724	SetQuantumAlphaType(quantum_info,AssociatedQuantumAlpha);
				2725	}
				2726	(void) TIFFSetField(tiff,TIFFTAG_PHOTOMETRIC,photometric);
				2727	switch (quantum_info->format)
				2728	{
				2729	case FloatingPointQuantumFormat:
				2730	{
				2731	(void) TIFFSetField(tiff,TIFFTAG_SAMPLEFORMAT,SAMPLEFORMAT_IEEEFP);
				2732	(void) TIFFSetField(tiff,TIFFTAG_SMINSAMPLEVALUE,quantum_info->minimum);
				2733	(void) TIFFSetField(tiff,TIFFTAG_SMAXSAMPLEVALUE,quantum_info->maximum);
				2734	break;
				2735	}
				2736	case SignedQuantumFormat:
				2737	{
				2738	(void) TIFFSetField(tiff,TIFFTAG_SAMPLEFORMAT,SAMPLEFORMAT_INT);
				2739	break;
				2740	}
				2741	case UnsignedQuantumFormat:
				2742	{
				2743	(void) TIFFSetField(tiff,TIFFTAG_SAMPLEFORMAT,SAMPLEFORMAT_UINT);
				2744	break;
				2745	}
				2746	default:
				2747	break;
				2748	}
cristy	3ed852e	2009-09-05 21:47:34 +0000	[diff] [blame]	2749	(void) TIFFSetField(tiff,TIFFTAG_ORIENTATION,ORIENTATION_TOPLEFT);
				2750	(void) TIFFSetField(tiff,TIFFTAG_PLANARCONFIG,PLANARCONFIG_CONTIG);
				2751	if (photometric == PHOTOMETRIC_RGB)
				2752	if ((image_info->interlace == PlaneInterlace) \|\|
				2753	(image_info->interlace == PartitionInterlace))
				2754	(void) TIFFSetField(tiff,TIFFTAG_PLANARCONFIG,PLANARCONFIG_SEPARATE);
				2755	rows_per_strip=1;
				2756	if (TIFFScanlineSize(tiff) != 0)
				2757	rows_per_strip=(unsigned long) MagickMax((size_t)
				2758	TIFFDefaultStripSize(tiff,-1),1);
				2759	option=GetImageOption(image_info,"tiff:rows-per-strip");
				2760	if (option != (const char *) NULL)
				2761	rows_per_strip=(unsigned long) strtol(option,(char **) NULL,10);
				2762	switch (compress_tag)
				2763	{
				2764	case COMPRESSION_JPEG:
				2765	{
				2766	#if defined(JPEG_SUPPORT)
				2767	const char
				2768	*sampling_factor;
				2769
				2770	GeometryInfo
				2771	geometry_info;
				2772
				2773	MagickStatusType
				2774	flags;
				2775
				2776	rows_per_strip+=(16-(rows_per_strip % 16));
				2777	if (image->quality != 0)
				2778	(void) TIFFSetField(tiff,TIFFTAG_JPEGQUALITY,image->quality);
				2779	if (image_info->quality != UndefinedCompressionQuality)
				2780	(void) TIFFSetField(tiff,TIFFTAG_JPEGQUALITY,image_info->quality);
				2781	(void) TIFFSetField(tiff,TIFFTAG_JPEGCOLORMODE,JPEGCOLORMODE_RAW);
				2782	if (image->colorspace == RGBColorspace)
				2783	{
				2784	(void) TIFFSetField(tiff,TIFFTAG_JPEGCOLORMODE,JPEGCOLORMODE_RGB);
				2785	sampling_factor=(const char *) NULL;
				2786	value=GetImageProperty(image,"jpeg:sampling-factor");
				2787	if (value != (char *) NULL)
				2788	{
				2789	sampling_factor=value;
				2790	if (image->debug != MagickFalse)
				2791	(void) LogMagickEvent(CoderEvent,GetMagickModule(),
				2792	" Input sampling-factors=%s",sampling_factor);
				2793	}
				2794	if (image_info->sampling_factor != (char *) NULL)
				2795	sampling_factor=image_info->sampling_factor;
				2796	if (sampling_factor != (const char *) NULL)
				2797	{
				2798	flags=ParseGeometry(sampling_factor,&geometry_info);
				2799	if ((flags & SigmaValue) == 0)
				2800	geometry_info.sigma=geometry_info.rho;
				2801	(void) TIFFSetField(tiff,TIFFTAG_YCBCRSUBSAMPLING,(uint16)
				2802	geometry_info.rho,(uint16) geometry_info.sigma);
				2803	}
				2804	}
				2805	if (bits_per_sample == 12)
				2806	(void) TIFFSetField(tiff,TIFFTAG_JPEGTABLESMODE,JPEGTABLESMODE_QUANT);
				2807	#endif
				2808	break;
				2809	}
				2810	case COMPRESSION_ADOBE_DEFLATE:
				2811	{
				2812	rows_per_strip=image->rows;
				2813	(void) TIFFGetFieldDefaulted(tiff,TIFFTAG_BITSPERSAMPLE,
				2814	&bits_per_sample);
				2815	if (((photometric == PHOTOMETRIC_RGB) \|\|
				2816	(photometric == PHOTOMETRIC_MINISBLACK)) &&
				2817	((bits_per_sample == 8) \|\| (bits_per_sample == 16)))
				2818	(void) TIFFSetField(tiff,TIFFTAG_PREDICTOR,2);
				2819	(void) TIFFSetField(tiff,TIFFTAG_ZIPQUALITY,image_info->quality ==
				2820	UndefinedCompressionQuality ? 7 : MagickMin(1L*image_info->quality/10,
				2821	9));
				2822	break;
				2823	}
				2824	case COMPRESSION_CCITTFAX3:
				2825	{
				2826	/*
				2827	Byte-aligned EOL.
				2828	*/
				2829	rows_per_strip=image->rows;
				2830	(void) TIFFSetField(tiff,TIFFTAG_GROUP3OPTIONS,4);
				2831	break;
				2832	}
				2833	case COMPRESSION_CCITTFAX4:
				2834	{
				2835	rows_per_strip=image->rows;
				2836	break;
				2837	}
				2838	case COMPRESSION_LZW:
				2839	{
				2840	(void) TIFFGetFieldDefaulted(tiff,TIFFTAG_BITSPERSAMPLE,
				2841	&bits_per_sample);
				2842	if (((photometric == PHOTOMETRIC_RGB) \|\|
				2843	(photometric == PHOTOMETRIC_MINISBLACK)) &&
				2844	((bits_per_sample == 8) \|\| (bits_per_sample == 16)))
				2845	(void) TIFFSetField(tiff,TIFFTAG_PREDICTOR,2);
				2846	break;
				2847	}
				2848	default:
				2849	break;
				2850	}
				2851	(void) TIFFSetField(tiff,TIFFTAG_ROWSPERSTRIP,rows_per_strip);
				2852	if ((image->x_resolution != 0.0) && (image->y_resolution != 0.0))
				2853	{
				2854	unsigned short
				2855	units;
				2856
				2857	/*
				2858	Set image resolution.
				2859	*/
				2860	units=RESUNIT_NONE;
				2861	if (image->units == PixelsPerInchResolution)
				2862	units=RESUNIT_INCH;
				2863	if (image->units == PixelsPerCentimeterResolution)
				2864	units=RESUNIT_CENTIMETER;
				2865	(void) TIFFSetField(tiff,TIFFTAG_RESOLUTIONUNIT,(uint16) units);
				2866	(void) TIFFSetField(tiff,TIFFTAG_XRESOLUTION,image->x_resolution);
				2867	(void) TIFFSetField(tiff,TIFFTAG_YRESOLUTION,image->y_resolution);
				2868	if ((image->page.x != 0) \|\| (image->page.y != 0))
				2869	{
				2870	/*
				2871	Set image position.
				2872	*/
				2873	(void) TIFFSetField(tiff,TIFFTAG_XPOSITION,(float) image->page.x/
				2874	image->x_resolution);
				2875	(void) TIFFSetField(tiff,TIFFTAG_YPOSITION,(float) image->page.y/
				2876	image->y_resolution);
				2877	}
				2878	}
				2879	if (image->chromaticity.white_point.x != 0.0)
				2880	{
				2881	float
				2882	chromaticity[6];
				2883
				2884	/*
				2885	Set image chromaticity.
				2886	*/
				2887	chromaticity[0]=(float) image->chromaticity.red_primary.x;
				2888	chromaticity[1]=(float) image->chromaticity.red_primary.y;
				2889	chromaticity[2]=(float) image->chromaticity.green_primary.x;
				2890	chromaticity[3]=(float) image->chromaticity.green_primary.y;
				2891	chromaticity[4]=(float) image->chromaticity.blue_primary.x;
				2892	chromaticity[5]=(float) image->chromaticity.blue_primary.y;
				2893	(void) TIFFSetField(tiff,TIFFTAG_PRIMARYCHROMATICITIES,chromaticity);
				2894	chromaticity[0]=(float) image->chromaticity.white_point.x;
				2895	chromaticity[1]=(float) image->chromaticity.white_point.y;
				2896	(void) TIFFSetField(tiff,TIFFTAG_WHITEPOINT,chromaticity);
				2897	}
				2898	if ((image_info->adjoin != MagickFalse) && (GetImageListLength(image) > 1))
				2899	{
				2900	(void) TIFFSetField(tiff,TIFFTAG_SUBFILETYPE,FILETYPE_PAGE);
				2901	if (image->scene != 0)
				2902	(void) TIFFSetField(tiff,TIFFTAG_PAGENUMBER,(uint16) image->scene,
				2903	GetImageListLength(image));
				2904	}
				2905	if (image->orientation != UndefinedOrientation)
				2906	(void) TIFFSetField(tiff,TIFFTAG_ORIENTATION,(uint16) image->orientation);
				2907	(void) TIFFSetProfiles(tiff,image);
				2908	{
				2909	uint16
				2910	page,
				2911	pages;
				2912
				2913	page=(uint16) scene;
				2914	pages=GetImageListLength(image);
				2915	if ((image_info->adjoin != MagickFalse) && (pages > 1))
				2916	(void) TIFFSetField(tiff,TIFFTAG_SUBFILETYPE,FILETYPE_PAGE);
				2917	(void) TIFFSetField(tiff,TIFFTAG_PAGENUMBER,page,pages);
				2918	}
				2919	(void) TIFFSetProperties(tiff,image);
				2920	if (0)
				2921	(void) TIFFSetEXIFProperties(tiff,image);
				2922	/*
				2923	Write image scanlines.
				2924	*/
				2925	if (GetTIFFInfo(image_info,tiff,&tiff_info) == MagickFalse)
				2926	ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
				2927	pixels=GetQuantumPixels(quantum_info);
				2928	tiff_info.scanline=GetQuantumPixels(quantum_info);
				2929	switch (photometric)
				2930	{
				2931	case PHOTOMETRIC_CIELAB:
				2932	case PHOTOMETRIC_YCBCR:
				2933	case PHOTOMETRIC_RGB:
				2934	{
				2935	/*
				2936	RGB TIFF image.
				2937	*/
				2938	switch (image_info->interlace)
				2939	{
				2940	case NoInterlace:
				2941	default:
				2942	{
				2943	quantum_type=RGBQuantum;
				2944	if (image->matte != MagickFalse)
				2945	quantum_type=RGBAQuantum;
				2946	for (y=0; y < (long) image->rows; y++)
				2947	{
				2948	register const PixelPacket
				2949	*__restrict p;
				2950
				2951	p=GetVirtualPixels(image,0,y,image->columns,1,
				2952	&image->exception);
				2953	if (p == (const PixelPacket *) NULL)
				2954	break;
				2955	length=ExportQuantumPixels(image,(const CacheView *) NULL,
				2956	quantum_info,quantum_type,pixels,&image->exception);
				2957	if (TIFFWritePixels(tiff,&tiff_info,y,0,image) == -1)
				2958	break;
				2959	if (image->previous == (Image *) NULL)
				2960	{
				2961	status=SetImageProgress(image,SaveImageTag,y,image->rows);
				2962	if (status == MagickFalse)
				2963	break;
				2964	}
				2965	}
				2966	break;
				2967	}
				2968	case PlaneInterlace:
				2969	case PartitionInterlace:
				2970	{
				2971	/*
				2972	Plane interlacing: RRRRRR...GGGGGG...BBBBBB...
				2973	*/
				2974	for (y=0; y < (long) image->rows; y++)
				2975	{
				2976	register const PixelPacket
				2977	*__restrict p;
				2978
				2979	p=GetVirtualPixels(image,0,y,image->columns,1,
				2980	&image->exception);
				2981	if (p == (const PixelPacket *) NULL)
				2982	break;
				2983	length=ExportQuantumPixels(image,(const CacheView *) NULL,
				2984	quantum_info,RedQuantum,pixels,&image->exception);
				2985	if (TIFFWritePixels(tiff,&tiff_info,y,0,image) == -1)
				2986	break;
				2987	}
				2988	if (image->previous == (Image *) NULL)
				2989	{
				2990	status=SetImageProgress(image,SaveImageTag,100,400);
				2991	if (status == MagickFalse)
				2992	break;
				2993	}
				2994	for (y=0; y < (long) image->rows; y++)
				2995	{
				2996	register const PixelPacket
				2997	*__restrict p;
				2998
				2999	p=GetVirtualPixels(image,0,y,image->columns,1,
				3000	&image->exception);
				3001	if (p == (const PixelPacket *) NULL)
				3002	break;
				3003	length=ExportQuantumPixels(image,(const CacheView *) NULL,
				3004	quantum_info,GreenQuantum,pixels,&image->exception);
				3005	if (TIFFWritePixels(tiff,&tiff_info,y,1,image) == -1)
				3006	break;
				3007	}
				3008	if (image->previous == (Image *) NULL)
				3009	{
				3010	status=SetImageProgress(image,SaveImageTag,200,400);
				3011	if (status == MagickFalse)
				3012	break;
				3013	}
				3014	for (y=0; y < (long) image->rows; y++)
				3015	{
				3016	register const PixelPacket
				3017	*__restrict p;
				3018
				3019	p=GetVirtualPixels(image,0,y,image->columns,1,
				3020	&image->exception);
				3021	if (p == (const PixelPacket *) NULL)
				3022	break;
				3023	length=ExportQuantumPixels(image,(const CacheView *) NULL,
				3024	quantum_info,BlueQuantum,pixels,&image->exception);
				3025	if (TIFFWritePixels(tiff,&tiff_info,y,2,image) == -1)
				3026	break;
				3027	}
				3028	if (image->previous == (Image *) NULL)
				3029	{
				3030	status=SetImageProgress(image,SaveImageTag,300,400);
				3031	if (status == MagickFalse)
				3032	break;
				3033	}
				3034	if (image->matte != MagickFalse)
				3035	for (y=0; y < (long) image->rows; y++)
				3036	{
				3037	register const PixelPacket
				3038	*__restrict p;
				3039
				3040	p=GetVirtualPixels(image,0,y,image->columns,1,
				3041	&image->exception);
				3042	if (p == (const PixelPacket *) NULL)
				3043	break;
				3044	length=ExportQuantumPixels(image,(const CacheView *) NULL,
				3045	quantum_info,AlphaQuantum,pixels,&image->exception);
				3046	if (TIFFWritePixels(tiff,&tiff_info,y,3,image) == -1)
				3047	break;
				3048	}
				3049	if (image->previous == (Image *) NULL)
				3050	{
				3051	status=SetImageProgress(image,SaveImageTag,400,400);
				3052	if (status == MagickFalse)
				3053	break;
				3054	}
				3055	break;
				3056	}
				3057	}
				3058	break;
				3059	}
				3060	case PHOTOMETRIC_SEPARATED:
				3061	{
				3062	/*
				3063	CMYK TIFF image.
				3064	*/
				3065	quantum_type=CMYKQuantum;
				3066	if (image->matte != MagickFalse)
				3067	quantum_type=CMYKAQuantum;
				3068	if (image->colorspace != CMYKColorspace)
				3069	(void) TransformImageColorspace(image,CMYKColorspace);
				3070	for (y=0; y < (long) image->rows; y++)
				3071	{
				3072	register const PixelPacket
				3073	*__restrict p;
				3074
				3075	p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
				3076	if (p == (const PixelPacket *) NULL)
				3077	break;
				3078	length=ExportQuantumPixels(image,(const CacheView *) NULL,
				3079	quantum_info,quantum_type,pixels,&image->exception);
				3080	if (TIFFWritePixels(tiff,&tiff_info,y,0,image) == -1)
				3081	break;
				3082	if (image->previous == (Image *) NULL)
				3083	{
				3084	status=SetImageProgress(image,SaveImageTag,y,image->rows);
				3085	if (status == MagickFalse)
				3086	break;
				3087	}
				3088	}
				3089	break;
				3090	}
				3091	case PHOTOMETRIC_PALETTE:
				3092	{
				3093	uint16
				3094	*blue,
				3095	*green,
				3096	*red;
				3097
				3098	/*
				3099	Colormapped TIFF image.
				3100	*/
				3101	red=(uint16 ) AcquireQuantumMemory(65536,sizeof(red));
				3102	green=(uint16 ) AcquireQuantumMemory(65536,sizeof(green));
				3103	blue=(uint16 ) AcquireQuantumMemory(65536,sizeof(blue));
				3104	if ((red == (uint16 ) NULL) \|\| (green == (uint16 ) NULL) \|\|
				3105	(blue == (uint16 *) NULL))
				3106	ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
				3107	/*
				3108	Initialize TIFF colormap.
				3109	*/
				3110	(void) ResetMagickMemory(red,0,65536sizeof(red));
				3111	(void) ResetMagickMemory(green,0,65536sizeof(green));
				3112	(void) ResetMagickMemory(blue,0,65536sizeof(blue));
				3113	for (i=0; i < (long) image->colors; i++)
				3114	{
				3115	red[i]=ScaleQuantumToShort(image->colormap[i].red);
				3116	green[i]=ScaleQuantumToShort(image->colormap[i].green);
				3117	blue[i]=ScaleQuantumToShort(image->colormap[i].blue);
				3118	}
				3119	(void) TIFFSetField(tiff,TIFFTAG_COLORMAP,red,green,blue);
				3120	red=(uint16 *) RelinquishMagickMemory(red);
				3121	green=(uint16 *) RelinquishMagickMemory(green);
				3122	blue=(uint16 *) RelinquishMagickMemory(blue);
				3123	}
				3124	default:
				3125	{
				3126	/*
				3127	Convert PseudoClass packets to contiguous grayscale scanlines.
				3128	*/
				3129	quantum_type=IndexQuantum;
				3130	if (image->matte != MagickFalse)
				3131	{
				3132	if (photometric != PHOTOMETRIC_PALETTE)
				3133	quantum_type=GrayAlphaQuantum;
				3134	else
				3135	quantum_type=IndexAlphaQuantum;
				3136	}
				3137	else
				3138	if (photometric != PHOTOMETRIC_PALETTE)
				3139	quantum_type=GrayQuantum;
				3140	for (y=0; y < (long) image->rows; y++)
				3141	{
				3142	register const PixelPacket
				3143	*__restrict p;
				3144
				3145	p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
				3146	if (p == (const PixelPacket *) NULL)
				3147	break;
				3148	length=ExportQuantumPixels(image,(const CacheView *) NULL,
				3149	quantum_info,quantum_type,pixels,&image->exception);
				3150	if (TIFFWritePixels(tiff,&tiff_info,y,0,image) == -1)
				3151	break;
				3152	if (image->previous == (Image *) NULL)
				3153	{
				3154	status=SetImageProgress(image,SaveImageTag,y,image->rows);
				3155	if (status == MagickFalse)
				3156	break;
				3157	}
				3158	}
				3159	break;
				3160	}
				3161	}
				3162	quantum_info=DestroyQuantumInfo(quantum_info);
				3163	DestroyTIFFInfo(&tiff_info);
				3164	if (0 && (image_info->verbose == MagickTrue))
				3165	TIFFPrintDirectory(tiff,stdout,MagickFalse);
				3166	(void) TIFFWriteDirectory(tiff);
				3167	image->endian=MSBEndian;
				3168	if (endian == FILLORDER_LSB2MSB)
				3169	image->endian=LSBEndian;
				3170	image=SyncNextImageInList(image);
				3171	if (image == (Image *) NULL)
				3172	break;
				3173	status=SetImageProgress(image,SaveImagesTag,scene++,
				3174	GetImageListLength(image));
				3175	if (status == MagickFalse)
				3176	break;
				3177	} while (image_info->adjoin != MagickFalse);
				3178	(void) TIFFSetWarningHandler(warning_handler);
				3179	(void) TIFFSetErrorHandler(error_handler);
				3180	TIFFClose(tiff);
				3181	return(MagickTrue);
				3182	}
				3183	#endif