% July 1992 %
% %
% %
-% Copyright 1999-2010 ImageMagick Studio LLC, a non-profit organization %
+% Copyright 1999-2011 ImageMagick Studio LLC, a non-profit organization %
% dedicated to making software imaging solutions freely available. %
% %
% You may not use this file except in compliance with the License. You may %
/*
Include declarations.
*/
-#include "magick/studio.h"
-#include "magick/blob.h"
-#include "magick/blob-private.h"
-#include "magick/cache.h"
-#include "magick/color.h"
-#include "magick/color-private.h"
-#include "magick/colormap.h"
-#include "magick/colorspace.h"
-#include "magick/exception.h"
-#include "magick/exception-private.h"
-#include "magick/image.h"
-#include "magick/image-private.h"
-#include "magick/list.h"
-#include "magick/magick.h"
-#include "magick/memory_.h"
-#include "magick/monitor.h"
-#include "magick/monitor-private.h"
-#include "magick/property.h"
-#include "magick/quantum-private.h"
-#include "magick/static.h"
-#include "magick/string_.h"
-#include "magick/module.h"
+#include "MagickCore/studio.h"
+#include "MagickCore/attribute.h"
+#include "MagickCore/blob.h"
+#include "MagickCore/blob-private.h"
+#include "MagickCore/cache.h"
+#include "MagickCore/color.h"
+#include "MagickCore/color-private.h"
+#include "MagickCore/colormap.h"
+#include "MagickCore/colorspace.h"
+#include "MagickCore/colorspace-private.h"
+#include "MagickCore/exception.h"
+#include "MagickCore/exception-private.h"
+#include "MagickCore/image.h"
+#include "MagickCore/image-private.h"
+#include "MagickCore/list.h"
+#include "MagickCore/magick.h"
+#include "MagickCore/memory_.h"
+#include "MagickCore/monitor.h"
+#include "MagickCore/monitor-private.h"
+#include "MagickCore/pixel-accessor.h"
+#include "MagickCore/property.h"
+#include "MagickCore/quantum-private.h"
+#include "MagickCore/static.h"
+#include "MagickCore/string_.h"
+#include "MagickCore/module.h"
\f
/*
Forward declarations.
*/
static MagickBooleanType
- WriteVIFFImage(const ImageInfo *,Image *);
+ WriteVIFFImage(const ImageInfo *,Image *,ExceptionInfo *);
\f
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% o length: Specifies the length of the magick string.
%
-%
*/
static MagickBooleanType IsVIFF(const unsigned char *magick,const size_t length)
{
int
bit;
- ssize_t
- y;
-
MagickBooleanType
status;
MagickSizeType
number_pixels;
- register IndexPacket
- *indexes;
-
register ssize_t
x;
- register PixelPacket
+ register Quantum
*q;
register ssize_t
register unsigned char
*p;
- ssize_t
- count;
-
- unsigned char
- buffer[7],
- *viff_pixels;
-
size_t
bytes_per_pixel,
lsb_first,
max_packets,
quantum;
+ ssize_t
+ count,
+ y;
+
+ unsigned char
+ buffer[7],
+ *viff_pixels;
+
ViffInfo
viff_info;
image_info->filename);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
- image=AcquireImage(image_info);
+ image=AcquireImage(image_info,exception);
status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
if (status == MagickFalse)
{
viff_info.rows=ReadBlobLSBLong(image);
viff_info.columns=ReadBlobLSBLong(image);
viff_info.subrows=ReadBlobLSBLong(image);
- viff_info.x_offset=(ssize_t) ReadBlobLSBLong(image);
- viff_info.y_offset=(ssize_t) ReadBlobLSBLong(image);
+ viff_info.x_offset=(int) ReadBlobLSBLong(image);
+ viff_info.y_offset=(int) ReadBlobLSBLong(image);
viff_info.x_bits_per_pixel=(float) ReadBlobLSBLong(image);
viff_info.y_bits_per_pixel=(float) ReadBlobLSBLong(image);
viff_info.location_type=ReadBlobLSBLong(image);
viff_info.rows=ReadBlobMSBLong(image);
viff_info.columns=ReadBlobMSBLong(image);
viff_info.subrows=ReadBlobMSBLong(image);
- viff_info.x_offset=(ssize_t) ReadBlobMSBLong(image);
- viff_info.y_offset=(ssize_t) ReadBlobMSBLong(image);
+ viff_info.x_offset=(int) ReadBlobMSBLong(image);
+ viff_info.y_offset=(int) ReadBlobMSBLong(image);
viff_info.x_bits_per_pixel=(float) ReadBlobMSBLong(image);
viff_info.y_bits_per_pixel=(float) ReadBlobMSBLong(image);
viff_info.location_type=ReadBlobMSBLong(image);
(void) ReadBlobByte(image);
image->columns=viff_info.rows;
image->rows=viff_info.columns;
- image->depth=viff_info.x_bits_per_pixel <= 8 ? 8UL : MAGICKCORE_QUANTUM_DEPTH;
+ image->depth=viff_info.x_bits_per_pixel <= 8 ? 8UL :
+ MAGICKCORE_QUANTUM_DEPTH;
/*
Verify that we can read this VIFF image.
*/
image->colors=image->depth <= 8 ? 256UL : 65536UL;
if (viff_info.data_storage_type == VFF_TYP_BIT)
image->colors=2;
- if (AcquireImageColormap(image,image->colors) == MagickFalse)
+ if (AcquireImageColormap(image,image->colors,exception) == MagickFalse)
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
}
break;
default: bytes_per_pixel=1; break;
}
image->colors=viff_info.map_columns;
- if (AcquireImageColormap(image,image->colors) == MagickFalse)
+ if (AcquireImageColormap(image,image->colors,exception) == MagickFalse)
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
viff_colormap=(unsigned char *) AcquireQuantumMemory(image->colors,
viff_info.map_rows*bytes_per_pixel*sizeof(*viff_colormap));
/*
Convert bitmap scanline.
*/
- (void) SetImageType(image,BilevelType);
- (void) SetImageType(image,PaletteType);
+ (void) SetImageType(image,BilevelType,exception);
+ (void) SetImageType(image,PaletteType,exception);
for (y=0; y < (ssize_t) image->rows; y++)
{
q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
- if (q == (PixelPacket *) NULL)
+ if (q == (Quantum *) NULL)
break;
- indexes=GetAuthenticIndexQueue(image);
for (x=0; x < (ssize_t) (image->columns-7); x+=8)
{
for (bit=0; bit < 8; bit++)
- if (PixelIntensity(q) < ((MagickRealType) QuantumRange/2.0))
+ {
+ if (GetPixelIntensity(image,q) < ((MagickRealType) QuantumRange/2.0))
{
- quantum=(size_t) indexes[x+bit];
+ quantum=(size_t) GetPixelIndex(image,q);
quantum|=0x01;
- indexes[x+bit]=(IndexPacket) quantum;
+ SetPixelIndex(image,quantum,q);
}
+ q+=GetPixelChannels(image);
+ }
p++;
}
if ((image->columns % 8) != 0)
{
for (bit=0; bit < (ssize_t) (image->columns % 8); bit++)
- if (PixelIntensity(q) < ((MagickRealType) QuantumRange/2.0))
+ if (GetPixelIntensity(image,q) < ((MagickRealType) QuantumRange/2.0))
{
- quantum=(size_t) indexes[x+bit];
+ quantum=(size_t) GetPixelIndex(image,q);
quantum|=0x01;
- indexes[x+bit]=(IndexPacket) quantum;
+ SetPixelIndex(image,quantum,q);
+ q+=GetPixelChannels(image);
}
p++;
}
for (y=0; y < (ssize_t) image->rows; y++)
{
q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
- if (q == (PixelPacket *) NULL)
+ if (q == (Quantum *) NULL)
break;
- indexes=GetAuthenticIndexQueue(image);
for (x=0; x < (ssize_t) image->columns; x++)
- indexes[x]=(IndexPacket) (*p++);
+ {
+ SetPixelIndex(image,*p++,q);
+ q+=GetPixelChannels(image);
+ }
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
if (image->previous == (Image *) NULL)
for (y=0; y < (ssize_t) image->rows; y++)
{
q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
- if (q == (PixelPacket *) NULL)
+ if (q == (Quantum *) NULL)
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
- q->red=ScaleCharToQuantum(*p);
- q->green=ScaleCharToQuantum(*(p+number_pixels));
- q->blue=ScaleCharToQuantum(*(p+2*number_pixels));
+ SetPixelRed(image,ScaleCharToQuantum(*p),q);
+ SetPixelGreen(image,ScaleCharToQuantum(*(p+number_pixels)),q);
+ SetPixelBlue(image,ScaleCharToQuantum(*(p+2*number_pixels)),q);
if (image->colors != 0)
{
- q->red=image->colormap[(ssize_t) q->red].red;
- q->green=image->colormap[(ssize_t) q->green].green;
- q->blue=image->colormap[(ssize_t) q->blue].blue;
+ SetPixelRed(image,image->colormap[(ssize_t)
+ GetPixelRed(image,q)].red,q);
+ SetPixelGreen(image,image->colormap[(ssize_t)
+ GetPixelGreen(image,q)].green,q);
+ SetPixelBlue(image,image->colormap[(ssize_t)
+ GetPixelBlue(image,q)].blue,q);
}
- q->opacity=(Quantum) (image->matte ? QuantumRange-
- ScaleCharToQuantum(*(p+number_pixels*3)) : OpaqueOpacity);
+ SetPixelAlpha(image,image->matte != MagickFalse ?
+ ScaleCharToQuantum(*(p+number_pixels*3)) : OpaqueAlpha,q);
p++;
- q++;
+ q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
/*
Allocate next image structure.
*/
- AcquireNextImage(image_info,image);
+ AcquireNextImage(image_info,image,exception);
if (GetNextImageInList(image) == (Image *) NULL)
{
image=DestroyImageList(image);
% The format of the WriteVIFFImage method is:
%
% MagickBooleanType WriteVIFFImage(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 MagickMin(const size_t x,const size_t y)
}
static MagickBooleanType WriteVIFFImage(const ImageInfo *image_info,
- Image *image)
+ Image *image,ExceptionInfo *exception)
{
#define VFF_CM_genericRGB 15
#define VFF_CM_NONE 0
const char
*value;
- ssize_t
- y;
-
MagickBooleanType
status;
number_pixels,
packets;
- register const IndexPacket
- *indexes;
-
- register const PixelPacket
+ register const Quantum
*p;
register ssize_t
register unsigned char
*q;
+ ssize_t
+ y;
+
unsigned char
buffer[8],
*viff_pixels;
assert(image->signature == MagickSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
- status=OpenBlob(image_info,image,WriteBinaryBlobMode,&image->exception);
+ assert(exception != (ExceptionInfo *) NULL);
+ assert(exception->signature == MagickSignature);
+ status=OpenBlob(image_info,image,WriteBinaryBlobMode,exception);
if (status == MagickFalse)
return(status);
(void) ResetMagickMemory(&viff_info,0,sizeof(ViffInfo));
/*
Initialize VIFF image structure.
*/
- if (image->colorspace != RGBColorspace)
+ if (IsRGBColorspace(image->colorspace) == MagickFalse)
(void) TransformImageColorspace(image,RGBColorspace);
- if (IsGrayImage(image,&image->exception) != MagickFalse)
- (void) SetImageStorageClass(image,DirectClass);
+ if (IsImageGray(image,exception) != MagickFalse)
+ (void) SetImageStorageClass(image,DirectClass,exception);
viff_info.identifier=(char) 0xab;
viff_info.file_type=1;
viff_info.release=1;
*viff_info.comment='\0';
value=GetImageProperty(image,"comment");
if (value != (const char *) NULL)
- (void) CopyMagickString(viff_info.comment,value,MagickMin(strlen(value),511)+1);
+ (void) CopyMagickString(viff_info.comment,value,MagickMin(strlen(value),
+ 511)+1);
viff_info.rows=image->columns;
viff_info.columns=image->rows;
viff_info.subrows=0;
viff_info.color_space_model=VFF_CM_NONE;
viff_info.data_storage_type=VFF_TYP_1_BYTE;
packets=number_pixels;
- if (IsGrayImage(image,&image->exception) == MagickFalse)
+ if (IsImageGray(image,exception) == MagickFalse)
{
/*
Colormapped VIFF raster.
viff_info.map_scheme=VFF_MS_ONEPERBAND;
viff_info.map_storage_type=VFF_MAPTYP_1_BYTE;
viff_info.map_rows=3;
- viff_info.map_columns=image->colors;
+ viff_info.map_columns=(unsigned int) image->colors;
}
else
if (image->colors <= 2)
buffer[7]=(unsigned char) viff_info.reserve[2];
(void) WriteBlob(image,8,buffer);
(void) WriteBlob(image,512,(unsigned char *) viff_info.comment);
- (void) WriteBlobMSBLong(image,viff_info.rows);
- (void) WriteBlobMSBLong(image,viff_info.columns);
+ (void) WriteBlobMSBLong(image,(unsigned int) viff_info.rows);
+ (void) WriteBlobMSBLong(image,(unsigned int) viff_info.columns);
(void) WriteBlobMSBLong(image,(unsigned int) viff_info.subrows);
(void) WriteBlobMSBLong(image,(unsigned int) viff_info.x_offset);
(void) WriteBlobMSBLong(image,(unsigned int) viff_info.y_offset);
number_pixels=(MagickSizeType) image->columns*image->rows;
for (y=0; y < (ssize_t) image->rows; y++)
{
- p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
- if (p == (const PixelPacket *) NULL)
+ p=GetVirtualPixels(image,0,y,image->columns,1,exception);
+ if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
- *q=ScaleQuantumToChar(GetRedPixelComponent(p));
- *(q+number_pixels)=ScaleQuantumToChar(GetGreenPixelComponent(p));
- *(q+number_pixels*2)=ScaleQuantumToChar(GetBluePixelComponent(p));
+ *q=ScaleQuantumToChar(GetPixelRed(image,p));
+ *(q+number_pixels)=ScaleQuantumToChar(GetPixelGreen(image,p));
+ *(q+number_pixels*2)=ScaleQuantumToChar(GetPixelBlue(image,p));
if (image->matte != MagickFalse)
*(q+number_pixels*3)=ScaleQuantumToChar((Quantum)
- (GetAlphaPixelComponent(p)));
- p++;
+ (GetPixelAlpha(image,p)));
+ p+=GetPixelChannels(image);
q++;
}
if (image->previous == (Image *) NULL)
}
}
else
- if (IsGrayImage(image,&image->exception) == MagickFalse)
+ if (IsImageGray(image,exception) == MagickFalse)
{
unsigned char
*viff_colormap;
q=viff_pixels;
for (y=0; y < (ssize_t) image->rows; y++)
{
- p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
- if (p == (const PixelPacket *) NULL)
+ p=GetVirtualPixels(image,0,y,image->columns,1,exception);
+ if (p == (const Quantum *) NULL)
break;
- indexes=GetVirtualIndexQueue(image);
for (x=0; x < (ssize_t) image->columns; x++)
- *q++=(unsigned char) indexes[x];
+ {
+ *q++=(unsigned char) GetPixelIndex(image,p);
+ p+=GetPixelChannels(image);
+ }
if (image->previous == (Image *) NULL)
{
status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
/*
Convert PseudoClass image to a VIFF monochrome image.
*/
- (void) SetImageType(image,BilevelType);
+ (void) SetImageType(image,BilevelType,exception);
for (y=0; y < (ssize_t) image->rows; y++)
{
- p=GetVirtualPixels(image,0,y,image->columns,1,
- &image->exception);
- if (p == (const PixelPacket *) NULL)
+ p=GetVirtualPixels(image,0,y,image->columns,1,exception);
+ if (p == (const Quantum *) NULL)
break;
- indexes=GetVirtualIndexQueue(image);
bit=0;
byte=0;
for (x=0; x < (ssize_t) image->columns; x++)
{
byte>>=1;
- if (PixelIntensity(p) < ((MagickRealType) QuantumRange/2.0))
+ if (GetPixelIntensity(image,p) < ((MagickRealType) QuantumRange/2.0))
byte|=0x80;
bit++;
if (bit == 8)
bit=0;
byte=0;
}
+ p+=GetPixelChannels(image);
}
if (bit != 0)
*q++=byte >> (8-bit);
*/
for (y=0; y < (ssize_t) image->rows; y++)
{
- p=GetVirtualPixels(image,0,y,image->columns,1,
- &image->exception);
- if (p == (const PixelPacket *) NULL)
+ p=GetVirtualPixels(image,0,y,image->columns,1,exception);
+ if (p == (const Quantum *) NULL)
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
- *q++=(unsigned char) PixelIntensityToQuantum(p);
- p++;
+ *q++=(unsigned char) GetPixelIntensity(image,p);
+ p+=GetPixelChannels(image);
}
if (image->previous == (Image *) NULL)
{