thread_support=GetMagickThreadSupport(magick_info);
if ((thread_support & EncoderThreadSupport) == 0)
LockSemaphoreInfo(constitute_semaphore);
- status=GetImageEncoder(magick_info)(write_info,image);
+ status=GetImageEncoder(magick_info)(write_info,image,exception);
if ((thread_support & EncoderThreadSupport) == 0)
UnlockSemaphoreInfo(constitute_semaphore);
}
thread_support=GetMagickThreadSupport(magick_info);
if ((thread_support & EncoderThreadSupport) == 0)
LockSemaphoreInfo(constitute_semaphore);
- status=GetImageEncoder(magick_info)(write_info,image);
+ status=GetImageEncoder(magick_info)(write_info,image,exception);
if ((thread_support & EncoderThreadSupport) == 0)
UnlockSemaphoreInfo(constitute_semaphore);
}
*DecodeImageHandler(const ImageInfo *,ExceptionInfo *);
typedef MagickBooleanType
- EncodeImageHandler(const ImageInfo *,Image *);
+ EncodeImageHandler(const ImageInfo *,Image *,ExceptionInfo *);
typedef MagickBooleanType
IsImageFormatHandler(const unsigned char *,const size_t);
Forward declarations.
*/
static MagickBooleanType
- WriteAAIImage(const ImageInfo *,Image *);
+ WriteAAIImage(const ImageInfo *,Image *,ExceptionInfo *);
\f
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% The format of the WriteAAIImage method is:
%
-% MagickBooleanType WriteAAIImage(const ImageInfo *image_info,Image *image)
+% MagickBooleanType WriteAAIImage(const ImageInfo *image_info,
+% Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows.
%
%
% o image: The image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
-static MagickBooleanType WriteAAIImage(const ImageInfo *image_info,Image *image)
+static MagickBooleanType WriteAAIImage(const ImageInfo *image_info,Image *image,
+ ExceptionInfo *exception)
{
MagickBooleanType
status;
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);
scene=0;
*/
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;
q=pixels;
Forward declarations.
*/
static MagickBooleanType
- WriteARTImage(const ImageInfo *,Image *);
+ WriteARTImage(const ImageInfo *,Image *,ExceptionInfo *);
\f
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% The format of the WriteARTImage method is:
%
-% MagickBooleanType WriteARTImage(const ImageInfo *image_info,Image *image)
+% MagickBooleanType WriteARTImage(const ImageInfo *image_info,
+% Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows.
%
%
% o image: The image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
-static MagickBooleanType WriteARTImage(const ImageInfo *image_info,Image *image)
+static MagickBooleanType WriteARTImage(const ImageInfo *image_info,Image *image,
+ ExceptionInfo *exception)
{
MagickBooleanType
status;
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 ((image->columns > 65535UL) || (image->rows > 65535UL))
quantum_info=AcquireQuantumInfo(image_info,image);
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;
(void) ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
- GrayQuantum,pixels,&image->exception);
+ GrayQuantum,pixels,exception);
count=WriteBlob(image,length,pixels);
if (count != (ssize_t) length)
ThrowWriterException(CorruptImageError,"UnableToWriteImageData");
Forward declarations.
*/
static MagickBooleanType
- WriteAVSImage(const ImageInfo *,Image *);
+ WriteAVSImage(const ImageInfo *,Image *,ExceptionInfo *);
\f
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% The format of the WriteAVSImage method is:
%
-% MagickBooleanType WriteAVSImage(const ImageInfo *image_info,Image *image)
+% MagickBooleanType WriteAVSImage(const ImageInfo *image_info,
+% Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows.
%
%
% o image: The image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
-static MagickBooleanType WriteAVSImage(const ImageInfo *image_info,Image *image)
+static MagickBooleanType WriteAVSImage(const ImageInfo *image_info,Image *image,
+ ExceptionInfo *exception)
{
MagickBooleanType
status;
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);
scene=0;
*/
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;
q=pixels;
Forward declarations.
*/
static MagickBooleanType
- WriteBGRImage(const ImageInfo *,Image *);
+ WriteBGRImage(const ImageInfo *,Image *,ExceptionInfo *);
\f
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% The format of the WriteBGRImage method is:
%
% MagickBooleanType WriteBGRImage(const ImageInfo *image_info,
-% Image *image)
+% Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows.
%
%
% o image: The image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
-static MagickBooleanType WriteBGRImage(const ImageInfo *image_info,Image *image)
+static MagickBooleanType WriteBGRImage(const ImageInfo *image_info,Image *image,
+ ExceptionInfo *exception)
{
MagickBooleanType
status;
/*
Open output image file.
*/
- status=OpenBlob(image_info,image,WriteBinaryBlobMode,&image->exception);
+ status=OpenBlob(image_info,image,WriteBinaryBlobMode,exception);
if (status == MagickFalse)
return(status);
}
(void) TransformImageColorspace(image,RGBColorspace);
if ((LocaleCompare(image_info->magick,"BGRA") == 0) &&
(image->matte == MagickFalse))
- (void) SetImageAlphaChannel(image,OpaqueAlphaChannel,&image->exception);
+ (void) SetImageAlphaChannel(image,OpaqueAlphaChannel,exception);
quantum_info=AcquireQuantumInfo(image_info,image);
if (quantum_info == (QuantumInfo *) NULL)
ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
register const Quantum
*restrict p;
- 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;
length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
- quantum_type,pixels,&image->exception);
+ quantum_type,pixels,exception);
count=WriteBlob(image,length,pixels);
if (count != (ssize_t) length)
break;
register const Quantum
*restrict p;
- 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;
length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
- BlueQuantum,pixels,&image->exception);
+ BlueQuantum,pixels,exception);
count=WriteBlob(image,length,pixels);
if (count != (ssize_t) length)
break;
length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
- GreenQuantum,pixels,&image->exception);
+ GreenQuantum,pixels,exception);
count=WriteBlob(image,length,pixels);
if (count != (ssize_t) length)
break;
length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
- RedQuantum,pixels,&image->exception);
+ RedQuantum,pixels,exception);
count=WriteBlob(image,length,pixels);
if (count != (ssize_t) length)
break;
if (quantum_type == BGRAQuantum)
{
length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
- AlphaQuantum,pixels,&image->exception);
+ AlphaQuantum,pixels,exception);
count=WriteBlob(image,length,pixels);
if (count != (ssize_t) length)
break;
register const Quantum
*restrict p;
- 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;
length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
- RedQuantum,pixels,&image->exception);
+ RedQuantum,pixels,exception);
count=WriteBlob(image,length,pixels);
if (count != (ssize_t) length)
break;
register const Quantum
*restrict p;
- 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;
length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
- GreenQuantum,pixels,&image->exception);
+ GreenQuantum,pixels,exception);
count=WriteBlob(image,length,pixels);
if (count != (ssize_t) length)
break;
register const Quantum
*restrict p;
- 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;
length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
- BlueQuantum,pixels,&image->exception);
+ BlueQuantum,pixels,exception);
count=WriteBlob(image,length,pixels);
if (count != (ssize_t) length)
break;
register const Quantum
*restrict p;
- 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;
length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
- AlphaQuantum,pixels,&image->exception);
+ AlphaQuantum,pixels,exception);
count=WriteBlob(image,length,pixels);
if (count != (ssize_t) length)
break;
*/
AppendImageFormat("B",image->filename);
status=OpenBlob(image_info,image,scene == 0 ? WriteBinaryBlobMode :
- AppendBinaryBlobMode,&image->exception);
+ AppendBinaryBlobMode,exception);
if (status == MagickFalse)
return(status);
for (y=0; y < (ssize_t) image->rows; y++)
register const Quantum
*restrict p;
- 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;
length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
- BlueQuantum,pixels,&image->exception);
+ BlueQuantum,pixels,exception);
count=WriteBlob(image,length,pixels);
if (count != (ssize_t) length)
break;
(void) CloseBlob(image);
AppendImageFormat("G",image->filename);
status=OpenBlob(image_info,image,scene == 0 ? WriteBinaryBlobMode :
- AppendBinaryBlobMode,&image->exception);
+ AppendBinaryBlobMode,exception);
if (status == MagickFalse)
return(status);
for (y=0; y < (ssize_t) image->rows; y++)
register const Quantum
*restrict p;
- 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;
length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
- GreenQuantum,pixels,&image->exception);
+ GreenQuantum,pixels,exception);
count=WriteBlob(image,length,pixels);
if (count != (ssize_t) length)
break;
(void) CloseBlob(image);
AppendImageFormat("R",image->filename);
status=OpenBlob(image_info,image,scene == 0 ? WriteBinaryBlobMode :
- AppendBinaryBlobMode,&image->exception);
+ AppendBinaryBlobMode,exception);
if (status == MagickFalse)
return(status);
for (y=0; y < (ssize_t) image->rows; y++)
register const Quantum
*restrict p;
- 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;
length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
- RedQuantum,pixels,&image->exception);
+ RedQuantum,pixels,exception);
count=WriteBlob(image,length,pixels);
if (count != (ssize_t) length)
break;
(void) CloseBlob(image);
AppendImageFormat("A",image->filename);
status=OpenBlob(image_info,image,scene == 0 ? WriteBinaryBlobMode :
- AppendBinaryBlobMode,&image->exception);
+ AppendBinaryBlobMode,exception);
if (status == MagickFalse)
return(status);
for (y=0; y < (ssize_t) image->rows; y++)
register const Quantum
*restrict p;
- 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;
length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
- AlphaQuantum,pixels,&image->exception);
+ AlphaQuantum,pixels,exception);
count=WriteBlob(image,length,pixels);
if (count != (ssize_t) length)
break;
Forward declarations.
*/
static MagickBooleanType
- WriteBMPImage(const ImageInfo *,Image *);
+ WriteBMPImage(const ImageInfo *,Image *,ExceptionInfo *);
\f
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% The format of the WriteBMPImage method is:
%
-% MagickBooleanType WriteBMPImage(const ImageInfo *image_info,Image *image)
+% MagickBooleanType WriteBMPImage(const ImageInfo *image_info,
+% Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows.
%
%
% o image: The image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
-static MagickBooleanType WriteBMPImage(const ImageInfo *image_info,Image *image)
+static MagickBooleanType WriteBMPImage(const ImageInfo *image_info,Image *image,
+ ExceptionInfo *exception)
{
BMPInfo
bmp_info;
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);
type=4;
bmp_info.offset_bits=bmp_info.file_size;
bmp_info.compression=BI_RGB;
if ((image->storage_class == PseudoClass) && (image->colors > 256))
- (void) SetImageStorageClass(image,DirectClass,&image->exception);
+ (void) SetImageStorageClass(image,DirectClass,exception);
if (image->storage_class != DirectClass)
{
/*
bmp_info.bits_per_pixel=8;
bmp_info.number_colors=1U << bmp_info.bits_per_pixel;
if (image->matte != MagickFalse)
- (void) SetImageStorageClass(image,DirectClass,&image->exception);
+ (void) SetImageStorageClass(image,DirectClass,exception);
else
if ((size_t) bmp_info.number_colors < image->colors)
- (void) SetImageStorageClass(image,DirectClass,&image->exception);
+ (void) SetImageStorageClass(image,DirectClass,exception);
else
{
bmp_info.file_size+=3*(1UL << bmp_info.bits_per_pixel);
ssize_t
offset;
- 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;
q=pixels+(image->rows-y-1)*bytes_per_line;
*/
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;
q=pixels+(image->rows-y-1)*bytes_per_line;
*/
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;
q=pixels+(image->rows-y-1)*bytes_per_line;
*/
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;
q=pixels+(image->rows-y-1)*bytes_per_line;
*/
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;
q=pixels+(image->rows-y-1)*bytes_per_line;
Forward declarations.
*/
static MagickBooleanType
- WriteBRAILLEImage(const ImageInfo *,Image *);
+ WriteBRAILLEImage(const ImageInfo *,Image *,ExceptionInfo *);
\f
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% The format of the WriteBRAILLEImage method is:
%
% MagickBooleanType WriteBRAILLEImage(const ImageInfo *image_info,
-% Image *image)
+% Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows.
%
%
% o image: The image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
static MagickBooleanType WriteBRAILLEImage(const ImageInfo *image_info,
- Image *image)
+ Image *image,ExceptionInfo *exception)
{
char
buffer[MaxTextExtent];
cell_height=3;
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 (!iso_11548_1)
if ((y+cell_height) > image->rows)
cell_height = (size_t) (image->rows-y);
- p=GetVirtualPixels(image,0,y,image->columns,cell_height,&image->exception);
+ p=GetVirtualPixels(image,0,y,image->columns,cell_height,exception);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) image->columns; x+=2)
Forward declarations.
*/
static MagickBooleanType
- WriteCALSImage(const ImageInfo *,Image *);
+ WriteCALSImage(const ImageInfo *,Image *,ExceptionInfo *);
#endif
\f
/*
% The format of the WriteCALSImage method is:
%
% MagickBooleanType WriteCALSImage(const ImageInfo *image_info,
-% Image *image)
+% Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows.
%
%
% o image: The image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
static ssize_t WriteCALSRecord(Image *image,const char *data)
}
static MagickBooleanType WriteCALSImage(const ImageInfo *image_info,
- Image *image)
+ Image *image,ExceptionInfo *exception)
{
char
header[129];
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);
/*
write_info=CloneImageInfo(image_info);
(void) CopyMagickString(write_info->filename,"GROUP4:",MaxTextExtent);
(void) CopyMagickString(write_info->magick,"GROUP4",MaxTextExtent);
- group4_image=CloneImage(image,0,0,MagickTrue,&image->exception);
+ group4_image=CloneImage(image,0,0,MagickTrue,exception);
if (group4_image == (Image *) NULL)
{
(void) CloseBlob(image);
return(MagickFalse);
}
group4=(unsigned char *) ImageToBlob(write_info,group4_image,&length,
- &image->exception);
+ exception);
group4_image=DestroyImage(group4_image);
if (group4 == (unsigned char *) NULL)
{
Forward declaractions.
*/
static MagickBooleanType
- WriteCINImage(const ImageInfo *,Image *);
+ WriteCINImage(const ImageInfo *,Image *,ExceptionInfo *);
\f
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% The format of the WriteCINImage method is:
%
-% MagickBooleanType WriteCINImage(const ImageInfo *image_info,Image *image)
+% MagickBooleanType WriteCINImage(const ImageInfo *image_info,
+% Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows.
%
%
% o image: The image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
static inline const char *GetCINProperty(const ImageInfo *image_info,
return(GetImageProperty(image,property));
}
-static MagickBooleanType WriteCINImage(const ImageInfo *image_info,Image *image)
+static MagickBooleanType WriteCINImage(const ImageInfo *image_info,Image *image,
+ ExceptionInfo *exception)
{
const char
*value;
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 (image->colorspace != LogColorspace)
}
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;
(void) ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
- quantum_type,pixels,&image->exception);
+ quantum_type,pixels,exception);
count=WriteBlob(image,length,pixels);
if (count != (ssize_t) length)
break;
Forward declarations.
*/
static MagickBooleanType
- WriteCIPImage(const ImageInfo *,Image *);
+ WriteCIPImage(const ImageInfo *,Image *,ExceptionInfo *);
\f
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% The format of the WriteCIPImage method is:
%
-% MagickBooleanType WriteCIPImage(const ImageInfo *image_info,Image *image)
+% MagickBooleanType WriteCIPImage(const ImageInfo *image_info,
+% Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows.
%
%
% o image: The image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
static inline ssize_t MagickMin(const ssize_t x,const ssize_t y)
return(y);
}
-static MagickBooleanType WriteCIPImage(const ImageInfo *image_info,Image *image)
+static MagickBooleanType WriteCIPImage(const ImageInfo *image_info,Image *image,
+ ExceptionInfo *exception)
{
char
buffer[MaxTextExtent];
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);
(void) WriteBlobString(image,"<CiscoIPPhoneImage>\n");
(void) TransformImageColorspace(image,RGBColorspace);
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-3); x+=4)
Forward declarations.
*/
static MagickBooleanType
- WriteCLIPImage(const ImageInfo *,Image *);
+ WriteCLIPImage(const ImageInfo *,Image *,ExceptionInfo *);
\f
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% The format of the WriteCLIPImage method is:
%
% MagickBooleanType WriteCLIPImage(const ImageInfo *image_info,
-% Image *image)
+% Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows.
%
%
% o image: The image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
static MagickBooleanType WriteCLIPImage(const ImageInfo *image_info,
- Image *image)
+ Image *image,ExceptionInfo *exception)
{
Image
*clip_image;
(void) ClipImage(image);
if (image->clip_mask == (Image *) NULL)
ThrowWriterException(CoderError,"ImageDoesNotHaveAClipMask");
- clip_image=CloneImage(image->clip_mask,0,0,MagickTrue,&image->exception);
+ clip_image=CloneImage(image->clip_mask,0,0,MagickTrue,exception);
if (clip_image == (Image *) NULL)
return(MagickFalse);
(void) SetImageType(clip_image,TrueColorType);
(void) CopyMagickString(clip_image->filename,image->filename,MaxTextExtent);
write_info=CloneImageInfo(image_info);
- (void) SetImageInfo(write_info,1,&image->exception);
+ (void) SetImageInfo(write_info,1,exception);
if (LocaleCompare(write_info->magick,"CLIP") == 0)
(void) FormatLocaleString(clip_image->filename,MaxTextExtent,"miff:%s",
write_info->filename);
- status=WriteImage(write_info,clip_image,&image->exception);
+ status=WriteImage(write_info,clip_image,exception);
clip_image=DestroyImage(clip_image);
write_info=DestroyImageInfo(write_info);
return(status);
*/
#if defined(MAGICKCORE_WINGDI32_DELEGATE)
static MagickBooleanType
- WriteCLIPBOARDImage(const ImageInfo *,Image *);
+ WriteCLIPBOARDImage(const ImageInfo *,Image *,ExceptionInfo *);
#endif
\f
/*
% The format of the WriteCLIPBOARDImage method is:
%
% MagickBooleanType WriteCLIPBOARDImage(const ImageInfo *image_info,
-% Image *image)
+% Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows.
%
%
% o image: The image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
#if defined(MAGICKCORE_WINGDI32_DELEGATE)
static MagickBooleanType WriteCLIPBOARDImage(const ImageInfo *image_info,
- Image *image)
+ Image *image,ExceptionInfo *exception)
{
/*
Allocate memory for pixels.
return(MagickTrue);
}
#endif /* MAGICKCORE_WINGDI32_DELEGATE */
-
Forward declarations.
*/
static MagickBooleanType
- WriteCMYKImage(const ImageInfo *,Image *);
+ WriteCMYKImage(const ImageInfo *,Image *,ExceptionInfo *);
\f
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% The format of the WriteCMYKImage method is:
%
% MagickBooleanType WriteCMYKImage(const ImageInfo *image_info,
-% Image *image)
+% Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows.
%
%
% o image: The image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
static MagickBooleanType WriteCMYKImage(const ImageInfo *image_info,
- Image *image)
+ Image *image,ExceptionInfo *exception)
{
MagickBooleanType
status;
QuantumType
quantum_type;
+ size_t
+ length;
+
ssize_t
count,
y;
- size_t
- length;
-
unsigned char
*pixels;
/*
Open output image file.
*/
- status=OpenBlob(image_info,image,WriteBinaryBlobMode,&image->exception);
+ status=OpenBlob(image_info,image,WriteBinaryBlobMode,exception);
if (status == MagickFalse)
return(status);
}
(void) TransformImageColorspace(image,CMYKColorspace);
if ((LocaleCompare(image_info->magick,"CMYKA") == 0) &&
(image->matte == MagickFalse))
- (void) SetImageAlphaChannel(image,OpaqueAlphaChannel,&image->exception);
+ (void) SetImageAlphaChannel(image,OpaqueAlphaChannel,exception);
quantum_info=AcquireQuantumInfo(image_info,image);
if (quantum_info == (QuantumInfo *) NULL)
ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
register const Quantum
*restrict p;
- 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;
length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
- quantum_type,pixels,&image->exception);
+ quantum_type,pixels,exception);
count=WriteBlob(image,length,pixels);
if (count != (ssize_t) length)
break;
register const Quantum
*restrict p;
- 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;
length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
- CyanQuantum,pixels,&image->exception);
+ CyanQuantum,pixels,exception);
count=WriteBlob(image,length,pixels);
if (count != (ssize_t) length)
break;
length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
- MagentaQuantum,pixels,&image->exception);
+ MagentaQuantum,pixels,exception);
count=WriteBlob(image,length,pixels);
if (count != (ssize_t) length)
break;
length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
- YellowQuantum,pixels,&image->exception);
+ YellowQuantum,pixels,exception);
count=WriteBlob(image,length,pixels);
if (count != (ssize_t) length)
break;
length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
- BlackQuantum,pixels,&image->exception);
+ BlackQuantum,pixels,exception);
count=WriteBlob(image,length,pixels);
if (count != (ssize_t) length)
break;
if (quantum_type == CMYKAQuantum)
{
length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
- AlphaQuantum,pixels,&image->exception);
+ AlphaQuantum,pixels,exception);
count=WriteBlob(image,length,pixels);
if (count != (ssize_t) length)
break;
register const Quantum
*restrict p;
- 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;
length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
- CyanQuantum,pixels,&image->exception);
+ CyanQuantum,pixels,exception);
count=WriteBlob(image,length,pixels);
if (count != (ssize_t) length)
break;
register const Quantum
*restrict p;
- 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;
length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
- MagentaQuantum,pixels,&image->exception);
+ MagentaQuantum,pixels,exception);
count=WriteBlob(image,length,pixels);
if (count != (ssize_t) length)
break;
register const Quantum
*restrict p;
- 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;
length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
- YellowQuantum,pixels,&image->exception);
+ YellowQuantum,pixels,exception);
count=WriteBlob(image,length,pixels);
if (count != (ssize_t) length)
break;
register const Quantum
*restrict p;
- 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;
length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
- BlackQuantum,pixels,&image->exception);
+ BlackQuantum,pixels,exception);
count=WriteBlob(image,length,pixels);
if (count != (ssize_t) length)
break;
register const Quantum
*restrict p;
- 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;
length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
- AlphaQuantum,pixels,&image->exception);
+ AlphaQuantum,pixels,exception);
count=WriteBlob(image,length,pixels);
if (count != (ssize_t) length)
break;
*/
AppendImageFormat("C",image->filename);
status=OpenBlob(image_info,image,scene == 0 ? WriteBinaryBlobMode :
- AppendBinaryBlobMode,&image->exception);
+ AppendBinaryBlobMode,exception);
if (status == MagickFalse)
return(status);
for (y=0; y < (ssize_t) image->rows; y++)
register const Quantum
*restrict p;
- 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;
length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
- CyanQuantum,pixels,&image->exception);
+ CyanQuantum,pixels,exception);
count=WriteBlob(image,length,pixels);
if (count != (ssize_t) length)
break;
(void) CloseBlob(image);
AppendImageFormat("M",image->filename);
status=OpenBlob(image_info,image,scene == 0 ? WriteBinaryBlobMode :
- AppendBinaryBlobMode,&image->exception);
+ AppendBinaryBlobMode,exception);
if (status == MagickFalse)
return(status);
for (y=0; y < (ssize_t) image->rows; y++)
register const Quantum
*restrict p;
- 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;
length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
- MagentaQuantum,pixels,&image->exception);
+ MagentaQuantum,pixels,exception);
count=WriteBlob(image,length,pixels);
if (count != (ssize_t) length)
break;
(void) CloseBlob(image);
AppendImageFormat("Y",image->filename);
status=OpenBlob(image_info,image,scene == 0 ? WriteBinaryBlobMode :
- AppendBinaryBlobMode,&image->exception);
+ AppendBinaryBlobMode,exception);
if (status == MagickFalse)
return(status);
for (y=0; y < (ssize_t) image->rows; y++)
register const Quantum
*restrict p;
- 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;
length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
- YellowQuantum,pixels,&image->exception);
+ YellowQuantum,pixels,exception);
count=WriteBlob(image,length,pixels);
if (count != (ssize_t) length)
break;
(void) CloseBlob(image);
AppendImageFormat("K",image->filename);
status=OpenBlob(image_info,image,scene == 0 ? WriteBinaryBlobMode :
- AppendBinaryBlobMode,&image->exception);
+ AppendBinaryBlobMode,exception);
if (status == MagickFalse)
return(status);
for (y=0; y < (ssize_t) image->rows; y++)
register const Quantum
*restrict p;
- 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;
length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
- BlackQuantum,pixels,&image->exception);
+ BlackQuantum,pixels,exception);
count=WriteBlob(image,length,pixels);
if (count != (ssize_t) length)
break;
(void) CloseBlob(image);
AppendImageFormat("A",image->filename);
status=OpenBlob(image_info,image,scene == 0 ? WriteBinaryBlobMode :
- AppendBinaryBlobMode,&image->exception);
+ AppendBinaryBlobMode,exception);
if (status == MagickFalse)
return(status);
for (y=0; y < (ssize_t) image->rows; y++)
register const Quantum
*restrict p;
- 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;
length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
- AlphaQuantum,pixels,&image->exception);
+ AlphaQuantum,pixels,exception);
count=WriteBlob(image,length,pixels);
if (count != (ssize_t) length)
break;
Forward declarations.
*/
static MagickBooleanType
- WriteDEBUGImage(const ImageInfo *,Image *);
+ WriteDEBUGImage(const ImageInfo *,Image *,ExceptionInfo *);
\f
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% The format of the WriteDEBUGImage method is:
%
% MagickBooleanType WriteDEBUGImage(const ImageInfo *image_info,
-% Image *image)
+% Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows.
%
%
% o image: The image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
static MagickBooleanType WriteDEBUGImage(const ImageInfo *image_info,
- Image *image)
+ Image *image,ExceptionInfo *exception)
{
char
buffer[MaxTextExtent],
assert(image->signature == MagickSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
- status=OpenBlob(image_info,image,WriteBlobMode,&image->exception);
+ status=OpenBlob(image_info,image,WriteBlobMode,exception);
if (status == MagickFalse)
return(status);
scene=0;
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++)
Forward declarations.
*/
static MagickBooleanType
- WriteDIBImage(const ImageInfo *,Image *);
+ WriteDIBImage(const ImageInfo *,Image *,ExceptionInfo *);
\f
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% The format of the WriteDIBImage method is:
%
-% MagickBooleanType WriteDIBImage(const ImageInfo *image_info,Image *image)
+% MagickBooleanType WriteDIBImage(const ImageInfo *image_info,
+% Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows.
%
%
% o image: The image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
-static MagickBooleanType WriteDIBImage(const ImageInfo *image_info,Image *image)
+static MagickBooleanType WriteDIBImage(const ImageInfo *image_info,Image *image,
+ ExceptionInfo *exception)
{
DIBInfo
dib_info;
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);
/*
dib_info.bits_per_pixel=8;
if (image_info->depth > 8)
dib_info.bits_per_pixel=16;
- if (IsImageMonochrome(image,&image->exception) != MagickFalse)
+ if (IsImageMonochrome(image,exception) != MagickFalse)
dib_info.bits_per_pixel=1;
dib_info.number_colors=(dib_info.bits_per_pixel == 16) ? 0 :
(1UL << dib_info.bits_per_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;
q=pixels+(image->rows-y-1)*bytes_per_line;
*/
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;
q=pixels+(image->rows-y-1)*bytes_per_line;
*/
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;
q=pixels+(image->rows-y-1)*bytes_per_line;
*/
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;
q=pixels+(image->rows-y-1)*bytes_per_line;
Forward declaractions.
*/
static MagickBooleanType
- WriteDPXImage(const ImageInfo *,Image *);
+ WriteDPXImage(const ImageInfo *,Image *,ExceptionInfo *);
\f
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% The format of the WriteDPXImage method is:
%
-% MagickBooleanType WriteDPXImage(const ImageInfo *image_info,Image *image)
+% MagickBooleanType WriteDPXImage(const ImageInfo *image_info,
+% Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows.
%
%
% o image: The image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
static inline const char *GetDPXProperty(const ImageInfo *image_info,
return(value);
}
-static MagickBooleanType WriteDPXImage(const ImageInfo *image_info,Image *image)
+static MagickBooleanType WriteDPXImage(const ImageInfo *image_info,Image *image,
+ ExceptionInfo *exception)
{
const char
*value;
register ssize_t
i;
+ size_t
+ extent;
+
ssize_t
count,
horizontal_factor,
vertical_factor,
y;
- size_t
- extent;
-
time_t
seconds;
((horizontal_factor == 2) || (vertical_factor == 2)))
if ((image->columns % 2) != 0)
image->columns++;
- status=OpenBlob(image_info,image,WriteBinaryBlobMode,&image->exception);
+ status=OpenBlob(image_info,image,WriteBinaryBlobMode,exception);
if (status == MagickFalse)
return(status);
/*
dpx.image.image_element[i].descriptor=RGBAComponentType;
if ((image_info->type != TrueColorType) &&
(image->matte == MagickFalse) &&
- (IsImageGray(image,&image->exception) != MagickFalse))
+ (IsImageGray(image,exception) != MagickFalse))
dpx.image.image_element[i].descriptor=LumaComponentType;
break;
}
count=WriteBlobByte(image,0x00);
if (count != 1)
{
- ThrowFileException(&image->exception,FileOpenError,"UnableToWriteFile",
+ ThrowFileException(exception,FileOpenError,"UnableToWriteFile",
image->filename);
break;
}
image->depth,MagickTrue);
if ((image_info->type != UndefinedType) &&
(image_info->type != TrueColorType) && (image->matte == MagickFalse) &&
- (IsImageGray(image,&image->exception) != MagickFalse))
+ (IsImageGray(image,exception) != MagickFalse))
{
quantum_type=GrayQuantum;
extent=GetBytesPerRow(image->columns,1UL,image->depth,MagickTrue);
pixels=GetQuantumPixels(quantum_info);
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;
(void) ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
- quantum_type,pixels,&image->exception);
+ quantum_type,pixels,exception);
count=WriteBlob(image,extent,pixels);
if (count != (ssize_t) extent)
break;
Forward declarations.
*/
static MagickBooleanType
- WriteEPTImage(const ImageInfo *,Image *);
+ WriteEPTImage(const ImageInfo *,Image *,ExceptionInfo *);
\f
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% The format of the WriteEPTImage method is:
%
-% MagickBooleanType WriteEPTImage(const ImageInfo *image_info,Image *image)
+% MagickBooleanType WriteEPTImage(const ImageInfo *image_info,
+% Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows.
%
%
% o image: The image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
-static MagickBooleanType WriteEPTImage(const ImageInfo *image_info,Image *image)
+static MagickBooleanType WriteEPTImage(const ImageInfo *image_info,Image *image,
+ ExceptionInfo *exception)
{
char
filename[MaxTextExtent];
assert(image->signature == MagickSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
- status=OpenBlob(image_info,image,WriteBinaryBlobMode,&image->exception);
+ status=OpenBlob(image_info,image,WriteBinaryBlobMode,exception);
if (status == MagickFalse)
return(status);
- write_image=CloneImage(image,0,0,MagickTrue,&image->exception);
+ write_image=CloneImage(image,0,0,MagickTrue,exception);
if (write_image == (Image *) NULL)
return(MagickFalse);
write_info=CloneImageInfo(image_info);
(void) ResetMagickMemory(&ept_info,0,sizeof(ept_info));
ept_info.magick=0xc6d3d0c5ul;
ept_info.postscript=(unsigned char *) ImageToBlob(write_info,write_image,
- &ept_info.postscript_length,&image->exception);
+ &ept_info.postscript_length,exception);
write_image=DestroyImage(write_image);
write_info=DestroyImageInfo(write_info);
if (ept_info.postscript == (void *) NULL)
return(MagickFalse);
- write_image=CloneImage(image,0,0,MagickTrue,&image->exception);
+ write_image=CloneImage(image,0,0,MagickTrue,exception);
if (write_image == (Image *) NULL)
return(MagickFalse);
write_info=CloneImageInfo(image_info);
EPT preview requires that the image is colormapped.
*/
GetQuantizeInfo(&quantize_info);
- quantize_info.dither=IsPaletteImage(write_image,&image->exception) ==
- MagickFalse ? MagickTrue : MagickFalse;
+ quantize_info.dither=IsPaletteImage(write_image,exception) == MagickFalse
+ ? MagickTrue : MagickFalse;
(void) QuantizeImage(&quantize_info,write_image);
}
write_info->compression=NoCompression;
ept_info.tiff=(unsigned char *) ImageToBlob(write_info,write_image,
- &ept_info.tiff_length,&image->exception);
+ &ept_info.tiff_length,exception);
write_image=DestroyImage(write_image);
write_info=DestroyImageInfo(write_info);
if (ept_info.tiff == (void *) NULL)
Forward declarations.
*/
static MagickBooleanType
- WriteEXRImage(const ImageInfo *,Image *);
+ WriteEXRImage(const ImageInfo *,Image *,ExceptionInfo *);
#endif
\f
/*
%
% The format of the WriteEXRImage method is:
%
-% MagickBooleanType WriteEXRImage(const ImageInfo *image_info,Image *image)
+% MagickBooleanType WriteEXRImage(const ImageInfo *image_info,
+% Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows.
%
%
% o image: The image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
-static MagickBooleanType WriteEXRImage(const ImageInfo *image_info,Image *image)
+static MagickBooleanType WriteEXRImage(const ImageInfo *image_info,Image *image,
+ ExceptionInfo *exception)
{
ImageInfo
*write_info;
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);
write_info=CloneImageInfo(image_info);
ImfDeleteHeader(hdr_info);
if (file == (ImfOutputFile *) NULL)
{
- ThrowFileException(&image->exception,BlobError,"UnableToOpenBlob",
+ ThrowFileException(exception,BlobError,"UnableToOpenBlob",
ImfErrorMessage());
write_info=DestroyImageInfo(write_info);
return(MagickFalse);
}
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++)
Forward declarations.
*/
static MagickBooleanType
- WriteFAXImage(const ImageInfo *,Image *);
+ WriteFAXImage(const ImageInfo *,Image *,ExceptionInfo *);
\f
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% The format of the WriteFAXImage method is:
%
-% MagickBooleanType WriteFAXImage(const ImageInfo *image_info,Image *image)
+% MagickBooleanType WriteFAXImage(const ImageInfo *image_info,
+% Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows.
%
%
% o image: The image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
-static MagickBooleanType WriteFAXImage(const ImageInfo *image_info,Image *image)
+static MagickBooleanType WriteFAXImage(const ImageInfo *image_info,Image *image,
+ ExceptionInfo *exception)
{
ImageInfo
*write_info;
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);
write_info=CloneImageInfo(image_info);
Forward declarations.
*/
static MagickBooleanType
- WriteFITSImage(const ImageInfo *,Image *);
+ WriteFITSImage(const ImageInfo *,Image *,ExceptionInfo *);
\f
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% The format of the WriteFITSImage method is:
%
% MagickBooleanType WriteFITSImage(const ImageInfo *image_info,
-% Image *image)
+% Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows.
%
%
% o image: The image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
static MagickBooleanType WriteFITSImage(const ImageInfo *image_info,
- Image *image)
+ Image *image,ExceptionInfo *exception)
{
char
header[FITSBlocksize],
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 (IsRGBColorspace(image->colorspace) == MagickFalse)
(void) strncpy(fits_info+offset,header,strlen(header));
offset+=80;
(void) FormatLocaleString(header,FITSBlocksize,"NAXIS = %10lu",
- IsImageGray(image,&image->exception) != MagickFalse ? 2UL : 3UL);
+ IsImageGray(image,exception) != MagickFalse ? 2UL : 3UL);
(void) strncpy(fits_info+offset,header,strlen(header));
offset+=80;
(void) FormatLocaleString(header,FITSBlocksize,"NAXIS1 = %10lu",
(unsigned long) image->rows);
(void) strncpy(fits_info+offset,header,strlen(header));
offset+=80;
- if (IsImageGray(image,&image->exception) == MagickFalse)
+ if (IsImageGray(image,exception) == MagickFalse)
{
(void) FormatLocaleString(header,FITSBlocksize,
"NAXIS3 = %10lu",3UL);
Convert image to fits scale PseudoColor class.
*/
pixels=GetQuantumPixels(quantum_info);
- if (IsImageGray(image,&image->exception) != MagickFalse)
+ if (IsImageGray(image,exception) != MagickFalse)
{
length=GetQuantumExtent(image,quantum_info,GrayQuantum);
for (y=(ssize_t) image->rows-1; y >= 0; 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;
length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
- GrayQuantum,pixels,&image->exception);
+ GrayQuantum,pixels,exception);
if (image->depth == 16)
SetFITSUnsignedPixels(image->columns,image->depth,pixels);
if (((image->depth == 32) || (image->depth == 64)) &&
length=GetQuantumExtent(image,quantum_info,RedQuantum);
for (y=(ssize_t) image->rows-1; y >= 0; 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;
length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
- RedQuantum,pixels,&image->exception);
+ RedQuantum,pixels,exception);
if (image->depth == 16)
SetFITSUnsignedPixels(image->columns,image->depth,pixels);
if (((image->depth == 32) || (image->depth == 64)) &&
length=GetQuantumExtent(image,quantum_info,GreenQuantum);
for (y=(ssize_t) image->rows-1; y >= 0; 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;
length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
- GreenQuantum,pixels,&image->exception);
+ GreenQuantum,pixels,exception);
if (image->depth == 16)
SetFITSUnsignedPixels(image->columns,image->depth,pixels);
if (((image->depth == 32) || (image->depth == 64)) &&
length=GetQuantumExtent(image,quantum_info,BlueQuantum);
for (y=(ssize_t) image->rows-1; y >= 0; 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;
length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
- BlueQuantum,pixels,&image->exception);
+ BlueQuantum,pixels,exception);
if (image->depth == 16)
SetFITSUnsignedPixels(image->columns,image->depth,pixels);
if (((image->depth == 32) || (image->depth == 64)) &&
Forward declarations.
*/
static MagickBooleanType
- WriteFPXImage(const ImageInfo *,Image *);
+ WriteFPXImage(const ImageInfo *,Image *,ExceptionInfo *);
#endif
\f
/*
%
% The format of the WriteFPXImage method is:
%
-% MagickBooleanType WriteFPXImage(const ImageInfo *image_info,Image *image)
+% MagickBooleanType WriteFPXImage(const ImageInfo *image_info,
+% Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows.
%
%
% o image: The image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
static void ColorTwistMultiply(FPXColorTwistMatrix first,
*color_twist=result;
}
-static MagickBooleanType WriteFPXImage(const ImageInfo *image_info,Image *image)
+static MagickBooleanType WriteFPXImage(const ImageInfo *image_info,Image *image,
+ ExceptionInfo *exception)
{
FPXBackground
background_color;
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);
(void) CloseBlob(image);
if (image->matte != MagickFalse)
colorspace.numberOfComponents=4;
if ((image_info->type != TrueColorType) &&
- IsImageGray(image,&image->exception))
+ (IsImageGray(image,exception) != MagickFalse))
{
colorspace.numberOfComponents=1;
colorspace.theComponents[0].myColor=MONOCHROME;
quantum_type=GrayQuantum;
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;
length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
- quantum_type,pixels,&image->exception);
+ quantum_type,pixels,exception);
fpx_status=FPX_WriteImageLine(flashpix,&fpx_info);
if (fpx_status != FPX_OK)
break;
GetNextLZWCode(LZWInfo *,const size_t);
static MagickBooleanType
- WriteGIFImage(const ImageInfo *,Image *);
+ WriteGIFImage(const ImageInfo *,Image *,ExceptionInfo *);
static ssize_t
ReadBlobBlock(Image *,unsigned char *);
%
% The format of the WriteGIFImage method is:
%
-% MagickBooleanType WriteGIFImage(const ImageInfo *image_info,Image *image)
+% MagickBooleanType WriteGIFImage(const ImageInfo *image_info,
+% Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows.
%
%
% o image: The image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
-static MagickBooleanType WriteGIFImage(const ImageInfo *image_info,Image *image)
+static MagickBooleanType WriteGIFImage(const ImageInfo *image_info,Image *image,
+ ExceptionInfo *exception)
{
Image
*next_image;
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 (IsRGBColorspace(image->colorspace) == MagickFalse)
(void) TransformImageColorspace(image,RGBColorspace);
opacity=(-1);
- if (IsImageOpaque(image,&image->exception) != MagickFalse)
+ if (IsImageOpaque(image,exception) != MagickFalse)
{
if ((image->storage_class == DirectClass) || (image->colors > 256))
(void) SetImageType(image,PaletteType);
Forward declarations.
*/
static MagickBooleanType
- WriteGRAYImage(const ImageInfo *,Image *);
+ WriteGRAYImage(const ImageInfo *,Image *,ExceptionInfo *);
\f
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% The format of the WriteGRAYImage method is:
%
% MagickBooleanType WriteGRAYImage(const ImageInfo *image_info,
-% Image *image)
+% Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows.
%
%
% o image: The image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
static MagickBooleanType WriteGRAYImage(const ImageInfo *image_info,
- Image *image)
+ Image *image,ExceptionInfo *exception)
{
MagickBooleanType
status;
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);
scene=0;
register const Quantum
*restrict p;
- 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;
length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
- quantum_type,pixels,&image->exception);
+ quantum_type,pixels,exception);
count=WriteBlob(image,length,pixels);
if (count != (ssize_t) length)
break;
Forward declarations.
*/
static MagickBooleanType
- WriteHDRImage(const ImageInfo *,Image *);
+ WriteHDRImage(const ImageInfo *,Image *,ExceptionInfo *);
\f
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% The format of the WriteHDRImage method is:
%
% MagickBooleanType WriteHDRImage(const ImageInfo *image_info,
-% Image *image)
+% Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows.
%
return(p);
}
-static MagickBooleanType WriteHDRImage(const ImageInfo *image_info,Image *image)
+static MagickBooleanType WriteHDRImage(const ImageInfo *image_info,Image *image,
+ ExceptionInfo *exception)
{
char
header[MaxTextExtent];
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 (IsRGBColorspace(image->colorspace) == MagickFalse)
ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
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->columns >= 8) && (image->columns <= 0x7ffff))
Forward declarations.
*/
static MagickBooleanType
- WriteHISTOGRAMImage(const ImageInfo *,Image *);
+ WriteHISTOGRAMImage(const ImageInfo *,Image *,ExceptionInfo *);
\f
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% The format of the WriteHISTOGRAMImage method is:
%
% MagickBooleanType WriteHISTOGRAMImage(const ImageInfo *image_info,
-% Image *image)
+% Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows.
%
%
% o image: The image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
static inline size_t MagickMax(const size_t x,const size_t y)
}
static MagickBooleanType WriteHISTOGRAMImage(const ImageInfo *image_info,
- Image *image)
+ Image *image,ExceptionInfo *exception)
{
#define HistogramDensity "256x200"
const char
*option;
- ExceptionInfo
- *exception;
-
Image
*histogram_image;
else
(void) ParseAbsoluteGeometry(image_info->density,&geometry);
histogram_image=CloneImage(image,geometry.width,geometry.height,MagickTrue,
- &image->exception);
+ exception);
if (histogram_image == (Image *) NULL)
ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
- (void) SetImageStorageClass(histogram_image,DirectClass,&image->exception);
+ (void) SetImageStorageClass(histogram_image,DirectClass,exception);
/*
Allocate histogram count arrays.
*/
(void) ResetMagickMemory(histogram,0,length*sizeof(*histogram));
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++)
/*
Initialize histogram image.
*/
- exception=(&image->exception);
(void) QueryColorDatabase("#000000",&histogram_image->background_color,
- &image->exception);
+ exception);
(void) SetImageBackgroundColor(histogram_image);
for (x=0; x < (ssize_t) histogram_image->columns; x++)
{
char
*property;
- (void) GetNumberColors(image,file,&image->exception);
+ (void) GetNumberColors(image,file,exception);
(void) fclose(file);
- property=FileToString(filename,~0UL,&image->exception);
+ property=FileToString(filename,~0UL,exception);
if (property != (char *) NULL)
{
(void) SetImageProperty(histogram_image,"comment",property);
(void) CopyMagickString(histogram_image->filename,image_info->filename,
MaxTextExtent);
write_info=CloneImageInfo(image_info);
- (void) SetImageInfo(write_info,1,&image->exception);
+ (void) SetImageInfo(write_info,1,exception);
if (LocaleCompare(write_info->magick,"HISTOGRAM") == 0)
(void) FormatLocaleString(histogram_image->filename,MaxTextExtent,
"miff:%s",write_info->filename);
- status=WriteImage(write_info,histogram_image,&image->exception);
+ status=WriteImage(write_info,histogram_image,exception);
histogram_image=DestroyImage(histogram_image);
write_info=DestroyImageInfo(write_info);
return(status);
Forward declarations.
*/
static MagickBooleanType
- WriteHRZImage(const ImageInfo *,Image *);
+ WriteHRZImage(const ImageInfo *,Image *,ExceptionInfo *);
\f
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% The format of the WriteHRZImage method is:
%
-% MagickBooleanType WriteHRZImage(const ImageInfo *image_info,Image *image)
+% MagickBooleanType WriteHRZImage(const ImageInfo *image_info,
+% Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows.
%
%
% o image: The image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
-static MagickBooleanType WriteHRZImage(const ImageInfo *image_info,Image *image)
+static MagickBooleanType WriteHRZImage(const ImageInfo *image_info,Image *image,
+ ExceptionInfo *exception)
{
Image
*hrz_image;
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);
- hrz_image=ResizeImage(image,256,240,image->filter,image->blur,
- &image->exception);
+ hrz_image=ResizeImage(image,256,240,image->filter,image->blur,exception);
if (hrz_image == (Image *) NULL)
return(MagickFalse);
if (IsRGBColorspace(hrz_image->colorspace) == MagickFalse)
*/
for (y=0; y < (ssize_t) hrz_image->rows; y++)
{
- p=GetVirtualPixels(hrz_image,0,y,hrz_image->columns,1,&image->exception);
+ p=GetVirtualPixels(hrz_image,0,y,hrz_image->columns,1,exception);
if (p == (const Quantum *) NULL)
break;
q=pixels;
Forward declarations.
*/
static MagickBooleanType
- WriteHTMLImage(const ImageInfo *,Image *);
+ WriteHTMLImage(const ImageInfo *,Image *,ExceptionInfo *);
\f
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% The format of the WriteHTMLImage method is:
%
-% MagickBooleanType WriteHTMLImage(const ImageInfo *image_info,Image *image)
+% MagickBooleanType WriteHTMLImage(const ImageInfo *image_info,
+% Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows.
%
%
% o image: The image.
%
+% o exception: return any errors or warnings in this structure.
%
*/
static MagickBooleanType WriteHTMLImage(const ImageInfo *image_info,
- Image *image)
+ Image *image,ExceptionInfo *exception)
{
char
basename[MaxTextExtent],
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
image_info->filename);
- status=OpenBlob(image_info,image,WriteBinaryBlobMode,&image->exception);
+ status=OpenBlob(image_info,image,WriteBinaryBlobMode,exception);
if (status == MagickFalse)
return(status);
(void) CloseBlob(image);
/*
Open output image file.
*/
- status=OpenBlob(image_info,image,WriteBinaryBlobMode,&image->exception);
+ status=OpenBlob(image_info,image,WriteBinaryBlobMode,exception);
if (status == MagickFalse)
return(status);
/*
next=GetNextImageInList(image);
image->next=NewImageList();
(void) CopyMagickString(image->magick,"PNG",MaxTextExtent);
- (void) WriteImage(write_info,image,&image->exception);
+ (void) WriteImage(write_info,image,exception);
image->next=next;
/*
Determine image map filename.
/*
Open image map.
*/
- status=OpenBlob(write_info,image,WriteBinaryBlobMode,&image->exception);
+ status=OpenBlob(write_info,image,WriteBinaryBlobMode,exception);
if (status == MagickFalse)
return(status);
write_info=DestroyImageInfo(write_info);
Forward declaractions.
*/
static MagickBooleanType
- WriteICONImage(const ImageInfo *,Image *);
+ WriteICONImage(const ImageInfo *,Image *,ExceptionInfo *);
\f
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% The format of the WriteICONImage method is:
%
% MagickBooleanType WriteICONImage(const ImageInfo *image_info,
-% Image *image)
+% Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows.
%
%
% o image: The image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
static MagickBooleanType WriteICONImage(const ImageInfo *image_info,
- Image *image)
+ Image *image,ExceptionInfo *exception)
{
IconFile
icon_file;
assert(image != (Image *) NULL);
assert(image->signature == MagickSignature);
(void) LogMagickEvent(CoderEvent,GetMagickModule(),"%s",image->filename);
- status=OpenBlob(image_info,image,WriteBinaryBlobMode,&image->exception);
+ status=OpenBlob(image_info,image,WriteBinaryBlobMode,exception);
if (status == MagickFalse)
return(status);
scene=0;
/*
Icon image encoded as a compressed PNG image.
*/
- write_image=CloneImage(next,0,0,MagickTrue,&image->exception);
+ write_image=CloneImage(next,0,0,MagickTrue,exception);
if (write_image == (Image *) NULL)
return(MagickFalse);
write_info=CloneImageInfo(image_info);
(void) CopyMagickString(write_info->filename,"PNG:",MaxTextExtent);
png=(unsigned char *) ImageToBlob(write_info,write_image,&length,
- &image->exception);
+ exception);
write_image=DestroyImage(write_image);
write_info=DestroyImageInfo(write_info);
if (png == (unsigned char *) NULL)
icon_info.offset_bits=icon_info.file_size;
icon_info.compression=BI_RGB;
if ((next->storage_class != DirectClass) && (next->colors > 256))
- (void) SetImageStorageClass(next,DirectClass,&next->exception);
+ (void) SetImageStorageClass(next,DirectClass,exception);
if (next->storage_class == DirectClass)
{
/*
icon_info.number_colors=one << icon_info.bits_per_pixel;
if (icon_info.number_colors < next->colors)
{
- (void) SetImageStorageClass(next,DirectClass,&next->exception);
+ (void) SetImageStorageClass(next,DirectClass,exception);
icon_info.number_colors=0;
icon_info.bits_per_pixel=(unsigned short) 24;
icon_info.compression=(size_t) BI_RGB;
*/
for (y=0; y < (ssize_t) next->rows; y++)
{
- p=GetVirtualPixels(next,0,y,next->columns,1,&next->exception);
+ p=GetVirtualPixels(next,0,y,next->columns,1,exception);
if (p == (const Quantum *) NULL)
break;
q=pixels+(next->rows-y-1)*bytes_per_line;
*/
for (y=0; y < (ssize_t) next->rows; y++)
{
- p=GetVirtualPixels(next,0,y,next->columns,1,&next->exception);
+ p=GetVirtualPixels(next,0,y,next->columns,1,exception);
if (p == (const Quantum *) NULL)
break;
q=pixels+(next->rows-y-1)*bytes_per_line;
*/
for (y=0; y < (ssize_t) next->rows; y++)
{
- p=GetVirtualPixels(next,0,y,next->columns,1,&next->exception);
+ p=GetVirtualPixels(next,0,y,next->columns,1,exception);
if (p == (const Quantum *) NULL)
break;
q=pixels+(next->rows-y-1)*bytes_per_line;
*/
for (y=0; y < (ssize_t) next->rows; y++)
{
- p=GetVirtualPixels(next,0,y,next->columns,1,&next->exception);
+ p=GetVirtualPixels(next,0,y,next->columns,1,exception);
if (p == (const Quantum *) NULL)
break;
q=pixels+(next->rows-y-1)*bytes_per_line;
scanline_pad=(((next->columns+31) & ~31)-next->columns) >> 3;
for (y=((ssize_t) next->rows - 1); y >= 0; y--)
{
- p=GetVirtualPixels(next,0,y,next->columns,1,&next->exception);
+ p=GetVirtualPixels(next,0,y,next->columns,1,exception);
if (p == (const Quantum *) NULL)
break;
bit=0;
Forward declarations.
*/
static MagickBooleanType
- WriteINFOImage(const ImageInfo *,Image *);
+ WriteINFOImage(const ImageInfo *,Image *,ExceptionInfo *);
\f
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% The format of the WriteINFOImage method is:
%
% MagickBooleanType WriteINFOImage(const ImageInfo *image_info,
-% Image *image)
+% Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows.
%
%
% o image: The image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
static MagickBooleanType WriteINFOImage(const ImageInfo *image_info,
- Image *image)
+ Image *image,ExceptionInfo *exception)
{
const char
*format;
assert(image->signature == MagickSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
- status=OpenBlob(image_info,image,WriteBlobMode,&image->exception);
+ status=OpenBlob(image_info,image,WriteBlobMode,exception);
if (status == MagickFalse)
return(status);
scene=0;
image->magick_columns=image->columns;
image->magick_rows=image->rows;
(void) IdentifyImage(image,GetBlobFileHandle(image),
- image_info->verbose,&image->exception);
+ image_info->verbose,exception);
}
else
{
} IPLInfo;
static MagickBooleanType
- WriteIPLImage(const ImageInfo *,Image *);
+ WriteIPLImage(const ImageInfo *,Image *,ExceptionInfo *);
void increase (void *pixel, int byteType){
switch(byteType){
}
/*
- %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
- % %
- % %
- % %
- % W r i t e I P L I m a g e %
- % %
- % %
- % %
- %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
- %
- % WriteIPLImage() writes an image to a file in Scanalytics IPLabimage format.
- %
- % The format of the WriteIPLImage method is:
- %
- % MagickBooleanType WriteIPLImage(const ImageInfo *image_info,Image *image)
- %
- % A description of each parameter follows.
- %
- % o image_info: The image info.
- %
- % o image: The image.
- %
- */
-
-static MagickBooleanType WriteIPLImage(const ImageInfo *image_info,Image *image)
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% %
+% %
+% %
+% W r i t e I P L I m a g e %
+% %
+% %
+% %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%
+% WriteIPLImage() writes an image to a file in Scanalytics IPLabimage format.
+%
+% The format of the WriteIPLImage method is:
+%
+% MagickBooleanType WriteIPLImage(const ImageInfo *image_info,Image *image)
+% Image *image,ExceptionInfo *exception)
+%
+% A description of each parameter follows.
+%
+% o image_info: The image info.
+%
+% o image: The image.
+%
+% o exception: return any errors or warnings in this structure.
+%
+*/
+static MagickBooleanType WriteIPLImage(const ImageInfo *image_info,Image *image,
+ ExceptionInfo *exception)
{
- ExceptionInfo
- *exception;
-
IPLInfo
ipl_info;
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);
scene=0;
quantum_info=AcquireQuantumInfo(image_info, image);
if ((quantum_info->format == UndefinedQuantumFormat) &&
- (IsHighDynamicRangeImage(image,&image->exception) != MagickFalse))
+ (IsHighDynamicRangeImage(image,exception) != MagickFalse))
SetQuantumFormat(image,quantum_info,FloatingPointQuantumFormat);
switch(quantum_info->depth){
case 8:
(void) WriteBlobLong(image, ipl_info.time);
(void) WriteBlobLong(image, ipl_info.byteType);
- exception=(&image->exception);
do
{
/*
if (p == (const Quantum *) NULL)
break;
(void) ExportQuantumPixels(image,(CacheView *) NULL, quantum_info,
- GrayQuantum, pixels,&image->exception);
+ GrayQuantum, pixels,exception);
(void) WriteBlob(image, image->columns*image->depth/8, pixels);
}
if (p == (const Quantum *) NULL)
break;
(void) ExportQuantumPixels(image,(CacheView *) NULL, quantum_info,
- RedQuantum, pixels,&image->exception);
+ RedQuantum, pixels,exception);
(void) WriteBlob(image, image->columns*image->depth/8, pixels);
}
/* Green frame */
for(y = 0; y < (ssize_t) ipl_info.height; 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;
(void) ExportQuantumPixels(image,(CacheView *) NULL, quantum_info,
- GreenQuantum, pixels,&image->exception);
+ GreenQuantum, pixels,exception);
(void) WriteBlob(image, image->columns*image->depth/8, pixels);
}
/* Blue frame */
for(y = 0; y < (ssize_t) ipl_info.height; 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;
(void) ExportQuantumPixels(image,(CacheView *) NULL, quantum_info,
- BlueQuantum, pixels,&image->exception);
+ BlueQuantum, pixels,exception);
(void) WriteBlob(image, image->columns*image->depth/8, pixels);
if (image->previous == (Image *) NULL)
{
*/
#if defined(MAGICKCORE_JBIG_DELEGATE)
static MagickBooleanType
- WriteJBIGImage(const ImageInfo *,Image *);
+ WriteJBIGImage(const ImageInfo *,Image *,ExceptionInfo *);
#endif
\f
#if defined(MAGICKCORE_JBIG_DELEGATE)
%
% The format of the WriteJBIGImage method is:
%
-% MagickBooleanType WriteJBIGImage(const ImageInfo *image_info,Image *image)
+% MagickBooleanType WriteJBIGImage(const ImageInfo *image_info,
+% Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows.
%
%
% o image: The image.
%
+% o exception: return any errors or warnings in this structure.
%
*/
}
static MagickBooleanType WriteJBIGImage(const ImageInfo *image_info,
- Image *image)
+ Image *image,ExceptionInfo *exception)
{
double
version;
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);
version=InterpretLocaleValue(JBG_VERSION,(char **) 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;
bit=0;
*/
#if defined(MAGICKCORE_JP2_DELEGATE)
static MagickBooleanType
- WriteJP2Image(const ImageInfo *,Image *);
+ WriteJP2Image(const ImageInfo *,Image *,ExceptionInfo *);
static volatile MagickBooleanType
instantiate_jp2 = MagickFalse;
%
% The format of the WriteJP2Image method is:
%
-% MagickBooleanType WriteJP2Image(const ImageInfo *image_info,Image *image)
+% MagickBooleanType WriteJP2Image(const ImageInfo *image_info,
+% Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows.
%
%
% o image: The image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
-static MagickBooleanType WriteJP2Image(const ImageInfo *image_info,Image *image)
+static MagickBooleanType WriteJP2Image(const ImageInfo *image_info,Image *image,
+ ExceptionInfo *exception)
{
char
*key,
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);
/*
ThrowWriterException(DelegateError,"UnableToManageJP2Stream");
number_components=image->matte ? 4UL : 3UL;
if ((image_info->type != TrueColorType) &&
- (IsImageGray(image,&image->exception) != MagickFalse))
+ (IsImageGray(image,exception) != MagickFalse))
number_components=1;
if ((image->columns != (unsigned int) image->columns) ||
(image->rows != (unsigned int) image->rows))
range=GetQuantumRange((size_t) component_info[0].prec);
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++)
*/
#if defined(MAGICKCORE_JPEG_DELEGATE)
static MagickBooleanType
- WriteJPEGImage(const ImageInfo *,Image *);
+ WriteJPEGImage(const ImageInfo *,Image *,ExceptionInfo *);
#endif
\f
/*
% The format of the WriteJPEGImage method is:
%
% MagickBooleanType WriteJPEGImage(const ImageInfo *image_info,
-% Image *image)
+% Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
%
% o jpeg_image: The image.
%
+% o exception: return any errors or warnings in this structure.
%
*/
}
static MagickBooleanType WriteJPEGImage(const ImageInfo *image_info,
- Image *image)
+ Image *image,ExceptionInfo *exception)
{
const char
*option,
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 ((image_info->type != TrueColorType) &&
- (IsImageGray(image,&image->exception) != MagickFalse))
+ (IsImageGray(image,exception) != MagickFalse))
{
jpeg_info.input_components=1;
jpeg_info.in_color_space=JCS_GRAYSCALE;
*jpeg_info;
jpeg_info=CloneImageInfo(image_info);
- jpeg_image=CloneImage(image,0,0,MagickTrue,&image->exception);
+ jpeg_image=CloneImage(image,0,0,MagickTrue,exception);
if (jpeg_image != (Image *) NULL)
{
MagickSizeType
for (minimum=0; minimum != maximum; )
{
jpeg_image->quality=minimum+(maximum-minimum)/2;
- status=WriteJPEGImage(jpeg_info,jpeg_image);
+ status=WriteJPEGImage(jpeg_info,jpeg_image,exception);
if (GetBlobSize(jpeg_image) <= extent)
minimum=jpeg_image->quality+1;
else
(void) LogMagickEvent(CoderEvent,GetMagickModule(),"Quality: 100");
#else
if (image->quality < 100)
- (void) ThrowMagickException(&image->exception,GetMagickModule(),
- CoderWarning,"LosslessToLossyJPEGConversion",image->filename);
+ (void) ThrowMagickException(exception,GetMagickModule(),CoderWarning,
+ "LosslessToLossyJPEGConversion",image->filename);
else
{
int
register ssize_t
x;
- 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;
q=jpeg_pixels;
register ssize_t
x;
- 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;
q=jpeg_pixels;
register ssize_t
x;
- 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;
q=jpeg_pixels;
register ssize_t
x;
- 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;
q=jpeg_pixels;
register ssize_t
x;
- 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;
q=jpeg_pixels;
register ssize_t
x;
- 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;
q=jpeg_pixels;
Forward declarations.
*/
static MagickBooleanType
- WriteMAGICKImage(const ImageInfo *,Image *);
+ WriteMAGICKImage(const ImageInfo *,Image *,ExceptionInfo *);
\f
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% The format of the WriteMAGICKImage method is:
%
% MagickBooleanType WriteMAGICKImage(const ImageInfo *image_info,
-% Image *image)
+% Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows.
%
%
% o image: The image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
static MagickBooleanType WriteMAGICKImage(const ImageInfo *image_info,
- Image *image)
+ Image *image,ExceptionInfo *exception)
{
char
buffer[MaxTextExtent];
image_info->filename);
assert(image != (Image *) NULL);
assert(image->signature == MagickSignature);
- magick_image=CloneImage(image,0,0,MagickTrue,&image->exception);
+ magick_image=CloneImage(image,0,0,MagickTrue,exception);
if (magick_image == (Image *) NULL)
- ThrowWriterException(ResourceLimitError,image->exception.reason);
+ return(MagickFalse);
write_info=CloneImageInfo(image_info);
*write_info->filename='\0';
(void) CopyMagickString(write_info->magick,"GIF",MaxTextExtent);
(void) CopyMagickString(write_info->magick,"PNM",MaxTextExtent);
length*=3;
}
- blob=ImageToBlob(write_info,magick_image,&length,&image->exception);
+ blob=ImageToBlob(write_info,magick_image,&length,exception);
magick_image=DestroyImage(magick_image);
(void) DestroyImageInfo(write_info);
if (blob == (void *) NULL)
return(MagickFalse);
- status=OpenBlob(image_info,image,WriteBinaryBlobMode,&image->exception);
+ status=OpenBlob(image_info,image,WriteBinaryBlobMode,exception);
if (status == MagickFalse)
return(status);
(void) WriteBlobString(image,"/*\n");
Forward declarations.
*/
static MagickBooleanType
- WriteMAPImage(const ImageInfo *,Image *);
+ WriteMAPImage(const ImageInfo *,Image *,ExceptionInfo *);
\f
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% The format of the WriteMAPImage method is:
%
-% MagickBooleanType WriteMAPImage(const ImageInfo *image_info,Image *image)
+% MagickBooleanType WriteMAPImage(const ImageInfo *image_info,
+% Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows.
%
%
% o image: The image.
%
+% o exception: return any errors or warnings in this structure.
%
*/
-static MagickBooleanType WriteMAPImage(const ImageInfo *image_info,Image *image)
+static MagickBooleanType WriteMAPImage(const ImageInfo *image_info,Image *image,
+ ExceptionInfo *exception)
{
MagickBooleanType
status;
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 (IsRGBColorspace(image->colorspace) == MagickFalse)
/*
Allocate colormap.
*/
- if (IsPaletteImage(image,&image->exception) == MagickFalse)
+ if (IsPaletteImage(image,exception) == MagickFalse)
(void) SetImageType(image,PaletteType);
depth=GetImageQuantumDepth(image,MagickTrue);
packet_size=(size_t) (depth/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)
break;
q=pixels;
Forward declaration.
*/
static MagickBooleanType
- WriteMATImage(const ImageInfo *,Image *);
+ WriteMATImage(const ImageInfo *,Image *,ExceptionInfo *);
/* Auto coloring method, sorry this creates some artefact inside data
%
% The format of the WriteMATImage method is:
%
-% unsigned int WriteMATImage(const ImageInfo *image_info,Image *image)
+% MagickBooleanType WriteMATImage(const ImageInfo *image_info,
+% Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows.
%
-% o status: Function WriteMATImage return True if the image is written.
-% False is returned is there is a memory shortage or if the image file
-% fails to write.
-%
% o image_info: Specifies a pointer to a ImageInfo structure.
%
% o image: A pointer to an Image structure.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
-static MagickBooleanType WriteMATImage(const ImageInfo *image_info,Image *image)
+static MagickBooleanType WriteMATImage(const ImageInfo *image_info,Image *image,
+ ExceptionInfo *exception)
{
- ExceptionInfo
- *exception;
-
ssize_t y;
unsigned z;
register const Quantum *p;
assert(image->signature == MagickSignature);
logging=LogMagickEvent(CoderEvent,GetMagickModule(),"enter MAT");
(void) logging;
- status=OpenBlob(image_info,image,WriteBinaryBlobMode,&image->exception);
+ status=OpenBlob(image_info,image,WriteBinaryBlobMode,exception);
if (status == MagickFalse)
return(MagickFalse);
image->depth=8;
if (IsRGBColorspace(image->colorspace) == MagickFalse)
(void) TransformImageColorspace(image,RGBColorspace);
- is_gray = IsImageGray(image,&image->exception);
+ is_gray = IsImageGray(image,exception);
z = is_gray ? 0 : 3;
/*
/*
Store image data.
*/
- exception=(&image->exception);
quantum_info=AcquireQuantumInfo(image_info,image);
if (quantum_info == (QuantumInfo *) NULL)
ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
{
for (y=0; y < (ssize_t)image->columns; y++)
{
- p=GetVirtualPixels(image,y,0,1,image->rows,&image->exception);
+ p=GetVirtualPixels(image,y,0,1,image->rows,exception);
if (p == (const Quantum *) NULL)
break;
(void) ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
z2qtype[z],pixels,exception);
(void) WriteBlob(image,image->rows,pixels);
}
- if (!SyncAuthenticPixels(image,exception))
+ if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
} while(z-- >= 2);
while(padding-->0) (void) WriteBlobByte(image,0);
Forward declarations.
*/
static MagickBooleanType
- WriteMATTEImage(const ImageInfo *,Image *);
+ WriteMATTEImage(const ImageInfo *,Image *,ExceptionInfo *);
\f
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% Function WriteMATTEImage() writes an image of matte bytes to a file. It
-% consists of data from the matte component of the image [0..255].
+% WriteMATTEImage() writes an image of matte bytes to a file. It consists of
+% data from the matte component of the image [0..255].
%
% The format of the WriteMATTEImage method is:
%
% MagickBooleanType WriteMATTEImage(const ImageInfo *image_info,
-% Image *image)
+% Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows.
%
%
% o image: The image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
static MagickBooleanType WriteMATTEImage(const ImageInfo *image_info,
- Image *image)
+ Image *image,ExceptionInfo *exception)
{
- ExceptionInfo
- *exception;
-
Image
*matte_image;
if (image->matte == MagickFalse)
ThrowWriterException(CoderError,"ImageDoesNotHaveAAlphaChannel");
- matte_image=CloneImage(image,image->columns,image->rows,MagickTrue,
- &image->exception);
+ matte_image=CloneImage(image,image->columns,image->rows,MagickTrue,exception);
if (matte_image == (Image *) NULL)
return(MagickFalse);
(void) SetImageType(matte_image,TrueColorMatteType);
/*
Convert image to matte pixels.
*/
- exception=(&image->exception);
for (y=0; y < (ssize_t) image->rows; y++)
{
p=GetVirtualPixels(image,0,y,image->columns,1,exception);
Forward declarations.
*/
static MagickBooleanType
- WriteMETAImage(const ImageInfo *,Image *);
+ WriteMETAImage(const ImageInfo *,Image *,ExceptionInfo *);
\f
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% The format of the WriteMETAImage method is:
%
% MagickBooleanType WriteMETAImage(const ImageInfo *image_info,
-% Image *image)
+% Image *image,ExceptionInfo *exception)
%
% Compression code contributed by Kyle Shorter.
%
%
% o image: A pointer to a Image structure.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
static size_t GetIPTCStream(unsigned char **info,size_t length)
}
static MagickBooleanType WriteMETAImage(const ImageInfo *image_info,
- Image *image)
+ Image *image,ExceptionInfo *exception)
{
const StringInfo
*profile;
profile=GetImageProfile(image,"8bim");
if (profile == (StringInfo *) NULL)
ThrowWriterException(CoderError,"No8BIMDataIsAvailable");
- status=OpenBlob(image_info,image,WriteBinaryBlobMode,&image->exception);
+ status=OpenBlob(image_info,image,WriteBinaryBlobMode,exception);
if (status == MagickFalse)
return(status);
(void) WriteBlob(image,GetStringInfoLength(profile),
profile=GetImageProfile(image,"8bim");
if (profile == (StringInfo *) NULL)
ThrowWriterException(CoderError,"No8BIMDataIsAvailable");
- status=OpenBlob(image_info,image,WriteBinaryBlobMode,&image->exception);
+ status=OpenBlob(image_info,image,WriteBinaryBlobMode,exception);
info=GetStringInfoDatum(profile);
length=GetStringInfoLength(profile);
length=GetIPTCStream(&info,length);
profile=GetImageProfile(image,"8bim");
if (profile == (StringInfo *) NULL)
ThrowWriterException(CoderError,"No8BIMDataIsAvailable");
- status=OpenBlob(image_info,image,WriteBinaryBlobMode,&image->exception);
+ status=OpenBlob(image_info,image,WriteBinaryBlobMode,exception);
if (status == MagickFalse)
return(status);
buff=AcquireImage((ImageInfo *) NULL);
length=GetIPTCStream(&info,length);
if (length == 0)
ThrowWriterException(CoderError,"NoIPTCProfileAvailable");
- status=OpenBlob(image_info,image,WriteBinaryBlobMode,&image->exception);
+ status=OpenBlob(image_info,image,WriteBinaryBlobMode,exception);
if (status == MagickFalse)
return(status);
buff=AcquireImage((ImageInfo *) NULL);
profile=GetImageProfile(image,image_info->magick);
if (profile == (StringInfo *) NULL)
ThrowWriterException(CoderError,"NoAPP1DataIsAvailable");
- status=OpenBlob(image_info,image,WriteBinaryBlobMode,&image->exception);
+ status=OpenBlob(image_info,image,WriteBinaryBlobMode,exception);
if (status == MagickFalse)
return(status);
(void) WriteBlob(image,GetStringInfoLength(profile),
profile=GetImageProfile(image,"icc");
if (profile == (StringInfo *) NULL)
ThrowWriterException(CoderError,"NoColorProfileIsAvailable");
- status=OpenBlob(image_info,image,WriteBinaryBlobMode,&image->exception);
+ status=OpenBlob(image_info,image,WriteBinaryBlobMode,exception);
if (status == MagickFalse)
return(status);
(void) WriteBlob(image,GetStringInfoLength(profile),
Forward declarations.
*/
static MagickBooleanType
- WriteMIFFImage(const ImageInfo *,Image *);
+ WriteMIFFImage(const ImageInfo *,Image *,ExceptionInfo *);
\f
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% The format of the WriteMIFFImage method is:
%
% MagickBooleanType WriteMIFFImage(const ImageInfo *image_info,
-% Image *image)
+% Image *image,ExceptionInfo *exception)
%
% Compression code contributed by Kyle Shorter.
%
%
% o image: the image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
static unsigned char *PopRunlengthPacket(Image *image,unsigned char *pixels,
}
static MagickBooleanType WriteMIFFImage(const ImageInfo *image_info,
- Image *image)
+ Image *image,ExceptionInfo *exception)
{
#if defined(MAGICKCORE_BZLIB_DELEGATE)
bz_stream
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);
code=0;
ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
if ((image->storage_class != PseudoClass) && (image->depth >= 32) &&
(quantum_info->format == UndefinedQuantumFormat) &&
- (IsHighDynamicRangeImage(image,&image->exception) != MagickFalse))
+ (IsHighDynamicRangeImage(image,exception) != MagickFalse))
{
status=SetQuantumFormat(image,quantum_info,FloatingPointQuantumFormat);
if (status == MagickFalse)
}
if ((image->storage_class == PseudoClass) &&
(image->colors > (size_t) (GetQuantumRange(image->depth)+1)))
- (void) SetImageStorageClass(image,DirectClass,&image->exception);
+ (void) SetImageStorageClass(image,DirectClass,exception);
if ((image->colorspace != sRGBColorspace) &&
- (IsImageGray(image,&image->exception) != MagickFalse))
+ (IsImageGray(image,exception) != MagickFalse))
{
- (void) SetImageStorageClass(image,DirectClass,&image->exception);
- (void) SetImageColorspace(image,GRAYColorspace,&image->exception);
+ (void) SetImageStorageClass(image,DirectClass,exception);
+ (void) SetImageColorspace(image,GRAYColorspace,exception);
}
compression=image->compression;
if (image_info->compression != UndefinedCompression)
default:
break;
}
- quantum_type=GetQuantumType(image,&image->exception);
+ quantum_type=GetQuantumType(image,exception);
pixels=GetQuantumPixels(quantum_info);
for (y=0; y < (ssize_t) image->rows; y++)
{
if (status == MagickFalse)
break;
- 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;
q=pixels;
bzip_info.next_in=(char *) pixels;
bzip_info.avail_in=(unsigned int) (packet_size*image->columns);
(void) ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
- quantum_type,pixels,&image->exception);
+ quantum_type,pixels,exception);
do
{
bzip_info.next_out=(char *) compress_pixels;
lzma_info.next_in=pixels;
lzma_info.avail_in=packet_size*image->columns;
(void) ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
- quantum_type,pixels,&image->exception);
+ quantum_type,pixels,exception);
do
{
lzma_info.next_out=compress_pixels;
zip_info.next_in=pixels;
zip_info.avail_in=(uInt) (packet_size*image->columns);
(void) ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
- quantum_type,pixels,&image->exception);
+ quantum_type,pixels,exception);
do
{
zip_info.next_out=compress_pixels;
default:
{
(void) ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
- quantum_type,pixels,&image->exception);
+ quantum_type,pixels,exception);
(void) WriteBlob(image,packet_size*image->columns,pixels);
break;
}
Forward declarations.
*/
static MagickBooleanType
- WriteMONOImage(const ImageInfo *,Image *);
+ WriteMONOImage(const ImageInfo *,Image *,ExceptionInfo *);
\f
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% The format of the WriteMONOImage method is:
%
% MagickBooleanType WriteMONOImage(const ImageInfo *image_info,
-% Image *image)
+% Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows.
%
%
% o image: The image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
static MagickBooleanType WriteMONOImage(const ImageInfo *image_info,
- Image *image)
+ Image *image,ExceptionInfo *exception)
{
MagickBooleanType
status;
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 (IsRGBColorspace(image->colorspace) == MagickFalse)
(void) SetImageType(image,BilevelType);
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;
bit=0;
Forward declarations.
*/
static MagickBooleanType
- WriteMPCImage(const ImageInfo *,Image *);
+ WriteMPCImage(const ImageInfo *,Image *,ExceptionInfo *);
\f
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% The format of the WriteMPCImage method is:
%
-% MagickBooleanType WriteMPCImage(const ImageInfo *image_info,Image *image)
+% MagickBooleanType WriteMPCImage(const ImageInfo *image_info,
+% Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
%
% o image: the image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
-static MagickBooleanType WriteMPCImage(const ImageInfo *image_info,Image *image)
+static MagickBooleanType WriteMPCImage(const ImageInfo *image_info,Image *image,
+ ExceptionInfo *exception)
{
char
buffer[MaxTextExtent],
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);
(void) CopyMagickString(cache_filename,image->filename,MaxTextExtent);
Initialize persistent pixel cache.
*/
status=PersistPixelCache(image,cache_filename,MagickFalse,&offset,
- &image->exception);
+ exception);
if (status == MagickFalse)
ThrowWriterException(CacheError,"UnableToPersistPixelCache");
if (GetNextImageInList(image) == (Image *) NULL)
Forward declarations.
*/
static MagickBooleanType
- WriteMPEGImage(const ImageInfo *image_info,Image *image);
+ WriteMPEGImage(const ImageInfo *,Image *,ExceptionInfo *);
\f
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% The format of the WriteMPEGImage method is:
%
% MagickBooleanType WriteMPEGImage(const ImageInfo *image_info,
-% Image *image)
+% Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows.
%
%
% o image: The image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
static inline double MagickMax(const double x,const double y)
}
static MagickBooleanType WriteMPEGImage(const ImageInfo *image_info,
- Image *image)
+ Image *image,ExceptionInfo *exception)
{
#define WriteMPEGIntermediateFormat "jpg"
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);
(void) CloseBlob(image);
/*
Write intermediate files.
*/
- coalesce_image=CoalesceImages(image,&image->exception);
+ coalesce_image=CoalesceImages(image,exception);
if (coalesce_image == (Image *) NULL)
return(MagickFalse);
file=AcquireUniqueFileResource(basename);
(void) FormatLocaleString(previous_image,MaxTextExtent,
"%s%.20g.%s",basename,(double) p->scene,
WriteMPEGIntermediateFormat);
- frame=CloneImage(p,0,0,MagickTrue,&p->exception);
+ frame=CloneImage(p,0,0,MagickTrue,exception);
if (frame == (Image *) NULL)
break;
- status=WriteImage(write_info,frame,&image->exception);
+ status=WriteImage(write_info,frame,exception);
frame=DestroyImage(frame);
break;
}
case 1:
{
blob=(unsigned char *) FileToBlob(previous_image,~0UL,&length,
- &image->exception);
+ exception);
}
default:
{
(void) FormatLocaleString(filename,MaxTextExtent,"%s%.20g.%s",
basename,(double) p->scene,WriteMPEGIntermediateFormat);
if (length > 0)
- status=BlobToFile(filename,blob,length,&image->exception);
+ status=BlobToFile(filename,blob,length,exception);
break;
}
}
if (*coalesce_image->magick == '\0')
(void) CopyMagickString(coalesce_image->magick,image->magick,MaxTextExtent);
status=InvokeDelegate(write_info,coalesce_image,(char *) NULL,"mpeg:encode",
- &image->exception);
+ exception);
(void) FormatLocaleString(write_info->filename,MaxTextExtent,"%s.%s",
write_info->unique,coalesce_image->magick);
status=CopyDelegateFile(write_info->filename,image->filename);
Forward declarations.
*/
static MagickBooleanType
- WriteMPRImage(const ImageInfo *,Image *);
+ WriteMPRImage(const ImageInfo *,Image *,ExceptionInfo *);
\f
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% The format of the WriteMPRImage method is:
%
-% MagickBooleanType WriteMPRImage(const ImageInfo *image_info,Image *image)
+% MagickBooleanType WriteMPRImage(const ImageInfo *image_info,
+% Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows.
%
%
% o image: The image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
-static MagickBooleanType WriteMPRImage(const ImageInfo *image_info,Image *image)
+static MagickBooleanType WriteMPRImage(const ImageInfo *image_info,Image *image,
+ ExceptionInfo *exception)
{
MagickBooleanType
status;
assert(image->signature == MagickSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
- status=SetImageRegistry(ImageRegistryType,image->filename,image,
- &image->exception);
+ status=SetImageRegistry(ImageRegistryType,image->filename,image,exception);
return(status);
}
*/
#if defined(MAGICKCORE_XML_DELEGATE)
static MagickBooleanType
- WriteMSLImage(const ImageInfo *,Image *);
+ WriteMSLImage(const ImageInfo *,Image *,ExceptionInfo *);
static MagickBooleanType
SetMSLAttributes(MSLInfo *,const char *,const char *);
%
% The format of the WriteMSLImage method is:
%
-% MagickBooleanType WriteMSLImage(const ImageInfo *image_info,Image *image)
+% MagickBooleanType WriteMSLImage(const ImageInfo *image_info,
+% Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows.
%
%
% o image: The image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
-static MagickBooleanType WriteMSLImage(const ImageInfo *image_info,Image *image)
+static MagickBooleanType WriteMSLImage(const ImageInfo *image_info,Image *image,
+ ExceptionInfo *exception)
{
assert(image_info != (const ImageInfo *) NULL);
assert(image_info->signature == MagickSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
(void) ReferenceImage(image);
- (void) ProcessMSLScript(image_info,&image,&image->exception);
+ (void) ProcessMSLScript(image_info,&image,exception);
return(MagickTrue);
}
#endif
Forward declarations.
*/
static MagickBooleanType
- WriteMTVImage(const ImageInfo *,Image *);
+ WriteMTVImage(const ImageInfo *,Image *,ExceptionInfo *);
\f
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% The format of the WriteMTVImage method is:
%
-% MagickBooleanType WriteMTVImage(const ImageInfo *image_info,Image *image)
+% MagickBooleanType WriteMTVImage(const ImageInfo *image_info,
+% Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows.
%
%
% o image: The image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
-static MagickBooleanType WriteMTVImage(const ImageInfo *image_info,Image *image)
+static MagickBooleanType WriteMTVImage(const ImageInfo *image_info,Image *image,
+ ExceptionInfo *exception)
{
char
buffer[MaxTextExtent];
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);
scene=0;
(void) WriteBlobString(image,buffer);
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;
q=pixels;
Forward declarations.
*/
static MagickBooleanType
- WriteMVGImage(const ImageInfo *,Image *);
+ WriteMVGImage(const ImageInfo *,Image *,ExceptionInfo *);
\f
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% The format of the WriteMVGImage method is:
%
-% MagickBooleanType WriteMVGImage(const ImageInfo *image_info,Image *image)
+% MagickBooleanType WriteMVGImage(const ImageInfo *image_info,
+% Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows.
%
%
% o image: The image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
-static MagickBooleanType WriteMVGImage(const ImageInfo *image_info,Image *image)
+static MagickBooleanType WriteMVGImage(const ImageInfo *image_info,Image *image,
+ ExceptionInfo *exception)
{
const char
*value;
value=GetImageArtifact(image,"MVG");
if (value == (const char *) NULL)
ThrowWriterException(OptionError,"NoImageVectorGraphics");
- status=OpenBlob(image_info,image,WriteBlobMode,&image->exception);
+ status=OpenBlob(image_info,image,WriteBlobMode,exception);
if (status == MagickFalse)
return(status);
(void) WriteBlob(image,strlen(value),(const unsigned char *) value);
Forward declarations.
*/
static MagickBooleanType
- WriteNULLImage(const ImageInfo *,Image *);
+ WriteNULLImage(const ImageInfo *,Image *,ExceptionInfo *);
\f
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% The format of the WriteNULLImage method is:
%
% MagickBooleanType WriteNULLImage(const ImageInfo *image_info,
-% Image *image)
+% Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows.
%
%
% o image: The image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
static MagickBooleanType WriteNULLImage(const ImageInfo *image_info,
- Image *image)
+ Image *image,ExceptionInfo *exception)
{
assert(image_info != (const ImageInfo *) NULL);
assert(image_info->signature == MagickSignature);
assert(image != (Image *) NULL);
assert(image->signature == MagickSignature);
+ assert(exception != (ExceptionInfo *) NULL);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
return(MagickTrue);
Forward declarations.
*/
static MagickBooleanType
- WriteOTBImage(const ImageInfo *,Image *);
+ WriteOTBImage(const ImageInfo *,Image *,ExceptionInfo *);
\f
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% The format of the WriteOTBImage method is:
%
-% MagickBooleanType WriteOTBImage(const ImageInfo *image_info,Image *image)
+% MagickBooleanType WriteOTBImage(const ImageInfo *image_info,
+% Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows.
%
%
% o image: The image.
%
+% o exception: return any errors or warnings in this structure.
%
*/
-static MagickBooleanType WriteOTBImage(const ImageInfo *image_info,Image *image)
+static MagickBooleanType WriteOTBImage(const ImageInfo *image_info,Image *image,
+ ExceptionInfo *exception)
{
#define SetBit(a,i,set) \
a=(unsigned char) ((set) ? (a) | (1L << (i)) : (a) & ~(1L << (i)))
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 (IsRGBColorspace(image->colorspace) == MagickFalse)
(void) WriteBlobByte(image,1); /* depth */
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;
bit=0;
Forward declarations.
*/
static MagickBooleanType
- WritePALMImage(const ImageInfo *,Image *);
+ WritePALMImage(const ImageInfo *,Image *,ExceptionInfo *);
\f
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% The format of the WritePALMImage method is:
%
% MagickBooleanType WritePALMImage(const ImageInfo *image_info,
-% Image *image)
+% Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows.
%
%
% o image: A pointer to a Image structure.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
static MagickBooleanType WritePALMImage(const ImageInfo *image_info,
- Image *image)
+ Image *image,ExceptionInfo *exception)
{
int
y;
- ExceptionInfo
- exception;
-
MagickBooleanType
status;
assert(image->signature == MagickSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
- status=OpenBlob(image_info,image,WriteBinaryBlobMode,&exception);
+ status=OpenBlob(image_info,image,WriteBinaryBlobMode,exception);
if (status == MagickFalse)
return(status);
- GetExceptionInfo(&exception);
quantize_info=AcquireQuantizeInfo(image_info);
flags=0;
currentOffset=0;
{
if (IsRGBColorspace(image->colorspace) == MagickFalse)
(void) TransformImageColorspace(image,RGBColorspace);
- count=GetNumberColors(image,NULL,&exception);
+ count=GetNumberColors(image,NULL,exception);
for (bits_per_pixel=1; (one << bits_per_pixel) < count; bits_per_pixel*=2) ;
if (image_info->depth > 100)
bits_per_pixel=image_info->depth-100;
(void) SortColormapByIntensity(image);
}
if ((image->storage_class == PseudoClass) && (image->colors > 256))
- (void) SetImageStorageClass(image,DirectClass,&image->exception);
+ (void) SetImageStorageClass(image,DirectClass,exception);
if (image->storage_class == PseudoClass)
flags|=PALM_HAS_COLORMAP_FLAG;
else
{
if (flags & PALM_HAS_COLORMAP_FLAG) /* Write out colormap */
{
- quantize_info->dither=IsPaletteImage(image,&image->exception);
+ quantize_info->dither=IsPaletteImage(image,exception);
quantize_info->number_colors=image->colors;
(void) QuantizeImage(quantize_info,image);
(void) WriteBlobMSBShort(image,(unsigned short) image->colors);
*affinity_image;
affinity_image=ConstituteImage(256,1,"RGB",CharPixel,&PalmPalette,
- &exception);
+ exception);
(void) TransformImageColorspace(affinity_image,
affinity_image->colorspace);
(void) RemapImage(quantize_info,image,affinity_image);
for (y=0; y < (ssize_t) image->rows; y++)
{
- q=GetAuthenticPixels(image,0,y,image->columns,1,&exception);
+ q=GetAuthenticPixels(image,0,y,image->columns,1,exception);
for (x=0; x < (ssize_t) image->columns; x++)
{
SetPixelIndex(image,FindColor(image,&image->colormap[(ssize_t)
{
ptr=one_row;
(void) ResetMagickMemory(ptr,0,bytes_per_row);
- p=GetVirtualPixels(image,0,y,image->columns,1,&exception);
+ p=GetVirtualPixels(image,0,y,image->columns,1,exception);
if (p == (const Quantum *) NULL)
break;
if (bits_per_pixel == 16)
} while (image_info->adjoin != MagickFalse);
quantize_info=DestroyQuantizeInfo(quantize_info);
(void) CloseBlob(image);
- (void) DestroyExceptionInfo(&exception);
return(MagickTrue);
}
Forward declarations.
*/
static MagickBooleanType
- WritePCDImage(const ImageInfo *,Image *);
+ WritePCDImage(const ImageInfo *,Image *,ExceptionInfo *);
\f
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% The format of the WritePCDImage method is:
%
-% MagickBooleanType WritePCDImage(const ImageInfo *image_info,Image *image)
+% MagickBooleanType WritePCDImage(const ImageInfo *image_info,
+% Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows.
%
%
% o image: The image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
static MagickBooleanType WritePCDTile(Image *image,const char *page_geometry,
return(MagickTrue);
}
-static MagickBooleanType WritePCDImage(const ImageInfo *image_info,Image *image)
+static MagickBooleanType WritePCDImage(const ImageInfo *image_info,Image *image,
+ ExceptionInfo *exception)
{
Image
*pcd_image;
/*
Rotate portrait to landscape.
*/
- rotate_image=RotateImage(image,90.0,&image->exception);
+ rotate_image=RotateImage(image,90.0,exception);
if (rotate_image == (Image *) NULL)
return(MagickFalse);
pcd_image=rotate_image;
/*
Open output image file.
*/
- status=OpenBlob(image_info,pcd_image,WriteBinaryBlobMode,&image->exception);
+ status=OpenBlob(image_info,pcd_image,WriteBinaryBlobMode,exception);
if (status == MagickFalse)
return(status);
if (IsRGBColorspace(image->colorspace) == MagickFalse)
Forward declarations.
*/
static MagickBooleanType
- WritePCLImage(const ImageInfo *,Image *);
+ WritePCLImage(const ImageInfo *,Image *,ExceptionInfo *);
\f
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% The format of the WritePCLImage method is:
%
-% MagickBooleanType WritePCLImage(const ImageInfo *image_info,Image *image)
+% MagickBooleanType WritePCLImage(const ImageInfo *image_info,
+% Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows.
%
%
% o image: The image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
static size_t PCLDeltaCompressImage(const size_t length,
return((size_t) (q-compress_pixels));
}
-static MagickBooleanType WritePCLImage(const ImageInfo *image_info,Image *image)
+static MagickBooleanType WritePCLImage(const ImageInfo *image_info,Image *image,
+ ExceptionInfo *exception)
{
char
buffer[MaxTextExtent];
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);
density=75;
density);
(void) WriteBlobString(image,buffer);
(void) WriteBlobString(image,"\033&l0E"); /* top margin 0 */
- if (IsImageMonochrome(image,&image->exception) != MagickFalse)
+ if (IsImageMonochrome(image,exception) != MagickFalse)
{
/*
Monochrome image: use default printer monochrome setup.
}
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;
q=pixels;
Forward declarations.
*/
static MagickBooleanType
- WritePCXImage(const ImageInfo *,Image *);
+ WritePCXImage(const ImageInfo *,Image *,ExceptionInfo *);
\f
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% The format of the WritePCXImage method is:
%
-% MagickBooleanType WritePCXImage(const ImageInfo *image_info,Image *image)
+% MagickBooleanType WritePCXImage(const ImageInfo *image_info,
+% Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows.
%
%
% o image: The image.
%
+% o exception: return any errors or warnings in this structure.
%
*/
+
static MagickBooleanType PCXWritePixels(PCXInfo *pcx_info,
const unsigned char *pixels,Image *image)
{
return (MagickTrue);
}
-static MagickBooleanType WritePCXImage(const ImageInfo *image_info,Image *image)
+static MagickBooleanType WritePCXImage(const ImageInfo *image_info,Image *image,
+ ExceptionInfo *exception)
{
MagickBooleanType
status;
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 (IsRGBColorspace(image->colorspace) == MagickFalse)
pcx_info.encoding=image_info->compression == NoCompression ? 0 : 1;
pcx_info.bits_per_pixel=8;
if ((image->storage_class == PseudoClass) &&
- (IsImageMonochrome(image,&image->exception) != MagickFalse))
+ (IsImageMonochrome(image,exception) != MagickFalse))
pcx_info.bits_per_pixel=1;
pcx_info.left=0;
pcx_info.top=0;
*/
for (y=0; y < (ssize_t) image->rows; y++)
{
- pixels=GetVirtualPixels(image,0,y,image->columns,1,
- &image->exception);
+ pixels=GetVirtualPixels(image,0,y,image->columns,1,exception);
if (pixels == (const Quantum *) NULL)
break;
q=pcx_pixels;
if (pcx_info.bits_per_pixel > 1)
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;
q=pcx_pixels;
GetPixelPacketIntensity(&image->colormap[1]) ? 1 : 0);
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;
bit=0;
*message;
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);
}
(void) CloseBlob(image);
Forward declarations.
*/
static MagickBooleanType
- WritePDBImage(const ImageInfo *,Image *);
+ WritePDBImage(const ImageInfo *,Image *,ExceptionInfo *);
\f
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% The format of the WritePDBImage method is:
%
-% MagickBooleanType WritePDBImage(const ImageInfo *image_info,Image *image)
+% MagickBooleanType WritePDBImage(const ImageInfo *image_info,
+% Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows.
%
%
% o image: The image.
%
+% o exception: return any errors or warnings in this structure.
%
*/
return(destination);
}
-static MagickBooleanType WritePDBImage(const ImageInfo *image_info,Image *image)
+static MagickBooleanType WritePDBImage(const ImageInfo *image_info,Image *image,
+ ExceptionInfo *exception)
{
const char
*comment;
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 (IsRGBColorspace(image->colorspace) == MagickFalse)
(void) TransformImageColorspace(image,RGBColorspace);
- if (image -> colors <= 2 || GetImageType( image, &image -> exception ) == BilevelType) { /* TS */
+ if (image -> colors <= 2 || GetImageType( image, exception ) == BilevelType) { /* TS */
bits_per_pixel = 1;
} else if (image -> colors <= 4) {
bits_per_pixel = 2;
buffer[0]=0x00;
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;
(void) ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
- GrayQuantum,scanline,&image->exception);
+ GrayQuantum,scanline,exception);
for (x=0; x < pdb_image.width; x++)
{
if (x < (ssize_t) image->columns)
Forward declarations.
*/
static MagickBooleanType
- WritePDFImage(const ImageInfo *,Image *);
+ WritePDFImage(const ImageInfo *,Image *,ExceptionInfo *);
\f
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% The format of the WritePDFImage method is:
%
-% MagickBooleanType WritePDFImage(const ImageInfo *image_info,Image *image)
+% MagickBooleanType WritePDFImage(const ImageInfo *image_info,
+% Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows.
%
%
% o image: The image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
static inline size_t MagickMax(const size_t x,const size_t y)
return(status);
}
-static MagickBooleanType WritePDFImage(const ImageInfo *image_info,Image *image)
+static MagickBooleanType WritePDFImage(const ImageInfo *image_info,Image *image,
+ ExceptionInfo *exception)
{
#define CFormat "/Filter [ /%s ]\n"
#define ObjectsPerImage 14
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);
/*
case FaxCompression:
case Group4Compression:
{
- if ((IsImageMonochrome(image,&image->exception) == MagickFalse) ||
+ if ((IsImageMonochrome(image,exception) == MagickFalse) ||
(image->matte != MagickFalse))
compression=RLECompression;
break;
case JPEGCompression:
{
compression=RLECompression;
- (void) ThrowMagickException(&image->exception,GetMagickModule(),
+ (void) ThrowMagickException(exception,GetMagickModule(),
MissingDelegateError,"DelegateLibrarySupportNotBuiltIn","`%s' (JPEG)",
image->filename);
break;
case JPEG2000Compression:
{
compression=RLECompression;
- (void) ThrowMagickException(&image->exception,GetMagickModule(),
+ (void) ThrowMagickException(exception,GetMagickModule(),
MissingDelegateError,"DelegateLibrarySupportNotBuiltIn","`%s' (JP2)",
image->filename);
break;
case ZipCompression:
{
compression=RLECompression;
- (void) ThrowMagickException(&image->exception,GetMagickModule(),
+ (void) ThrowMagickException(exception,GetMagickModule(),
MissingDelegateError,"DelegateLibrarySupportNotBuiltIn","`%s' (ZLIB)",
image->filename);
break;
scale.y=(double) (geometry.height*delta.y)/resolution.y;
geometry.height=(size_t) floor(scale.y+0.5);
(void) ParseAbsoluteGeometry(page_geometry,&media_info);
- (void) ParseGravityGeometry(image,page_geometry,&page_info,
- &image->exception);
+ (void) ParseGravityGeometry(image,page_geometry,&page_info,exception);
if (image->gravity != UndefinedGravity)
{
geometry.x=(-page_info.x);
ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
if ((compression == FaxCompression) || (compression == Group4Compression) ||
((image_info->type != TrueColorType) &&
- (IsImageGray(image,&image->exception) != MagickFalse)))
+ (IsImageGray(image,exception) != MagickFalse)))
{
switch (compression)
{
}
case JPEGCompression:
{
- status=InjectImageBlob(image_info,image,image,"jpeg",
- &image->exception);
+ status=InjectImageBlob(image_info,image,image,"jpeg",exception);
if (status == MagickFalse)
- ThrowWriterException(CoderError,image->exception.reason);
+ {
+ (void) CloseBlob(image);
+ return(MagickFalse);
+ }
break;
}
case JPEG2000Compression:
{
- status=InjectImageBlob(image_info,image,image,"jp2",
- &image->exception);
+ status=InjectImageBlob(image_info,image,image,"jp2",exception);
if (status == MagickFalse)
- ThrowWriterException(CoderError,image->exception.reason);
+ {
+ (void) CloseBlob(image);
+ return(MagickFalse);
+ }
break;
}
case RLECompression:
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++)
Ascii85Initialize(image);
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++)
{
case JPEGCompression:
{
- status=InjectImageBlob(image_info,image,image,"jpeg",
- &image->exception);
+ status=InjectImageBlob(image_info,image,image,"jpeg",exception);
if (status == MagickFalse)
- ThrowWriterException(CoderError,image->exception.reason);
+ {
+ (void) CloseBlob(image);
+ return(MagickFalse);
+ }
break;
}
case JPEG2000Compression:
{
- status=InjectImageBlob(image_info,image,image,"jp2",
- &image->exception);
+ status=InjectImageBlob(image_info,image,image,"jp2",exception);
if (status == MagickFalse)
- ThrowWriterException(CoderError,image->exception.reason);
+ {
+ (void) CloseBlob(image);
+ return(MagickFalse);
+ }
break;
}
case RLECompression:
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++)
Ascii85Initialize(image);
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++)
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++)
Ascii85Initialize(image);
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++)
if ((compression == FaxCompression) ||
(compression == Group4Compression) ||
((image_info->type != TrueColorType) &&
- (IsImageGray(image,&image->exception) != MagickFalse)))
+ (IsImageGray(image,exception) != MagickFalse)))
(void) CopyMagickString(buffer,"/DeviceGray\n",MaxTextExtent);
else
if ((image->storage_class == DirectClass) || (image->colors > 256) ||
SetGeometry(image,&geometry);
(void) ParseMetaGeometry("106x106+0+0>",&geometry.x,&geometry.y,
&geometry.width,&geometry.height);
- tile_image=ThumbnailImage(image,geometry.width,geometry.height,
- &image->exception);
+ tile_image=ThumbnailImage(image,geometry.width,geometry.height,exception);
if (tile_image == (Image *) NULL)
- ThrowWriterException(ResourceLimitError,image->exception.reason);
+ return(MagickFalse);
xref[object++]=TellBlob(image);
(void) FormatLocaleString(buffer,MaxTextExtent,"%.20g 0 obj\n",(double)
object);
if ((compression == FaxCompression) ||
(compression == Group4Compression) ||
((image_info->type != TrueColorType) &&
- (IsImageGray(tile_image,&image->exception) != MagickFalse)))
+ (IsImageGray(tile_image,exception) != MagickFalse)))
{
switch (compression)
{
case JPEGCompression:
{
status=InjectImageBlob(image_info,image,tile_image,"jpeg",
- &image->exception);
+ exception);
if (status == MagickFalse)
- ThrowWriterException(CoderError,tile_image->exception.reason);
+ {
+ (void) CloseBlob(image);
+ return(MagickFalse);
+ }
break;
}
case JPEG2000Compression:
{
- status=InjectImageBlob(image_info,image,tile_image,"jp2",
- &image->exception);
+ status=InjectImageBlob(image_info,image,tile_image,"jp2",exception);
if (status == MagickFalse)
- ThrowWriterException(CoderError,tile_image->exception.reason);
+ {
+ (void) CloseBlob(image);
+ return(MagickFalse);
+ }
break;
}
case RLECompression:
for (y=0; y < (ssize_t) tile_image->rows; y++)
{
p=GetVirtualPixels(tile_image,0,y,tile_image->columns,1,
- &tile_image->exception);
+ exception);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) tile_image->columns; x++)
for (y=0; y < (ssize_t) tile_image->rows; y++)
{
p=GetVirtualPixels(tile_image,0,y,tile_image->columns,1,
- &tile_image->exception);
+ exception);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) tile_image->columns; x++)
case JPEGCompression:
{
status=InjectImageBlob(image_info,image,tile_image,"jpeg",
- &image->exception);
+ exception);
if (status == MagickFalse)
- ThrowWriterException(CoderError,tile_image->exception.reason);
+ {
+ (void) CloseBlob(image);
+ return(MagickFalse);
+ }
break;
}
case JPEG2000Compression:
{
- status=InjectImageBlob(image_info,image,tile_image,"jp2",
- &image->exception);
+ status=InjectImageBlob(image_info,image,tile_image,"jp2",exception);
if (status == MagickFalse)
- ThrowWriterException(CoderError,tile_image->exception.reason);
+ {
+ (void) CloseBlob(image);
+ return(MagickFalse);
+ }
break;
}
case RLECompression:
for (y=0; y < (ssize_t) tile_image->rows; y++)
{
p=GetVirtualPixels(tile_image,0,y,tile_image->columns,1,
- &tile_image->exception);
+ exception);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) tile_image->columns; x++)
for (y=0; y < (ssize_t) tile_image->rows; y++)
{
p=GetVirtualPixels(tile_image,0,y,tile_image->columns,1,
- &tile_image->exception);
+ exception);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) tile_image->columns; x++)
for (y=0; y < (ssize_t) tile_image->rows; y++)
{
p=GetVirtualPixels(tile_image,0,y,tile_image->columns,1,
- &tile_image->exception);
+ exception);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) tile_image->columns; x++)
for (y=0; y < (ssize_t) tile_image->rows; y++)
{
p=GetVirtualPixels(tile_image,0,y,tile_image->columns,1,
- &tile_image->exception);
+ exception);
if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) tile_image->columns; x++)
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++)
Ascii85Initialize(image);
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++)
Forward declarations.
*/
static MagickBooleanType
- WritePICTImage(const ImageInfo *,Image *);
+ WritePICTImage(const ImageInfo *,Image *,ExceptionInfo *);
\f
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% The format of the WritePICTImage method is:
%
% MagickBooleanType WritePICTImage(const ImageInfo *image_info,
-% Image *image)
+% Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows.
%
%
% o image: The image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
static MagickBooleanType WritePICTImage(const ImageInfo *image_info,
- Image *image)
+ Image *image,ExceptionInfo *exception)
{
#define MaxCount 128
#define PictCropRegionOp 0x01
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
if ((image->columns > 65535L) || (image->rows > 65535L))
ThrowWriterException(ImageError,"WidthOrHeightExceedsLimit");
- status=OpenBlob(image_info,image,WriteBinaryBlobMode,&image->exception);
+ status=OpenBlob(image_info,image,WriteBinaryBlobMode,exception);
if (status == MagickFalse)
return(status);
if (IsRGBColorspace(image->colorspace) == MagickFalse)
unsigned char
*blob;
- jpeg_image=CloneImage(image,0,0,MagickTrue,&image->exception);
+ jpeg_image=CloneImage(image,0,0,MagickTrue,exception);
if (jpeg_image == (Image *) NULL)
{
(void) CloseBlob(image);
(void) CopyMagickString(jpeg_info->magick,"JPEG",MaxTextExtent);
length=0;
blob=(unsigned char *) ImageToBlob(jpeg_info,jpeg_image,&length,
- &image->exception);
+ exception);
jpeg_info=DestroyImageInfo(jpeg_info);
if (blob == (unsigned char *) NULL)
return(MagickFalse);
if ((storage_class == PseudoClass) && (image->matte == MagickFalse))
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++)
opacity=scanline+3*image->columns;
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;
red=scanline;
Forward declarations.
*/
static MagickBooleanType
- WritePNGImage(const ImageInfo *,Image *);
+ WritePNGImage(const ImageInfo *,Image *,ExceptionInfo *);
static MagickBooleanType
- WriteMNGImage(const ImageInfo *,Image *);
+ WriteMNGImage(const ImageInfo *,Image *,ExceptionInfo *);
#if defined(JNG_SUPPORTED)
static MagickBooleanType
- WriteJNGImage(const ImageInfo *,Image *);
+ WriteJNGImage(const ImageInfo *,Image *,ExceptionInfo *);
#endif
#if PNG_LIBPNG_VER > 10011
%
% The format of the WriteMNGImage method is:
%
-% MagickBooleanType WriteMNGImage(const ImageInfo *image_info,Image *image)
+% MagickBooleanType WriteMNGImage(const ImageInfo *image_info,
+% Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows.
%
%
% o image: The image.
%
+% o exception: return any errors or warnings in this structure.
%
% To do (as of version 5.5.2, November 26, 2002 -- glennrp -- see also
% "To do" under ReadPNGImage):
%
% The format of the WritePNGImage method is:
%
-% MagickBooleanType WritePNGImage(const ImageInfo *image_info,Image *image)
+% MagickBooleanType WritePNGImage(const ImageInfo *image_info,
+% Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
%
% o image: The image.
%
+% o exception: return any errors or warnings in this structure.
+%
% Returns MagickTrue on success, MagickFalse on failure.
%
% Communicating with the PNG encoder:
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
*/
static MagickBooleanType WritePNGImage(const ImageInfo *image_info,
- Image *image)
+ Image *image,ExceptionInfo *exception)
{
MagickBooleanType
excluding,
%
% The format of the WriteJNGImage method is:
%
-% MagickBooleanType WriteJNGImage(const ImageInfo *image_info,Image *image)
+% MagickBooleanType WriteJNGImage(const ImageInfo *image_info,
+% Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
%
% o image: The image.
%
+% o exception: return any errors or warnings in this structure.
+%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
*/
-static MagickBooleanType WriteJNGImage(const ImageInfo *image_info,Image *image)
+static MagickBooleanType WriteJNGImage(const ImageInfo *image_info,Image *image,
+ ExceptionInfo *exception)
{
MagickBooleanType
have_mng_structure,
}
#endif
-
-
-static MagickBooleanType WriteMNGImage(const ImageInfo *image_info,Image *image)
+static MagickBooleanType WriteMNGImage(const ImageInfo *image_info,Image *image,
+ ExceptionInfo *exception)
{
const char
*option;
Forward declarations.
*/
static MagickBooleanType
- WritePNMImage(const ImageInfo *,Image *);
+ WritePNMImage(const ImageInfo *,Image *,ExceptionInfo *);
\f
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% The format of the WritePNMImage method is:
%
-% MagickBooleanType WritePNMImage(const ImageInfo *image_info,Image *image)
+% MagickBooleanType WritePNMImage(const ImageInfo *image_info,
+% Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows.
%
%
% o image: The image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
-static MagickBooleanType WritePNMImage(const ImageInfo *image_info,Image *image)
+static MagickBooleanType WritePNMImage(const ImageInfo *image_info,Image *image,
+ ExceptionInfo *exception)
{
char
buffer[MaxTextExtent],
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);
scene=0;
case 'f':
{
format='F';
- if (IsImageGray(image,&image->exception) != MagickFalse)
+ if (IsImageGray(image,exception) != MagickFalse)
format='f';
break;
}
case 'n':
{
if ((image_info->type != TrueColorType) &&
- (IsImageGray(image,&image->exception) != MagickFalse))
+ (IsImageGray(image,exception) != MagickFalse))
{
format='5';
if (image_info->compression == NoCompression)
format='2';
- if (IsImageMonochrome(image,&image->exception) != MagickFalse)
+ if (IsImageMonochrome(image,exception) != MagickFalse)
{
format='4';
if (image_info->compression == NoCompression)
"WIDTH %.20g\nHEIGHT %.20g\n",(double) image->columns,(double)
image->rows);
(void) WriteBlobString(image,buffer);
- quantum_type=GetQuantumType(image,&image->exception);
+ quantum_type=GetQuantumType(image,exception);
switch (quantum_type)
{
case CMYKQuantum:
register ssize_t
x;
- 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++)
register ssize_t
x;
- 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++)
register ssize_t
x;
- 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++)
register const Quantum
*restrict p;
- 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;
extent=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
- GrayQuantum,pixels,&image->exception);
+ GrayQuantum,pixels,exception);
count=WriteBlob(image,extent,pixels);
if (count != (ssize_t) extent)
break;
register ssize_t
x;
- 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;
q=pixels;
if ((image->depth == 8) || (image->depth == 16))
extent=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
- GrayQuantum,pixels,&image->exception);
+ GrayQuantum,pixels,exception);
else
{
if (image->depth <= 8)
register ssize_t
x;
- 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;
q=pixels;
if ((image->depth == 8) || (image->depth == 16))
extent=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
- quantum_type,pixels,&image->exception);
+ quantum_type,pixels,exception);
else
{
if (image->depth <= 8)
register ssize_t
x;
- 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;
q=pixels;
if ((image->depth == 8) || (image->depth == 16))
extent=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
- quantum_type,pixels,&image->exception);
+ quantum_type,pixels,exception);
else
{
switch (quantum_type)
register const Quantum
*restrict p;
- 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;
extent=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
- quantum_type,pixels,&image->exception);
+ quantum_type,pixels,exception);
(void) WriteBlob(image,extent,pixels);
if (image->previous == (Image *) NULL)
{
Forward declarations.
*/
static MagickBooleanType
- WritePreviewImage(const ImageInfo *,Image *);
+ WritePreviewImage(const ImageInfo *,Image *,ExceptionInfo *);
\f
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% The format of the WritePreviewImage method is:
%
% MagickBooleanType WritePreviewImage(const ImageInfo *image_info,
-% Image *image)
+% Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows.
%
%
% o image: The image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
static MagickBooleanType WritePreviewImage(const ImageInfo *image_info,
- Image *image)
+ Image *image,ExceptionInfo *exception)
{
Image
*preview_image;
assert(image->signature == MagickSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
- preview_image=PreviewImage(image,image_info->preview_type,&image->exception);
+ preview_image=PreviewImage(image,image_info->preview_type,exception);
if (preview_image == (Image *) NULL)
return(MagickFalse);
(void) CopyMagickString(preview_image->filename,image_info->filename,
MaxTextExtent);
write_info=CloneImageInfo(image_info);
- (void) SetImageInfo(write_info,1,&image->exception);
+ (void) SetImageInfo(write_info,1,exception);
if (LocaleCompare(write_info->magick,"PREVIEW") == 0)
(void) FormatLocaleString(preview_image->filename,MaxTextExtent,
"miff:%s",image_info->filename);
- status=WriteImage(write_info,preview_image,&image->exception);
+ status=WriteImage(write_info,preview_image,exception);
preview_image=DestroyImage(preview_image);
write_info=DestroyImageInfo(write_info);
return(status);
Forward declarations.
*/
static MagickBooleanType
- WritePSImage(const ImageInfo *,Image *);
+ WritePSImage(const ImageInfo *,Image *,ExceptionInfo *);
\f
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% The format of the WritePSImage method is:
%
-% MagickBooleanType WritePSImage(const ImageInfo *image_info,Image *image)
+% MagickBooleanType WritePSImage(const ImageInfo *image_info,
+% Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
%
% o image: the image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
static inline size_t MagickMin(const size_t x,const size_t y)
return(pixels);
}
-static MagickBooleanType WritePSImage(const ImageInfo *image_info,Image *image)
+static MagickBooleanType WritePSImage(const ImageInfo *image_info,Image *image,
+ ExceptionInfo *exception)
{
#define WriteRunlengthPacket(image,pixel,length,p) \
{ \
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);
(void) ResetMagickMemory(&bounds,0,sizeof(bounds));
scale.y=(double) (geometry.height*delta.y)/resolution.y;
geometry.height=(size_t) floor(scale.y+0.5);
(void) ParseAbsoluteGeometry(page_geometry,&media_info);
- (void) ParseGravityGeometry(image,page_geometry,&page_info,
- &image->exception);
+ (void) ParseGravityGeometry(image,page_geometry,&page_info,exception);
if (image->gravity != UndefinedGravity)
{
geometry.x=(-page_info.x);
/*
Create preview image.
*/
- preview_image=CloneImage(image,0,0,MagickTrue,&image->exception);
+ preview_image=CloneImage(image,0,0,MagickTrue,exception);
if (preview_image == (Image *) NULL)
ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
/*
for (y=0; y < (ssize_t) image->rows; y++)
{
p=GetVirtualPixels(preview_image,0,y,preview_image->columns,1,
- &preview_image->exception);
+ exception);
if (p == (const Quantum *) NULL)
break;
bit=0;
index=0;
x=0;
if ((image_info->type != TrueColorType) &&
- (IsImageGray(image,&image->exception) != MagickFalse))
+ (IsImageGray(image,exception) != MagickFalse))
{
- if (IsImageMonochrome(image,&image->exception) == MagickFalse)
+ if (IsImageMonochrome(image,exception) == MagickFalse)
{
Quantum
pixel;
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++)
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;
bit=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;
GetPixelPacket(image,p,&pixel);
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++)
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;
index=GetPixelIndex(image,p);
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++)
Forward declarations.
*/
static MagickBooleanType
- WritePS2Image(const ImageInfo *,Image *);
+ WritePS2Image(const ImageInfo *,Image *,ExceptionInfo *);
\f
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% The format of the WritePS2Image method is:
%
-% MagickBooleanType WritePS2Image(const ImageInfo *image_info,Image *image)
+% MagickBooleanType WritePS2Image(const ImageInfo *image_info,
+% Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
%
% o image: the image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
static MagickBooleanType Huffman2DEncodeImage(const ImageInfo *image_info,
return(status);
}
-static MagickBooleanType WritePS2Image(const ImageInfo *image_info,Image *image)
+static MagickBooleanType WritePS2Image(const ImageInfo *image_info,Image *image,
+ ExceptionInfo *exception)
{
static const char
*PostscriptProlog[]=
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);
compression=image->compression;
case JPEGCompression:
{
compression=RLECompression;
- (void) ThrowMagickException(&image->exception,GetMagickModule(),
+ (void) ThrowMagickException(exception,GetMagickModule(),
MissingDelegateError,"DelegateLibrarySupportNotBuiltIn","`%s' (JPEG)",
image->filename);
break;
scale.y=(double) (geometry.height*delta.y)/resolution.y;
geometry.height=(size_t) floor(scale.y+0.5);
(void) ParseAbsoluteGeometry(page_geometry,&media_info);
- (void) ParseGravityGeometry(image,page_geometry,&page_info,
- &image->exception);
+ (void) ParseGravityGeometry(image,page_geometry,&page_info,exception);
if (image->gravity != UndefinedGravity)
{
geometry.x=(-page_info.x);
ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
if ((compression == FaxCompression) || (compression == Group4Compression) ||
((image_info->type != TrueColorType) &&
- (IsImageGray(image,&image->exception) != MagickFalse)))
+ (IsImageGray(image,exception) != MagickFalse)))
{
(void) FormatLocaleString(buffer,MaxTextExtent,"%.20g %.20g\n1\n%d\n",
(double) image->columns,(double) image->rows,(int)
}
case JPEGCompression:
{
- status=InjectImageBlob(image_info,image,image,"jpeg",
- &image->exception);
+ status=InjectImageBlob(image_info,image,image,"jpeg",exception);
if (status == MagickFalse)
- ThrowWriterException(CoderError,image->exception.reason);
+ {
+ (void) CloseBlob(image);
+ return(MagickFalse);
+ }
break;
}
case RLECompression:
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++)
Ascii85Initialize(image);
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++)
{
case JPEGCompression:
{
- status=InjectImageBlob(image_info,image,image,"jpeg",
- &image->exception);
+ status=InjectImageBlob(image_info,image,image,"jpeg",exception);
if (status == MagickFalse)
- ThrowWriterException(CoderError,image->exception.reason);
+ {
+ (void) CloseBlob(image);
+ return(MagickFalse);
+ }
break;
}
case RLECompression:
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++)
Ascii85Initialize(image);
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++)
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++)
Ascii85Initialize(image);
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++)
Forward declarations.
*/
static MagickBooleanType
- WritePS3Image(const ImageInfo *,Image *);
+ WritePS3Image(const ImageInfo *,Image *,ExceptionInfo *);
\f
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% The format of the WritePS3Image method is:
%
-% MagickBooleanType WritePS3Image(const ImageInfo *image_info,Image *image)
+% MagickBooleanType WritePS3Image(const ImageInfo *image_info,
+% Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
%
% o image: the image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
static MagickBooleanType Huffman2DEncodeImage(const ImageInfo *image_info,
return(status);
}
-static MagickBooleanType WritePS3Image(const ImageInfo *image_info,Image *image)
+static MagickBooleanType WritePS3Image(const ImageInfo *image_info,Image *image,
+ ExceptionInfo *exception)
{
static const char
*PostscriptProlog[]=
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(MagickFalse);
compression=image->compression;
case FaxCompression:
case Group4Compression:
{
- if ((IsImageMonochrome(image,&image->exception) == MagickFalse) ||
+ if ((IsImageMonochrome(image,exception) == MagickFalse) ||
(image->matte != MagickFalse))
compression=RLECompression;
break;
case JPEGCompression:
{
compression=RLECompression;
- (void) ThrowMagickException(&image->exception,GetMagickModule(),
+ (void) ThrowMagickException(exception,GetMagickModule(),
MissingDelegateError,"DelegateLibrarySupportNotBuiltIn","`%s' (JPEG)",
image->filename);
break;
case ZipCompression:
{
compression=RLECompression;
- (void) ThrowMagickException(&image->exception,GetMagickModule(),
+ (void) ThrowMagickException(exception,GetMagickModule(),
MissingDelegateError,"DelegateLibrarySupportNotBuiltIn","`%s' (ZLIB)",
image->filename);
break;
scale.y=(double) (geometry.height*delta.y)/resolution.y;
geometry.height=(size_t) floor(scale.y+0.5);
(void) ParseAbsoluteGeometry(page_geometry,&media_info);
- (void) ParseGravityGeometry(image,page_geometry,&page_info,
- &image->exception);
+ (void) ParseGravityGeometry(image,page_geometry,&page_info,exception);
if (image->gravity != UndefinedGravity)
{
geometry.x=(-page_info.x);
(void) WriteBlobString(image,
"%%DocumentProcessColors: Cyan Magenta Yellow Black\n");
else
- if (IsImageGray(image,&image->exception) != MagickFalse)
+ if (IsImageGray(image,exception) != MagickFalse)
(void) WriteBlobString(image,
"%%DocumentProcessColors: Black\n");
}
(void) WriteBlobString(image,
"%%PageProcessColors: Cyan Magenta Yellow Black\n");
else
- if (IsImageGray(image,&image->exception) != MagickFalse)
+ if (IsImageGray(image,exception) != MagickFalse)
(void) WriteBlobString(image,"%%PageProcessColors: Black\n");
/*
Adjust document bounding box to bound page bounding box.
*/
option=GetImageOption(image_info,"ps3:imagemask");
(void) WriteBlobString(image,((option != (const char *) NULL) &&
- (IsImageMonochrome(image,&image->exception) != MagickFalse)) ?
+ (IsImageMonochrome(image,exception) != MagickFalse)) ?
"true\n" : "false\n");
/*
Output pixel data.
(image_info->type != ColorSeparationType) &&
(image_info->type != ColorSeparationMatteType) &&
(image->colorspace != CMYKColorspace) &&
- ((IsImageGray(image,&image->exception) != MagickFalse) ||
- (IsImageMonochrome(image,&image->exception) != MagickFalse)))
+ ((IsImageGray(image,exception) != MagickFalse) ||
+ (IsImageMonochrome(image,exception) != MagickFalse)))
{
/*
Gray images.
1 bit or 8 bit components?
*/
(void) FormatLocaleString(buffer,MaxTextExtent,"%d\n",
- IsImageMonochrome(image,&image->exception) != MagickFalse ? 1 : 8);
+ IsImageMonochrome(image,exception) != MagickFalse ? 1 : 8);
(void) WriteBlobString(image,buffer);
/*
Image data.
*/
if (compression == JPEGCompression)
- status=InjectImageBlob(image_info,image,image,"jpeg",
- &image->exception);
+ status=InjectImageBlob(image_info,image,image,"jpeg",exception);
else
if ((compression == FaxCompression) ||
(compression == Group4Compression))
Image data.
*/
if (compression == JPEGCompression)
- status=InjectImageBlob(image_info,image,image,"jpeg",
- &image->exception);
+ status=InjectImageBlob(image_info,image,image,"jpeg",exception);
else
{
/*
}
case JPEGCompression:
{
- status=InjectImageBlob(image_info,image,image,"jpeg",
- &image->exception);
+ status=InjectImageBlob(image_info,image,image,"jpeg",exception);
break;
}
case RLECompression:
projects / imagemagick / commitdiff