{
drawable_.operator()(wand);
- if( constImage()->exception.severity == UndefinedException)
- DrawRender(wand);
+ DrawRender(wand);
wand=DestroyDrawingWand(wand);
}
p != drawable_.end(); p++ )
{
p->operator()(wand);
- if( constImage()->exception.severity != UndefinedException)
- break;
}
- if( constImage()->exception.severity == UndefinedException)
- DrawRender(wand);
+ DrawRender(wand);
wand=DestroyDrawingWand(wand);
}
{
modifyImage();
+ ExceptionInfo exceptionInfo;
+ GetExceptionInfo( &exceptionInfo );
size_t status =
InvokeDynamicImageFilter( name_.c_str(), &image(), argc, argv,
- &image()->exception );
-
- if (status == false)
- throwException( image()->exception );
+ &exceptionInfo );
+ throwException( exceptionInfo );
+ (void) DestroyExceptionInfo( &exceptionInfo );
}
// Quantize colors in image using current quantization settings
}
replaceImage( image );
throwException( exceptionInfo );
- if ( image )
- throwException( image->exception );
(void) DestroyExceptionInfo( &exceptionInfo );
}
blob_.length(), &exceptionInfo );
replaceImage( image );
throwException( exceptionInfo );
- if ( image )
- throwException( image->exception );
(void) DestroyExceptionInfo( &exceptionInfo );
}
&exceptionInfo );
replaceImage( image );
throwException( exceptionInfo );
- if ( image )
- throwException( image->exception );
(void) DestroyExceptionInfo( &exceptionInfo );
}
std::string color = color_;
PixelInfo target;
- (void) QueryColorCompliance(std::string(color_).c_str(),AllCompliance,
- &target,&image()->exception);
ExceptionInfo exceptionInfo;
GetExceptionInfo( &exceptionInfo );
+ (void) QueryColorCompliance(std::string(color_).c_str(),AllCompliance,
+ &target,&exceptionInfo);
modifyImage();
TransparentPaintImage ( image(), &target, TransparentAlpha, MagickFalse,
&exceptionInfo );
PixelInfo targetLow;
PixelInfo targetHigh;
- (void) QueryColorCompliance(std::string(colorLow_).c_str(),
- AllCompliance,&targetLow,&image()->exception);
- (void) QueryColorCompliance(std::string(colorHigh_).c_str(),
- AllCompliance,&targetHigh,&image()->exception);
ExceptionInfo exceptionInfo;
GetExceptionInfo( &exceptionInfo );
+ (void) QueryColorCompliance(std::string(colorLow_).c_str(),
+ AllCompliance,&targetLow,&exceptionInfo);
+ (void) QueryColorCompliance(std::string(colorHigh_).c_str(),
+ AllCompliance,&targetHigh,&exceptionInfo);
modifyImage();
TransparentPaintImageChroma ( image(), &targetLow, &targetHigh,
TransparentAlpha, MagickFalse, &exceptionInfo );
void Magick::Image::throwImageException( void ) const
{
// Throw C++ exception while resetting Image exception to default state
- throwException( const_cast<MagickCore::Image*>(constImage())->exception );
}
// Register image with image registry or obtain registration id
_mutexLock()
{
// Allocate default image
- _image = AcquireImage( _options->imageInfo(), &_image->exception );
+ ExceptionInfo exceptionInfo;
+ GetExceptionInfo( &exceptionInfo );
- // Test for error and throw exception (like throwImageException())
- throwException(_image->exception);
+ _image = AcquireImage( _options->imageInfo(), &exceptionInfo );
+ throwException( exceptionInfo );
+ (void) DestroyExceptionInfo( &exceptionInfo );
}
// Destructor
using MagickCore::GetAffineMatrix;
using MagickCore::GetAuthenticMetacontent;
using MagickCore::GetBlobSize;
- using MagickCore::GetCacheViewException;
using MagickCore::GetCacheViewAuthenticMetacontent;
using MagickCore::GetCacheViewAuthenticPixels;
using MagickCore::GetColorTuple;
MagickCore::GetExceptionInfo( &exceptionInfo );
linkImages( first_, last_ );
MagickCore::AnimateImages( first_->imageInfo(), first_->image() );
- MagickCore::GetImageException( first_->image(), &exceptionInfo );
unlinkImages( first_, last_ );
throwException( exceptionInfo );
(void) MagickCore::DestroyExceptionInfo( &exceptionInfo );
MagickCore::GetExceptionInfo( &exceptionInfo );
linkImages( first_, last_ );
MagickCore::DisplayImages( first_->imageInfo(), first_->image() );
- MagickCore::GetImageException( first_->image(), &exceptionInfo );
unlinkImages( first_, last_ );
throwException( exceptionInfo );
(void) MagickCore::DestroyExceptionInfo( &exceptionInfo );
linkImages( first_, last_ );
MagickCore::RemapImages( &quantizeInfo, first_->image(),
mapImage_.constImage());
- MagickCore::GetImageException( first_->image(), &exceptionInfo );
if ( exceptionInfo.severity != MagickCore::UndefinedException )
{
unlinkImages( first_, last_ );
// Udate DirectClass representation of pixels
MagickCore::SyncImage( image, &exceptionInfo );
- if ( image->exception.severity > MagickCore::UndefinedException )
- {
- unlinkImages( first_, last_ );
- throwException( exceptionInfo );
- }
+ unlinkImages( first_, last_ );
+ throwException( exceptionInfo );
(void) MagickCore::DestroyExceptionInfo( &exceptionInfo );
// Next image
}
// Report any transparentImage() error
- MagickCore::GetImageException( first_->image(), &exceptionInfo );
throwException( exceptionInfo );
(void) MagickCore::DestroyExceptionInfo( &exceptionInfo );
}
MagickCore::QuantizeImages( first_->quantizeInfo(),
first_->image() );
- MagickCore::GetImageException( first_->image(), &exceptionInfo );
if ( exceptionInfo.severity > MagickCore::UndefinedException )
{
unlinkImages( first_, last_ );
return((ssize_t) length);
}
-MagickExport MagickBooleanType FileToImage(Image *image,const char *filename)
+MagickExport MagickBooleanType FileToImage(Image *image,const char *filename,
+ ExceptionInfo *exception)
{
int
file;
file=open_utf8(filename,O_RDONLY | O_BINARY,0);
if (file == -1)
{
- ThrowFileException(&image->exception,BlobError,"UnableToOpenBlob",
- filename);
+ ThrowFileException(exception,BlobError,"UnableToOpenBlob",filename);
return(MagickFalse);
}
quantum=(size_t) MagickMaxBufferExtent;
blob=(unsigned char *) AcquireQuantumMemory(quantum,sizeof(*blob));
if (blob == (unsigned char *) NULL)
{
- ThrowFileException(&image->exception,ResourceLimitError,
- "MemoryAllocationFailed",filename);
+ ThrowFileException(exception,ResourceLimitError,"MemoryAllocationFailed",
+ filename);
return(MagickFalse);
}
for ( ; ; )
count=WriteBlobStream(image,length,blob);
if (count != (ssize_t) length)
{
- ThrowFileException(&image->exception,BlobError,"UnableToWriteBlob",
- filename);
+ ThrowFileException(exception,BlobError,"UnableToWriteBlob",filename);
break;
}
}
file=close(file);
if (file == -1)
- ThrowFileException(&image->exception,BlobError,"UnableToWriteBlob",
- filename);
+ ThrowFileException(exception,BlobError,"UnableToWriteBlob",filename);
blob=(unsigned char *) RelinquishMagickMemory(blob);
return(MagickTrue);
}
BlobToFile(char *,const void *,const size_t,ExceptionInfo *),
CloseBlob(Image *),
DiscardBlobBytes(Image *,const MagickSizeType),
- FileToImage(Image *,const char *),
+ FileToImage(Image *,const char *,ExceptionInfo *),
ImageToFile(Image *,char *,ExceptionInfo *),
InjectImageBlob(const ImageInfo *,Image *,Image *,const char *,
ExceptionInfo *),
% %
% %
% %
-% G e t C a c h e V i e w E x c e p t i o n %
-% %
-% %
-% %
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%
-% GetCacheViewException() returns the image exception associated with the
-% specified view.
-%
-% The format of the GetCacheViewException method is:
-%
-% ExceptionInfo GetCacheViewException(const CacheView *cache_view)
-%
-% A description of each parameter follows:
-%
-% o cache_view: the cache view.
-%
-*/
-MagickExport ExceptionInfo *GetCacheViewException(const CacheView *cache_view)
-{
- assert(cache_view != (CacheView *) NULL);
- assert(cache_view->signature == MagickSignature);
- if (cache_view->debug != MagickFalse)
- (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
- cache_view->image->filename);
- return(&cache_view->image->exception);
-}
-\f
-/*
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-% %
-% %
-% %
+ G e t C a c h e V i e w E x t e n t %
% %
% %
% The format of the SetCacheViewStorageClass method is:
%
% MagickBooleanType SetCacheViewStorageClass(CacheView *cache_view,
-% const ClassType storage_class)
+% const ClassType storage_class,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
%
% o storage_class: the image storage class: PseudoClass or DirectClass.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
MagickExport MagickBooleanType SetCacheViewStorageClass(CacheView *cache_view,
- const ClassType storage_class)
+ const ClassType storage_class,ExceptionInfo *exception)
{
- MagickBooleanType
- status;
-
assert(cache_view != (CacheView *) NULL);
assert(cache_view->signature == MagickSignature);
if (cache_view->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
cache_view->image->filename);
- status=SetImageStorageClass(cache_view->image,storage_class,
- &cache_view->image->exception);
- return(status);
+ return(SetImageStorageClass(cache_view->image,storage_class,exception));
}
\f
/*
extern MagickExport const void
*GetCacheViewVirtualMetacontent(const CacheView *);
-extern MagickExport ExceptionInfo
- *GetCacheViewException(const CacheView *);
-
extern MagickExport MagickBooleanType
GetOneCacheViewVirtualPixel(const CacheView *,const ssize_t,const ssize_t,
Quantum *,ExceptionInfo *),
const ssize_t,const ssize_t,Quantum *,ExceptionInfo *),
GetOneCacheViewAuthenticPixel(const CacheView *,const ssize_t,const ssize_t,
Quantum *,ExceptionInfo *),
- SetCacheViewStorageClass(CacheView *,const ClassType),
+ SetCacheViewStorageClass(CacheView *,const ClassType,ExceptionInfo *),
SetCacheViewVirtualPixelMethod(CacheView *,const VirtualPixelMethod),
SyncCacheViewAuthenticPixels(CacheView *,ExceptionInfo *);
q=nexus_info->pixels;
r=GetVirtualPixelsFromNexus(image->mask,MaskVirtualPixelMethod,
nexus_info->region.x,nexus_info->region.y,nexus_info->region.width,
- nexus_info->region.height,clip_nexus[0],&image->exception);
+ nexus_info->region.height,clip_nexus[0],exception);
GetPixelInfo(image,&alpha);
GetPixelInfo(image,&beta);
number_pixels=(MagickSizeType) nexus_info->region.width*
cache_info=(CacheInfo *) image->cache;
status=OpenPixelCache(image,IOMode,exception);
if (status != MagickFalse)
- status=ClonePixelCachePixels(cache_info,clone_info,&image->exception);
+ status=ClonePixelCachePixels(cache_info,clone_info,exception);
*offset+=cache_info->length+page_size-(cache_info->length % page_size);
clone_info=(CacheInfo *) DestroyPixelCache(clone_info);
return(status);
#include <MagickCore/color.h>
#include <MagickCore/exception-private.h>
-static inline Quantum ConstrainColormapIndex(Image *image,const size_t index)
+static inline Quantum ConstrainColormapIndex(Image *image,const size_t index,
+ ExceptionInfo *exception)
{
if (index < image->colors)
return((Quantum) index);
- (void) ThrowMagickException(&image->exception,GetMagickModule(),
- CorruptImageError,"InvalidColormapIndex","`%s'",image->filename);
+ (void) ThrowMagickException(exception,GetMagickModule(),CorruptImageError,
+ "InvalidColormapIndex","`%s'",image->filename);
return((Quantum) 0);
}
image->colormap[i].blue=(Quantum) pixel;
image->colormap[i].alpha=OpaqueAlpha;
}
- return(SetImageStorageClass(image,PseudoClass,&image->exception));
+ return(SetImageStorageClass(image,PseudoClass,exception));
}
\f
/*
if ((reconstruct_image->columns != image->columns) ||
(reconstruct_image->rows != image->rows))
{
- (void) ThrowMagickException(&image->exception,GetMagickModule(),
- ImageError,"ImageSizeDiffers","`%s'",image->filename);
+ (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
+ "ImageSizeDiffers","`%s'",image->filename);
return((double *) NULL);
}
/*
ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
inject_image->filename);
(void) ResetMagickMemory(scanline,0,width*sizeof(*scanline));
- huffman_image=CloneImage(inject_image,0,0,MagickTrue,&image->exception);
+ huffman_image=CloneImage(inject_image,0,0,MagickTrue,exception);
if (huffman_image == (Image *) NULL)
{
scanline=(unsigned char *) RelinquishMagickMemory(scanline);
progress_monitor=SetImageProgressMonitor(p,(MagickProgressMonitor) NULL,
p->client_data);
status&=WriteImage(write_info,p,exception);
- GetImageException(p,exception);
if (number_images != 1)
(void) SetImageProgressMonitor(p,progress_monitor,p->client_data);
if (write_info->adjoin != MagickFalse)
break;
}
histogram=(MagickRealType *) RelinquishMagickMemory(histogram);
- status=LevelImage(image,(double) black,(double) white,1.0,&image->exception);
+ status=LevelImage(image,(double) black,(double) white,1.0,exception);
return(status);
}
\f
% %
% %
% %
+% C l o n e E x c e p t i o n I n f o %
+% %
+% %
+% %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%
+% CloneExceptionInfo() clones the ExceptionInfo structure.
+%
+% The format of the CloneExceptionInfo method is:
+%
+% ExceptionInfo *CloneException(ExceptionInfo *exception)
+%
+% A description of each parameter follows:
+%
+% o exception: the exception info.
+%
+*/
+MagickExport ExceptionInfo *CloneExceptionInfo(ExceptionInfo *exception)
+{
+ ExceptionInfo
+ *clone_exception;
+
+ clone_exception=(ExceptionInfo *) AcquireMagickMemory(sizeof(*exception));
+ if (clone_exception == (ExceptionInfo *) NULL)
+ ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
+ GetExceptionInfo(clone_exception);
+ InheritException(clone_exception,exception);
+ exception->relinquish=MagickTrue;
+ return(exception);
+}
+\f
+/*
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% %
+% %
+% %
+ D e f a u l t E r r o r H a n d l e r %
% %
% %
extern MagickExport ExceptionInfo
*AcquireExceptionInfo(void),
+ *CloneExceptionInfo(ExceptionInfo *),
*DestroyExceptionInfo(ExceptionInfo *);
extern MagickExport FatalErrorHandler
picture_image=DestroyImage(picture_image);
if (bend_image == (Image *) NULL)
return((Image *) NULL);
- InheritException(&bend_image->exception,exception);
picture_image=bend_image;
rotate_image=RotateImage(picture_image,-90.0,exception);
picture_image=DestroyImage(picture_image);
image->ticks_per_second=UndefinedTicksPerSecond;
image->compose=OverCompositeOp;
image->blur=1.0;
- GetExceptionInfo(&image->exception);
(void) QueryColorCompliance(BackgroundColor,AllCompliance,
&image->background_color,exception);
(void) QueryColorCompliance(BorderColor,AllCompliance,&image->border_color,
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
exception=AcquireExceptionInfo();
- GetImageException(image,exception);
CatchException(exception);
severity=exception->severity;
exception=DestroyExceptionInfo(exception);
(void) CloneImageProperties(clone_image,image);
(void) CloneImageArtifacts(clone_image,image);
GetTimerInfo(&clone_image->timer);
- GetExceptionInfo(&clone_image->exception);
- InheritException(&clone_image->exception,&image->exception);
if (image->ascii85 != (void *) NULL)
Ascii85Initialize(clone_image);
clone_image->magick_columns=image->magick_columns;
if (image->ascii85 != (Ascii85Info*) NULL)
image->ascii85=(Ascii85Info *) RelinquishMagickMemory(image->ascii85);
DestroyBlob(image);
- (void) DestroyExceptionInfo(&image->exception);
if (image->semaphore != (SemaphoreInfo *) NULL)
DestroySemaphoreInfo(&image->semaphore);
image->signature=(~MagickSignature);
% %
% %
% %
-% G e t I m a g e E x c e p t i o n %
-% %
-% %
-% %
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%
-% GetImageException() traverses an image sequence and returns any
-% error more severe than noted by the exception parameter.
-%
-% The format of the GetImageException method is:
-%
-% void GetImageException(Image *image,ExceptionInfo *exception)
-%
-% A description of each parameter follows:
-%
-% o image: Specifies a pointer to a list of one or more images.
-%
-% o exception: return the highest severity exception.
-%
-*/
-MagickExport void GetImageException(Image *image,ExceptionInfo *exception)
-{
- register Image
- *next;
-
- assert(image != (Image *) NULL);
- assert(image->signature == MagickSignature);
- if (image->debug != MagickFalse)
- (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
- assert(exception != (ExceptionInfo *) NULL);
- assert(exception->signature == MagickSignature);
- for (next=image; next != (Image *) NULL; next=GetNextImageInList(next))
- {
- if (next->exception.severity == UndefinedException)
- continue;
- if (next->exception.severity > exception->severity)
- InheritException(exception,&next->exception);
- next->exception.severity=UndefinedException;
- }
-}
-\f
-/*
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-% %
-% %
-% %
% G e t I m a g e I n f o %
% %
% %
BlobInfo
*blob; /* image file as in-memory string of 'extent' */
- ExceptionInfo
- exception; /* Error handling report */
-
MagickBooleanType
debug; /* debug output attribute */
AcquireNextImage(const ImageInfo *,Image *,ExceptionInfo *),
DestroyImagePixels(Image *),
DisassociateImageStream(Image *),
- GetImageException(Image *,ExceptionInfo *),
GetImageInfo(ImageInfo *),
SetImageInfoBlob(ImageInfo *,const void *,const size_t),
SetImageInfoFile(ImageInfo *,FILE *);
/*
Set floodfill state.
*/
- floodplane_image=CloneImage(image,0,0,MagickTrue,&image->exception);
+ floodplane_image=CloneImage(image,0,0,MagickTrue,exception);
if (floodplane_image == (Image *) NULL)
return(MagickFalse);
(void) SetImageAlphaChannel(floodplane_image,OpaqueAlphaChannel,exception);
default:
{
quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
- (void) ThrowMagickException(&image->exception,GetMagickModule(),
- OptionError,"UnrecognizedPixelMap","`%s'",map);
+ (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
+ "UnrecognizedPixelMap","`%s'",map);
break;
}
}
assert(image->signature == MagickSignature);
if (image->colorspace != CMYKColorspace)
{
- (void) ThrowMagickException(&image->exception,GetMagickModule(),
- ImageError,"ColorSeparatedImageRequired","`%s'",image->filename);
+ (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
+ "ColorSeparatedImageRequired","`%s'",image->filename);
return(0.0);
}
status=MagickTrue;
char
value[MaxTextExtent];
+ ExceptionInfo
+ *exception;
+
+ MagickBooleanType
+ status;
+
ssize_t
n;
n=FormatLocaleStringList(value,MaxTextExtent,format,operands);
(void) n;
va_end(operands);
- return(SetImageProperty(image,property,value,&image->exception));
+ exception=AcquireExceptionInfo();
+ status=SetImageProperty(image,property,value,exception);
+ exception=DestroyExceptionInfo(exception);
+ return(status);
}
\f
/*
Image storage class and colorspace.
*/
colorspace=image->colorspace;
- if (IsImageGray(image,&image->exception) != MagickFalse)
+ if (IsImageGray(image,exception) != MagickFalse)
colorspace=GRAYColorspace;
(void) FormatLocaleString(value,MaxTextExtent,"%s",
CommandOptionToMnemonic(MagickColorspaceOptions,(ssize_t)
kurtosis,
skewness;
- (void) GetImageKurtosis(image,&kurtosis,&skewness,&image->exception);
+ (void) GetImageKurtosis(image,&kurtosis,&skewness,exception);
(void) FormatLocaleString(value,MaxTextExtent,"%.*g",
GetMagickPrecision(),kurtosis);
break;
maximum,
minimum;
- (void) GetImageRange(image,&minimum,&maximum,&image->exception);
+ (void) GetImageRange(image,&minimum,&maximum,exception);
(void) FormatLocaleString(value,MaxTextExtent,"%.*g",
GetMagickPrecision(),maximum);
break;
standard_deviation;
(void) GetImageMean(image,&mean,&standard_deviation,
- &image->exception);
+ exception);
(void) FormatLocaleString(value,MaxTextExtent,"%.*g",
GetMagickPrecision(),mean);
break;
maximum,
minimum;
- (void) GetImageRange(image,&minimum,&maximum,&image->exception);
+ (void) GetImageRange(image,&minimum,&maximum,exception);
(void) FormatLocaleString(value,MaxTextExtent,"%.*g",
GetMagickPrecision(),minimum);
break;
MagickBooleanType
opaque;
- opaque=IsImageOpaque(image,&image->exception);
+ opaque=IsImageOpaque(image,exception);
(void) CopyMagickString(value,opaque == MagickFalse ? "false" :
"true",MaxTextExtent);
break;
kurtosis,
skewness;
- (void) GetImageKurtosis(image,&kurtosis,&skewness,&image->exception);
+ (void) GetImageKurtosis(image,&kurtosis,&skewness,exception);
(void) FormatLocaleString(value,MaxTextExtent,"%.*g",
GetMagickPrecision(),skewness);
break;
standard_deviation;
(void) GetImageMean(image,&mean,&standard_deviation,
- &image->exception);
+ exception);
(void) FormatLocaleString(value,MaxTextExtent,"%.*g",
GetMagickPrecision(),standard_deviation);
break;
text=(char *) embed_text;
if ((*text == '@') && ((*(text+1) == '-') ||
(IsPathAccessible(text+1) != MagickFalse)))
- return(FileToString(embed_text+1,~0,&image->exception));
+ return(FileToString(embed_text+1,~0,exception));
/*
Translate any embedded format characters.
*/
case 'k': /* Number of unique colors */
{
q+=FormatLocaleString(q,extent,"%.20g",(double) GetNumberColors(image,
- (FILE *) NULL,&image->exception));
+ (FILE *) NULL,exception));
break;
}
case 'l': /* Image label */
colorspace;
colorspace=image->colorspace;
- if (IsImageGray(image,&image->exception) != MagickFalse)
+ if (IsImageGray(image,exception) != MagickFalse)
colorspace=GRAYColorspace;
q+=FormatLocaleString(q,extent,"%s%s%s",CommandOptionToMnemonic(
MagickClassOptions,(ssize_t) image->storage_class),
/*
Initialize histogram.
*/
- InitializeHistogram(image,histogram,&image->exception);
+ InitializeHistogram(image,histogram,exception);
(void) OptimalTau(histogram[Red],Tau,0.2,DeltaTau,
smooth_threshold == 0.0 ? 1.0 : smooth_threshold,extrema[Red]);
(void) OptimalTau(histogram[Green],Tau,0.2,DeltaTau,
% The format of the WriteStream() method is:
%
% MagickBooleanType WriteStream(const ImageInfo *image_info,Image *,
-% StreamHandler stream)
+% StreamHandler stream,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
%
% o stream: A callback method.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
MagickExport MagickBooleanType WriteStream(const ImageInfo *image_info,
- Image *image,StreamHandler stream)
+ Image *image,StreamHandler stream,ExceptionInfo *exception)
{
ImageInfo
*write_info;
assert(image->signature == MagickSignature);
write_info=CloneImageInfo(image_info);
write_info->stream=stream;
- status=WriteImage(write_info,image,&image->exception);
+ status=WriteImage(write_info,image,exception);
write_info=DestroyImageInfo(write_info);
return(status);
}
extern MagickExport MagickBooleanType
OpenStream(const ImageInfo *,StreamInfo *,const char *,ExceptionInfo *),
- WriteStream(const ImageInfo *,Image *,StreamHandler);
+ WriteStream(const ImageInfo *,Image *,StreamHandler,ExceptionInfo *);
extern MagickExport StreamInfo
*AcquireStreamInfo(const ImageInfo *,ExceptionInfo *),
*channel_distortion;
channel_distortion=GetImageDistortions(image,reconstruct_image,
- metric,&image->exception);
+ metric,exception);
(void) FormatLocaleFile(stderr,"Image: %s\n",image->filename);
if ((reconstruct_image->columns != image->columns) ||
(reconstruct_image->rows != image->rows))
for (x=0; x < (ssize_t) (*image)->columns; x+=(ssize_t) columns)
status&=CompositeImage(*image,composite_options->compose,
composite_image,x,y,exception);
- GetImageException(*image,exception);
}
else
{
*/
status&=CompositeImage(*image,composite_options->compose,
composite_image,geometry.x,geometry.y,exception);
- GetImageException(*image,exception);
}
}
(void) SetPixelChannelMap(composite_image,channel_mask);
*/
(void) CopyMagickString(display_image->filename,
resource_info.write_filename,MaxTextExtent);
- (void) SetImageInfo(image_info,1,&display_image->exception);
- status&=WriteImage(image_info,display_image,
- &display_image->exception);
- GetImageException(display_image,exception);
+ (void) SetImageInfo(image_info,1,exception);
+ status&=WriteImage(image_info,display_image,exception);
}
/*
Proceed to next/previous image.
{ \
FireImageStack(MagickTrue,advance,MagickTrue); \
if (image != (Image *) NULL) \
- { \
- InheritException(exception,&(image)->exception); \
- (void) SyncImagesSettings(image_info,image,exception); \
- } \
+ (void) SyncImagesSettings(image_info,image,exception); \
}
#define FireImageStack(postfix,advance,fire) \
if ((j <= i) && (i < (ssize_t) argc)) \
/*
Write image.
*/
- GetImageException(montage_image,exception);
(void) CopyMagickString(image_info->filename,argv[argc-1],MaxTextExtent);
(void) CopyMagickString(montage_image->magick_filename,argv[argc-1],
MaxTextExtent);
*/
WandExport MagickBooleanType PixelSyncIterator(PixelIterator *iterator)
{
+ MagickBooleanType
+ status;
+
register ssize_t
x;
assert(iterator->signature == WandSignature);
if (iterator->debug != MagickFalse)
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",iterator->name);
- if (SetCacheViewStorageClass(iterator->view,DirectClass) == MagickFalse)
+ status=SetCacheViewStorageClass(iterator->view,DirectClass,
+ iterator->exception);
+ if (status == MagickFalse)
return(MagickFalse);
pixels=GetCacheViewAuthenticPixels(iterator->view,iterator->region.x,
iterator->region.y+iterator->y,iterator->region.width,1,
layers=CoalesceImages(image,exception);
if (layers == (Image *) NULL)
break;
- InheritException(&(layers->exception),exception);
image=layers;
layers=OptimizeImageLayers(image,exception);
if (layers == (Image *) NULL)
break;
- InheritException(&(layers->exception),exception);
image=DestroyImageList(image);
image=layers;
layers=(Image *) NULL;
}
}
if (layers != (Image *) NULL)
- {
- InheritException(&(layers->exception),exception);
- image=layers;
- }
+ image=layers;
if ((image == (Image *) NULL) || (exception->severity >= ErrorException))
goto PerlException;
for ( ; image; image=image->next)
scene++;
} while (count == (ssize_t) length);
quantum_info=DestroyQuantumInfo(quantum_info);
- InheritException(&image->exception,&canvas_image->exception);
canvas_image=DestroyImage(canvas_image);
(void) CloseBlob(image);
return(GetFirstImageInList(image));
break;
for (x=0; x < ((ssize_t) image->columns-1); x+=2)
{
- index=ConstrainColormapIndex(image,(*p >> 4) & 0x0f);
+ index=ConstrainColormapIndex(image,(*p >> 4) & 0x0f,exception);
SetPixelIndex(image,index,q);
q+=GetPixelChannels(image);
- index=ConstrainColormapIndex(image,*p & 0x0f);
+ index=ConstrainColormapIndex(image,*p & 0x0f,exception);
SetPixelIndex(image,index,q);
q+=GetPixelChannels(image);
p++;
}
if ((image->columns % 2) != 0)
{
- index=ConstrainColormapIndex(image,(*p >> 4) & 0xf);
+ index=ConstrainColormapIndex(image,(*p >> 4) & 0xf,exception);
SetPixelIndex(image,index,q);
q+=GetPixelChannels(image);
p++;
break;
for (x = (ssize_t)image->columns; x != 0; --x)
{
- index=ConstrainColormapIndex(image,*p++);
+ index=ConstrainColormapIndex(image,*p++,exception);
SetPixelIndex(image,index,q);
q+=GetPixelChannels(image);
}
draw_info->interline_spacing+draw_info->stroke_width+0.5);
if (SetImageBackgroundColor(image,exception) == MagickFalse)
{
- InheritException(exception,&image->exception);
image=DestroyImageList(image);
return((Image *) NULL);
}
scene++;
} while (count == (ssize_t) length);
quantum_info=DestroyQuantumInfo(quantum_info);
- InheritException(&image->exception,&canvas_image->exception);
canvas_image=DestroyImage(canvas_image);
(void) CloseBlob(image);
return(GetFirstImageInList(image));
} CUTPalHeader;
\f
-static void InsertRow(ssize_t depth,unsigned char *p,ssize_t y,Image *image)
+static void InsertRow(Image *image,ssize_t depth,unsigned char *p,ssize_t y,
+ ExceptionInfo *exception)
{
- ExceptionInfo
- *exception;
-
size_t bit; ssize_t x;
register Quantum *q;
Quantum index;
index=0;
- exception=(&image->exception);
switch (depth)
{
case 1: /* Convert bitmap scanline. */
break;
for (x=0; x < ((ssize_t) image->columns-1); x+=2)
{
- index=ConstrainColormapIndex(image,(*p >> 6) & 0x3);
+ index=ConstrainColormapIndex(image,(*p >> 6) & 0x3,exception);
SetPixelIndex(image,index,q);
q+=GetPixelChannels(image);
- index=ConstrainColormapIndex(image,(*p >> 4) & 0x3);
+ index=ConstrainColormapIndex(image,(*p >> 4) & 0x3,exception);
SetPixelIndex(image,index,q);
q+=GetPixelChannels(image);
- index=ConstrainColormapIndex(image,(*p >> 2) & 0x3);
+ index=ConstrainColormapIndex(image,(*p >> 2) & 0x3,exception);
SetPixelIndex(image,index,q);
q+=GetPixelChannels(image);
- index=ConstrainColormapIndex(image,(*p) & 0x3);
+ index=ConstrainColormapIndex(image,(*p) & 0x3,exception);
SetPixelIndex(image,index,q);
q+=GetPixelChannels(image);
p++;
}
if ((image->columns % 4) != 0)
{
- index=ConstrainColormapIndex(image,(*p >> 6) & 0x3);
+ index=ConstrainColormapIndex(image,(*p >> 6) & 0x3,exception);
SetPixelIndex(image,index,q);
q+=GetPixelChannels(image);
if ((image->columns % 4) >= 1)
{
- index=ConstrainColormapIndex(image,(*p >> 4) & 0x3);
+ index=ConstrainColormapIndex(image,(*p >> 4) & 0x3,exception);
SetPixelIndex(image,index,q);
q+=GetPixelChannels(image);
if ((image->columns % 4) >= 2)
{
- index=ConstrainColormapIndex(image,(*p >> 2) & 0x3);
+ index=ConstrainColormapIndex(image,(*p >> 2) & 0x3,
+ exception);
SetPixelIndex(image,index,q);
q+=GetPixelChannels(image);
}
break;
for (x=0; x < ((ssize_t) image->columns-1); x+=2)
{
- index=ConstrainColormapIndex(image,(*p >> 4) & 0xf);
+ index=ConstrainColormapIndex(image,(*p >> 4) & 0xf,exception);
SetPixelIndex(image,index,q);
q+=GetPixelChannels(image);
- index=ConstrainColormapIndex(image,(*p) & 0xf);
+ index=ConstrainColormapIndex(image,(*p) & 0xf,exception);
SetPixelIndex(image,index,q);
q+=GetPixelChannels(image);
p++;
}
if ((image->columns % 2) != 0)
{
- index=ConstrainColormapIndex(image,(*p >> 4) & 0xf);
+ index=ConstrainColormapIndex(image,(*p >> 4) & 0xf,exception);
SetPixelIndex(image,index,q);
q+=GetPixelChannels(image);
p++;
if (q == (Quantum *) NULL) break;
for (x=0; x < (ssize_t) image->columns; x++)
{
- index=ConstrainColormapIndex(image,*p);
+ index=ConstrainColormapIndex(image,*p,exception);
SetPixelIndex(image,index,q);
p++;
q+=GetPixelChannels(image);
/*
Compute the number of colors in Grayed R[i]=G[i]=B[i] image
*/
-static int GetCutColors(Image *image)
+static int GetCutColors(Image *image,ExceptionInfo *exception)
{
- ExceptionInfo
- *exception;
-
Quantum
intensity,
scale_intensity;
x,
y;
- exception=(&image->exception);
intensity=0;
scale_intensity=ScaleCharToQuantum(16);
for (y=0; y < (ssize_t) image->rows; y++)
RunCountMasked=RunCount & 0x7F;
}
- InsertRow(depth,BImgBuff,i,image);
+ InsertRow(image,depth,BImgBuff,i,exception);
}
(void) SyncImage(image,exception);
if(palette==NULL)
{ /*attempt to detect binary (black&white) images*/
if ((image->storage_class == PseudoClass) &&
- (IsImageGray(image,&image->exception) != MagickFalse))
+ (IsImageGray(image,exception) != MagickFalse))
{
- if(GetCutColors(image)==2)
+ if(GetCutColors(image,exception)==2)
{
for (i=0; i < (ssize_t)image->colors; i++)
{
0.5)/(window_width-1))+0.5));
}
index&=mask;
- index=(int) ConstrainColormapIndex(image,(size_t) index);
+ index=(int) ConstrainColormapIndex(image,(size_t) index,
+ exception);
SetPixelIndex(image,index,q);
pixel.red=1UL*image->colormap[index].red;
pixel.green=1UL*image->colormap[index].green;
0.5)/(window_width-1))+0.5));
}
index&=mask;
- index=(int) ConstrainColormapIndex(image,(size_t) index);
+ index=(int) ConstrainColormapIndex(image,(size_t) index,
+ exception);
SetPixelIndex(image,(((size_t) GetPixelIndex(image,q)) |
(((size_t) index) << 8)),q);
pixel.red=1UL*image->colormap[index].red;
} DDSColors;
typedef MagickBooleanType
- DDSDecoder(Image *,DDSInfo *);
+ DDSDecoder(Image *,DDSInfo *,ExceptionInfo *);
/*
Macros
DDSColors *c, MagickBooleanType ignoreAlpha);
static MagickBooleanType
- ReadDXT1(Image *image, DDSInfo *dds_info);
+ ReadDXT1(Image *, DDSInfo *,ExceptionInfo *);
static MagickBooleanType
- ReadDXT3(Image *image, DDSInfo *dds_info);
+ ReadDXT3(Image *image, DDSInfo *dds_info,ExceptionInfo *);
static MagickBooleanType
- ReadDXT5(Image *image, DDSInfo *dds_info);
+ ReadDXT5(Image *image, DDSInfo *dds_info,ExceptionInfo *);
static MagickBooleanType
- ReadUncompressedRGB(Image *image, DDSInfo *dds_info);
+ ReadUncompressedRGB(Image *image, DDSInfo *dds_info,ExceptionInfo *);
static MagickBooleanType
- ReadUncompressedRGBA(Image *image, DDSInfo *dds_info);
+ ReadUncompressedRGBA(Image *image, DDSInfo *dds_info,ExceptionInfo *);
static void
SkipDXTMipmaps(Image *image, DDSInfo *dds_info, int texel_size);
return(GetFirstImageInList(image));
}
- if ((decoder)(image, &dds_info) != MagickTrue)
+ if ((decoder)(image, &dds_info, exception) != MagickTrue)
{
(void) CloseBlob(image);
return(GetFirstImageInList(image));
}
}
-static MagickBooleanType ReadDXT1(Image *image, DDSInfo *dds_info)
+static MagickBooleanType ReadDXT1(Image *image, DDSInfo *dds_info,
+ ExceptionInfo *exception)
{
DDSColors
colors;
- ExceptionInfo
- *exception;
-
register Quantum
*q;
c0,
c1;
- exception=(&image->exception);
for (y = 0; y < (ssize_t) dds_info->height; y += 4)
{
for (x = 0; x < (ssize_t) dds_info->width; x += 4)
return MagickTrue;
}
-static MagickBooleanType ReadDXT3(Image *image, DDSInfo *dds_info)
+static MagickBooleanType ReadDXT3(Image *image, DDSInfo *dds_info,
+ ExceptionInfo *exception)
{
DDSColors
colors;
- ExceptionInfo
- *exception;
-
register Quantum
*q;
c0,
c1;
- exception=(&image->exception);
for (y = 0; y < (ssize_t) dds_info->height; y += 4)
{
for (x = 0; x < (ssize_t) dds_info->width; x += 4)
return MagickTrue;
}
-static MagickBooleanType ReadDXT5(Image *image, DDSInfo *dds_info)
+static MagickBooleanType ReadDXT5(Image *image, DDSInfo *dds_info,
+ ExceptionInfo *exception)
{
DDSColors
colors;
- ExceptionInfo
- *exception;
-
MagickSizeType
alpha_bits;
c0,
c1;
- exception=(&image->exception);
for (y = 0; y < (ssize_t) dds_info->height; y += 4)
{
for (x = 0; x < (ssize_t) dds_info->width; x += 4)
return MagickTrue;
}
-static MagickBooleanType ReadUncompressedRGB(Image *image, DDSInfo *dds_info)
+static MagickBooleanType ReadUncompressedRGB(Image *image, DDSInfo *dds_info,
+ ExceptionInfo *exception)
{
- ExceptionInfo
- *exception;
-
ssize_t
x, y;
register Quantum
*q;
- exception=(&image->exception);
for (y = 0; y < (ssize_t) dds_info->height; y++)
{
q = QueueAuthenticPixels(image, 0, y, dds_info->width, 1,exception);
return MagickTrue;
}
-static MagickBooleanType ReadUncompressedRGBA(Image *image, DDSInfo *dds_info)
+static MagickBooleanType ReadUncompressedRGBA(Image *image, DDSInfo *dds_info,
+ ExceptionInfo *exception)
{
- ExceptionInfo
- *exception;
-
ssize_t
x, y;
register Quantum
*q;
- exception=(&image->exception);
for (y = 0; y < (ssize_t) dds_info->height; y++)
{
q = QueueAuthenticPixels(image, 0, y, dds_info->width, 1,exception);
break;
for (x=0; x < ((ssize_t) image->columns-1); x+=2)
{
- index=ConstrainColormapIndex(image,(*p >> 4) & 0xf);
+ index=ConstrainColormapIndex(image,(*p >> 4) & 0xf,exception);
SetPixelIndex(image,index,q);
q+=GetPixelChannels(image);
- index=ConstrainColormapIndex(image,*p & 0xf);
+ index=ConstrainColormapIndex(image,*p & 0xf,exception);
SetPixelIndex(image,index,q);
p++;
q+=GetPixelChannels(image);
}
if ((image->columns % 2) != 0)
{
- index=ConstrainColormapIndex(image,(*p >> 4) & 0xf);
+ index=ConstrainColormapIndex(image,(*p >> 4) & 0xf,exception);
SetPixelIndex(image,index,q);
q+=GetPixelChannels(image);
p++;
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
- index=ConstrainColormapIndex(image,*p);
+ index=ConstrainColormapIndex(image,*p,exception);
SetPixelIndex(image,index,q);
p++;
q+=GetPixelChannels(image);
* we use the RGB format!
*/
static void
-get_page_image(LoadContext *lc, ddjvu_page_t *page, int x, int y, int w, int h, const ImageInfo *image_info ) {
+get_page_image(LoadContext *lc, ddjvu_page_t *page, int x, int y, int w, int h, const ImageInfo *image_info, ExceptionInfo *exception ) {
ddjvu_format_t
*format;
for (y=0; y < (ssize_t) image->rows; y++)
{
- Quantum * o = QueueAuthenticPixels(image,0,y,image->columns,1,&image->exception);
+ Quantum * o = QueueAuthenticPixels(image,0,y,image->columns,1,exception);
if (o == (Quantum *) NULL)
break;
bit=0;
byte>>=1;
o+=GetPixelChannels(image);
}
- if (SyncAuthenticPixels(image,&image->exception) == MagickFalse)
+ if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
}
if (!image->ping)
- SyncImage(image,&image->exception);
+ SyncImage(image,exception);
} else {
#if DEBUG
printf("%s: expanding PHOTO page/image\n", __FUNCTION__);
#if DEBUG
if (i % 1000 == 0) printf("%d\n",i);
#endif
- r = QueueAuthenticPixels(image,0,i,image->columns,1,&image->exception);
+ r = QueueAuthenticPixels(image,0,i,image->columns,1,exception);
if (r == (Quantum *) NULL)
break;
for (x=0; x < (ssize_t) image->columns; x++)
r+=GetPixelChannels(image);
}
- SyncAuthenticPixels(image,&image->exception);
+ SyncAuthenticPixels(image,exception);
}
}
q=(unsigned char *) RelinquishMagickMemory(q);
#if 1 /* per_line */
/* q = QueueAuthenticPixels(image,0,0,image->columns,image->rows); */
- get_page_image(lc, lc->page, 0, 0, info.width, info.height, image_info);
+ get_page_image(lc, lc->page, 0, 0, info.width, info.height, image_info,
+ exception);
#else
int i;
for (i = 0;i< image->rows; i++)
}
(void) ImfCloseOutputFile(file);
scanline=(ImfRgba *) RelinquishMagickMemory(scanline);
- (void) FileToImage(image,write_info->filename);
+ (void) FileToImage(image,write_info->filename,exception);
(void) RelinquishUniqueFileResource(write_info->filename);
write_info=DestroyImageInfo(write_info);
(void) CloseBlob(image);
c=ReadBlobLZWByte(lzw_info);
if (c < 0)
break;
- index=ConstrainColormapIndex(image,(size_t) c);
+ index=ConstrainColormapIndex(image,(size_t) c,exception);
SetPixelIndex(image,index,q);
SetPixelPixelInfo(image,image->colormap+(ssize_t) index,q);
SetPixelAlpha(image,(ssize_t) index == opacity ? TransparentAlpha :
%
*/
static MagickBooleanType EncodeImage(const ImageInfo *image_info,Image *image,
- const size_t data_size)
+ const size_t data_size,ExceptionInfo *exception)
{
#define MaxCode(number_bits) ((one << (number_bits))-1)
#define MaxHashTable 5003
register ssize_t
x;
- p=GetVirtualPixels(image,0,offset,image->columns,1,&image->exception);
+ p=GetVirtualPixels(image,0,offset,image->columns,1,exception);
if (p == (const Quantum *) NULL)
break;
if (y == 0)
*/
c=(int) MagickMax(bits_per_pixel,2);
(void) WriteBlobByte(image,(unsigned char) c);
- status=EncodeImage(write_info,image,(size_t) MagickMax(bits_per_pixel,2)+1);
+ status=EncodeImage(write_info,image,(size_t) MagickMax(bits_per_pixel,2)+1,
+ exception);
if (status == MagickFalse)
{
global_colormap=(unsigned char *) RelinquishMagickMemory(
scene++;
} while (count == (ssize_t) length);
quantum_info=DestroyQuantumInfo(quantum_info);
- InheritException(&image->exception,&canvas_image->exception);
canvas_image=DestroyImage(canvas_image);
(void) CloseBlob(image);
return(GetFirstImageInList(image));
ErrorManager
*error_manager;
+ ExceptionInfo
+ *exception;
+
Image
*image;
*message='\0';
error_manager=(ErrorManager *) jpeg_info->client_data;
image=error_manager->image;
+ exception=error_manager->exception;
(jpeg_info->err->format_message)(jpeg_info,message);
if (image->debug != MagickFalse)
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
"[%s] JPEG Trace: \"%s\"",image->filename,message);
if (error_manager->finished != MagickFalse)
- (void) ThrowMagickException(&image->exception,GetMagickModule(),
- CorruptImageWarning,(char *) message,"`%s'",image->filename);
+ (void) ThrowMagickException(exception,GetMagickModule(),CorruptImageWarning,
+ (char *) message,"`%s'",image->filename);
else
- (void) ThrowMagickException(&image->exception,GetMagickModule(),
- CorruptImageError,(char *) message,"`%s'",image->filename);
+ (void) ThrowMagickException(exception,GetMagickModule(),CorruptImageError,
+ (char *) message,"`%s'",image->filename);
longjmp(error_manager->error_recovery,1);
}
number_pixels=(MagickSizeType) image->columns*image->rows;
if (number_pixels != 0)
return(GetFirstImageInList(image));
- InheritException(exception,&image->exception);
return(DestroyImage(image));
}
jpeg_info.client_data=(void *) &error_manager;
pixel=(size_t) GETJSAMPLE(*p);
else
pixel=(size_t) ((GETJSAMPLE(*p) ^ 0x80) << 4);
- index=ConstrainColormapIndex(image,pixel);
+ index=ConstrainColormapIndex(image,pixel,exception);
SetPixelIndex(image,index,q);
SetPixelPixelInfo(image,image->colormap+(ssize_t) index,q);
p++;
if (jpeg_info.output_components == 1)
for (x=0; x < (ssize_t) image->columns; x++)
{
- index=ConstrainColormapIndex(image,(size_t) GETJSAMPLE(*p));
+ index=ConstrainColormapIndex(image,(size_t) GETJSAMPLE(*p),exception);
SetPixelIndex(image,index,q);
SetPixelPixelInfo(image,image->colormap+(ssize_t) index,q);
p++;
status=GetMultilineTypeMetrics(image,draw_info,&metrics,exception);
if (status == MagickFalse)
{
- InheritException(exception,&image->exception);
image=DestroyImageList(image);
return((Image *) NULL);
}
0.5);
if (SetImageBackgroundColor(image,exception) == MagickFalse)
{
- InheritException(exception,&image->exception);
image=DestroyImageList(image);
return((Image *) NULL);
}
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
- index=ConstrainColormapIndex(image,*p);
+ index=ConstrainColormapIndex(image,*p,exception);
p++;
if (image->colors > 256)
{
- index=ConstrainColormapIndex(image,((size_t) index << 8)+(*p));
+ index=ConstrainColormapIndex(image,((size_t) index << 8)+(*p),
+ exception);
p++;
}
SetPixelIndex(image,index,q);
static const QuantumType z2qtype[4] = {GrayQuantum, BlueQuantum, GreenQuantum, RedQuantum};
-static void InsertComplexDoubleRow(double *p, int y, Image * image, double MinVal,
- double MaxVal)
+static void InsertComplexDoubleRow(Image *image,double *p,int y,double MinVal,
+ double MaxVal,ExceptionInfo *exception)
{
- ExceptionInfo
- *exception;
double f;
int x;
if (MaxVal == 0)
MaxVal = 1;
- exception=(&image->exception);
q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
if (q == (Quantum *) NULL)
return;
}
-static void InsertComplexFloatRow(float *p, int y, Image * image, double MinVal,
- double MaxVal)
+static void InsertComplexFloatRow(Image *image,float *p,int y,double MinVal,
+ double MaxVal,ExceptionInfo *exception)
{
- ExceptionInfo
- *exception;
-
double f;
int x;
register Quantum *q;
if (MaxVal == 0)
MaxVal = 1;
- exception=(&image->exception);
q = QueueAuthenticPixels(image, 0, y, image->columns, 1,exception);
if (q == (Quantum *) NULL)
return;
for (i = 0; i < (ssize_t) MATLAB_HDR.SizeY; i++)
{
ReadBlobDoublesXXX(image2, ldblk, (double *)BImgBuff);
- InsertComplexDoubleRow((double *)BImgBuff, i, image, MinVal, MaxVal);
+ InsertComplexDoubleRow(image, (double *)BImgBuff, i, MinVal, MaxVal,
+ exception);
}
if (CellType==miSINGLE)
for (i = 0; i < (ssize_t) MATLAB_HDR.SizeY; i++)
{
ReadBlobFloatsXXX(image2, ldblk, (float *)BImgBuff);
- InsertComplexFloatRow((float *)BImgBuff, i, image, MinVal, MaxVal);
+ InsertComplexFloatRow(image,(float *)BImgBuff,i,MinVal,MaxVal,
+ exception);
}
}
}
static void PushRunlengthPacket(Image *image,const unsigned char *pixels,
- size_t *length,PixelInfo *pixel)
+ size_t *length,PixelInfo *pixel,ExceptionInfo *exception)
{
const unsigned char
*p;
case 32:
{
pixel->index=ConstrainColormapIndex(image,
- (*p << 24) | (*(p+1) << 16) | (*(p+2) << 8) | *(p+3));
+ (*p << 24) | (*(p+1) << 16) | (*(p+2) << 8) | *(p+3),exception);
p+=4;
break;
}
case 16:
{
- pixel->index=ConstrainColormapIndex(image,(*p << 8) | *(p+1));
+ pixel->index=ConstrainColormapIndex(image,(*p << 8) | *(p+1),
+ exception);
p+=2;
break;
}
case 8:
{
- pixel->index=ConstrainColormapIndex(image,*p);
+ pixel->index=ConstrainColormapIndex(image,*p,exception);
p++;
break;
}
default:
- (void) ThrowMagickException(&image->exception,GetMagickModule(),
+ (void) ThrowMagickException(exception,GetMagickModule(),
CorruptImageError,"ImageDepthNotSupported","`%s'",image->filename);
}
switch (image->depth)
break;
}
default:
- (void) ThrowMagickException(&image->exception,GetMagickModule(),
+ (void) ThrowMagickException(exception,GetMagickModule(),
CorruptImageError,"ImageDepthNotSupported","`%s'",image->filename);
}
*length=(size_t) (*p++)+1;
break;
}
default:
- (void) ThrowMagickException(&image->exception,GetMagickModule(),
- CorruptImageError,"ImageDepthNotSupported","`%s'",image->filename);
+ (void) ThrowMagickException(exception,GetMagickModule(),CorruptImageError,
+ "ImageDepthNotSupported","`%s'",image->filename);
}
*length=(size_t) (*p++)+1;
}
if (length == 0)
{
count=ReadBlob(image,packet_size,pixels);
- PushRunlengthPacket(image,pixels,&length,&pixel);
+ PushRunlengthPacket(image,pixels,&length,&pixel,exception);
}
length--;
if (image->storage_class == PseudoClass)
*/
static unsigned char *PopRunlengthPacket(Image *image,unsigned char *pixels,
- size_t length,PixelInfo *pixel)
+ size_t length,PixelInfo *pixel,ExceptionInfo *exception)
{
if (image->storage_class != DirectClass)
{
break;
}
default:
- (void) ThrowMagickException(&image->exception,GetMagickModule(),
+ (void) ThrowMagickException(exception,GetMagickModule(),
CorruptImageError,"ImageDepthNotSupported","`%s'",image->filename);
}
switch (image->depth)
break;
}
default:
- (void) ThrowMagickException(&image->exception,GetMagickModule(),
+ (void) ThrowMagickException(exception,GetMagickModule(),
CorruptImageError,"ImageDepthNotSupported","`%s'",image->filename);
}
*pixels++=(unsigned char) length;
break;
}
default:
- (void) ThrowMagickException(&image->exception,GetMagickModule(),
- CorruptImageError,"ImageDepthNotSupported","`%s'",image->filename);
+ (void) ThrowMagickException(exception,GetMagickModule(),CorruptImageError,
+ "ImageDepthNotSupported","`%s'",image->filename);
}
*pixels++=(unsigned char) length;
return(pixels);
length++;
else
{
- q=PopRunlengthPacket(image,q,length,&pixel);
+ q=PopRunlengthPacket(image,q,length,&pixel,exception);
length=0;
}
SetPixelInfo(image,p,&pixel);
p+=GetPixelChannels(image);
}
- q=PopRunlengthPacket(image,q,length,&pixel);
+ q=PopRunlengthPacket(image,q,length,&pixel,exception);
(void) WriteBlob(image,(size_t) (q-pixels),pixels);
break;
}
msl_info->draw_info[n-1]);
if (image == (Image *) NULL)
msl_info->attributes[n]=AcquireImage(msl_info->image_info[n],
- &image->exception);
+ msl_info->exception);
else
- msl_info->attributes[n]=CloneImage(image,0,0,MagickTrue,&image->exception);
+ msl_info->attributes[n]=CloneImage(image,0,0,MagickTrue,
+ msl_info->exception);
msl_info->image[n]=(Image *) image;
if ((msl_info->image_info[n] == (ImageInfo *) NULL) ||
(msl_info->attributes[n] == (Image *) NULL))
}
channel_mask=SetPixelChannelMask(msl_info->image[n],channel);
noise_image=AddNoiseImage(msl_info->image[n],noise,1.0,
- &msl_info->image[n]->exception);
+ msl_info->exception);
(void) SetPixelChannelMap(msl_info->image[n],channel_mask);
if (noise_image == (Image *) NULL)
break;
draw_info->affine.ty=affine.rx*current.tx+affine.sy*current.ty+
affine.ty;
(void) AnnotateImage(msl_info->image[n],draw_info,
- &msl_info->image[n]->exception);
+ msl_info->exception);
draw_info=DestroyDrawInfo(draw_info);
break;
}
}
}
append_image=AppendImages(msl_info->image[n],stack,
- &msl_info->image[n]->exception);
+ msl_info->exception);
if (append_image == (Image *) NULL)
break;
msl_info->image[n]=DestroyImage(msl_info->image[n]);
channel_mask=SetPixelChannelMask(msl_info->image[n],channel);
blur_image=BlurImage(msl_info->image[n],geometry_info.rho,
geometry_info.sigma,geometry_info.xi,
- &msl_info->image[n]->exception);
+ msl_info->exception);
(void) SetPixelChannelMap(msl_info->image[n],channel_mask);
if (blur_image == (Image *) NULL)
break;
}
}
border_image=BorderImage(msl_info->image[n],&geometry,
- msl_info->image[n]->compose,&msl_info->image[n]->exception);
+ msl_info->image[n]->compose,msl_info->exception);
if (border_image == (Image *) NULL)
break;
msl_info->image[n]=DestroyImage(msl_info->image[n]);
if (LocaleCompare(keyword,"fill") == 0)
{
(void) QueryColorCompliance(value,AllCompliance,
- &target,&msl_info->image[n]->exception);
+ &target,msl_info->exception);
break;
}
ThrowMSLException(OptionError,"UnrecognizedAttribute",
}
}
colorize_image=ColorizeImage(msl_info->image[n],blend,&target,
- &msl_info->image[n]->exception);
+ msl_info->exception);
if (colorize_image == (Image *) NULL)
break;
msl_info->image[n]=DestroyImage(msl_info->image[n]);
*newImage;
newImage=CharcoalImage(msl_info->image[n],radius,sigma,bias,
- &msl_info->image[n]->exception);
+ msl_info->exception);
if (newImage == (Image *) NULL)
break;
msl_info->image[n]=DestroyImage(msl_info->image[n]);
}
}
chop_image=ChopImage(msl_info->image[n],&geometry,
- &msl_info->image[n]->exception);
+ msl_info->exception);
if (chop_image == (Image *) NULL)
break;
msl_info->image[n]=DestroyImage(msl_info->image[n]);
}
(void) FloodfillPaintImage(msl_info->image[n],draw_info,&target,
geometry.x,geometry.y,paint_method == FloodfillMethod ?
- MagickFalse : MagickTrue,&msl_info->image[n]->exception);
+ MagickFalse : MagickTrue,msl_info->exception);
draw_info=DestroyDrawInfo(draw_info);
break;
}
}
}
(void) ContrastImage(msl_info->image[n],sharpen,
- &msl_info->image[n]->exception);
+ msl_info->exception);
break;
}
if (LocaleCompare((const char *) tag,"crop") == 0)
}
}
crop_image=CropImage(msl_info->image[n],&geometry,
- &msl_info->image[n]->exception);
+ msl_info->exception);
if (crop_image == (Image *) NULL)
break;
msl_info->image[n]=DestroyImage(msl_info->image[n]);
ThrowMSLException(OptionError,"UnrecognizedAttribute",keyword);
}
despeckle_image=DespeckleImage(msl_info->image[n],
- &msl_info->image[n]->exception);
+ msl_info->exception);
if (despeckle_image == (Image *) NULL)
break;
msl_info->image[n]=DestroyImage(msl_info->image[n]);
}
}
(void) DisplayImages(msl_info->image_info[n],msl_info->image[n],
- &msl_info->image[n]->exception);
+ msl_info->exception);
break;
}
if (LocaleCompare((const char *) tag,"draw") == 0)
}
}
edge_image=EdgeImage(msl_info->image[n],geometry_info.rho,
- geometry_info.sigma,&msl_info->image[n]->exception);
+ geometry_info.sigma,msl_info->exception);
if (edge_image == (Image *) NULL)
break;
msl_info->image[n]=DestroyImage(msl_info->image[n]);
}
}
emboss_image=EmbossImage(msl_info->image[n],geometry_info.rho,
- geometry_info.sigma,&msl_info->image[n]->exception);
+ geometry_info.sigma,msl_info->exception);
if (emboss_image == (Image *) NULL)
break;
msl_info->image[n]=DestroyImage(msl_info->image[n]);
ThrowMSLException(OptionError,"UnrecognizedAttribute",keyword);
}
enhance_image=EnhanceImage(msl_info->image[n],
- &msl_info->image[n]->exception);
+ msl_info->exception);
if (enhance_image == (Image *) NULL)
break;
msl_info->image[n]=DestroyImage(msl_info->image[n]);
}
}
(void) EqualizeImage(msl_info->image[n],
- &msl_info->image[n]->exception);
+ msl_info->exception);
break;
}
ThrowMSLException(OptionError,"UnrecognizedElement",(const char *) tag);
*newImage;
newImage=MergeImageLayers(msl_info->image[n],FlattenLayer,
- &msl_info->image[n]->exception);
+ msl_info->exception);
if (newImage == (Image *) NULL)
break;
msl_info->image[n]=DestroyImage(msl_info->image[n]);
ThrowMSLException(OptionError,"UnrecognizedAttribute",keyword);
}
flip_image=FlipImage(msl_info->image[n],
- &msl_info->image[n]->exception);
+ msl_info->exception);
if (flip_image == (Image *) NULL)
break;
msl_info->image[n]=DestroyImage(msl_info->image[n]);
ThrowMSLException(OptionError,"UnrecognizedAttribute",keyword);
}
flop_image=FlopImage(msl_info->image[n],
- &msl_info->image[n]->exception);
+ msl_info->exception);
if (flop_image == (Image *) NULL)
break;
msl_info->image[n]=DestroyImage(msl_info->image[n]);
frame_info.width=msl_info->image[n]->columns+2*frame_info.x;
frame_info.height=msl_info->image[n]->rows+2*frame_info.y;
frame_image=FrameImage(msl_info->image[n],&frame_info,
- msl_info->image[n]->compose,&msl_info->image[n]->exception);
+ msl_info->image[n]->compose,msl_info->exception);
if (frame_image == (Image *) NULL)
break;
msl_info->image[n]=DestroyImage(msl_info->image[n]);
(void) FormatLocaleString(gamma,MaxTextExtent,"%g,%g,%g",
(double) pixel.red,(double) pixel.green,(double) pixel.blue);
(void) GammaImage(msl_info->image[n],atof(gamma),
- &msl_info->image[n]->exception);
+ msl_info->exception);
break;
}
else if (LocaleCompare((const char *) tag,"get") == 0)
}
}
implode_image=ImplodeImage(msl_info->image[n],geometry_info.rho,
- msl_info->image[n]->interpolate,&msl_info->image[n]->exception);
+ msl_info->image[n]->interpolate,msl_info->exception);
if (implode_image == (Image *) NULL)
break;
msl_info->image[n]=DestroyImage(msl_info->image[n]);
/* process image */
LevelImage(msl_info->image[n],levelBlack,levelWhite,levelGamma,
- &msl_info->image[n]->exception);
+ msl_info->exception);
break;
}
}
ThrowMSLException(OptionError,"UnrecognizedAttribute",keyword);
}
magnify_image=MagnifyImage(msl_info->image[n],
- &msl_info->image[n]->exception);
+ msl_info->exception);
if (magnify_image == (Image *) NULL)
break;
msl_info->image[n]=DestroyImage(msl_info->image[n]);
channel_mask=SetPixelChannelMask(msl_info->image[n],AlphaChannel);
(void) FloodfillPaintImage(msl_info->image[n],draw_info,&target,
geometry.x,geometry.y,paint_method == FloodfillMethod ?
- MagickFalse : MagickTrue,&msl_info->image[n]->exception);
+ MagickFalse : MagickTrue,msl_info->exception);
(void) SetPixelChannelMap(msl_info->image[n],channel_mask);
draw_info=DestroyDrawInfo(draw_info);
break;
}
median_image=StatisticImage(msl_info->image[n],MedianStatistic,
(size_t) geometry_info.rho,(size_t) geometry_info.sigma,
- &msl_info->image[n]->exception);
+ msl_info->exception);
if (median_image == (Image *) NULL)
break;
msl_info->image[n]=DestroyImage(msl_info->image[n]);
ThrowMSLException(OptionError,"UnrecognizedAttribute",keyword);
}
minify_image=MinifyImage(msl_info->image[n],
- &msl_info->image[n]->exception);
+ msl_info->exception);
if (minify_image == (Image *) NULL)
break;
msl_info->image[n]=DestroyImage(msl_info->image[n]);
(void) FormatLocaleString(modulate,MaxTextExtent,"%g,%g,%g",
geometry_info.rho,geometry_info.sigma,geometry_info.xi);
(void) ModulateImage(msl_info->image[n],modulate,
- &msl_info->image[n]->exception);
+ msl_info->exception);
break;
}
ThrowMSLException(OptionError,"UnrecognizedElement",(const char *) tag);
}
channel_mask=SetPixelChannelMask(msl_info->image[n],channel);
(void) NegateImage(msl_info->image[n],gray,
- &msl_info->image[n]->exception);
+ msl_info->exception);
(void) SetPixelChannelMap(msl_info->image[n],channel_mask);
break;
}
}
}
(void) NormalizeImage(msl_info->image[n],
- &msl_info->image[n]->exception);
+ msl_info->exception);
break;
}
ThrowMSLException(OptionError,"UnrecognizedElement",(const char *) tag);
}
}
paint_image=OilPaintImage(msl_info->image[n],geometry_info.rho,
- geometry_info.sigma,&msl_info->image[n]->exception);
+ geometry_info.sigma,msl_info->exception);
if (paint_image == (Image *) NULL)
break;
msl_info->image[n]=DestroyImage(msl_info->image[n]);
}
channel_mask=SetPixelChannelMask(msl_info->image[n],channel);
(void) OpaquePaintImage(msl_info->image[n],&target,&fill_color,
- MagickFalse,&msl_info->image[n]->exception);
+ MagickFalse,msl_info->exception);
(void) SetPixelChannelMap(msl_info->image[n],channel_mask);
break;
}
draw_info->affine.ty=affine.rx*current.tx+affine.sy*current.ty+
affine.ty;
status=GetTypeMetrics(msl_info->attributes[n],draw_info,&metrics,
- &msl_info->image[n]->exception);
+ msl_info->exception);
if (status != MagickFalse)
{
Image
}
}
(void) RaiseImage(msl_info->image[n],&geometry,raise,
- &msl_info->image[n]->exception);
+ msl_info->exception);
break;
}
if (LocaleCompare((const char *) tag,"read") == 0)
}
paint_image=StatisticImage(msl_info->image[n],NonpeakStatistic,
(size_t) geometry_info.rho,(size_t) geometry_info.sigma,
- &msl_info->image[n]->exception);
+ msl_info->exception);
if (paint_image == (Image *) NULL)
break;
msl_info->image[n]=DestroyImage(msl_info->image[n]);
msl_info->image[n]->y_resolution))+0.5);
resample_image=ResizeImage(msl_info->image[n],width,height,
msl_info->image[n]->filter,msl_info->image[n]->blur,
- &msl_info->image[n]->exception);
+ msl_info->exception);
if (resample_image == (Image *) NULL)
break;
msl_info->image[n]=DestroyImage(msl_info->image[n]);
}
}
resize_image=ResizeImage(msl_info->image[n],geometry.width,
- geometry.height,filter,blur,&msl_info->image[n]->exception);
+ geometry.height,filter,blur,msl_info->exception);
if (resize_image == (Image *) NULL)
break;
msl_info->image[n]=DestroyImage(msl_info->image[n]);
}
}
roll_image=RollImage(msl_info->image[n],geometry.x,geometry.y,
- &msl_info->image[n]->exception);
+ msl_info->exception);
if (roll_image == (Image *) NULL)
break;
msl_info->image[n]=DestroyImage(msl_info->image[n]);
Image
*newImage;
- newImage=RollImage(msl_info->image[n], x, y, &msl_info->image[n]->exception);
+ newImage=RollImage(msl_info->image[n], x, y, msl_info->exception);
if (newImage == (Image *) NULL)
break;
msl_info->image[n]=DestroyImage(msl_info->image[n]);
}
}
rotate_image=RotateImage(msl_info->image[n],geometry_info.rho,
- &msl_info->image[n]->exception);
+ msl_info->exception);
if (rotate_image == (Image *) NULL)
break;
msl_info->image[n]=DestroyImage(msl_info->image[n]);
Image
*newImage;
- newImage=RotateImage(msl_info->image[n], degrees, &msl_info->image[n]->exception);
+ newImage=RotateImage(msl_info->image[n], degrees, msl_info->exception);
if (newImage == (Image *) NULL)
break;
msl_info->image[n]=DestroyImage(msl_info->image[n]);
}
}
sample_image=SampleImage(msl_info->image[n],geometry.width,
- geometry.height,&msl_info->image[n]->exception);
+ geometry.height,msl_info->exception);
if (sample_image == (Image *) NULL)
break;
msl_info->image[n]=DestroyImage(msl_info->image[n]);
}
}
scale_image=ScaleImage(msl_info->image[n],geometry.width,
- geometry.height,&msl_info->image[n]->exception);
+ geometry.height,msl_info->exception);
if (scale_image == (Image *) NULL)
break;
msl_info->image[n]=DestroyImage(msl_info->image[n]);
}
}
shade_image=ShadeImage(msl_info->image[n],gray,geometry_info.rho,
- geometry_info.sigma,&msl_info->image[n]->exception);
+ geometry_info.sigma,msl_info->exception);
if (shade_image == (Image *) NULL)
break;
msl_info->image[n]=DestroyImage(msl_info->image[n]);
}
shadow_image=ShadowImage(msl_info->image[n],geometry_info.rho,
geometry_info.sigma,(ssize_t) ceil(geometry_info.xi-0.5),(ssize_t)
- ceil(geometry_info.psi-0.5),&msl_info->image[n]->exception);
+ ceil(geometry_info.psi-0.5),msl_info->exception);
if (shadow_image == (Image *) NULL)
break;
msl_info->image[n]=DestroyImage(msl_info->image[n]);
*newImage;
newImage=SharpenImage(msl_info->image[n],radius,sigma,bias,
- &msl_info->image[n]->exception);
+ msl_info->exception);
if (newImage == (Image *) NULL)
break;
msl_info->image[n]=DestroyImage(msl_info->image[n]);
newImage=ShaveImage(msl_info->image[n], &rectInfo,
- &msl_info->image[n]->exception);
+ msl_info->exception);
if (newImage == (Image *) NULL)
break;
msl_info->image[n]=DestroyImage(msl_info->image[n]);
}
}
shear_image=ShearImage(msl_info->image[n],geometry_info.rho,
- geometry_info.sigma,&msl_info->image[n]->exception);
+ geometry_info.sigma,msl_info->exception);
if (shear_image == (Image *) NULL)
break;
msl_info->image[n]=DestroyImage(msl_info->image[n]);
}
}
(void) SolarizeImage(msl_info->image[n],geometry_info.rho,
- &msl_info->image[n]->exception);
+ msl_info->exception);
break;
}
if (LocaleCompare((const char *) tag,"spread") == 0)
}
}
spread_image=SpreadImage(msl_info->image[n],geometry_info.rho,
- msl_info->image[n]->interpolate,&msl_info->image[n]->exception);
+ msl_info->image[n]->interpolate,msl_info->exception);
if (spread_image == (Image *) NULL)
break;
msl_info->image[n]=DestroyImage(msl_info->image[n]);
Image
*newImage;
- newImage=SteganoImage(msl_info->image[n], watermark, &msl_info->image[n]->exception);
+ newImage=SteganoImage(msl_info->image[n], watermark, msl_info->exception);
if (newImage == (Image *) NULL)
break;
msl_info->image[n]=DestroyImage(msl_info->image[n]);
Image
*newImage;
- newImage=StereoImage(msl_info->image[n], stereoImage, &msl_info->image[n]->exception);
+ newImage=StereoImage(msl_info->image[n], stereoImage, msl_info->exception);
if (newImage == (Image *) NULL)
break;
msl_info->image[n]=DestroyImage(msl_info->image[n]);
ThrowMSLException(OptionError,"NoSuchImage",(const char *) tag);
break;
}
- swap=CloneImage(p,0,0,MagickTrue,&p->exception);
- ReplaceImageInList(&p,CloneImage(q,0,0,MagickTrue,&q->exception));
+ swap=CloneImage(p,0,0,MagickTrue,msl_info->exception);
+ ReplaceImageInList(&p,CloneImage(q,0,0,MagickTrue,
+ msl_info->exception));
ReplaceImageInList(&q,swap);
msl_info->image[n]=GetFirstImageInList(q);
break;
}
}
swirl_image=SwirlImage(msl_info->image[n],geometry_info.rho,
- msl_info->image[n]->interpolate,&msl_info->image[n]->exception);
+ msl_info->image[n]->interpolate,msl_info->exception);
if (swirl_image == (Image *) NULL)
break;
msl_info->image[n]=DestroyImage(msl_info->image[n]);
(void) QueryColorCompliance(value,AllCompliance,&target,
&exception);
(void) TransparentPaintImage(msl_info->image[n],&target,
- TransparentAlpha,MagickFalse,&msl_info->image[n]->exception);
+ TransparentAlpha,MagickFalse,msl_info->exception);
break;
}
ThrowMSLException(OptionError,"UnrecognizedAttribute",keyword);
rectInfo.height = rectInfo.width = 0;
rectInfo.x = rectInfo.y = 0;
- newImage=CropImage(msl_info->image[n],&rectInfo, &msl_info->image[n]->exception);
+ newImage=CropImage(msl_info->image[n],&rectInfo, msl_info->exception);
if (newImage == (Image *) NULL)
break;
msl_info->image[n]=DestroyImage(msl_info->image[n]);
/* process */
{
(void) WriteImage(msl_info->image_info[n], msl_info->image[n],
- &msl_info->image[n]->exception);
+ msl_info->exception);
break;
}
}
msl_info.group_info);
if (*image == (Image *) NULL)
*image=(*msl_info.image);
- if ((*msl_info.image)->exception.severity != UndefinedException)
+ if (msl_info.exception->severity != UndefinedException)
return(MagickFalse);
return(MagickTrue);
}
for (i=0; i < (ssize_t) count; i++)
{
ReadBlobByte(image);
- index=ConstrainColormapIndex(image,255-i);
+ index=ConstrainColormapIndex(image,255-i,exception);
image->colormap[(int) index].red=
ScaleCharToQuantum((unsigned char) ReadBlobByte(image));
image->colormap[(int) index].green=
{
for (i=0; i < (ssize_t) (1L << bits_per_pixel); i++)
{
- index=ConstrainColormapIndex(image,255-i);
+ index=ConstrainColormapIndex(image,255-i,exception);
image->colormap[(int) index].red=
ScaleCharToQuantum(PalmPalette[i][0]);
image->colormap[(int) index].green=
r++;
if ((row > image->rows) || (r == (PCDTable *) NULL))
{
- (void) ThrowMagickException(&image->exception,GetMagickModule(),
+ (void) ThrowMagickException(exception,GetMagickModule(),
CorruptImageWarning,"SkipToSyncByte","`%s'",image->filename);
while ((sum & 0x00fff000) != 0x00fff000)
PCDGetBits(8);
if ((geometry.height % 2) != 0)
geometry.height--;
tile_image=ResizeImage(image,geometry.width,geometry.height,TriangleFilter,
- 1.0,&image->exception);
+ 1.0,exception);
if (tile_image == (Image *) NULL)
return(MagickFalse);
flags=ParseGeometry(page_geometry,&geometry_info);
border_info.width=(geometry.width-tile_image->columns+1) >> 1;
border_info.height=(geometry.height-tile_image->rows+1) >> 1;
bordered_image=BorderImage(tile_image,&border_info,image->compose,
- &image->exception);
+ exception);
if (bordered_image == (Image *) NULL)
return(MagickFalse);
tile_image=DestroyImage(tile_image);
if (IsRGBColorspace(image->colorspace) == MagickFalse)
(void) TransformImageColorspace(tile_image,YCCColorspace,exception);
downsample_image=ResizeImage(tile_image,tile_image->columns/2,
- tile_image->rows/2,TriangleFilter,1.0,&image->exception);
+ tile_image->rows/2,TriangleFilter,1.0,exception);
if (downsample_image == (Image *) NULL)
return(MagickFalse);
/*
*/
for (y=0; y < (ssize_t) tile_image->rows; y+=2)
{
- p=GetVirtualPixels(tile_image,0,y,tile_image->columns,2,
- &tile_image->exception);
+ p=GetVirtualPixels(tile_image,0,y,tile_image->columns,2,exception);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) (tile_image->columns << 1); x++)
(void) WriteBlobByte(image,ScaleQuantumToChar(GetPixelRed(tile_image,p)));
p+=GetPixelChannels(tile_image);
}
- q=GetVirtualPixels(downsample_image,0,y >> 1,downsample_image->columns,
- 1,&downsample_image->exception);
+ q=GetVirtualPixels(downsample_image,0,y >> 1,downsample_image->columns,1,
+ exception);
if (q == (Quantum *) NULL)
break;
for (x=0; x < (ssize_t) downsample_image->columns; x++)
GetPixelGreen(tile_image,q)));
q++;
}
- q=GetVirtualPixels(downsample_image,0,y >> 1,downsample_image->columns,
- 1,&downsample_image->exception);
+ q=GetVirtualPixels(downsample_image,0,y >> 1,downsample_image->columns,1,
+ exception);
if (q == (Quantum *) NULL)
break;
for (x=0; x < (ssize_t) downsample_image->columns; x++)
Image
*cmyk_image;
- cmyk_image=ConsolidateCMYKImages(image,&image->exception);
+ cmyk_image=ConsolidateCMYKImages(image,exception);
if (cmyk_image != (Image *) NULL)
{
image=DestroyImageList(image);
break;
for (x=0; x < (ssize_t) image->columns; x+=4)
{
- index=ConstrainColormapIndex(image,3UL-((*p >> 6) & 0x03));
+ index=ConstrainColormapIndex(image,3UL-((*p >> 6) & 0x03),exception);
SetPixelIndex(image,index,q);
q+=GetPixelChannels(image);
- index=ConstrainColormapIndex(image,3UL-((*p >> 4) & 0x03));
+ index=ConstrainColormapIndex(image,3UL-((*p >> 4) & 0x03),exception);
SetPixelIndex(image,index,q);
q+=GetPixelChannels(image);
- index=ConstrainColormapIndex(image,3UL-((*p >> 2) & 0x03));
+ index=ConstrainColormapIndex(image,3UL-((*p >> 2) & 0x03),exception);
SetPixelIndex(image,index,q);
q+=GetPixelChannels(image);
- index=ConstrainColormapIndex(image,3UL-((*p) & 0x03));
+ index=ConstrainColormapIndex(image,3UL-((*p) & 0x03),exception);
SetPixelIndex(image,index,q);
p++;
q+=GetPixelChannels(image);
break;
for (x=0; x < (ssize_t) image->columns; x+=2)
{
- index=ConstrainColormapIndex(image,15UL-((*p >> 4) & 0x0f));
+ index=ConstrainColormapIndex(image,15UL-((*p >> 4) & 0x0f),exception);
SetPixelIndex(image,index,q);
q+=GetPixelChannels(image);
- index=ConstrainColormapIndex(image,15UL-((*p) & 0x0f));
+ index=ConstrainColormapIndex(image,15UL-((*p) & 0x0f),exception);
SetPixelIndex(image,index,q);
p++;
q+=GetPixelChannels(image);
}
static unsigned char *DecodeImage(Image *blob,Image *image,
- size_t bytes_per_line,const unsigned int bits_per_pixel,size_t *extent)
+ size_t bytes_per_line,const unsigned int bits_per_pixel,size_t *extent,
+ ExceptionInfo *exception)
{
MagickSizeType
number_pixels;
p=ExpandBuffer(scanline,&number_pixels,bits_per_pixel);
if ((q+number_pixels) > (pixels+(*extent)))
{
- (void) ThrowMagickException(&image->exception,GetMagickModule(),
+ (void) ThrowMagickException(exception,GetMagickModule(),
CorruptImageError,"UnableToUncompressImage","`%s'",
image->filename);
break;
scanline_length=1UL*ReadBlobByte(blob);
if (scanline_length >= row_bytes)
{
- (void) ThrowMagickException(&image->exception,GetMagickModule(),
+ (void) ThrowMagickException(exception,GetMagickModule(),
CorruptImageError,"UnableToUncompressImage","`%s'",image->filename);
break;
}
}
if ((code != 0x9a) && (code != 0x9b) &&
(bytes_per_line & 0x8000) == 0)
- pixels=DecodeImage(image,tile_image,1UL*bytes_per_line,1,&extent);
+ pixels=DecodeImage(image,tile_image,1UL*bytes_per_line,1,&extent,
+ exception);
else
pixels=DecodeImage(image,tile_image,1UL*bytes_per_line,1U*
- pixmap.bits_per_pixel,&extent);
+ pixmap.bits_per_pixel,&extent,exception);
if (pixels == (unsigned char *) NULL)
{
tile_image=DestroyImage(tile_image);
{
if (tile_image->storage_class == PseudoClass)
{
- index=ConstrainColormapIndex(tile_image,*p);
+ index=ConstrainColormapIndex(tile_image,*p,exception);
SetPixelIndex(tile_image,index,q);
SetPixelRed(tile_image,
tile_image->colormap[(ssize_t) index].red,q);
}
static inline void PlasmaPixel(Image *image,RandomInfo *random_info,double x,
- double y)
+ double y,ExceptionInfo *exception)
{
- ExceptionInfo
- *exception;
-
QuantumAny
range;
register Quantum
*q;
- exception=(&image->exception);
q=GetAuthenticPixels(image,(ssize_t) ceil(x-0.5),(ssize_t) ceil(y-0.5),1,1,
exception);
if (q == (Quantum *) NULL)
Seed pixels before recursion.
*/
random_info=AcquireRandomInfo();
- PlasmaPixel(image,random_info,segment_info.x1,segment_info.y1);
+ PlasmaPixel(image,random_info,segment_info.x1,segment_info.y1,exception);
PlasmaPixel(image,random_info,segment_info.x1,(segment_info.y1+
- segment_info.y2)/2);
- PlasmaPixel(image,random_info,segment_info.x1,segment_info.y2);
+ segment_info.y2)/2,exception);
+ PlasmaPixel(image,random_info,segment_info.x1,segment_info.y2,exception);
PlasmaPixel(image,random_info,(segment_info.x1+segment_info.x2)/2,
- segment_info.y1);
+ segment_info.y1,exception);
PlasmaPixel(image,random_info,(segment_info.x1+segment_info.x2)/2,
- (segment_info.y1+segment_info.y2)/2);
+ (segment_info.y1+segment_info.y2)/2,exception);
PlasmaPixel(image,random_info,(segment_info.x1+segment_info.x2)/2,
- segment_info.y2);
- PlasmaPixel(image,random_info,segment_info.x2,segment_info.y1);
+ segment_info.y2,exception);
+ PlasmaPixel(image,random_info,segment_info.x2,segment_info.y1,exception);
PlasmaPixel(image,random_info,segment_info.x2,(segment_info.y1+
- segment_info.y2)/2);
- PlasmaPixel(image,random_info,segment_info.x2,segment_info.y2);
+ segment_info.y2)/2,exception);
+ PlasmaPixel(image,random_info,segment_info.x2,segment_info.y2,exception);
random_info=DestroyRandomInfo(random_info);
}
i=(size_t) MagickMax(image->columns,image->rows)/2;
#if (MAGICKCORE_QUANTUM_DEPTH >= 16)
static MagickBooleanType
-LosslessReduceDepthOK(Image *image)
+LosslessReduceDepthOK(Image *image,ExceptionInfo *exception)
{
/* Reduce bit depth if it can be reduced losslessly from 16+ to 8.
*
for (y=0; y < (ssize_t) image->rows; y++)
{
- p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
+ p=GetVirtualPixels(image,0,y,image->columns,1,exception);
if (p == (const Quantum *) NULL)
{
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
*/
-static MagickBooleanType ImageIsGray(Image *image)
+static MagickBooleanType ImageIsGray(Image *image,ExceptionInfo *exception)
{
register const Quantum
*p;
}
for (y=0; y < (ssize_t) image->rows; y++)
{
- p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
+ p=GetVirtualPixels(image,0,y,image->columns,1,exception);
if (p == (const Quantum *) NULL)
return(MagickFalse);
for (x=(ssize_t) image->columns-1; x >= 0; x--)
return((long) ((p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3]));
}
+typedef struct _PNGErrorInfo
+{
+ Image
+ *image;
+
+ ExceptionInfo
+ *exception;
+} PNGErrorInfo;
+
static void MagickPNGErrorHandler(png_struct *ping,png_const_charp message)
{
+ ExceptionInfo
+ *exception;
+
Image
*image;
- image=(Image *) png_get_error_ptr(ping);
+ PNGErrorInfo
+ *error_info;
- if (image->debug != MagickFalse)
- (void) LogMagickEvent(CoderEvent,GetMagickModule(),
- " libpng-%s error: %s", PNG_LIBPNG_VER_STRING,message);
+ error_info=(PNGErrorInfo *) png_get_error_ptr(ping);
+ image=error_info->image;
+ exception=error_info->exception;
- (void) ThrowMagickException(&image->exception,GetMagickModule(),CoderError,
- message,"`%s'",image->filename);
+ (void) LogMagickEvent(CoderEvent,GetMagickModule(),
+ " libpng-%s error: %s", PNG_LIBPNG_VER_STRING,message);
+
+ (void) ThrowMagickException(exception,GetMagickModule(),CoderError,message,
+ "`%s'",image->filename);
#if (PNG_LIBPNG_VER < 10500)
/* A warning about deprecated use of jmpbuf here is unavoidable if you
static void MagickPNGWarningHandler(png_struct *ping,png_const_charp message)
{
+ ExceptionInfo
+ *exception;
+
Image
*image;
+ PNGErrorInfo
+ *error_info;
+
if (LocaleCompare(message, "Missing PLTE before tRNS") == 0)
png_error(ping, message);
- image=(Image *) png_get_error_ptr(ping);
- if (image->debug != MagickFalse)
- (void) LogMagickEvent(CoderEvent,GetMagickModule(),
- " libpng-%s warning: %s", PNG_LIBPNG_VER_STRING,message);
+ error_info=(PNGErrorInfo *) png_get_error_ptr(ping);
+ image=error_info->image;
+ exception=error_info->exception;
+ (void) LogMagickEvent(CoderEvent,GetMagickModule(),
+ " libpng-%s warning: %s", PNG_LIBPNG_VER_STRING,message);
- (void) ThrowMagickException(&image->exception,GetMagickModule(),CoderWarning,
+ (void) ThrowMagickException(exception,GetMagickModule(),CoderWarning,
message,"`%s'",image->filename);
}
/* allocate space */
if (length == 0)
{
- (void) ThrowMagickException(&image->exception,GetMagickModule(),
+ (void) ThrowMagickException(exception,GetMagickModule(),
CoderWarning,"UnableToCopyProfile","`%s'","invalid profile length");
return(MagickFalse);
}
if (profile == (StringInfo *) NULL)
{
- (void) ThrowMagickException(&image->exception,GetMagickModule(),
+ (void) ThrowMagickException(exception,GetMagickModule(),
ResourceLimitError,"MemoryAllocationFailed","`%s'",
"unable to copy profile");
return(MagickFalse);
{
if (*sp == '\0')
{
- (void) ThrowMagickException(&image->exception,GetMagickModule(),
+ (void) ThrowMagickException(exception,GetMagickModule(),
CoderWarning,"UnableToCopyProfile","`%s'","ran out of data");
profile=DestroyStringInfo(profile);
return(MagickFalse);
double
file_gamma;
- PixelInfo
- transparent_color;
-
MagickBooleanType
logging,
status;
+ PixelInfo
+ transparent_color;
+
+ PNGErrorInfo
+ error_info;
+
png_bytep
ping_trans_alpha;
Allocate the PNG structures
*/
#ifdef PNG_USER_MEM_SUPPORTED
- ping=png_create_read_struct_2(PNG_LIBPNG_VER_STRING, image,
+ error_info.image=image;
+ error_info.exception=exception;
+ ping=png_create_read_struct_2(PNG_LIBPNG_VER_STRING,&error_info,
MagickPNGErrorHandler,MagickPNGWarningHandler, NULL,
(png_malloc_ptr) Magick_png_malloc,(png_free_ptr) Magick_png_free);
#else
- ping=png_create_read_struct(PNG_LIBPNG_VER_STRING,image,
+ ping=png_create_read_struct(PNG_LIBPNG_VER_STRING,&error_info,
MagickPNGErrorHandler,MagickPNGWarningHandler);
#endif
if (ping == (png_struct *) NULL)
if (image != (Image *) NULL)
{
- InheritException(exception,&image->exception);
+ InheritException(exception,exception);
image->columns=0;
}
profile=BlobToStringInfo(info,profile_length);
if (profile == (StringInfo *) NULL)
{
- (void) ThrowMagickException(&image->exception,GetMagickModule(),
+ (void) ThrowMagickException(exception,GetMagickModule(),
ResourceLimitError,"MemoryAllocationFailed","`%s'",
"unable to copy profile");
return((Image *) NULL);
{
if (mng_info->global_trns_length >
mng_info->global_plte_length)
- (void) ThrowMagickException(&image->exception,
+ (void) ThrowMagickException(exception,
GetMagickModule(),CoderError,
"global tRNS has more entries than global PLTE",
"`%s'",image_info->filename);
#endif
}
else
- (void) ThrowMagickException(&image->exception,GetMagickModule(),
+ (void) ThrowMagickException(exception,GetMagickModule(),
CoderError,"No global PLTE in file","`%s'",
image_info->filename);
}
if (image != (Image *) NULL)
{
- InheritException(exception,&image->exception);
+ InheritException(exception,exception);
image->columns=0;
}
sizeof(*value));
if (value == (char *) NULL)
{
- (void) ThrowMagickException(&image->exception,GetMagickModule(),
+ (void) ThrowMagickException(exception,GetMagickModule(),
ResourceLimitError,"MemoryAllocationFailed","`%s'",
image->filename);
break;
mng_info->ob[object_id]->frozen)
{
if (mng_info->ob[object_id] == (MngBuffer *) NULL)
- (void) ThrowMagickException(&image->exception,GetMagickModule(),
+ (void) ThrowMagickException(exception,GetMagickModule(),
ResourceLimitError,"MemoryAllocationFailed","`%s'",
image->filename);
if (mng_info->ob[object_id]->frozen)
- (void) ThrowMagickException(&image->exception,GetMagickModule(),
+ (void) ThrowMagickException(exception,GetMagickModule(),
ResourceLimitError,"Cannot overwrite frozen MNG object buffer",
"`%s'",image->filename);
}
(mng_info->ob[object_id]->image);
mng_info->ob[object_id]->image=CloneImage(image,0,0,MagickTrue,
- &image->exception);
+ exception);
if (mng_info->ob[object_id]->image != (Image *) NULL)
mng_info->ob[object_id]->image->file=(FILE *) NULL;
else
- (void) ThrowMagickException(&image->exception,GetMagickModule(),
+ (void) ThrowMagickException(exception,GetMagickModule(),
ResourceLimitError,"Cloning image for object buffer failed",
"`%s'",image->filename);
for (y=0; y < (ssize_t) image->rows; y++)
{
- s=GetVirtualPixels(jng_image,0,y,image->columns,1,&image->exception);
+ s=GetVirtualPixels(jng_image,0,y,image->columns,1,exception);
q=GetAuthenticPixels(image,0,y,image->columns,1,exception);
for (x=(ssize_t) image->columns; x != 0; x--)
{
for (y=0; y < (ssize_t) image->rows; y++)
{
s=GetVirtualPixels(jng_image,0,y,image->columns,1,
- &image->exception);
+ exception);
q=GetAuthenticPixels(image,0,y,image->columns,1,exception);
if (image->matte != MagickFalse)
skip_to_iend=MagickTrue;
if (mng_info->jhdr_warning == 0)
- (void) ThrowMagickException(&image->exception,GetMagickModule(),
+ (void) ThrowMagickException(exception,GetMagickModule(),
CoderError,"JNGCompressNotSupported","`%s'",image->filename);
mng_info->jhdr_warning++;
skip_to_iend=MagickTrue;
if (mng_info->dhdr_warning == 0)
- (void) ThrowMagickException(&image->exception,GetMagickModule(),
+ (void) ThrowMagickException(exception,GetMagickModule(),
CoderError,"DeltaPNGNotSupported","`%s'",image->filename);
mng_info->dhdr_warning++;
if (memcmp(type,mng_DEFI,4) == 0)
{
if (mng_type == 3)
- (void) ThrowMagickException(&image->exception,GetMagickModule(),
+ (void) ThrowMagickException(exception,GetMagickModule(),
CoderError,"DEFI chunk found in MNG-VLC datastream","`%s'",
image->filename);
object_id=(p[0] << 8) | p[1];
if (mng_type == 2 && object_id != 0)
- (void) ThrowMagickException(&image->exception,GetMagickModule(),
+ (void) ThrowMagickException(exception,GetMagickModule(),
CoderError,"Nonzero object_id in MNG-LC datastream","`%s'",
image->filename);
Instead ofsuing a warning we should allocate a larger
MngInfo structure and continue.
*/
- (void) ThrowMagickException(&image->exception,GetMagickModule(),
+ (void) ThrowMagickException(exception,GetMagickModule(),
CoderError,"object id too large","`%s'",image->filename);
object_id=MNG_MAX_OBJECTS;
}
if (mng_info->frozen[object_id])
{
chunk=(unsigned char *) RelinquishMagickMemory(chunk);
- (void) ThrowMagickException(&image->exception,
+ (void) ThrowMagickException(exception,
GetMagickModule(),CoderError,
"DEFI cannot redefine a frozen MNG object","`%s'",
image->filename);
if (memcmp(type,mng_FRAM,4) == 0)
{
if (mng_type == 3)
- (void) ThrowMagickException(&image->exception,GetMagickModule(),
+ (void) ThrowMagickException(exception,GetMagickModule(),
CoderError,"FRAM chunk found in MNG-VLC datastream","`%s'",
image->filename);
if (memcmp(type,mng_CLON,4) == 0)
{
if (mng_info->clon_warning == 0)
- (void) ThrowMagickException(&image->exception,GetMagickModule(),
+ (void) ThrowMagickException(exception,GetMagickModule(),
CoderError,"CLON is not implemented yet","`%s'",
image->filename);
if (magn_first || magn_last)
if (mng_info->magn_warning == 0)
{
- (void) ThrowMagickException(&image->exception,
+ (void) ThrowMagickException(exception,
GetMagickModule(),CoderError,
"MAGN is not implemented yet for nonzero objects",
"`%s'",image->filename);
if (magn_methx > 5 || magn_methy > 5)
if (mng_info->magn_warning == 0)
{
- (void) ThrowMagickException(&image->exception,
+ (void) ThrowMagickException(exception,
GetMagickModule(),CoderError,
"Unknown MAGN method in MNG datastream","`%s'",
image->filename);
if (memcmp(type,mng_PAST,4) == 0)
{
if (mng_info->past_warning == 0)
- (void) ThrowMagickException(&image->exception,GetMagickModule(),
+ (void) ThrowMagickException(exception,GetMagickModule(),
CoderError,"PAST is not implemented yet","`%s'",
image->filename);
if (memcmp(type,mng_SHOW,4) == 0)
{
if (mng_info->show_warning == 0)
- (void) ThrowMagickException(&image->exception,GetMagickModule(),
+ (void) ThrowMagickException(exception,GetMagickModule(),
CoderError,"SHOW is not implemented yet","`%s'",
image->filename);
if (memcmp(type,mng_pHYg,4) == 0)
{
if (mng_info->phyg_warning == 0)
- (void) ThrowMagickException(&image->exception,GetMagickModule(),
+ (void) ThrowMagickException(exception,GetMagickModule(),
CoderError,"pHYg is not implemented.","`%s'",image->filename);
mng_info->phyg_warning++;
skip_to_iend=MagickTrue;
if (mng_info->basi_warning == 0)
- (void) ThrowMagickException(&image->exception,GetMagickModule(),
+ (void) ThrowMagickException(exception,GetMagickModule(),
CoderError,"BASI is not implemented yet","`%s'",
image->filename);
#endif
#if (MAGICKCORE_QUANTUM_DEPTH > 8)
- if (LosslessReduceDepthOK(image) != MagickFalse)
+ if (LosslessReduceDepthOK(image,exception) != MagickFalse)
image->depth = 8;
#endif
- GetImageException(image,exception);
-
if (image_info->number_scenes != 0)
{
if (mng_info->scenes_found >
if (logging != MagickFalse)
(void) LogMagickEvent(CoderEvent,GetMagickModule()," No beginning");
- (void) ThrowMagickException(&image->exception,GetMagickModule(),
+ (void) ThrowMagickException(exception,GetMagickModule(),
CoderError,"Linked list is corrupted, beginning of list not found",
"`%s'",image_info->filename);
if (logging != MagickFalse)
(void) LogMagickEvent(CoderEvent,GetMagickModule()," Corrupt list");
- (void) ThrowMagickException(&image->exception,GetMagickModule(),
+ (void) ThrowMagickException(exception,GetMagickModule(),
CoderError,"Linked list is corrupted; next_image is NULL","`%s'",
image_info->filename);
}
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
" First image null");
- (void) ThrowMagickException(&image->exception,GetMagickModule(),
+ (void) ThrowMagickException(exception,GetMagickModule(),
CoderError,"image->next for first image is NULL but shouldn't be.",
"`%s'",image_info->filename);
}
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
" No visible images found.");
- (void) ThrowMagickException(&image->exception,GetMagickModule(),
+ (void) ThrowMagickException(exception,GetMagickModule(),
CoderError,"No visible images in file","`%s'",image_info->filename);
if (image != (Image *) NULL)
(void) LogMagickEvent(CoderEvent,GetMagickModule()," Coalesce Images");
scene=image->scene;
- next_image=CoalesceImages(image,&image->exception);
+ next_image=CoalesceImages(image,exception);
if (next_image == (Image *) NULL)
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
QuantumInfo
*quantum_info;
+ PNGErrorInfo
+ error_info;
+
register ssize_t
i,
x;
logging=LogMagickEvent(CoderEvent,GetMagickModule(),
" Enter WriteOnePNGImage()");
- image = CloneImage(IMimage,0,0,MagickFalse,&IMimage->exception);
+ image = CloneImage(IMimage,0,0,MagickFalse,exception);
image_info=(ImageInfo *) CloneImageInfo(IMimage_info);
if (image_info == (ImageInfo *) NULL)
ThrowWriterException(ResourceLimitError, "MemoryAllocationFailed");
register Quantum
*r;
- ExceptionInfo
- *exception;
-
- exception=(&image->exception);
-
if (image->depth > 8)
{
#if MAGICKCORE_QUANTUM_DEPTH > 16
for (y=0; y < (ssize_t) image->rows; y++)
{
- r=GetAuthenticPixels(image,0,y,image->columns,1,
- exception);
+ r=GetAuthenticPixels(image,0,y,image->columns,1,exception);
if (r == (Quantum *) NULL)
break;
#if (MAGICKCORE_QUANTUM_DEPTH > 8)
if (image->depth == 16 && mng_info->write_png_depth != 16)
- if (mng_info->write_png8 || LosslessReduceDepthOK(image) != MagickFalse)
+ if (mng_info->write_png8 || LosslessReduceDepthOK(image,exception) != MagickFalse)
image->depth = 8;
#endif
* we need to check for bogus non-opaque values, at least.
*/
- ExceptionInfo
- *exception;
-
int
n;
" Regenerate the colormap");
}
- exception=(&image->exception);
-
image_colors=0;
number_opaque = 0;
number_semitransparent = 0;
else if (image_colors == 0 || image_colors > 256 ||
image->colormap == NULL)
{
- ExceptionInfo
- *exception;
-
register const Quantum
*q;
- exception=(&image->exception);
-
for (y=0; y < (ssize_t) image->rows; y++)
{
q=GetVirtualPixels(image,0,y,image->columns,1, exception);
{
image_info=DestroyImageInfo(image_info);
image=DestroyImage(image);
- (void) ThrowMagickException(&IMimage->exception,
- GetMagickModule(),CoderError,
+ (void) ThrowMagickException(exception,GetMagickModule(),CoderError,
"Cannot write PNG8 or color-type 3; colormap is NULL",
"`%s'",IMimage->filename);
#if defined(PNG_SETJMP_NOT_THREAD_SAFE)
Allocate the PNG structures
*/
#ifdef PNG_USER_MEM_SUPPORTED
- ping=png_create_write_struct_2(PNG_LIBPNG_VER_STRING,image,
+ error_info.image=image;
+ error_info.exception=exception;
+ ping=png_create_write_struct_2(PNG_LIBPNG_VER_STRING,&error_info,
MagickPNGErrorHandler,MagickPNGWarningHandler,(void *) NULL,
(png_malloc_ptr) Magick_png_malloc,(png_free_ptr) Magick_png_free);
#else
- ping=png_create_write_struct(PNG_LIBPNG_VER_STRING,image,
+ ping=png_create_write_struct(PNG_LIBPNG_VER_STRING,&error_info,
MagickPNGErrorHandler,MagickPNGWarningHandler);
#endif
if (image->colors == 0)
{
/* DO SOMETHING */
- (void) ThrowMagickException(&image->exception,
+ (void) ThrowMagickException(exception,
GetMagickModule(),CoderError,
"image has 0 colors", "`%s'","");
}
if (mng_info->need_blob != MagickFalse)
{
- if (OpenBlob(image_info,image,WriteBinaryBlobMode,&image->exception) ==
+ if (OpenBlob(image_info,image,WriteBinaryBlobMode,exception) ==
MagickFalse)
png_error(ping,"WriteBlob Failed");
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
" Writing row of pixels (0)");
- p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
+ p=GetVirtualPixels(image,0,y,image->columns,1,exception);
if (p == (const Quantum *) NULL)
break;
if (mng_info->IsPalette)
{
(void) ExportQuantumPixels(image,(CacheView *) NULL,
- quantum_info,GrayQuantum,ping_pixels,&image->exception);
+ quantum_info,GrayQuantum,ping_pixels,exception);
if (mng_info->write_png_colortype-1 == PNG_COLOR_TYPE_PALETTE &&
mng_info->write_png_depth &&
mng_info->write_png_depth != old_bit_depth)
else
{
(void) ExportQuantumPixels(image,(CacheView *) NULL,
- quantum_info,RedQuantum,ping_pixels,&image->exception);
+ quantum_info,RedQuantum,ping_pixels,exception);
}
if (mng_info->write_png_colortype-1 != PNG_COLOR_TYPE_PALETTE)
for (y=0; y < (ssize_t) image->rows; y++)
{
- p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
+ p=GetVirtualPixels(image,0,y,image->columns,1,exception);
if (p == (const Quantum *) NULL)
break;
{
if (mng_info->IsPalette)
(void) ExportQuantumPixels(image,(CacheView *) NULL,
- quantum_info,GrayQuantum,ping_pixels,&image->exception);
+ quantum_info,GrayQuantum,ping_pixels,exception);
else
(void) ExportQuantumPixels(image,(CacheView *) NULL,
- quantum_info,RedQuantum,ping_pixels,&image->exception);
+ quantum_info,RedQuantum,ping_pixels,exception);
if (logging != MagickFalse && y == 0)
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
" Writing GRAY_ALPHA PNG pixels (2)");
(void) ExportQuantumPixels(image,(CacheView *) NULL,
- quantum_info,GrayAlphaQuantum,ping_pixels,&image->exception);
+ quantum_info,GrayAlphaQuantum,ping_pixels,exception);
}
if (logging != MagickFalse && y == 0)
for (y=0; y < (ssize_t) image->rows; y++)
{
p=GetVirtualPixels(image,0,y,image->columns,1,
- &image->exception);
+ exception);
if (p == (const Quantum *) NULL)
break;
{
if (image->storage_class == DirectClass)
(void) ExportQuantumPixels(image,(CacheView *) NULL,
- quantum_info,RedQuantum,ping_pixels,&image->exception);
+ quantum_info,RedQuantum,ping_pixels,exception);
else
(void) ExportQuantumPixels(image,(CacheView *) NULL,
- quantum_info,GrayQuantum,ping_pixels,&image->exception);
+ quantum_info,GrayQuantum,ping_pixels,exception);
}
else if (ping_color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
{
(void) ExportQuantumPixels(image,(CacheView *) NULL,
quantum_info,GrayAlphaQuantum,ping_pixels,
- &image->exception);
+ exception);
if (logging != MagickFalse && y == 0)
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
else if (image_matte != MagickFalse)
(void) ExportQuantumPixels(image,(CacheView *) NULL,
- quantum_info,RGBAQuantum,ping_pixels,&image->exception);
+ quantum_info,RGBAQuantum,ping_pixels,exception);
else
(void) ExportQuantumPixels(image,(CacheView *) NULL,
- quantum_info,RGBQuantum,ping_pixels,&image->exception);
+ quantum_info,RGBQuantum,ping_pixels,exception);
if (logging != MagickFalse && y == 0)
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
" pass %d, Image Is RGB, 16-bit GRAY, or GRAY_ALPHA",pass);
p=GetVirtualPixels(image,0,y,image->columns,1,
- &image->exception);
+ exception);
if (p == (const Quantum *) NULL)
break;
quantum_info->depth=image->depth;
(void) ExportQuantumPixels(image,(CacheView *) NULL,
- quantum_info,GrayQuantum,ping_pixels,&image->exception);
+ quantum_info,GrayQuantum,ping_pixels,exception);
}
else if (ping_color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
(void) ExportQuantumPixels(image,(CacheView *) NULL,
quantum_info,GrayAlphaQuantum,ping_pixels,
- &image->exception);
+ exception);
}
else
{
(void) ExportQuantumPixels(image,(CacheView *) NULL,
- quantum_info,IndexQuantum,ping_pixels,&image->exception);
+ quantum_info,IndexQuantum,ping_pixels,exception);
if (logging != MagickFalse && y <= 2)
{
}
if (mng_info->write_mng && !mng_info->need_fram &&
((int) image->dispose == 3))
- (void) ThrowMagickException(&image->exception,GetMagickModule(),
+ (void) ThrowMagickException(exception,GetMagickModule(),
CoderError,"Cannot convert GIF with disposal method 3 to MNG-LC",
"`%s'",image->filename);
mng_info->write_png_depth = 16;
else
- (void) ThrowMagickException(&image->exception,
+ (void) ThrowMagickException(exception,
GetMagickModule(),CoderWarning,
"ignoring invalid defined png:bit-depth",
"=%s",value);
mng_info->write_png_colortype = 7;
else
- (void) ThrowMagickException(&image->exception,
+ (void) ThrowMagickException(exception,
GetMagickModule(),CoderWarning,
"ignoring invalid defined png:color-type",
"=%s",value);
mng_info->write_png_compression_level = 10;
else
- (void) ThrowMagickException(&image->exception,
+ (void) ThrowMagickException(exception,
GetMagickModule(),CoderWarning,
"ignoring invalid defined png:compression-level",
"=%s",value);
#endif
else
- (void) ThrowMagickException(&image->exception,
+ (void) ThrowMagickException(exception,
GetMagickModule(),CoderWarning,
"ignoring invalid defined png:compression-strategy",
"=%s",value);
mng_info->write_png_compression_filter = 6;
else
- (void) ThrowMagickException(&image->exception,
+ (void) ThrowMagickException(exception,
GetMagickModule(),CoderWarning,
"ignoring invalid defined png:compression-filter",
"=%s",value);
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
" Creating jpeg_image.");
- jpeg_image=CloneImage(image,0,0,MagickTrue,&image->exception);
+ jpeg_image=CloneImage(image,0,0,MagickTrue,exception);
if (jpeg_image == (Image *) NULL)
ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
/* Check if image is grayscale. */
if (image_info->type != TrueColorMatteType && image_info->type !=
- TrueColorType && ImageIsGray(image))
+ TrueColorType && ImageIsGray(image,exception))
jng_color_type-=2;
if (transparent)
/* Encode alpha as a grayscale PNG blob */
status=OpenBlob(jpeg_image_info,jpeg_image,WriteBinaryBlobMode,
- &image->exception);
+ exception);
if (logging != MagickFalse)
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
" Creating PNG blob.");
jpeg_image_info->interlace=NoInterlace;
blob=ImageToBlob(jpeg_image_info,jpeg_image,&length,
- &image->exception);
+ exception);
/* Retrieve sample depth used */
value=GetImageProperty(jpeg_image,"png:bit-depth-written",exception);
/* Encode alpha as a grayscale JPEG blob */
status=OpenBlob(jpeg_image_info,jpeg_image,WriteBinaryBlobMode,
- &image->exception);
+ exception);
(void) CopyMagickString(jpeg_image_info->magick,"JPEG",MaxTextExtent);
(void) CopyMagickString(jpeg_image->magick,"JPEG",MaxTextExtent);
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
" Creating blob.");
blob=ImageToBlob(jpeg_image_info,jpeg_image,&length,
- &image->exception);
+ exception);
jng_alpha_sample_depth=8;
if (logging != MagickFalse)
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
" Creating jpeg_image.");
- jpeg_image=CloneImage(image,0,0,MagickTrue,&image->exception);
+ jpeg_image=CloneImage(image,0,0,MagickTrue,exception);
if (jpeg_image == (Image *) NULL)
ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
(void) CopyMagickString(jpeg_image->magick,"JPEG",MaxTextExtent);
jpeg_image->filename);
status=OpenBlob(jpeg_image_info,jpeg_image,WriteBinaryBlobMode,
- &image->exception);
+ exception);
if (logging != MagickFalse)
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
" Creating blob.");
- blob=ImageToBlob(jpeg_image_info,jpeg_image,&length,&image->exception);
+ blob=ImageToBlob(jpeg_image_info,jpeg_image,&length,exception);
if (logging != MagickFalse)
{
assert(image->signature == MagickSignature);
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
logging=LogMagickEvent(CoderEvent,GetMagickModule(),"Enter WriteJNGImage()");
- status=OpenBlob(image_info,image,WriteBinaryBlobMode,&image->exception);
+ status=OpenBlob(image_info,image,WriteBinaryBlobMode,exception);
if (status == MagickFalse)
return(status);
assert(image->signature == MagickSignature);
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
logging=LogMagickEvent(CoderEvent,GetMagickModule(),"Enter WriteMNGImage()");
- status=OpenBlob(image_info,image,WriteBinaryBlobMode,&image->exception);
+ status=OpenBlob(image_info,image,WriteBinaryBlobMode,exception);
if (status == MagickFalse)
return(status);
if (need_local_plte == 0)
{
- if (ImageIsGray(image) == MagickFalse)
+ if (ImageIsGray(image,exception) == MagickFalse)
all_images_are_gray=MagickFalse;
mng_info->equal_palettes=PalettesAreEqual(image,next_image);
if (use_global_plte == 0)
if (mng_info->adjoin)
{
final_delay=10;
- (void) ThrowMagickException(&image->exception,
- GetMagickModule(),CoderWarning,
+ (void) ThrowMagickException(exception,GetMagickModule(),
+ CoderWarning,
"input has zero delay between all frames; assuming",
" 10 cs `%s'","");
}
*/
static inline ssize_t ConstrainPixel(Image *image,const ssize_t offset,
- const size_t extent)
+ const size_t extent,ExceptionInfo *exception)
{
if ((offset < 0) || (offset > (ssize_t) extent))
{
- (void) ThrowMagickException(&image->exception,GetMagickModule(),
- CorruptImageError,"InvalidPixel","`%s'",image->filename);
+ (void) ThrowMagickException(exception,GetMagickModule(),CorruptImageError,
+ "InvalidPixel","`%s'",image->filename);
return(0);
}
return(offset);
SetPixelRed(image,intensity,q);
if (scale != (Quantum *) NULL)
SetPixelRed(image,scale[ConstrainPixel(image,(ssize_t) intensity,
- max_value)],q);
+ max_value,exception)],q);
SetPixelGreen(image,GetPixelRed(image,q),q);
SetPixelBlue(image,GetPixelRed(image,q),q);
q+=GetPixelChannels(image);
if (scale != (Quantum *) NULL)
{
pixel.red=(MagickRealType) scale[ConstrainPixel(image,(ssize_t)
- pixel.red,max_value)];
+ pixel.red,max_value,exception)];
pixel.green=(MagickRealType) scale[ConstrainPixel(image,
- (ssize_t) pixel.green,max_value)];
+ (ssize_t) pixel.green,max_value,exception)];
pixel.blue=(MagickRealType) scale[ConstrainPixel(image,(ssize_t)
- pixel.blue,max_value)];
+ pixel.blue,max_value,exception)];
}
SetPixelRed(image,ClampToQuantum(pixel.red),q);
SetPixelGreen(image,ClampToQuantum(pixel.green),q);
file=AcquireUniqueFileResource(postscript_filename);
if (file == -1)
{
- ThrowFileException(&image->exception,FileOpenError,"UnableToOpenFile",
+ ThrowFileException(exception,FileOpenError,"UnableToOpenFile",
image_info->filename);
image=DestroyImageList(image);
return((Image *) NULL);
q=(*pixels);
for (y=0; y < (ssize_t) image->rows; y++)
{
- p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
+ p=GetVirtualPixels(image,0,y,image->columns,1,exception);
if (p == (const Quantum *) NULL)
break;
if (image->colorspace != CMYKColorspace)
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
status=MagickTrue;
- pack=IsImageMonochrome(image,&image->exception) == MagickFalse ? 1UL : 8UL;
+ pack=IsImageMonochrome(image,exception) == MagickFalse ? 1UL : 8UL;
padded_columns=((image->columns+pack-1)/pack)*pack;
*length=(size_t) padded_columns*image->rows/pack;
*pixels=(unsigned char *) AcquireQuantumMemory(*length,sizeof(**pixels));
}
(void) WriteBlobString(image,buffer);
(void) WriteBlobString(image,"/ReusableStreamDecode filter\n");
- mask_image=CloneImage(image,0,0,MagickTrue,&image->exception);
+ mask_image=CloneImage(image,0,0,MagickTrue,exception);
if (mask_image == (Image *) NULL)
- ThrowWriterException(CoderError,image->exception.reason);
+ ThrowWriterException(CoderError,exception->reason);
channel_mask=SetPixelChannelMask(mask_image,AlphaChannel);
status=SeparateImage(mask_image,exception);
(void) SetPixelChannelMap(mask_image,channel_mask);
image->rows=psd_info.rows;
if (SetImageBackgroundColor(image,exception) == MagickFalse)
{
- InheritException(exception,&image->exception);
image=DestroyImageList(image);
return((Image *) NULL);
}
*/
layer_info[i].image=CloneImage(image,layer_info[i].page.width,
layer_info[i].page.height == ~0U ? 1 : layer_info[i].page.height,
- MagickFalse,&image->exception);
+ MagickFalse,exception);
if (layer_info[i].image == (Image *) NULL)
{
for (j=0; j < i; j++)
pixels=GetQuantumPixels(quantum_info);
for (y=0; y < (ssize_t) next_image->rows; y++)
{
- p=GetVirtualPixels(next_image,0,y,next_image->columns,1,&image->exception);
+ p=GetVirtualPixels(next_image,0,y,next_image->columns,1,exception);
if (p == (const Quantum *) NULL)
break;
length=ExportQuantumPixels(next_image,(CacheView *) NULL,quantum_info,
- quantum_type,pixels,&image->exception);
+ quantum_type,pixels,exception);
length=PSDPackbitsEncodeImage(image,length,pixels,compact_pixels,
exception);
(void) SetPSDOffset(psd_info,image,length);
(void) WriteBlobMSBShort(image,0);
if (next_image->depth > 8)
next_image->depth=16;
- monochrome=IsImageMonochrome(image,&image->exception) && (image->depth == 1)
- ? MagickTrue : MagickFalse;
+ monochrome=IsImageMonochrome(image,exception) && (image->depth == 1) ?
+ MagickTrue : MagickFalse;
packet_size=next_image->depth > 8UL ? 2UL : 1UL;
(void) packet_size;
quantum_info=AcquireQuantumInfo(image_info,image);
pixels=GetQuantumPixels(quantum_info);
for (y=0; y < (ssize_t) next_image->rows; y++)
{
- p=GetVirtualPixels(next_image,0,y,next_image->columns,1,&image->exception);
+ p=GetVirtualPixels(next_image,0,y,next_image->columns,1,exception);
if (p == (const Quantum *) NULL)
break;
length=ExportQuantumPixels(next_image,(CacheView *) NULL,quantum_info,
- quantum_type,pixels,&image->exception);
+ quantum_type,pixels,exception);
if (monochrome != MagickFalse)
for (i=0; i < (ssize_t) length; i++)
pixels[i]=(~pixels[i]);
ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
}
i=0;
- if (IsImageGray(next_image,&next_image->exception) != MagickFalse)
+ if (IsImageGray(next_image,exception) != MagickFalse)
{
if (next_image->compression == RLECompression)
{
else
{
if (next_image->colorspace == CMYKColorspace)
- (void) NegateImage(next_image,MagickFalse,&next_image->exception);
+ (void) NegateImage(next_image,MagickFalse,exception);
if (next_image->compression == RLECompression)
{
/*
MagickFalse,exception);
(void) SetImageProgress(image,SaveImagesTag,5,6);
if (next_image->colorspace == CMYKColorspace)
- (void) NegateImage(next_image,MagickFalse,&next_image->exception);
+ (void) NegateImage(next_image,MagickFalse,exception);
}
if (next_image->compression == RLECompression)
compact_pixels=(unsigned char *) RelinquishMagickMemory(compact_pixels);
scene++;
} while (count == (ssize_t) length);
quantum_info=DestroyQuantumInfo(quantum_info);
- InheritException(&image->exception,&canvas_image->exception);
canvas_image=DestroyImage(canvas_image);
(void) CloseBlob(image);
return(GetFirstImageInList(image));
scene++;
} while (count == (ssize_t) length);
quantum_info=DestroyQuantumInfo(quantum_info);
- InheritException(&image->exception,&canvas_image->exception);
canvas_image=DestroyImage(canvas_image);
(void) CloseBlob(image);
return(GetFirstImageInList(image));
(void) remove_utf8(read_info->filename);
read_info=DestroyImageInfo(read_info);
message=GetExceptionMessage(errno);
- (void) ThrowMagickException(&image->exception,GetMagickModule(),
- FileOpenError,"UnableToWriteFile","`%s': %s",image->filename,message);
+ (void) ThrowMagickException(exception,GetMagickModule(),FileOpenError,
+ "UnableToWriteFile","`%s': %s",image->filename,message);
message=DestroyString(message);
image=DestroyImageList(image);
return((Image *) NULL);
return(p != point ? MagickTrue : MagickFalse);
}
-static MagickBooleanType TraceSVGImage(Image *image)
+static MagickBooleanType TraceSVGImage(Image *image,ExceptionInfo *exception)
{
ssize_t
y;
GetPixelInfo(image,&pixel);
for (y=0; y < (ssize_t) image->rows; y++)
{
- p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
+ p=GetVirtualPixels(image,0,y,image->columns,1,exception);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
SetPixelInfo(image,p,&pixel);
- (void) QueryColorname(image,&pixel,SVGCompliance,tuple,
- &image->exception);
+ (void) QueryColorname(image,&pixel,SVGCompliance,tuple,exception);
(void) FormatLocaleString(message,MaxTextExtent,
" <circle cx=\"%.20g\" cy=\"%.20g\" r=\"1\" fill=\"%s\"/>\n",
(double) x,(double) y,tuple);
}
value=GetImageArtifact(image,"MVG");
if (value == (char *) NULL)
- return(TraceSVGImage(image));
+ return(TraceSVGImage(image,exception));
/*
Write SVG header.
*/
index=(Quantum) ReadBlobByte(image);
if (tga_info.colormap_type != 0)
pixel=image->colormap[(ssize_t) ConstrainColormapIndex(image,
- 1UL*index)];
+ 1UL*index,exception)];
else
{
pixel.red=ScaleCharToQuantum((unsigned char) index);
pixel.alpha=(k & 0x80) == 0 ? (Quantum) OpaqueAlpha :
(Quantum) TransparentAlpha;
if (image->storage_class == PseudoClass)
- index=ConstrainColormapIndex(image,((size_t) k << 8)+j);
+ index=ConstrainColormapIndex(image,((size_t) k << 8)+j,exception);
break;
}
case 24:
TIFFClose(tiff);
ThrowReaderException(CoderError,"ImageIsNotTiled");
}
- (void) SetImageStorageClass(image,DirectClass,&image->exception);
+ (void) SetImageStorageClass(image,DirectClass,exception);
number_pixels=columns*rows;
tile_pixels=(uint32 *) AcquireQuantumMemory(number_pixels,
sizeof(*tile_pixels));
assert(image->signature == MagickSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
- status=OpenBlob(image_info,image,WriteBinaryBlobMode,&image->exception);
+ status=OpenBlob(image_info,image,WriteBinaryBlobMode,exception);
if (status == MagickFalse)
return(status);
if (WebPPictureInit(&picture) == 0)
q=pixels;
for (y=0; y < (ssize_t) image->rows; y++)
{
- p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
+ p=GetVirtualPixels(image,0,y,image->columns,1,exception);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) image->columns; x++)
return;
}
-static void InsertRow(unsigned char *p,ssize_t y,Image *image, int bpp)
+static void InsertRow(Image *image,unsigned char *p,ssize_t y,int bpp,
+ ExceptionInfo *exception)
{
- ExceptionInfo
- *exception;
-
int
bit;
ssize_t
x;
- exception=(&image->exception);
switch (bpp)
{
case 1: /* Convert bitmap scanline. */
break;
for (x=0; x < ((ssize_t) image->columns-1); x+=2)
{
- index=ConstrainColormapIndex(image,(*p >> 6) & 0x3);
+ index=ConstrainColormapIndex(image,(*p >> 6) & 0x3,exception);
SetPixelIndex(image,index,q);
SetPixelPixelInfo(image,image->colormap+(ssize_t) index,q);
q+=GetPixelChannels(image);
- index=ConstrainColormapIndex(image,(*p >> 4) & 0x3);
+ index=ConstrainColormapIndex(image,(*p >> 4) & 0x3,exception);
SetPixelIndex(image,index,q);
SetPixelPixelInfo(image,image->colormap+(ssize_t) index,q);
q+=GetPixelChannels(image);
- index=ConstrainColormapIndex(image,(*p >> 2) & 0x3);
+ index=ConstrainColormapIndex(image,(*p >> 2) & 0x3,exception);
SetPixelIndex(image,index,q);
SetPixelPixelInfo(image,image->colormap+(ssize_t) index,q);
q+=GetPixelChannels(image);
- index=ConstrainColormapIndex(image,(*p) & 0x3);
+ index=ConstrainColormapIndex(image,(*p) & 0x3,exception);
SetPixelIndex(image,index,q);
SetPixelPixelInfo(image,image->colormap+(ssize_t) index,q);
p++;
}
if ((image->columns % 4) != 0)
{
- index=ConstrainColormapIndex(image,(*p >> 6) & 0x3);
+ index=ConstrainColormapIndex(image,(*p >> 6) & 0x3,exception);
SetPixelIndex(image,index,q);
SetPixelPixelInfo(image,image->colormap+(ssize_t) index,q);
q+=GetPixelChannels(image);
if ((image->columns % 4) >= 1)
{
- index=ConstrainColormapIndex(image,(*p >> 4) & 0x3);
+ index=ConstrainColormapIndex(image,(*p >> 4) & 0x3,exception);
SetPixelIndex(image,index,q);
SetPixelPixelInfo(image,image->colormap+(ssize_t) index,q);
q+=GetPixelChannels(image);
if ((image->columns % 4) >= 2)
{
- index=ConstrainColormapIndex(image,(*p >> 2) & 0x3);
+ index=ConstrainColormapIndex(image,(*p >> 2) & 0x3,
+ exception);
SetPixelIndex(image,index,q);
SetPixelPixelInfo(image,image->colormap+(ssize_t) index,q);
q+=GetPixelChannels(image);
break;
for (x=0; x < ((ssize_t) image->columns-1); x+=2)
{
- index=ConstrainColormapIndex(image,(*p >> 4) & 0x0f);
+ index=ConstrainColormapIndex(image,(*p >> 4) & 0x0f,exception);
SetPixelIndex(image,index,q);
SetPixelPixelInfo(image,image->colormap+(ssize_t) index,q);
q+=GetPixelChannels(image);
- index=ConstrainColormapIndex(image,(*p) & 0x0f);
+ index=ConstrainColormapIndex(image,(*p) & 0x0f,exception);
SetPixelIndex(image,index,q);
SetPixelPixelInfo(image,image->colormap+(ssize_t) index,q);
p++;
}
if ((image->columns % 2) != 0)
{
- index=ConstrainColormapIndex(image,(*p >> 4) & 0x0f);
+ index=ConstrainColormapIndex(image,(*p >> 4) & 0x0f,exception);
SetPixelIndex(image,index,q);
SetPixelPixelInfo(image,image->colormap+(ssize_t) index,q);
p++;
for (x=0; x < (ssize_t) image->columns; x++)
{
- index=ConstrainColormapIndex(image,*p);
+ index=ConstrainColormapIndex(image,*p,exception);
SetPixelIndex(image,index,q);
SetPixelPixelInfo(image,image->colormap+(ssize_t) index,q);
p++;
x++; \
if((ssize_t) x>=ldblk) \
{ \
- InsertRow(BImgBuff,(ssize_t) y,image,bpp); \
+ InsertRow(image,BImgBuff,(ssize_t) y,bpp,exception); \
x=0; \
y++; \
} \
}
/* WPG1 raster reader. */
-static int UnpackWPGRaster(Image *image,int bpp)
+static int UnpackWPGRaster(Image *image,int bpp,ExceptionInfo *exception)
{
int
x,
BImgBuff=(unsigned char *) RelinquishMagickMemory(BImgBuff);
return(-4);
}
- InsertRow(BImgBuff,y-1,image,bpp);
+ InsertRow(image,BImgBuff,y-1,bpp,exception);
}
}
}
x++; \
if((ssize_t) x >= ldblk) \
{ \
- InsertRow(BImgBuff,(ssize_t) y,image,bpp); \
+ InsertRow(image,BImgBuff,(ssize_t) y,bpp,exception); \
x=0; \
y++; \
} \
}
/* WPG2 raster reader. */
-static int UnpackWPG2Raster(Image *image,int bpp)
+static int UnpackWPG2Raster(Image *image,int bpp,ExceptionInfo *exception)
{
size_t
x,
/* duplicate the previous row RunCount x */
for(i=0;i<=RunCount;i++)
{
- InsertRow(BImgBuff,(ssize_t) (image->rows >= y ? y : image->rows-1),
- image,bpp);
+ InsertRow(image,BImgBuff,(ssize_t) (image->rows >= y ? y : image->rows-1),
+ bpp,exception);
y++;
}
}
}
}
- if(UnpackWPGRaster(image,bpp) < 0)
+ if(UnpackWPGRaster(image,bpp,exception) < 0)
/* The raster cannot be unpacked */
{
DecompressionFailed:
for(i=0; i< (ssize_t) image->rows; i++)
{
(void) ReadBlob(image,ldblk,BImgBuff);
- InsertRow(BImgBuff,i,image,bpp);
+ InsertRow(image,BImgBuff,i,bpp,exception);
}
if(BImgBuff)
}
case 1: /*RLE for WPG2 */
{
- if( UnpackWPG2Raster(image,bpp) < 0)
+ if( UnpackWPG2Raster(image,bpp,exception) < 0)
goto DecompressionFailed;
break;
}
return(y);
}
-static char *ReadBlobStringWithLongSize(Image *image,char *string,size_t max)
+static char *ReadBlobStringWithLongSize(Image *image,char *string,size_t max,
+ ExceptionInfo *exception)
{
int
c;
string[i]='\0';
offset=SeekBlob(image,(MagickOffsetType) (length-i),SEEK_CUR);
if (offset < 0)
- (void) ThrowMagickException(&image->exception,GetMagickModule(),
+ (void) ThrowMagickException(exception,GetMagickModule(),
CorruptImageError,"ImproperImageHeader","`%s'",image->filename);
return(string);
}
xcfodata=xcfdata;
count=ReadBlob(image, (size_t) data_length, xcfdata);
xcfdatalimit = xcfodata+count-1;
- exception=(&image->exception);
+ exception=(exception);
for (i=0; i < (ssize_t) bytes_per_pixel; i++)
{
q=GetAuthenticPixels(tile_image,0,0,tile_image->columns,tile_image->rows,
outLayer->height = ReadBlobMSBLong(image);
outLayer->type = ReadBlobMSBLong(image);
(void) ReadBlobStringWithLongSize(image, outLayer->name,
- sizeof(outLayer->name));
+ sizeof(outLayer->name),exception);
/* allocate the image for this layer */
outLayer->image=CloneImage(image,outLayer->width, outLayer->height,MagickTrue,
- &image->exception);
+ exception);
if (outLayer->image == (Image *) NULL)
return MagickFalse;
/* read the layer properties! */
case PROP_PARASITES:
{
if (DiscardBlobBytes(image,prop_size) == MagickFalse)
- ThrowFileException(&image->exception,CorruptImageError,
+ ThrowFileException(exception,CorruptImageError,
"UnexpectedEndOfFile",image->filename);
/*
/* read in the hierarchy */
offset=SeekBlob(image, (MagickOffsetType) hierarchy_offset, SEEK_SET);
if (offset < 0)
- (void) ThrowMagickException(&image->exception,GetMagickModule(),
+ (void) ThrowMagickException(exception,GetMagickModule(),
CorruptImageError,"InvalidImageHeader","`%s'",image->filename);
if (load_hierarchy (image, inDocInfo, outLayer) == 0)
return(MagickFalse);
*/
size_t num_colours = ReadBlobMSBLong(image);
if (DiscardBlobBytes(image,3*num_colours) == MagickFalse)
- ThrowFileException(&image->exception,CorruptImageError,
+ ThrowFileException(exception,CorruptImageError,
"UnexpectedEndOfFile",image->filename);
/*
if (info->file_version == 0)
{
/* just skip it - we don't care about guides */
if (DiscardBlobBytes(image,prop_size) == MagickFalse)
- ThrowFileException(&image->exception,CorruptImageError,
+ ThrowFileException(exception,CorruptImageError,
"UnexpectedEndOfFile",image->filename);
}
break;
{
/* BOGUS: we may need these for IPTC stuff */
if (DiscardBlobBytes(image,prop_size) == MagickFalse)
- ThrowFileException(&image->exception,CorruptImageError,
+ ThrowFileException(exception,CorruptImageError,
"UnexpectedEndOfFile",image->filename);
/*
gssize_t base = info->cp;
{
/* BOGUS: just skip it for now */
if (DiscardBlobBytes(image,prop_size) == MagickFalse)
- ThrowFileException(&image->exception,CorruptImageError,
- "UnexpectedEndOfFile",image->filename);
+ ThrowFileException(exception,CorruptImageError,"UnexpectedEndOfFile",
+ image->filename);
/*
PathList *paths = xcf_load_bzpaths (gimage, info);
/* size_t digits = */ (void) ReadBlobMSBLong(image);
for (i=0; i<5; i++)
(void) ReadBlobStringWithLongSize(image, unit_string,
- sizeof(unit_string));
+ sizeof(unit_string),exception);
}
break;
Image
*cmyk_image;
- cmyk_image=ConsolidateCMYKImages(image,&image->exception);
+ cmyk_image=ConsolidateCMYKImages(image,exception);
if (cmyk_image != (Image *) NULL)
{
image=DestroyImageList(image);
for (x=0; x < (ssize_t) image->columns; x++)
{
index=ConstrainColormapIndex(image,XGetPixel(ximage,(int) x,
- (int) y));
+ (int) y),exception);
SetPixelIndex(image,index,q);
SetPixelPixelInfo(image,image->colormap+(ssize_t) index,q);
q+=GetPixelChannels(image);
scene++;
} while (count == (ssize_t) length);
quantum_info=DestroyQuantumInfo(quantum_info);
- InheritException(&image->exception,&canvas_image->exception);
canvas_image=DestroyImage(canvas_image);
(void) CloseBlob(image);
return(GetFirstImageInList(image));
{
q=GetAuthenticPixels(image,0,y,image->columns,1,exception);
chroma_pixels=GetVirtualPixels(resize_image,0,y,resize_image->columns,1,
- &resize_image->exception);
+ exception);
if ((q == (Quantum *) NULL) ||
(chroma_pixels == (const Quantum *) NULL))
break;
projects / imagemagick / commitdiff