% July 1992 %
% %
% %
-% Copyright 1999-2010 ImageMagick Studio LLC, a non-profit organization %
+% Copyright 1999-2011 ImageMagick Studio LLC, a non-profit organization %
% dedicated to making software imaging solutions freely available. %
% %
% You may not use this file except in compliance with the License. You may %
/*
Include declarations.
*/
-#include "magick/studio.h"
-#include "magick/attribute.h"
-#include "magick/blob.h"
-#include "magick/blob-private.h"
-#include "magick/cache.h"
-#include "magick/color.h"
-#include "magick/color-private.h"
-#include "magick/colormap.h"
-#include "magick/colorspace.h"
-#include "magick/constitute.h"
-#include "magick/enhance.h"
-#include "magick/exception.h"
-#include "magick/exception-private.h"
-#include "magick/geometry.h"
-#include "magick/image.h"
-#include "magick/image-private.h"
-#include "magick/list.h"
-#include "magick/log.h"
-#include "magick/magick.h"
-#include "magick/memory_.h"
-#include "magick/module.h"
-#include "magick/monitor.h"
-#include "magick/monitor-private.h"
-#include "magick/option.h"
-#include "magick/property.h"
-#include "magick/quantum.h"
-#include "magick/quantum-private.h"
-#include "magick/profile.h"
-#include "magick/resize.h"
-#include "magick/resource_.h"
-#include "magick/semaphore.h"
-#include "magick/splay-tree.h"
-#include "magick/static.h"
-#include "magick/statistic.h"
-#include "magick/string_.h"
-#include "magick/string-private.h"
-#include "magick/thread_.h"
-#include "magick/utility.h"
+#include "MagickCore/studio.h"
+#include "MagickCore/attribute.h"
+#include "MagickCore/blob.h"
+#include "MagickCore/blob-private.h"
+#include "MagickCore/cache.h"
+#include "MagickCore/color.h"
+#include "MagickCore/color-private.h"
+#include "MagickCore/colormap.h"
+#include "MagickCore/colorspace.h"
+#include "MagickCore/colorspace-private.h"
+#include "MagickCore/constitute.h"
+#include "MagickCore/enhance.h"
+#include "MagickCore/exception.h"
+#include "MagickCore/exception-private.h"
+#include "MagickCore/geometry.h"
+#include "MagickCore/image.h"
+#include "MagickCore/image-private.h"
+#include "MagickCore/list.h"
+#include "MagickCore/log.h"
+#include "MagickCore/magick.h"
+#include "MagickCore/memory_.h"
+#include "MagickCore/module.h"
+#include "MagickCore/monitor.h"
+#include "MagickCore/monitor-private.h"
+#include "MagickCore/option.h"
+#include "MagickCore/pixel-accessor.h"
+#include "MagickCore/property.h"
+#include "MagickCore/quantum.h"
+#include "MagickCore/quantum-private.h"
+#include "MagickCore/profile.h"
+#include "MagickCore/resize.h"
+#include "MagickCore/resource_.h"
+#include "MagickCore/semaphore.h"
+#include "MagickCore/splay-tree.h"
+#include "MagickCore/static.h"
+#include "MagickCore/statistic.h"
+#include "MagickCore/string_.h"
+#include "MagickCore/string-private.h"
+#include "MagickCore/thread_.h"
+#include "MagickCore/utility.h"
#if defined(MAGICKCORE_TIFF_DELEGATE)
# if defined(MAGICKCORE_HAVE_TIFFCONF_H)
# include "tiffconf.h"
-#endif
+# endif
# include "tiff.h"
# include "tiffio.h"
# if !defined(COMPRESSION_ADOBE_DEFLATE)
# define COMPRESSION_ADOBE_DEFLATE 8
# endif
+# if !defined(PREDICTOR_HORIZONTAL)
+# define PREDICTOR_HORIZONTAL 2
+# endif
+# if !defined(TIFFTAG_COPYRIGHT)
+# define TIFFTAG_COPYRIGHT 33432
+# endif
+# if !defined(TIFFTAG_OPIIMAGEID)
+# define TIFF_OPIIMAGEID 32781
+# endif
\f
/*
Typedef declarations.
{ EXIFTAG_EXPOSUREPROGRAM, TIFF_SHORT, "exif:ExposureProgram" },
{ EXIFTAG_SPECTRALSENSITIVITY, TIFF_ASCII, "exif:SpectralSensitivity" },
{ EXIFTAG_ISOSPEEDRATINGS, TIFF_SHORT, "exif:ISOSpeedRatings" },
- { EXIFTAG_OECF, TIFF_UNDEFINED, "exif:OptoelectricConversionFactor" },
- { EXIFTAG_EXIFVERSION, TIFF_UNDEFINED, "exif:ExifVersion" },
+ { EXIFTAG_OECF, TIFF_NOTYPE, "exif:OptoelectricConversionFactor" },
+ { EXIFTAG_EXIFVERSION, TIFF_NOTYPE, "exif:ExifVersion" },
{ EXIFTAG_DATETIMEORIGINAL, TIFF_ASCII, "exif:DateTimeOriginal" },
{ EXIFTAG_DATETIMEDIGITIZED, TIFF_ASCII, "exif:DateTimeDigitized" },
- { EXIFTAG_COMPONENTSCONFIGURATION, TIFF_UNDEFINED, "exif:ComponentsConfiguration" },
+ { EXIFTAG_COMPONENTSCONFIGURATION, TIFF_NOTYPE, "exif:ComponentsConfiguration" },
{ EXIFTAG_COMPRESSEDBITSPERPIXEL, TIFF_RATIONAL, "exif:CompressedBitsPerPixel" },
{ EXIFTAG_SHUTTERSPEEDVALUE, TIFF_SRATIONAL, "exif:ShutterSpeedValue" },
{ EXIFTAG_APERTUREVALUE, TIFF_RATIONAL, "exif:ApertureValue" },
{ EXIFTAG_LIGHTSOURCE, TIFF_SHORT, "exif:LightSource" },
{ EXIFTAG_FLASH, TIFF_SHORT, "exif:Flash" },
{ EXIFTAG_FOCALLENGTH, TIFF_RATIONAL, "exif:FocalLength" },
- /* { EXIFTAG_SUBJECTAREA, TIFF_SHORT, "exif:SubjectArea" }, */
- { EXIFTAG_MAKERNOTE, TIFF_UNDEFINED, "exif:MakerNote" },
- { EXIFTAG_USERCOMMENT, TIFF_UNDEFINED, "exif:UserComment" },
+ { EXIFTAG_SUBJECTAREA, TIFF_NOTYPE, "exif:SubjectArea" },
+ { EXIFTAG_MAKERNOTE, TIFF_NOTYPE, "exif:MakerNote" },
+ { EXIFTAG_USERCOMMENT, TIFF_NOTYPE, "exif:UserComment" },
{ EXIFTAG_SUBSECTIME, TIFF_ASCII, "exif:SubSecTime" },
{ EXIFTAG_SUBSECTIMEORIGINAL, TIFF_ASCII, "exif:SubSecTimeOriginal" },
{ EXIFTAG_SUBSECTIMEDIGITIZED, TIFF_ASCII, "exif:SubSecTimeDigitized" },
- { EXIFTAG_FLASHPIXVERSION, TIFF_UNDEFINED, "exif:FlashpixVersion" },
+ { EXIFTAG_FLASHPIXVERSION, TIFF_NOTYPE, "exif:FlashpixVersion" },
{ EXIFTAG_PIXELXDIMENSION, TIFF_LONG, "exif:PixelXDimension" },
{ EXIFTAG_PIXELXDIMENSION, TIFF_SHORT, "exif:PixelXDimension" },
{ EXIFTAG_PIXELYDIMENSION, TIFF_LONG, "exif:PixelYDimension" },
{ EXIFTAG_PIXELYDIMENSION, TIFF_SHORT, "exif:PixelYDimension" },
{ EXIFTAG_RELATEDSOUNDFILE, TIFF_ASCII, "exif:RelatedSoundFile" },
{ EXIFTAG_FLASHENERGY, TIFF_RATIONAL, "exif:FlashEnergy" },
- { EXIFTAG_SPATIALFREQUENCYRESPONSE, TIFF_UNDEFINED, "exif:SpatialFrequencyResponse" },
+ { EXIFTAG_SPATIALFREQUENCYRESPONSE, TIFF_NOTYPE, "exif:SpatialFrequencyResponse" },
{ EXIFTAG_FOCALPLANEXRESOLUTION, TIFF_RATIONAL, "exif:FocalPlaneXResolution" },
{ EXIFTAG_FOCALPLANEYRESOLUTION, TIFF_RATIONAL, "exif:FocalPlaneYResolution" },
{ EXIFTAG_FOCALPLANERESOLUTIONUNIT, TIFF_SHORT, "exif:FocalPlaneResolutionUnit" },
{ EXIFTAG_SUBJECTLOCATION, TIFF_SHORT, "exif:SubjectLocation" },
{ EXIFTAG_EXPOSUREINDEX, TIFF_RATIONAL, "exif:ExposureIndex" },
{ EXIFTAG_SENSINGMETHOD, TIFF_SHORT, "exif:SensingMethod" },
- { EXIFTAG_FILESOURCE, TIFF_UNDEFINED, "exif:FileSource" },
- { EXIFTAG_SCENETYPE, TIFF_UNDEFINED, "exif:SceneType" },
- { EXIFTAG_CFAPATTERN, TIFF_UNDEFINED, "exif:CFAPattern" },
+ { EXIFTAG_FILESOURCE, TIFF_NOTYPE, "exif:FileSource" },
+ { EXIFTAG_SCENETYPE, TIFF_NOTYPE, "exif:SceneType" },
+ { EXIFTAG_CFAPATTERN, TIFF_NOTYPE, "exif:CFAPattern" },
{ EXIFTAG_CUSTOMRENDERED, TIFF_SHORT, "exif:CustomRendered" },
{ EXIFTAG_EXPOSUREMODE, TIFF_SHORT, "exif:ExposureMode" },
{ EXIFTAG_WHITEBALANCE, TIFF_SHORT, "exif:WhiteBalance" },
{ EXIFTAG_CONTRAST, TIFF_SHORT, "exif:Contrast" },
{ EXIFTAG_SATURATION, TIFF_SHORT, "exif:Saturation" },
{ EXIFTAG_SHARPNESS, TIFF_SHORT, "exif:Sharpness" },
- { EXIFTAG_DEVICESETTINGDESCRIPTION, TIFF_UNDEFINED, "exif:DeviceSettingDescription" },
+ { EXIFTAG_DEVICESETTINGDESCRIPTION, TIFF_NOTYPE, "exif:DeviceSettingDescription" },
{ EXIFTAG_SUBJECTDISTANCERANGE, TIFF_SHORT, "exif:SubjectDistanceRange" },
{ EXIFTAG_IMAGEUNIQUEID, TIFF_ASCII, "exif:ImageUniqueID" },
{ 0, 0, (char *) NULL }
};
#endif
+#endif /* MAGICKCORE_TIFF_DELEGATE */
\f
/*
Global declarations.
static volatile MagickBooleanType
instantiate_key = MagickFalse;
-#endif
\f
/*
Forward declarations.
ReadTIFFImage(const ImageInfo *,ExceptionInfo *);
static MagickBooleanType
- WriteGROUP4Image(const ImageInfo *,Image *),
- WritePTIFImage(const ImageInfo *,Image *),
- WriteTIFFImage(const ImageInfo *,Image *);
+ WriteGROUP4Image(const ImageInfo *,Image *,ExceptionInfo *),
+ WritePTIFImage(const ImageInfo *,Image *,ExceptionInfo *),
+ WriteTIFFImage(const ImageInfo *,Image *,ExceptionInfo *);
#endif
\f
/*
image_info->filename);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
- image=AcquireImage(image_info);
+ image=AcquireImage(image_info,exception);
status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
if (status == MagickFalse)
{
length=WriteLSBLong(file,(size_t) (strip_offset-8));
length=fwrite("\050\001\003\000\001\000\000\000\002\000\000\000",1,12,file);
length=fwrite("\000\000\000\000",1,4,file);
- length=WriteLSBLong(file,image->x_resolution);
+ length=WriteLSBLong(file,(long) image->resolution.x);
length=WriteLSBLong(file,1);
for (length=0; (c=ReadBlobByte(image)) != EOF; length++)
(void) fputc(c,file);
Read TIFF image.
*/
read_info=CloneImageInfo((ImageInfo *) NULL);
- (void) FormatMagickString(read_info->filename,MaxTextExtent,"%.1024s",
- filename);
+ (void) FormatLocaleString(read_info->filename,MaxTextExtent,"%s",filename);
image=ReadTIFFImage(read_info,exception);
read_info=DestroyImageInfo(read_info);
if (image != (Image *) NULL)
}
static MagickBooleanType ReadProfile(Image *image,const char *name,
- unsigned char *datum,ssize_t length)
+ unsigned char *datum,ssize_t length,ExceptionInfo *exception)
{
MagickBooleanType
status;
if (length < 4)
return(MagickFalse);
}
- profile=AcquireStringInfo((size_t) length);
- SetStringInfoDatum(profile,datum+i);
- status=SetImageProfile(image,name,profile);
+ profile=BlobToStringInfo(datum+i,(size_t) length);
+ if (profile == (StringInfo *) NULL)
+ ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
+ image->filename);
+ status=SetImageProfile(image,name,profile,exception);
profile=DestroyStringInfo(profile);
if (status == MagickFalse)
ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
(void) ConcatenateMagickString(message,".",MaxTextExtent);
exception=(ExceptionInfo *) MagickGetThreadValue(tiff_exception);
if (exception != (ExceptionInfo *) NULL)
- (void) ThrowMagickException(exception,GetMagickModule(),CoderWarning,
- message,"`%s'",module);
+ (void) ThrowMagickException(exception,GetMagickModule(),CoderError,message,
+ "`%s'",module);
}
-static void TIFFGetProfiles(TIFF *tiff,Image *image)
+static toff_t TIFFGetBlobSize(thandle_t image)
+{
+ return((toff_t) GetBlobSize((Image *) image));
+}
+
+static void TIFFGetProfiles(TIFF *tiff,Image *image,ExceptionInfo *exception)
{
uint32
length;
#if defined(TIFFTAG_ICCPROFILE)
length=0;
if (TIFFGetField(tiff,TIFFTAG_ICCPROFILE,&length,&profile) == 1)
- (void) ReadProfile(image,"icc",profile,(ssize_t) length);
+ (void) ReadProfile(image,"icc",profile,(ssize_t) length,exception);
#endif
#if defined(TIFFTAG_PHOTOSHOP)
length=0;
if (TIFFGetField(tiff,TIFFTAG_PHOTOSHOP,&length,&profile) == 1)
- (void) ReadProfile(image,"8bim",profile,(ssize_t) length);
+ (void) ReadProfile(image,"8bim",profile,(ssize_t) length,exception);
#endif
#if defined(TIFFTAG_RICHTIFFIPTC)
length=0;
{
if (TIFFIsByteSwapped(tiff) != 0)
TIFFSwabArrayOfLong((uint32 *) profile,(size_t) length);
- (void) ReadProfile(image,"iptc",profile,4L*length);
+ (void) ReadProfile(image,"iptc",profile,4L*length,exception);
}
#endif
#if defined(TIFFTAG_XMLPACKET)
length=0;
if (TIFFGetField(tiff,TIFFTAG_XMLPACKET,&length,&profile) == 1)
- (void) ReadProfile(image,"xmp",profile,(ssize_t) length);
+ (void) ReadProfile(image,"xmp",profile,(ssize_t) length,exception);
#endif
length=0;
if (TIFFGetField(tiff,37724,&length,&profile) == 1)
- (void) ReadProfile(image,"tiff:37724",profile,(ssize_t) length);
+ (void) ReadProfile(image,"tiff:37724",profile,(ssize_t) length,exception);
}
-static void TIFFGetProperties(TIFF *tiff,Image *image)
+static void TIFFGetProperties(TIFF *tiff,Image *image,ExceptionInfo *exception)
{
char
+ message[MaxTextExtent],
*text;
+ uint32
+ count;
+
if (TIFFGetField(tiff,TIFFTAG_ARTIST,&text) == 1)
- (void) SetImageProperty(image,"tiff:artist",text);
+ (void) SetImageProperty(image,"tiff:artist",text,exception);
+ if (TIFFGetField(tiff,TIFFTAG_COPYRIGHT,&text) == 1)
+ (void) SetImageProperty(image,"tiff:copyright",text,exception);
if (TIFFGetField(tiff,TIFFTAG_DATETIME,&text) == 1)
- (void) SetImageProperty(image,"tiff:timestamp",text);
- if (TIFFGetField(tiff,TIFFTAG_SOFTWARE,&text) == 1)
- (void) SetImageProperty(image,"tiff:software",text);
- if (TIFFGetField(tiff,TIFFTAG_HOSTCOMPUTER,&text) == 1)
- (void) SetImageProperty(image,"tiff:hostcomputer",text);
+ (void) SetImageProperty(image,"tiff:timestamp",text,exception);
if (TIFFGetField(tiff,TIFFTAG_DOCUMENTNAME,&text) == 1)
- (void) SetImageProperty(image,"tiff:document",text);
+ (void) SetImageProperty(image,"tiff:document",text,exception);
+ if (TIFFGetField(tiff,TIFFTAG_HOSTCOMPUTER,&text) == 1)
+ (void) SetImageProperty(image,"tiff:hostcomputer",text,exception);
+ if (TIFFGetField(tiff,TIFFTAG_IMAGEDESCRIPTION,&text) == 1)
+ (void) SetImageProperty(image,"comment",text,exception);
if (TIFFGetField(tiff,TIFFTAG_MAKE,&text) == 1)
- (void) SetImageProperty(image,"tiff:make",text);
+ (void) SetImageProperty(image,"tiff:make",text,exception);
if (TIFFGetField(tiff,TIFFTAG_MODEL,&text) == 1)
- (void) SetImageProperty(image,"tiff:model",text);
- if (TIFFGetField(tiff,33432,&text) == 1)
- (void) SetImageProperty(image,"tiff:copyright",text);
+ (void) SetImageProperty(image,"tiff:model",text,exception);
+ if (TIFFGetField(tiff,TIFFTAG_OPIIMAGEID,&count,&text) == 1)
+ {
+ if (count >= MaxTextExtent)
+ count=MaxTextExtent-1;
+ (void) CopyMagickString(message,text,count+1);
+ (void) SetImageProperty(image,"tiff:image-id",message,exception);
+ }
if (TIFFGetField(tiff,TIFFTAG_PAGENAME,&text) == 1)
- (void) SetImageProperty(image,"label",text);
- if (TIFFGetField(tiff,TIFFTAG_IMAGEDESCRIPTION,&text) == 1)
- (void) SetImageProperty(image,"comment",text);
+ (void) SetImageProperty(image,"label",text,exception);
+ if (TIFFGetField(tiff,TIFFTAG_SOFTWARE,&text) == 1)
+ (void) SetImageProperty(image,"tiff:software",text,exception);
+ if (TIFFGetField(tiff,33423,&count,&text) == 1)
+ {
+ if (count >= MaxTextExtent)
+ count=MaxTextExtent-1;
+ (void) CopyMagickString(message,text,count+1);
+ (void) SetImageProperty(image,"tiff:kodak-33423",message,exception);
+ }
+ if (TIFFGetField(tiff,36867,&count,&text) == 1)
+ {
+ if (count >= MaxTextExtent)
+ count=MaxTextExtent-1;
+ (void) CopyMagickString(message,text,count+1);
+ (void) SetImageProperty(image,"tiff:kodak-36867",message,exception);
+ }
}
-static void TIFFGetEXIFProperties(TIFF *tiff,Image *image)
+static void TIFFGetEXIFProperties(TIFF *tiff,Image *image,
+ ExceptionInfo *exception)
{
#if defined(MAGICKCORE_HAVE_TIFFREADEXIFDIRECTORY)
char
tdir_t
directory;
+#if defined(TIFF_VERSION_BIG)
+ uint64
+#else
uint32
+#endif
offset;
+ void
+ *sans;
+
/*
Read EXIF properties.
*/
directory=TIFFCurrentDirectory(tiff);
if (TIFFReadEXIFDirectory(tiff,offset) == 0)
return;
+ sans=NULL;
for (i=0; exif_info[i].tag != 0; i++)
{
*value='\0';
char
*ascii;
- if (TIFFGetField(tiff,exif_info[i].tag,&ascii) != 0)
+ ascii=(char *) NULL;
+ if ((TIFFGetField(tiff,exif_info[i].tag,&ascii,&sans) != 0) &&
+ (ascii != (char *) NULL) && (*ascii != '\0'))
(void) CopyMagickMemory(value,ascii,MaxTextExtent);
break;
}
case TIFF_SHORT:
{
uint16
- shorty;
+ shorty[2] = { 0, 0};
- if (TIFFGetField(tiff,exif_info[i].tag,&shorty) != 0)
- (void) FormatMagickString(value,MaxTextExtent,"%d",shorty);
+ if (TIFFGetField(tiff,exif_info[i].tag,&shorty,&sans) != 0)
+ (void) FormatLocaleString(value,MaxTextExtent,"%d",(int) shorty[0]);
break;
}
case TIFF_LONG:
{
uint32
- ssize_ty;
+ longy;
- if (TIFFGetField(tiff,exif_info[i].tag,&ssize_ty) != 0)
- (void) FormatMagickString(value,MaxTextExtent,"%d",ssize_ty);
+ if (TIFFGetField(tiff,exif_info[i].tag,&longy,&sans) != 0)
+ (void) FormatLocaleString(value,MaxTextExtent,"%d",longy);
break;
}
+#if defined(TIFF_VERSION_BIG)
+ case TIFF_LONG8:
+ {
+ uint64
+ longy;
+
+ if (TIFFGetField(tiff,exif_info[i].tag,&longy,&sans) != 0)
+ (void) FormatLocaleString(value,MaxTextExtent,"%ld",longy);
+ break;
+ }
+#endif
case TIFF_RATIONAL:
case TIFF_SRATIONAL:
+ case TIFF_FLOAT:
+ case TIFF_DOUBLE:
{
float
- rational;
+ rational[16];
- if (TIFFGetField(tiff,exif_info[i].tag,&rational) != 0)
- (void) FormatMagickString(value,MaxTextExtent,"%g",rational);
+ if (TIFFGetField(tiff,exif_info[i].tag,&rational,&sans) != 0)
+ (void) FormatLocaleString(value,MaxTextExtent,"%g",rational[0]);
break;
}
default:
break;
}
if (*value != '\0')
- (void) SetImageProperty(image,exif_info[i].property,value);
+ (void) SetImageProperty(image,exif_info[i].property,value,exception);
}
TIFFSetDirectory(tiff,directory);
#else
return((toff_t) SeekBlob((Image *) image,(MagickOffsetType) offset,whence));
}
-static toff_t TIFFGetBlobSize(thandle_t image)
+#if defined(MAGICKCORE_HAVE_TIFFMERGEFIELDINFO) && defined(MAGICKCORE_HAVE_TIFFSETTAGEXTENDER)
+static TIFFExtendProc
+ tiff_extensions = (TIFFExtendProc) NULL;
+
+static void TIFFTagExtender(TIFF *tiff)
{
- return((toff_t) GetBlobSize((Image *) image));
+ static const TIFFFieldInfo
+ TIFFExtensions[] =
+ {
+ { 37724, -3, -3, TIFF_UNDEFINED, FIELD_CUSTOM, 1, 1, "PhotoshopLayerData" }
+ };
+
+ TIFFMergeFieldInfo(tiff,TIFFExtensions,sizeof(TIFFExtensions)/
+ sizeof(*TIFFExtensions));
+ if (tiff_extensions != (TIFFExtendProc) NULL)
+ (*tiff_extensions)(tiff);
}
+#endif
static void TIFFUnmapBlob(thandle_t image,tdata_t base,toff_t size)
{
Image
*image;
- ssize_t
- y;
-
MagickBooleanType
associated_alpha,
debug,
size_t
length,
+ lsb_first,
pad;
+ ssize_t
+ y;
+
TIFF
*tiff;
unsigned char
*pixels;
- size_t
- lsb_first;
-
/*
Open image.
*/
image_info->filename);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
- image=AcquireImage(image_info);
+#if defined(MAGICKCORE_HAVE_TIFFMERGEFIELDINFO) && defined(MAGICKCORE_HAVE_TIFFSETTAGEXTENDER)
+ if (tiff_extensions == (TIFFExtendProc) NULL)
+ tiff_extensions=TIFFSetTagExtender(TIFFTagExtender);
+#endif
+ image=AcquireImage(image_info,exception);
status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
if (status == MagickFalse)
{
(void) MagickSetThreadValue(tiff_exception,exception);
error_handler=TIFFSetErrorHandler(TIFFErrors);
warning_handler=TIFFSetWarningHandler(TIFFWarnings);
- tiff=TIFFClientOpen(image->filename,"r",(thandle_t) image,TIFFReadBlob,
+ tiff=TIFFClientOpen(image->filename,"rb",(thandle_t) image,TIFFReadBlob,
TIFFWriteBlob,TIFFSeekBlob,TIFFCloseBlob,TIFFGetBlobSize,TIFFMapBlob,
TIFFUnmapBlob);
if (tiff == (TIFF *) NULL)
return((Image *) NULL);
}
debug=IsEventLogging();
+ (void) debug;
if (image_info->number_scenes != 0)
{
/*
for (i=0; i < (ssize_t) image_info->scene; i++)
{
(void) TIFFReadDirectory(tiff);
- AcquireNextImage(image_info,image);
+ AcquireNextImage(image_info,image,exception);
if (GetNextImageInList(image) == (Image *) NULL)
{
image=DestroyImageList(image);
{
if (0 && (image_info->verbose != MagickFalse))
TIFFPrintDirectory(tiff,stdout,MagickFalse);
+ TIFFGetEXIFProperties(tiff,image,exception);
+ TIFFGetProfiles(tiff,image,exception);
+ TIFFGetProperties(tiff,image,exception);
(void) SetImageProperty(image,"tiff:endian",TIFFIsBigEndian(tiff) == 0 ?
- "lsb" : "msb");
+ "lsb" : "msb",exception);
(void) TIFFGetFieldDefaulted(tiff,TIFFTAG_COMPRESSION,&compress_tag);
(void) TIFFGetFieldDefaulted(tiff,TIFFTAG_ORIENTATION,&orientation);
(void) TIFFGetFieldDefaulted(tiff,TIFFTAG_IMAGEWIDTH,&width);
(void) TIFFGetFieldDefaulted(tiff,TIFFTAG_PLANARCONFIG,&interlace);
(void) TIFFGetFieldDefaulted(tiff,TIFFTAG_BITSPERSAMPLE,&bits_per_sample);
(void) TIFFGetFieldDefaulted(tiff,TIFFTAG_SAMPLEFORMAT,&sample_format);
+ if (sample_format == SAMPLEFORMAT_IEEEFP)
+ (void) SetImageProperty(image,"quantum:format","floating-point",
+ exception);
(void) TIFFGetFieldDefaulted(tiff,TIFFTAG_MINSAMPLEVALUE,&min_sample_value);
(void) TIFFGetFieldDefaulted(tiff,TIFFTAG_MAXSAMPLEVALUE,&max_sample_value);
(void) TIFFGetFieldDefaulted(tiff,TIFFTAG_PHOTOMETRIC,&photometric);
{
case PHOTOMETRIC_MINISBLACK:
{
- (void) SetImageProperty(image,"tiff:photometric","min-is-black");
+ (void) SetImageProperty(image,"tiff:photometric","min-is-black",
+ exception);
break;
}
case PHOTOMETRIC_MINISWHITE:
{
- (void) SetImageProperty(image,"tiff:photometric","min-is-white");
+ (void) SetImageProperty(image,"tiff:photometric","min-is-white",
+ exception);
break;
}
case PHOTOMETRIC_PALETTE:
{
- (void) SetImageProperty(image,"tiff:photometric","palette");
+ (void) SetImageProperty(image,"tiff:photometric","palette",exception);
break;
}
case PHOTOMETRIC_RGB:
{
- (void) SetImageProperty(image,"tiff:photometric","RGB");
+ (void) SetImageProperty(image,"tiff:photometric","RGB",exception);
break;
}
case PHOTOMETRIC_CIELAB:
{
- (void) SetImageProperty(image,"tiff:photometric","CIELAB");
+ (void) SetImageProperty(image,"tiff:photometric","CIELAB",exception);
break;
}
case PHOTOMETRIC_SEPARATED:
{
- (void) SetImageProperty(image,"tiff:photometric","separated");
+ (void) SetImageProperty(image,"tiff:photometric","separated",exception);
+ break;
+ }
+ case PHOTOMETRIC_YCBCR:
+ {
+ (void) SetImageProperty(image,"tiff:photometric","YCBCR",exception);
break;
}
default:
{
- (void) SetImageProperty(image,"tiff:photometric","unknown");
+ (void) SetImageProperty(image,"tiff:photometric","unknown",exception);
break;
}
}
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
"Max sample value: %u",max_sample_value);
(void) LogMagickEvent(CoderEvent,GetMagickModule(),"Photometric "
- "interpretation: %s",GetImageProperty(image,"tiff:photometric"));
+ "interpretation: %s",GetImageProperty(image,"tiff:photometric",
+ exception));
}
image->columns=(size_t) width;
image->rows=(size_t) height;
(void) TIFFGetFieldDefaulted(tiff,TIFFTAG_SAMPLESPERPIXEL,
&samples_per_pixel);
(void) TIFFGetFieldDefaulted(tiff,TIFFTAG_RESOLUTIONUNIT,&units);
- x_resolution=(float) image->x_resolution;
- y_resolution=(float) image->y_resolution;
+ x_resolution=(float) image->resolution.x;
+ y_resolution=(float) image->resolution.y;
(void) TIFFGetFieldDefaulted(tiff,TIFFTAG_XRESOLUTION,&x_resolution);
(void) TIFFGetFieldDefaulted(tiff,TIFFTAG_YRESOLUTION,&y_resolution);
- image->x_resolution=x_resolution;
- image->y_resolution=y_resolution;
+ image->resolution.x=x_resolution;
+ image->resolution.y=y_resolution;
x_position=(float) image->page.x/x_resolution;
y_position=(float) image->page.y/y_resolution;
(void) TIFFGetFieldDefaulted(tiff,TIFFTAG_XPOSITION,&x_position);
image->chromaticity.blue_primary.x=chromaticity[4];
image->chromaticity.blue_primary.y=chromaticity[5];
}
- TIFFGetProperties(tiff,image);
- option=GetImageOption(image_info,"tiff:exif");
- if ((option != (const char *) NULL) &&
- (IsMagickTrue(option) != MagickFalse))
- TIFFGetEXIFProperties(tiff,image);
- TIFFGetProfiles(tiff,image);
/*
Allocate memory for the image and pixel buffer.
*/
(void) TIFFGetFieldDefaulted(tiff,TIFFTAG_YCBCRSUBSAMPLING,
&horizontal,&vertical);
- (void) FormatMagickString(sampling_factor,MaxTextExtent,"%dx%d",
+ (void) FormatLocaleString(sampling_factor,MaxTextExtent,"%dx%d",
horizontal,vertical);
(void) SetImageProperty(image,"jpeg:sampling-factor",
- sampling_factor);
+ sampling_factor,exception);
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
"Sampling Factors: %s",sampling_factor);
if ((samples_per_pixel > 1) && (photometric == PHOTOMETRIC_YCBCR))
break;
}
case COMPRESSION_OJPEG: image->compression=JPEGCompression; break;
+#if defined(COMPRESSION_LZMA)
+ case COMPRESSION_LZMA: image->compression=LZMACompression; break;
+#endif
case COMPRESSION_LZW: image->compression=LZWCompression; break;
case COMPRESSION_DEFLATE: image->compression=ZipCompression; break;
case COMPRESSION_ADOBE_DEFLATE: image->compression=ZipCompression; break;
status=SetQuantumFormat(image,quantum_info,FloatingPointQuantumFormat);
if (status == MagickFalse)
{
+ quantum_info=DestroyQuantumInfo(quantum_info);
TIFFClose(tiff);
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
}
MagickFalse;
if (image->matte != MagickFalse)
(void) SetImageProperty(image,"tiff:alpha",
- associated_alpha != MagickFalse ? "associated" : "unassociated");
+ associated_alpha != MagickFalse ? "associated" : "unassociated",
+ exception);
if ((photometric == PHOTOMETRIC_PALETTE) &&
(pow(2.0,1.0*bits_per_sample) <= MaxColormapSize))
{
colors;
colors=(size_t) GetQuantumRange(bits_per_sample)+1;
- if (AcquireImageColormap(image,colors) == MagickFalse)
+ if (AcquireImageColormap(image,colors,exception) == MagickFalse)
{
TIFFClose(tiff);
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
value[MaxTextExtent];
method=ReadStripMethod;
- (void) FormatMagickString(value,MaxTextExtent,"%u",
+ (void) FormatLocaleString(value,MaxTextExtent,"%u",
(unsigned int) rows_per_strip);
- (void) SetImageProperty(image,"tiff:rows-per-strip",value);
+ (void) SetImageProperty(image,"tiff:rows-per-strip",value,exception);
}
if ((samples_per_pixel >= 2) && (interlace == PLANARCONFIG_CONTIG))
method=ReadRGBAMethod;
(photometric == PHOTOMETRIC_MINISWHITE))
method=ReadSingleSampleMethod;
if ((photometric != PHOTOMETRIC_SEPARATED) &&
- (interlace == PLANARCONFIG_SEPARATE))
+ (interlace == PLANARCONFIG_SEPARATE) && (bits_per_sample < 64))
+ method=ReadGenericMethod;
+ if (image->compression == JPEGCompression)
method=ReadGenericMethod;
if (TIFFIsTiled(tiff) != MagickFalse)
method=ReadTileMethod;
int
status;
- register PixelPacket
+ register Quantum
*restrict q;
status=TIFFReadPixels(tiff,bits_per_sample,0,y,(char *) pixels);
if (status == -1)
break;
q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
- if (q == (PixelPacket *) NULL)
+ if (q == (Quantum *) NULL)
break;
length=ImportQuantumPixels(image,(CacheView *) NULL,quantum_info,
quantum_type,pixels,exception);
+ (void) length;
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
if (image->previous == (Image *) NULL)
int
status;
- register PixelPacket
+ register Quantum
*restrict q;
status=TIFFReadPixels(tiff,bits_per_sample,0,y,(char *) pixels);
if (status == -1)
break;
q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
- if (q == (PixelPacket *) NULL)
+ if (q == (Quantum *) NULL)
break;
length=ImportQuantumPixels(image,(CacheView *) NULL,quantum_info,
quantum_type,pixels,exception);
{
for (y=0; y < (ssize_t) image->rows; y++)
{
- register PixelPacket
+ register Quantum
*restrict q;
int
if (status == -1)
break;
q=GetAuthenticPixels(image,0,y,image->columns,1,exception);
- if (q == (PixelPacket *) NULL)
+ if (q == (Quantum *) NULL)
break;
if (image->colorspace != CMYKColorspace)
switch (i)
register ssize_t
x;
- register PixelPacket
+ register Quantum
*restrict q;
q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
- if (q == (PixelPacket *) NULL)
+ if (q == (Quantum *) NULL)
break;
if (i == 0)
{
image->rows-y);
}
i--;
- p=pixels+image->columns*i;
+ p=(unsigned char *) (((uint32 *) pixels)+image->columns*i);
for (x=0; x < (ssize_t) image->columns; x++)
{
- q->red=ScaleCharToQuantum((unsigned char) (TIFFGetR(*p)));
- q->green=ScaleCharToQuantum((unsigned char) (TIFFGetG(*p)));
- q->blue=ScaleCharToQuantum((unsigned char) (TIFFGetB(*p)));
+ SetPixelRed(image,ScaleCharToQuantum((unsigned char)
+ (TIFFGetR(*p))),q);
+ SetPixelGreen(image,ScaleCharToQuantum((unsigned char)
+ (TIFFGetG(*p))),q);
+ SetPixelBlue(image,ScaleCharToQuantum((unsigned char)
+ (TIFFGetB(*p))),q);
if (image->matte != MagickFalse)
- q->opacity=ScaleCharToQuantum((unsigned char) (TIFFGetA(*p)));
+ SetPixelAlpha(image,ScaleCharToQuantum((unsigned char)
+ (TIFFGetA(*p))),q);
p++;
- q++;
+ q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
TIFFClose(tiff);
ThrowReaderException(CoderError,"ImageIsNotTiled");
}
- (void) SetImageStorageClass(image,DirectClass);
+ (void) SetImageStorageClass(image,DirectClass,exception);
number_pixels=columns*rows;
- tile_pixels=(uint32 *) AcquireQuantumMemory((size_t) columns*rows,
+ tile_pixels=(uint32 *) AcquireQuantumMemory(number_pixels,
sizeof(*tile_pixels));
if (tile_pixels == (uint32 *) NULL)
{
}
for (y=0; y < (ssize_t) image->rows; y+=rows)
{
- PixelPacket
- *tile;
-
register ssize_t
x;
- register PixelPacket
- *restrict q;
+ register Quantum
+ *restrict q,
+ *restrict tile;
size_t
columns_remaining,
rows_remaining=rows;
tile=QueueAuthenticPixels(image,0,y,image->columns,rows_remaining,
exception);
- if (tile == (PixelPacket *) NULL)
+ if (tile == (Quantum *) NULL)
break;
for (x=0; x < (ssize_t) image->columns; x+=columns)
{
if ((ssize_t) (x+columns) < (ssize_t) image->columns)
columns_remaining=columns;
p=tile_pixels+(rows-rows_remaining)*columns;
- q=tile+(image->columns*(rows_remaining-1)+x);
+ q=tile+GetPixelChannels(image)*(image->columns*(rows_remaining-1)+
+ x);
for (row=rows_remaining; row > 0; row--)
{
if (image->matte != MagickFalse)
for (column=columns_remaining; column > 0; column--)
{
- q->red=ScaleCharToQuantum((unsigned char) TIFFGetR(*p));
- q->green=ScaleCharToQuantum((unsigned char) TIFFGetG(*p));
- q->blue=ScaleCharToQuantum((unsigned char) TIFFGetB(*p));
- q->opacity=(Quantum) (QuantumRange-ScaleCharToQuantum(
- (unsigned char) TIFFGetA(*p)));
- q++;
+ SetPixelRed(image,ScaleCharToQuantum((unsigned char)
+ TIFFGetR(*p)),q);
+ SetPixelGreen(image,ScaleCharToQuantum((unsigned char)
+ TIFFGetG(*p)),q);
+ SetPixelBlue(image,ScaleCharToQuantum((unsigned char)
+ TIFFGetB(*p)),q);
+ SetPixelAlpha(image,ScaleCharToQuantum((unsigned char)
+ TIFFGetA(*p)),q);
p++;
+ q+=GetPixelChannels(image);
}
else
for (column=columns_remaining; column > 0; column--)
{
- q->red=ScaleCharToQuantum((unsigned char) TIFFGetR(*p));
- q->green=ScaleCharToQuantum((unsigned char) TIFFGetG(*p));
- q->blue=ScaleCharToQuantum((unsigned char) TIFFGetB(*p));
- q++;
+ SetPixelRed(image,ScaleCharToQuantum((unsigned char)
+ TIFFGetR(*p)),q);
+ SetPixelGreen(image,ScaleCharToQuantum((unsigned char)
+ TIFFGetG(*p)),q);
+ SetPixelBlue(image,ScaleCharToQuantum((unsigned char)
+ TIFFGetB(*p)),q);
p++;
+ q+=GetPixelChannels(image);
}
p+=columns-columns_remaining;
- q-=(image->columns+columns_remaining);
+ q-=GetPixelChannels(image)*(image->columns+columns_remaining);
}
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
register ssize_t
x;
- register PixelPacket
+ register Quantum
*restrict q;
q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
- if (q == (PixelPacket *) NULL)
+ if (q == (Quantum *) NULL)
break;
- q+=image->columns-1;
+ q+=GetPixelChannels(image)*(image->columns-1);
for (x=0; x < (ssize_t) image->columns; x++)
{
- q->red=ScaleCharToQuantum((unsigned char) TIFFGetR(*p));
- q->green=ScaleCharToQuantum((unsigned char) TIFFGetG(*p));
- q->blue=ScaleCharToQuantum((unsigned char) TIFFGetB(*p));
+ SetPixelRed(image,ScaleCharToQuantum((unsigned char)
+ TIFFGetR(*p)),q);
+ SetPixelGreen(image,ScaleCharToQuantum((unsigned char)
+ TIFFGetG(*p)),q);
+ SetPixelBlue(image,ScaleCharToQuantum((unsigned char)
+ TIFFGetB(*p)),q);
if (image->matte != MagickFalse)
- q->opacity=ScaleCharToQuantum((unsigned char) TIFFGetA(*p));
+ SetPixelAlpha(image,ScaleCharToQuantum((unsigned char)
+ TIFFGetA(*p)),q);
p--;
- q--;
+ q-=GetPixelChannels(image);;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
}
SetQuantumImageType(image,quantum_type);
next_tiff_frame:
+ quantum_info=DestroyQuantumInfo(quantum_info);
if ((photometric == PHOTOMETRIC_LOGL) ||
(photometric == PHOTOMETRIC_MINISBLACK) ||
(photometric == PHOTOMETRIC_MINISWHITE))
/*
Allocate next image structure.
*/
- AcquireNextImage(image_info,image);
+ AcquireNextImage(image_info,image,exception);
if (GetNextImageInList(image) == (Image *) NULL)
{
image=DestroyImageList(image);
if (status == MagickFalse)
break;
}
- quantum_info=DestroyQuantumInfo(quantum_info);
} while (status == MagickTrue);
(void) TIFFSetWarningHandler(warning_handler);
(void) TIFFSetErrorHandler(error_handler);
UnlockSemaphoreInfo(tiff_semaphore);
*version='\0';
#if defined(TIFF_VERSION)
- (void) FormatMagickString(version,MaxTextExtent,"%d",TIFF_VERSION);
+ (void) FormatLocaleString(version,MaxTextExtent,"%d",TIFF_VERSION);
#endif
#if defined(MAGICKCORE_TIFF_DELEGATE)
{
% The format of the WriteGROUP4Image method is:
%
% MagickBooleanType WriteGROUP4Image(const ImageInfo *image_info,
-% Image *image)
+% Image *image,ExceptionInfo *)
%
% A description of each parameter follows:
%
%
% o image: The image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
static MagickBooleanType WriteGROUP4Image(const ImageInfo *image_info,
- Image *image)
+ Image *image,ExceptionInfo *exception)
{
char
filename[MaxTextExtent];
assert(image->signature == MagickSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
- status=OpenBlob(image_info,image,WriteBinaryBlobMode,&image->exception);
+ assert(exception != (ExceptionInfo *) NULL);
+ assert(exception->signature == MagickSignature);
+ status=OpenBlob(image_info,image,WriteBinaryBlobMode,exception);
if (status == MagickFalse)
return(status);
- huffman_image=CloneImage(image,0,0,MagickTrue,&image->exception);
+ huffman_image=CloneImage(image,0,0,MagickTrue,exception);
if (huffman_image == (Image *) NULL)
{
(void) CloseBlob(image);
file=fdopen(unique_file,"wb");
if ((unique_file == -1) || (file == (FILE *) NULL))
{
- ThrowFileException(&image->exception,FileOpenError,
- "UnableToCreateTemporaryFile",filename);
+ ThrowFileException(exception,FileOpenError,"UnableToCreateTemporaryFile",
+ filename);
return(MagickFalse);
}
- (void) FormatMagickString(huffman_image->filename,MaxTextExtent,"tiff:%s",
+ (void) FormatLocaleString(huffman_image->filename,MaxTextExtent,"tiff:%s",
filename);
- (void) SetImageType(huffman_image,BilevelType);
+ (void) SetImageType(huffman_image,BilevelType,exception);
write_info=CloneImageInfo((ImageInfo *) NULL);
SetImageInfoFile(write_info,file);
write_info->compression=Group4Compression;
write_info->type=BilevelType;
(void) SetImageOption(write_info,"quantum:polarity","min-is-white");
- status=WriteTIFFImage(write_info,huffman_image);
+ status=WriteTIFFImage(write_info,huffman_image,exception);
(void) fflush(file);
write_info=DestroyImageInfo(write_info);
if (status == MagickFalse)
{
- InheritException(&image->exception,&huffman_image->exception);
huffman_image=DestroyImage(huffman_image);
(void) fclose(file);
(void) RelinquishUniqueFileResource(filename);
huffman_image=DestroyImage(huffman_image);
(void) fclose(file);
(void) RelinquishUniqueFileResource(filename);
- ThrowFileException(&image->exception,FileOpenError,"UnableToOpenFile",
+ ThrowFileException(exception,FileOpenError,"UnableToOpenFile",
image_info->filename);
return(MagickFalse);
}
% The format of the WritePTIFImage method is:
%
% MagickBooleanType WritePTIFImage(const ImageInfo *image_info,
-% Image *image)
+% Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
%
% o image: The image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
static MagickBooleanType WritePTIFImage(const ImageInfo *image_info,
- Image *image)
+ Image *image,ExceptionInfo *exception)
{
Image
*images,
images=NewImageList();
for (next=image; next != (Image *) NULL; next=GetNextImageInList(next))
{
- AppendImageToList(&images,CloneImage(next,0,0,MagickFalse,
- &image->exception));
+ AppendImageToList(&images,CloneImage(next,0,0,MagickFalse,exception));
columns=next->columns;
rows=next->rows;
while ((columns > 64) && (rows > 64))
{
columns/=2;
rows/=2;
- pyramid_image=ResizeImage(next,columns,rows,UndefinedFilter,image->blur,
- &image->exception);
+ pyramid_image=ResizeImage(next,columns,rows,image->filter,image->blur,
+ exception);
AppendImageToList(&images,pyramid_image);
}
}
write_info=CloneImageInfo(image_info);
*write_info->magick='\0';
write_info->adjoin=MagickTrue;
- status=WriteTIFFImage(write_info,GetFirstImageInList(images));
+ status=WriteTIFFImage(write_info,GetFirstImageInList(images),exception);
images=DestroyImageList(images);
write_info=DestroyImageInfo(write_info);
return(status);
% The format of the WriteTIFFImage method is:
%
% MagickBooleanType WriteTIFFImage(const ImageInfo *image_info,
-% Image *image)
+% Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
%
% o image: The image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
typedef struct _TIFFInfo
MagickStatusType
flags;
+ uint32
+ tile_columns,
+ tile_rows;
+
assert(tiff_info != (TIFFInfo *) NULL);
(void) ResetMagickMemory(tiff_info,0,sizeof(*tiff_info));
option=GetImageOption(image_info,"tiff:tile-geometry");
flags=ParseAbsoluteGeometry(option,&tiff_info->tile_geometry);
if ((flags & HeightValue) == 0)
tiff_info->tile_geometry.height=tiff_info->tile_geometry.width;
- (void) TIFFSetField(tiff,TIFFTAG_TILEWIDTH,(uint32)
- tiff_info->tile_geometry.width);
- (void) TIFFSetField(tiff,TIFFTAG_TILELENGTH,(uint32)
- tiff_info->tile_geometry.height);
+ tile_columns=(uint32) tiff_info->tile_geometry.width;
+ tile_rows=(uint32) tiff_info->tile_geometry.height;
+ TIFFDefaultTileSize(tiff,&tile_columns,&tile_rows);
+ (void) TIFFSetField(tiff,TIFFTAG_TILEWIDTH,tile_columns);
+ (void) TIFFSetField(tiff,TIFFTAG_TILELENGTH,tile_rows);
+ tiff_info->tile_geometry.width=tile_columns;
+ tiff_info->tile_geometry.height=tile_rows;
tiff_info->scanlines=(unsigned char *) AcquireQuantumMemory((size_t)
- tiff_info->tile_geometry.height*TIFFScanlineSize(tiff),
- sizeof(*tiff_info->scanlines));
+ tile_rows*TIFFScanlineSize(tiff),sizeof(*tiff_info->scanlines));
tiff_info->pixels=(unsigned char *) AcquireQuantumMemory((size_t)
- TIFFTileSize(tiff),sizeof(*tiff_info->scanlines));
+ tile_rows*TIFFTileSize(tiff),sizeof(*tiff_info->scanlines));
if ((tiff_info->scanlines == (unsigned char *) NULL) ||
(tiff_info->pixels == (unsigned char *) NULL))
{
int32
status;
- ssize_t
- bytes_per_pixel,
- j,
- k,
- l;
-
register ssize_t
i;
number_tiles,
tile_width;
+ ssize_t
+ bytes_per_pixel,
+ j,
+ k,
+ l;
+
if (TIFFIsTiled(tiff) == 0)
return(TIFFWriteScanline(tiff,tiff_info->scanline,(uint32) row,sample));
/*
(void) CopyMagickMemory(tiff_info->scanlines+i,(char *) tiff_info->scanline,
(size_t) TIFFScanlineSize(tiff));
if (((size_t) (row % tiff_info->tile_geometry.height) !=
- (tiff_info->tile_geometry.height-1)) && (row != (ssize_t) (image->rows-1)))
+ (tiff_info->tile_geometry.height-1)) &&
+ (row != (ssize_t) (image->rows-1)))
return(0);
/*
Write tile to TIFF image.
GetStringInfoLength(profile),GetStringInfoDatum(profile));
#endif
if (LocaleCompare(name,"tiff:37724") == 0)
- (void) TIFFSetField(tiff,37724,(uint32)GetStringInfoLength(profile),
+ (void) TIFFSetField(tiff,37724,(uint32) GetStringInfoLength(profile),
GetStringInfoDatum(profile));
name=GetNextImageProfile(image);
}
}
-static void TIFFSetProperties(TIFF *tiff,Image *image)
+static void TIFFSetProperties(TIFF *tiff,Image *image,ExceptionInfo *exception)
{
const char
*value;
- value=GetImageProperty(image,"tiff:hostcomputer");
+ (void) TIFFSetField(tiff,TIFFTAG_DOCUMENTNAME,image->filename);
+ value=GetImageProperty(image,"tiff:hostcomputer",exception);
if (value != (const char *) NULL)
(void) TIFFSetField(tiff,TIFFTAG_HOSTCOMPUTER,value);
- value=GetImageProperty(image,"tiff:artist");
+ value=GetImageProperty(image,"tiff:artist",exception);
if (value != (const char *) NULL)
(void) TIFFSetField(tiff,TIFFTAG_ARTIST,value);
- value=GetImageProperty(image,"tiff:timestamp");
+ value=GetImageProperty(image,"tiff:timestamp",exception);
if (value != (const char *) NULL)
(void) TIFFSetField(tiff,TIFFTAG_DATETIME,value);
- value=GetImageProperty(image,"tiff:make");
+ value=GetImageProperty(image,"tiff:make",exception);
if (value != (const char *) NULL)
(void) TIFFSetField(tiff,TIFFTAG_MAKE,value);
- value=GetImageProperty(image,"tiff:model");
+ value=GetImageProperty(image,"tiff:model",exception);
if (value != (const char *) NULL)
(void) TIFFSetField(tiff,TIFFTAG_MODEL,value);
- (void) TIFFSetField(tiff,TIFFTAG_SOFTWARE,
- GetMagickVersion((size_t *) NULL));
- (void) TIFFSetField(tiff,TIFFTAG_DOCUMENTNAME,image->filename);
- value=GetImageProperty(image,"tiff:copyright");
+ value=GetImageProperty(image,"tiff:software",exception);
if (value != (const char *) NULL)
- (void) TIFFSetField(tiff,33432,value);
- value=GetImageProperty(image,"kodak-33423");
+ (void) TIFFSetField(tiff,TIFFTAG_SOFTWARE,value);
+ value=GetImageProperty(image,"tiff:copyright",exception);
+ if (value != (const char *) NULL)
+ (void) TIFFSetField(tiff,TIFFTAG_COPYRIGHT,value);
+ value=GetImageProperty(image,"kodak-33423",exception);
if (value != (const char *) NULL)
(void) TIFFSetField(tiff,33423,value);
- value=GetImageProperty(image,"kodak-36867");
+ value=GetImageProperty(image,"kodak-36867",exception);
if (value != (const char *) NULL)
(void) TIFFSetField(tiff,36867,value);
- value=GetImageProperty(image,"label");
+ value=GetImageProperty(image,"label",exception);
if (value != (const char *) NULL)
(void) TIFFSetField(tiff,TIFFTAG_PAGENAME,value);
- value=GetImageProperty(image,"comment");
+ value=GetImageProperty(image,"comment",exception);
if (value != (const char *) NULL)
(void) TIFFSetField(tiff,TIFFTAG_IMAGEDESCRIPTION,value);
}
-static void TIFFSetEXIFProperties(TIFF *tiff,Image *image)
+static void TIFFSetEXIFProperties(TIFF *tiff,Image *image,
+ ExceptionInfo *exception)
{
#if defined(MAGICKCORE_HAVE_TIFFREADEXIFDIRECTORY)
const char
(void) TIFFSetField(tiff,TIFFTAG_SUBIFD,1,&offset);
for (i=0; exif_info[i].tag != 0; i++)
{
- value=GetImageProperty(image,exif_info[i].property);
+ value=GetImageProperty(image,exif_info[i].property,exception);
if (value == (const char *) NULL)
continue;
switch (exif_info[i].type)
float
rational;
- rational=StringToDouble(value);
+ rational=StringToDouble(value,(char **) NULL);
(void) TIFFSetField(tiff,exif_info[i].tag,rational);
break;
}
}
static MagickBooleanType WriteTIFFImage(const ImageInfo *image_info,
- Image *image)
+ Image *image,ExceptionInfo *exception)
{
#if !defined(TIFFDefaultStripSize)
#define TIFFDefaultStripSize(tiff,request) (8192UL/TIFFScanlineSize(tiff))
EndianType
endian_type;
- ssize_t
- y;
-
MagickBooleanType
debug,
status;
i;
size_t
- length;
+ length,
+ lsb_first;
+
+ ssize_t
+ y;
TIFF
*tiff;
unsigned char
*pixels;
- size_t
- lsb_first;
-
/*
Open TIFF file.
*/
assert(image->signature == MagickSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
- status=OpenBlob(image_info,image,WriteBinaryBlobMode,&image->exception);
+ assert(exception != (ExceptionInfo *) NULL);
+ assert(exception->signature == MagickSignature);
+ assert(exception != (ExceptionInfo *) NULL);
+ assert(exception->signature == MagickSignature);
+ status=OpenBlob(image_info,image,WriteBinaryBlobMode,exception);
if (status == MagickFalse)
return(status);
- (void) MagickSetThreadValue(tiff_exception,&image->exception);
+ (void) MagickSetThreadValue(tiff_exception,exception);
error_handler=TIFFSetErrorHandler((TIFFErrorHandler) TIFFErrors);
warning_handler=TIFFSetWarningHandler((TIFFErrorHandler) TIFFWarnings);
endian_type=UndefinedEndian;
}
scene=0;
debug=IsEventLogging();
+ (void) debug;
do
{
/*
*/
if ((image_info->type != UndefinedType) &&
(image_info->type != OptimizeType))
- (void) SetImageType(image,image_info->type);
+ (void) SetImageType(image,image_info->type,exception);
quantum_info=AcquireQuantumInfo(image_info,image);
if (quantum_info == (QuantumInfo *) NULL)
ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
if ((image->storage_class != PseudoClass) && (image->depth >= 32) &&
(quantum_info->format == UndefinedQuantumFormat) &&
- (IsHighDynamicRangeImage(image,&image->exception) != MagickFalse))
+ (IsHighDynamicRangeImage(image,exception) != MagickFalse))
{
status=SetQuantumFormat(image,quantum_info,FloatingPointQuantumFormat);
if (status == MagickFalse)
SetQuantumMinIsWhite(quantum_info,MagickTrue);
break;
}
+#if defined(COMPRESSION_JBIG)
+ case JBIG1Compression:
+ {
+ compress_tag=COMPRESSION_JBIG;
+ break;
+ }
+#endif
case JPEGCompression:
{
compress_tag=COMPRESSION_JPEG;
break;
}
+#if defined(COMPRESSION_LZMA)
+ case LZMACompression:
+ {
+ compress_tag=COMPRESSION_LZMA;
+ break;
+ }
+#endif
case LZWCompression:
{
compress_tag=COMPRESSION_LZW;
if ((compress_tag != COMPRESSION_NONE) &&
(TIFFIsCODECConfigured(compress_tag) == 0))
{
- (void) ThrowMagickException(&image->exception,GetMagickModule(),
- CoderError,"CompressionNotSupported","`%s'",MagickOptionToMnemonic(
+ (void) ThrowMagickException(exception,GetMagickModule(),CoderError,
+ "CompressionNotSupported","`%s'",CommandOptionToMnemonic(
MagickCompressOptions,(ssize_t) compression));
compress_tag=COMPRESSION_NONE;
compression=NoCompression;
#if defined(YCBCR_SUPPORT) && defined(JPEG_SUPPORT)
case COMPRESSION_JPEG:
#endif
+#if defined(LZMA_SUPPORT) && defined(COMPRESSION_LZMA)
+ case COMPRESSION_LZMA:
+#endif
#if defined(LZW_SUPPORT)
case COMPRESSION_LZW:
#endif
break;
default:
{
- (void) ThrowMagickException(&image->exception,GetMagickModule(),
- CoderError,"CompressionNotSupported","`%s'",MagickOptionToMnemonic(
+ (void) ThrowMagickException(exception,GetMagickModule(),CoderError,
+ "CompressionNotSupported","`%s'",CommandOptionToMnemonic(
MagickCompressOptions,(ssize_t) compression));
compress_tag=COMPRESSION_NONE;
compression=NoCompression;
case FaxCompression:
case Group4Compression:
{
- (void) SetImageType(image,BilevelType);
+ (void) SetImageType(image,BilevelType,exception);
break;
}
case JPEGCompression:
{
- (void) SetImageStorageClass(image,DirectClass);
- (void) SetImageDepth(image,8);
+ (void) SetImageStorageClass(image,DirectClass,exception);
+ (void) SetImageDepth(image,8,exception);
break;
}
default:
{
photometric=PHOTOMETRIC_YCBCR;
(void) TIFFSetField(tiff,TIFFTAG_YCBCRSUBSAMPLING,1,1);
- (void) SetImageDepth(image,8);
+ (void) SetImageStorageClass(image,DirectClass,exception);
+ (void) SetImageDepth(image,8,exception);
}
else
{
- if (image->colorspace != RGBColorspace)
- (void) TransformImageColorspace(image,RGBColorspace);
+ if (IsRGBColorspace(image->colorspace) == MagickFalse)
+ (void) TransformImageColorspace(image,RGBColorspace,exception);
photometric=PHOTOMETRIC_RGB;
}
(void) TIFFSetField(tiff,TIFFTAG_SAMPLESPERPIXEL,3);
(image_info->type != TrueColorMatteType))
{
if ((image_info->type != PaletteType) &&
- (IsGrayImage(image,&image->exception) != MagickFalse))
+ (IsImageGray(image,exception) != MagickFalse))
{
photometric=(uint16) (quantum_info->min_is_white !=
MagickFalse ? PHOTOMETRIC_MINISWHITE :
PHOTOMETRIC_MINISBLACK);
(void) TIFFSetField(tiff,TIFFTAG_SAMPLESPERPIXEL,1);
- if ((image_info->depth == 0) &&
- (IsMonochromeImage(image,&image->exception) != MagickFalse))
+ if ((image_info->depth == 0) && (image->matte == MagickFalse) &&
+ (IsImageMonochrome(image,exception) != MagickFalse))
{
status=SetQuantumDepth(image,quantum_info,1);
if (status == MagickFalse)
compress_tag=COMPRESSION_NONE;
endian=FILLORDER_MSB2LSB;
}
- option=GetImageProperty(image,"tiff:fill-order");
+ option=GetImageProperty(image,"tiff:fill-order",exception);
if (option != (const char *) NULL)
{
if (LocaleNCompare(option,"msb",3) == 0)
*/
extra_samples=1;
sample_info[0]=EXTRASAMPLE_UNASSALPHA;
- option=GetImageProperty(image,"tiff:alpha");
+ option=GetImageProperty(image,"tiff:alpha",exception);
if ((option != (const char *) NULL) &&
(LocaleCompare(option,"associated") == 0))
sample_info[0]=EXTRASAMPLE_ASSOCALPHA;
if (image_info->quality != UndefinedCompressionQuality)
(void) TIFFSetField(tiff,TIFFTAG_JPEGQUALITY,image_info->quality);
(void) TIFFSetField(tiff,TIFFTAG_JPEGCOLORMODE,JPEGCOLORMODE_RAW);
- if (image->colorspace == RGBColorspace)
+ if (IsRGBColorspace(image->colorspace) == MagickTrue)
{
const char
*value;
(void) TIFFSetField(tiff,TIFFTAG_JPEGCOLORMODE,JPEGCOLORMODE_RGB);
sampling_factor=(const char *) NULL;
- value=GetImageProperty(image,"jpeg:sampling-factor");
+ value=GetImageProperty(image,"jpeg:sampling-factor",exception);
if (value != (char *) NULL)
{
sampling_factor=value;
flags=ParseGeometry(sampling_factor,&geometry_info);
if ((flags & SigmaValue) == 0)
geometry_info.sigma=geometry_info.rho;
- (void) TIFFSetField(tiff,TIFFTAG_YCBCRSUBSAMPLING,(uint16)
- geometry_info.rho,(uint16) geometry_info.sigma);
+ if (image->colorspace == YCbCrColorspace)
+ (void) TIFFSetField(tiff,TIFFTAG_YCBCRSUBSAMPLING,(uint16)
+ geometry_info.rho,(uint16) geometry_info.sigma);
}
}
if (bits_per_sample == 12)
if (((photometric == PHOTOMETRIC_RGB) ||
(photometric == PHOTOMETRIC_MINISBLACK)) &&
((bits_per_sample == 8) || (bits_per_sample == 16)))
- (void) TIFFSetField(tiff,TIFFTAG_PREDICTOR,2);
+ (void) TIFFSetField(tiff,TIFFTAG_PREDICTOR,PREDICTOR_HORIZONTAL);
(void) TIFFSetField(tiff,TIFFTAG_ZIPQUALITY,(long) (
image_info->quality == UndefinedCompressionQuality ? 7 :
MagickMin((ssize_t) image_info->quality/10,9)));
rows_per_strip=(uint32) image->rows;
break;
}
+#if defined(LZMA_SUPPORT) && defined(COMPRESSION_LZMA)
+ case COMPRESSION_LZMA:
+ {
+ if (((photometric == PHOTOMETRIC_RGB) ||
+ (photometric == PHOTOMETRIC_MINISBLACK)) &&
+ ((bits_per_sample == 8) || (bits_per_sample == 16)))
+ (void) TIFFSetField(tiff,TIFFTAG_PREDICTOR,PREDICTOR_HORIZONTAL);
+ (void) TIFFSetField(tiff,TIFFTAG_LZMAPRESET,(long) (
+ image_info->quality == UndefinedCompressionQuality ? 7 :
+ MagickMin((ssize_t) image_info->quality/10,9)));
+ break;
+ }
+#endif
case COMPRESSION_LZW:
{
(void) TIFFGetFieldDefaulted(tiff,TIFFTAG_BITSPERSAMPLE,
if (((photometric == PHOTOMETRIC_RGB) ||
(photometric == PHOTOMETRIC_MINISBLACK)) &&
((bits_per_sample == 8) || (bits_per_sample == 16)))
- (void) TIFFSetField(tiff,TIFFTAG_PREDICTOR,2);
+ (void) TIFFSetField(tiff,TIFFTAG_PREDICTOR,PREDICTOR_HORIZONTAL);
break;
}
default:
break;
}
- (void) TIFFSetField(tiff,TIFFTAG_ROWSPERSTRIP,rows_per_strip);
- if ((image->x_resolution != 0.0) && (image->y_resolution != 0.0))
+ option=GetImageOption(image_info,"tiff:tile-geometry");
+ if (option == (const char *) NULL)
+ (void) TIFFSetField(tiff,TIFFTAG_ROWSPERSTRIP,rows_per_strip);
+ if ((image->resolution.x != 0.0) && (image->resolution.y != 0.0))
{
unsigned short
units;
if (image->units == PixelsPerCentimeterResolution)
units=RESUNIT_CENTIMETER;
(void) TIFFSetField(tiff,TIFFTAG_RESOLUTIONUNIT,(uint16) units);
- (void) TIFFSetField(tiff,TIFFTAG_XRESOLUTION,image->x_resolution);
- (void) TIFFSetField(tiff,TIFFTAG_YRESOLUTION,image->y_resolution);
+ (void) TIFFSetField(tiff,TIFFTAG_XRESOLUTION,image->resolution.x);
+ (void) TIFFSetField(tiff,TIFFTAG_YRESOLUTION,image->resolution.y);
if ((image->page.x != 0) || (image->page.y != 0))
{
/*
Set image position.
*/
(void) TIFFSetField(tiff,TIFFTAG_XPOSITION,(float) image->page.x/
- image->x_resolution);
+ image->resolution.x);
(void) TIFFSetField(tiff,TIFFTAG_YPOSITION,(float) image->page.y/
- image->y_resolution);
+ image->resolution.y);
}
}
if (image->chromaticity.white_point.x != 0.0)
(void) TIFFSetField(tiff,TIFFTAG_SUBFILETYPE,FILETYPE_PAGE);
(void) TIFFSetField(tiff,TIFFTAG_PAGENUMBER,page,pages);
}
- (void) TIFFSetProperties(tiff,image);
+ (void) TIFFSetProperties(tiff,image,exception);
if (0)
- (void) TIFFSetEXIFProperties(tiff,image);
+ (void) TIFFSetEXIFProperties(tiff,image,exception);
/*
Write image scanlines.
*/
quantum_type=RGBAQuantum;
for (y=0; y < (ssize_t) image->rows; y++)
{
- register const PixelPacket
+ register const Quantum
*restrict p;
- p=GetVirtualPixels(image,0,y,image->columns,1,
- &image->exception);
- if (p == (const PixelPacket *) NULL)
+ p=GetVirtualPixels(image,0,y,image->columns,1,exception);
+ if (p == (const Quantum *) NULL)
break;
- length=ExportQuantumPixels(image,(const CacheView *) NULL,
- quantum_info,quantum_type,pixels,&image->exception);
+ length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
+ quantum_type,pixels,exception);
+ (void) length;
if (TIFFWritePixels(tiff,&tiff_info,y,0,image) == -1)
break;
if (image->previous == (Image *) NULL)
{
- status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
- image->rows);
+ status=SetImageProgress(image,SaveImageTag,(MagickOffsetType)
+ y,image->rows);
if (status == MagickFalse)
break;
}
*/
for (y=0; y < (ssize_t) image->rows; y++)
{
- register const PixelPacket
+ register const Quantum
*restrict p;
- p=GetVirtualPixels(image,0,y,image->columns,1,
- &image->exception);
- if (p == (const PixelPacket *) NULL)
+ p=GetVirtualPixels(image,0,y,image->columns,1,exception);
+ if (p == (const Quantum *) NULL)
break;
- length=ExportQuantumPixels(image,(const CacheView *) NULL,
- quantum_info,RedQuantum,pixels,&image->exception);
+ length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
+ RedQuantum,pixels,exception);
if (TIFFWritePixels(tiff,&tiff_info,y,0,image) == -1)
break;
}
}
for (y=0; y < (ssize_t) image->rows; y++)
{
- register const PixelPacket
+ register const Quantum
*restrict p;
- p=GetVirtualPixels(image,0,y,image->columns,1,
- &image->exception);
- if (p == (const PixelPacket *) NULL)
+ p=GetVirtualPixels(image,0,y,image->columns,1,exception);
+ if (p == (const Quantum *) NULL)
break;
- length=ExportQuantumPixels(image,(const CacheView *) NULL,
- quantum_info,GreenQuantum,pixels,&image->exception);
+ length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
+ GreenQuantum,pixels,exception);
if (TIFFWritePixels(tiff,&tiff_info,y,1,image) == -1)
break;
}
}
for (y=0; y < (ssize_t) image->rows; y++)
{
- register const PixelPacket
+ register const Quantum
*restrict p;
- p=GetVirtualPixels(image,0,y,image->columns,1,
- &image->exception);
- if (p == (const PixelPacket *) NULL)
+ p=GetVirtualPixels(image,0,y,image->columns,1,exception);
+ if (p == (const Quantum *) NULL)
break;
- length=ExportQuantumPixels(image,(const CacheView *) NULL,
- quantum_info,BlueQuantum,pixels,&image->exception);
+ length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
+ BlueQuantum,pixels,exception);
if (TIFFWritePixels(tiff,&tiff_info,y,2,image) == -1)
break;
}
if (image->matte != MagickFalse)
for (y=0; y < (ssize_t) image->rows; y++)
{
- register const PixelPacket
+ register const Quantum
*restrict p;
- p=GetVirtualPixels(image,0,y,image->columns,1,
- &image->exception);
- if (p == (const PixelPacket *) NULL)
+ p=GetVirtualPixels(image,0,y,image->columns,1,exception);
+ if (p == (const Quantum *) NULL)
break;
- length=ExportQuantumPixels(image,(const CacheView *) NULL,
- quantum_info,AlphaQuantum,pixels,&image->exception);
+ length=ExportQuantumPixels(image,(CacheView *) NULL,
+ quantum_info,AlphaQuantum,pixels,exception);
if (TIFFWritePixels(tiff,&tiff_info,y,3,image) == -1)
break;
}
if (image->matte != MagickFalse)
quantum_type=CMYKAQuantum;
if (image->colorspace != CMYKColorspace)
- (void) TransformImageColorspace(image,CMYKColorspace);
+ (void) TransformImageColorspace(image,CMYKColorspace,exception);
for (y=0; y < (ssize_t) image->rows; y++)
{
- register const PixelPacket
+ register const Quantum
*restrict p;
- p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
- if (p == (const PixelPacket *) NULL)
+ p=GetVirtualPixels(image,0,y,image->columns,1,exception);
+ if (p == (const Quantum *) NULL)
break;
- length=ExportQuantumPixels(image,(const CacheView *) NULL,
- quantum_info,quantum_type,pixels,&image->exception);
+ length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
+ quantum_type,pixels,exception);
if (TIFFWritePixels(tiff,&tiff_info,y,0,image) == -1)
break;
if (image->previous == (Image *) NULL)
quantum_type=GrayQuantum;
for (y=0; y < (ssize_t) image->rows; y++)
{
- register const PixelPacket
+ register const Quantum
*restrict p;
- p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
- if (p == (const PixelPacket *) NULL)
+ p=GetVirtualPixels(image,0,y,image->columns,1,exception);
+ if (p == (const Quantum *) NULL)
break;
- length=ExportQuantumPixels(image,(const CacheView *) NULL,
- quantum_info,quantum_type,pixels,&image->exception);
+ length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
+ quantum_type,pixels,exception);
if (TIFFWritePixels(tiff,&tiff_info,y,0,image) == -1)
break;
if (image->previous == (Image *) NULL)
projects / imagemagick / blobdiff