% Read/Write PBMPlus Portable Anymap Image Format %
% %
% Software Design %
-% John Cristy %
+% Cristy %
% July 1992 %
% %
% %
-% Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization %
+% Copyright 1999-2018 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 %
% obtain a copy of the License at %
% %
-% http://www.imagemagick.org/script/license.php %
+% https://www.imagemagick.org/script/license.php %
% %
% Unless required by applicable law or agreed to in writing, software %
% distributed under the License is distributed on an "AS IS" BASIS, %
%
*/
-static inline ssize_t ConstrainPixel(Image *image,const ssize_t offset,
- const size_t extent,ExceptionInfo *exception)
-{
- if ((offset < 0) || (offset > (ssize_t) extent))
- {
- (void) ThrowMagickException(exception,GetMagickModule(),CorruptImageError,
- "InvalidPixel","`%s'",image->filename);
- return(0);
- }
- return(offset);
-}
-
-static void PNMComment(Image *image,ExceptionInfo *exception)
+static int PNMComment(Image *image,ExceptionInfo *exception)
{
int
c;
Read comment.
*/
comment=AcquireString(GetImageProperty(image,"comment",exception));
- extent=strlen(comment);
p=comment+strlen(comment);
- for (c='#'; (c != EOF) && (c != (int) '\n'); p++)
+ extent=strlen(comment)+MagickPathExtent;
+ for (c='#'; (c != EOF) && (c != (int) '\n') && (c != (int) '\r'); p++)
{
if ((size_t) (p-comment+1) >= extent)
{
extent<<=1;
- comment=(char *) ResizeQuantumMemory(comment,extent+MaxTextExtent,
+ comment=(char *) ResizeQuantumMemory(comment,extent+MagickPathExtent,
sizeof(*comment));
if (comment == (char *) NULL)
break;
}
}
if (comment == (char *) NULL)
- return;
+ return(c);
(void) SetImageProperty(image,"comment",comment,exception);
comment=DestroyString(comment);
+ return(c);
}
-static size_t PNMInteger(Image *image,const unsigned int base,
+static unsigned int PNMInteger(Image *image,const unsigned int base,
ExceptionInfo *exception)
{
int
c;
- size_t
+ unsigned int
value;
/*
if (c == EOF)
return(0);
if (c == (int) '#')
- PNMComment(image,exception);
- } while (isdigit(c) == MagickFalse);
+ c=PNMComment(image,exception);
+ } while ((c == ' ') || (c == '\t') || (c == '\n') || (c == '\r'));
if (base == 2)
- return((size_t) (c-(int) '0'));
+ return((unsigned int) (c-(int) '0'));
/*
Evaluate number.
*/
value=0;
- do
+ while (isdigit(c) != 0)
{
- value*=10;
- value+=c-(int) '0';
+ if (value <= (unsigned int) (INT_MAX/10))
+ {
+ value*=10;
+ if (value <= (unsigned int) (INT_MAX-(c-(int) '0')))
+ value+=c-(int) '0';
+ }
c=ReadBlobByte(image);
if (c == EOF)
- return(value);
- } while (isdigit(c) != MagickFalse);
+ return(0);
+ }
+ if (c == (int) '#')
+ c=PNMComment(image,exception);
return(value);
}
MagickBooleanType
status;
- Quantum
- *scale;
-
QuantumAny
max_value;
QuantumType
quantum_type;
- register ssize_t
- i;
-
size_t
depth,
extent,
Open image file.
*/
assert(image_info != (const ImageInfo *) NULL);
- assert(image_info->signature == MagickSignature);
+ assert(image_info->signature == MagickCoreSignature);
if (image_info->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
image_info->filename);
assert(exception != (ExceptionInfo *) NULL);
- assert(exception->signature == MagickSignature);
+ assert(exception->signature == MagickCoreSignature);
image=AcquireImage(image_info,exception);
status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
if (status == MagickFalse)
/*
PBM, PGM, PPM, and PNM.
*/
- image->columns=PNMInteger(image,10,exception);
- image->rows=PNMInteger(image,10,exception);
+ image->columns=(size_t) PNMInteger(image,10,exception);
+ image->rows=(size_t) PNMInteger(image,10,exception);
if ((format == 'f') || (format == 'F'))
{
char
- scale[MaxTextExtent];
+ scale[MagickPathExtent];
(void) ReadBlobString(image,scale);
quantum_scale=StringToDouble(scale,(char **) NULL);
if ((format == '1') || (format == '4'))
max_value=1; /* bitmap */
else
- max_value=PNMInteger(image,10,exception);
+ max_value=(QuantumAny) PNMInteger(image,10,exception);
}
}
else
{
char
- keyword[MaxTextExtent],
- value[MaxTextExtent];
+ keyword[MagickPathExtent],
+ value[MagickPathExtent];
int
c;
/*
Comment.
*/
- PNMComment(image,exception);
+ c=PNMComment(image,exception);
c=ReadBlobByte(image);
while (isspace((int) ((unsigned char) c)) != 0)
c=ReadBlobByte(image);
p=keyword;
do
{
- if ((size_t) (p-keyword) < (MaxTextExtent-1))
+ if ((size_t) (p-keyword) < (MagickPathExtent-1))
*p++=c;
c=ReadBlobByte(image);
} while (isalnum(c));
p=value;
while (isalnum(c) || (c == '_'))
{
- if ((size_t) (p-value) < (MaxTextExtent-1))
+ if ((size_t) (p-value) < (MagickPathExtent-1))
*p++=c;
c=ReadBlobByte(image);
}
}
if ((image->columns == 0) || (image->rows == 0))
ThrowReaderException(CorruptImageError,"NegativeOrZeroImageSize");
- if (max_value >= 65536)
+ if ((max_value == 0) || (max_value > 4294967295UL))
ThrowReaderException(CorruptImageError,"ImproperImageHeader");
for (depth=1; GetQuantumRange(depth) < max_value; depth++) ;
image->depth=depth;
if ((image_info->ping != MagickFalse) && (image_info->number_scenes != 0))
if (image->scene >= (image_info->scene+image_info->number_scenes-1))
break;
+ status=SetImageExtent(image,image->columns,image->rows,exception);
+ if (status == MagickFalse)
+ return(DestroyImageList(image));
/*
Convert PNM pixels to runextent-encoded MIFF packets.
*/
- status=MagickTrue;
row=0;
+ y=0;
switch (format)
{
case '1':
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
if (q == (Quantum *) NULL)
{
SetPixelGray(image,PNMInteger(image,2,exception) == 0 ?
QuantumRange : 0,q);
+ if (EOFBlob(image) != MagickFalse)
+ break;
q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
if (status == MagickFalse)
break;
}
+ if (EOFBlob(image) != MagickFalse)
+ break;
}
image->type=BilevelType;
break;
}
case '2':
{
- size_t
+ Quantum
intensity;
/*
Convert PGM image to pixel packets.
*/
(void) SetImageColorspace(image,GRAYColorspace,exception);
- scale=(Quantum *) NULL;
- if (max_value != (1U*QuantumRange))
- {
- /*
- Compute pixel scaling table.
- */
- scale=(Quantum *) AcquireQuantumMemory((size_t) max_value+1UL,
- sizeof(*scale));
- if (scale == (Quantum *) NULL)
- ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
- for (i=0; i <= (ssize_t) max_value; i++)
- scale[i]=(Quantum) (((double) QuantumRange*i)/max_value+0.5);
- }
for (y=0; y < (ssize_t) image->rows; y++)
{
register ssize_t
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
if (q == (Quantum *) NULL)
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
- intensity=PNMInteger(image,10,exception);
- SetPixelGray(image,(Quantum) intensity,q);
- if (scale != (Quantum *) NULL)
- SetPixelGray(image,scale[ConstrainPixel(image,(ssize_t) intensity,
- (size_t) max_value,exception)],q);
+ intensity=ScaleAnyToQuantum(PNMInteger(image,10,exception),
+ max_value);
+ if (EOFBlob(image) != MagickFalse)
+ break;
+ SetPixelGray(image,intensity,q);
q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
if (status == MagickFalse)
break;
}
+ if (EOFBlob(image) != MagickFalse)
+ break;
}
image->type=GrayscaleType;
- if (scale != (Quantum *) NULL)
- scale=(Quantum *) RelinquishMagickMemory(scale);
break;
}
case '3':
{
- PixelInfo
- pixel;
-
/*
Convert PNM image to pixel packets.
*/
- scale=(Quantum *) NULL;
- if (max_value != (1U*QuantumRange))
- {
- /*
- Compute pixel scaling table.
- */
- scale=(Quantum *) AcquireQuantumMemory((size_t) max_value+1UL,
- sizeof(*scale));
- if (scale == (Quantum *) NULL)
- ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
- for (i=0; i <= (ssize_t) max_value; i++)
- scale[i]=(Quantum) (((double) QuantumRange*i)/max_value+0.5);
- }
for (y=0; y < (ssize_t) image->rows; y++)
{
register ssize_t
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
if (q == (Quantum *) NULL)
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
- pixel.red=(double) PNMInteger(image,10,exception);
- pixel.green=(double) PNMInteger(image,10,exception);
- pixel.blue=(double) PNMInteger(image,10,exception);
- if (scale != (Quantum *) NULL)
- {
- pixel.red=(double) scale[ConstrainPixel(image,(ssize_t)
- pixel.red,(size_t) max_value,exception)];
- pixel.green=(double) scale[ConstrainPixel(image,
- (ssize_t) pixel.green,(size_t) max_value,exception)];
- pixel.blue=(double) scale[ConstrainPixel(image,(ssize_t)
- pixel.blue,(size_t) max_value,exception)];
- }
- SetPixelRed(image,ClampToQuantum(pixel.red),q);
- SetPixelGreen(image,ClampToQuantum(pixel.green),q);
- SetPixelBlue(image,ClampToQuantum(pixel.blue),q);
+ Quantum
+ pixel;
+
+ pixel=ScaleAnyToQuantum(PNMInteger(image,10,exception),max_value);
+ if (EOFBlob(image) != MagickFalse)
+ break;
+ SetPixelRed(image,pixel,q);
+ pixel=ScaleAnyToQuantum(PNMInteger(image,10,exception),max_value);
+ SetPixelGreen(image,pixel,q);
+ pixel=ScaleAnyToQuantum(PNMInteger(image,10,exception),max_value);
+ SetPixelBlue(image,pixel,q);
q+=GetPixelChannels(image);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
if (status == MagickFalse)
break;
}
+ if (EOFBlob(image) != MagickFalse)
+ break;
}
- if (scale != (Quantum *) NULL)
- scale=(Quantum *) RelinquishMagickMemory(scale);
break;
}
case '4':
extent=GetQuantumExtent(image,quantum_info,quantum_type);
for (y=0; y < (ssize_t) image->rows; y++)
{
+ const unsigned char
+ *pixels;
+
MagickBooleanType
sync;
register Quantum
- *restrict q;
+ *magick_restrict q;
ssize_t
count,
size_t
length;
- unsigned char
- *pixels;
-
- if (status == MagickFalse)
- continue;
- pixels=GetQuantumPixels(quantum_info);
- {
- count=ReadBlob(image,extent,pixels);
- if ((image->progress_monitor != (MagickProgressMonitor) NULL) &&
- (image->previous == (Image *) NULL))
- {
- MagickBooleanType
- proceed;
-
- proceed=SetImageProgress(image,LoadImageTag,(MagickOffsetType)
- row,image->rows);
- if (proceed == MagickFalse)
- status=MagickFalse;
- }
- offset=row++;
- }
+ pixels=(unsigned char *) ReadBlobStream(image,extent,
+ GetQuantumPixels(quantum_info),&count);
if (count != (ssize_t) extent)
- status=MagickFalse;
- q=QueueAuthenticPixels(image,0,offset,image->columns,1,exception);
- if (q == (Quantum *) NULL)
+ break;
+ if ((image->progress_monitor != (MagickProgressMonitor) NULL) &&
+ (image->previous == (Image *) NULL))
{
- status=MagickFalse;
- continue;
+ MagickBooleanType
+ proceed;
+
+ proceed=SetImageProgress(image,LoadImageTag,(MagickOffsetType)
+ row,image->rows);
+ if (proceed == MagickFalse)
+ break;
}
+ offset=row++;
+ q=QueueAuthenticPixels(image,0,offset,image->columns,1,exception);
+ if (q == (Quantum *) NULL)
+ break;
length=ImportQuantumPixels(image,(CacheView *) NULL,quantum_info,
quantum_type,pixels,exception);
if (length != extent)
- status=MagickFalse;
+ break;
sync=SyncAuthenticPixels(image,exception);
if (sync == MagickFalse)
- status=MagickFalse;
+ break;
}
quantum_info=DestroyQuantumInfo(quantum_info);
- if (status == MagickFalse)
- ThrowReaderException(CorruptImageError,"UnableToReadImageData");
SetQuantumImageType(image,quantum_type);
break;
}
*/
(void) SetImageColorspace(image,GRAYColorspace,exception);
quantum_type=GrayQuantum;
- extent=(image->depth <= 8 ? 1 : 2)*image->columns;
+ if (image->depth <= 8)
+ extent=image->columns;
+ else
+ if (image->depth <= 16)
+ extent=2*image->columns;
+ else
+ extent=4*image->columns;
quantum_info=AcquireQuantumInfo(image_info,image);
if (quantum_info == (QuantumInfo *) NULL)
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
for (y=0; y < (ssize_t) image->rows; y++)
{
+ const unsigned char
+ *pixels;
+
MagickBooleanType
sync;
register const unsigned char
- *restrict p;
+ *magick_restrict p;
register ssize_t
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
ssize_t
count,
offset;
- unsigned char
- *pixels;
-
- if (status == MagickFalse)
- continue;
- pixels=GetQuantumPixels(quantum_info);
- {
- count=ReadBlob(image,extent,pixels);
- if ((image->progress_monitor != (MagickProgressMonitor) NULL) &&
- (image->previous == (Image *) NULL))
- {
- MagickBooleanType
- proceed;
-
- proceed=SetImageProgress(image,LoadImageTag,(MagickOffsetType)
- row,image->rows);
- if (proceed == MagickFalse)
- status=MagickFalse;
- }
- offset=row++;
- }
+ pixels=(unsigned char *) ReadBlobStream(image,extent,
+ GetQuantumPixels(quantum_info),&count);
if (count != (ssize_t) extent)
- status=MagickFalse;
+ break;
+ if ((image->progress_monitor != (MagickProgressMonitor) NULL) &&
+ (image->previous == (Image *) NULL))
+ {
+ MagickBooleanType
+ proceed;
+
+ proceed=SetImageProgress(image,LoadImageTag,(MagickOffsetType)
+ row,image->rows);
+ if (proceed == MagickFalse)
+ break;
+ }
+ offset=row++;
q=QueueAuthenticPixels(image,0,offset,image->columns,1,exception);
if (q == (Quantum *) NULL)
+ break;
+ p=pixels;
+ switch (image->depth)
+ {
+ case 8:
+ case 16:
+ case 32:
{
- status=MagickFalse;
- continue;
+ (void) ImportQuantumPixels(image,(CacheView *) NULL,quantum_info,
+ quantum_type,pixels,exception);
+ break;
}
- p=pixels;
- if ((image->depth == 8) || (image->depth == 16))
- (void) ImportQuantumPixels(image,(CacheView *) NULL,quantum_info,
- quantum_type,pixels,exception);
- else
- if (image->depth <= 8)
- {
- unsigned char
- pixel;
+ default:
+ {
+ unsigned int
+ pixel;
- for (x=0; x < (ssize_t) image->columns; x++)
+ if (image->depth <= 8)
{
- p=PushCharPixel(p,&pixel);
- SetPixelGray(image,ScaleAnyToQuantum(pixel,max_value),q);
- q+=GetPixelChannels(image);
- }
- }
- else
- {
- unsigned short
- pixel;
+ unsigned char
+ pixel;
- for (x=0; x < (ssize_t) image->columns; x++)
+ for (x=0; x < (ssize_t) image->columns; x++)
+ {
+ p=PushCharPixel(p,&pixel);
+ SetPixelGray(image,ScaleAnyToQuantum(pixel,max_value),q);
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ if (image->depth <= 16)
{
- p=PushShortPixel(MSBEndian,p,&pixel);
- SetPixelGray(image,ScaleAnyToQuantum(pixel,max_value),q);
- q+=GetPixelChannels(image);
+ unsigned short
+ pixel;
+
+ for (x=0; x < (ssize_t) image->columns; x++)
+ {
+ p=PushShortPixel(MSBEndian,p,&pixel);
+ SetPixelGray(image,ScaleAnyToQuantum(pixel,max_value),q);
+ q+=GetPixelChannels(image);
+ }
+ break;
}
+ for (x=0; x < (ssize_t) image->columns; x++)
+ {
+ p=PushLongPixel(MSBEndian,p,&pixel);
+ SetPixelGray(image,ScaleAnyToQuantum(pixel,max_value),q);
+ q+=GetPixelChannels(image);
}
+ break;
+ }
+ }
sync=SyncAuthenticPixels(image,exception);
if (sync == MagickFalse)
- status=MagickFalse;
+ break;
}
quantum_info=DestroyQuantumInfo(quantum_info);
- if (status == MagickFalse)
- ThrowReaderException(CorruptImageError,"UnableToReadImageData");
SetQuantumImageType(image,quantum_type);
break;
}
(void) SetQuantumEndian(image,quantum_info,MSBEndian);
for (y=0; y < (ssize_t) image->rows; y++)
{
+ const unsigned char
+ *pixels;
+
MagickBooleanType
sync;
register const unsigned char
- *restrict p;
+ *magick_restrict p;
register ssize_t
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
ssize_t
count,
offset;
- unsigned char
- *pixels;
-
- if (status == MagickFalse)
- continue;
- pixels=GetQuantumPixels(quantum_info);
- {
- count=ReadBlob(image,extent,pixels);
- if ((image->progress_monitor != (MagickProgressMonitor) NULL) &&
- (image->previous == (Image *) NULL))
- {
- MagickBooleanType
- proceed;
-
- proceed=SetImageProgress(image,LoadImageTag,(MagickOffsetType)
- row,image->rows);
- if (proceed == MagickFalse)
- status=MagickFalse;
- }
- offset=row++;
- }
+ pixels=(unsigned char *) ReadBlobStream(image,extent,
+ GetQuantumPixels(quantum_info),&count);
if (count != (ssize_t) extent)
- status=MagickFalse;
- q=QueueAuthenticPixels(image,0,offset,image->columns,1,exception);
- if (q == (Quantum *) NULL)
+ break;
+ if ((image->progress_monitor != (MagickProgressMonitor) NULL) &&
+ (image->previous == (Image *) NULL))
{
- status=MagickFalse;
- continue;
+ MagickBooleanType
+ proceed;
+
+ proceed=SetImageProgress(image,LoadImageTag,(MagickOffsetType)
+ row,image->rows);
+ if (proceed == MagickFalse)
+ break;
}
+ offset=row++;
+ q=QueueAuthenticPixels(image,0,offset,image->columns,1,exception);
+ if (q == (Quantum *) NULL)
+ break;
p=pixels;
- if (image->depth == 8)
- for (x=0; x < (ssize_t) image->columns; x++)
+ switch (image->depth)
+ {
+ case 8:
{
- SetPixelRed(image,ScaleCharToQuantum(*p++),q);
- SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
- SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
- SetPixelAlpha(image,OpaqueAlpha,q);
- q+=GetPixelChannels(image);
+ for (x=0; x < (ssize_t) image->columns; x++)
+ {
+ SetPixelRed(image,ScaleCharToQuantum(*p++),q);
+ SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
+ SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
+ SetPixelAlpha(image,OpaqueAlpha,q);
+ q+=GetPixelChannels(image);
+ }
+ break;
}
- else
- if (image->depth == 16)
+ case 16:
+ {
+ unsigned short
+ pixel;
+
+ for (x=0; x < (ssize_t) image->columns; x++)
{
- unsigned short
- pixel;
+ p=PushShortPixel(MSBEndian,p,&pixel);
+ SetPixelRed(image,ScaleShortToQuantum(pixel),q);
+ p=PushShortPixel(MSBEndian,p,&pixel);
+ SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
+ p=PushShortPixel(MSBEndian,p,&pixel);
+ SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
+ SetPixelAlpha(image,OpaqueAlpha,q);
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 32:
+ {
+ unsigned int
+ pixel;
- for (x=0; x < (ssize_t) image->columns; x++)
- {
- p=PushShortPixel(MSBEndian,p,&pixel);
- SetPixelRed(image,ScaleShortToQuantum(pixel),q);
- p=PushShortPixel(MSBEndian,p,&pixel);
- SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
- p=PushShortPixel(MSBEndian,p,&pixel);
- SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
- SetPixelAlpha(image,OpaqueAlpha,q);
- q+=GetPixelChannels(image);
- }
+ for (x=0; x < (ssize_t) image->columns; x++)
+ {
+ p=PushLongPixel(MSBEndian,p,&pixel);
+ SetPixelRed(image,ScaleLongToQuantum(pixel),q);
+ p=PushLongPixel(MSBEndian,p,&pixel);
+ SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
+ p=PushLongPixel(MSBEndian,p,&pixel);
+ SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
+ SetPixelAlpha(image,OpaqueAlpha,q);
+ q+=GetPixelChannels(image);
}
- else
+ break;
+ }
+ default:
+ {
+ unsigned int
+ pixel;
+
if (image->depth <= 8)
{
unsigned char
SetPixelAlpha(image,OpaqueAlpha,q);
q+=GetPixelChannels(image);
}
+ break;
}
- else
+ if (image->depth <= 16)
{
unsigned short
pixel;
SetPixelAlpha(image,OpaqueAlpha,q);
q+=GetPixelChannels(image);
}
+ break;
}
+ for (x=0; x < (ssize_t) image->columns; x++)
+ {
+ p=PushLongPixel(MSBEndian,p,&pixel);
+ SetPixelRed(image,ScaleAnyToQuantum(pixel,max_value),q);
+ p=PushLongPixel(MSBEndian,p,&pixel);
+ SetPixelGreen(image,ScaleAnyToQuantum(pixel,max_value),q);
+ p=PushLongPixel(MSBEndian,p,&pixel);
+ SetPixelBlue(image,ScaleAnyToQuantum(pixel,max_value),q);
+ SetPixelAlpha(image,OpaqueAlpha,q);
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ }
sync=SyncAuthenticPixels(image,exception);
if (sync == MagickFalse)
- status=MagickFalse;
+ break;
}
quantum_info=DestroyQuantumInfo(quantum_info);
- if (status == MagickFalse)
- ThrowReaderException(CorruptImageError,"UnableToReadImageData");
break;
}
case '7':
break;
}
}
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
channels++;
- extent=channels*(image->depth <= 8 ? 1 : 2)*image->columns;
+ if (image->depth <= 8)
+ extent=channels*image->columns;
+ else
+ if (image->depth <= 16)
+ extent=2*channels*image->columns;
+ else
+ extent=4*channels*image->columns;
quantum_info=AcquireQuantumInfo(image_info,image);
if (quantum_info == (QuantumInfo *) NULL)
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
for (y=0; y < (ssize_t) image->rows; y++)
{
+ const unsigned char
+ *pixels;
+
MagickBooleanType
sync;
register const unsigned char
- *restrict p;
+ *magick_restrict p;
register ssize_t
x;
register Quantum
- *restrict q;
+ *magick_restrict q;
ssize_t
count,
offset;
- unsigned char
- *pixels;
-
- if (status == MagickFalse)
- continue;
- pixels=GetQuantumPixels(quantum_info);
- {
- count=ReadBlob(image,extent,pixels);
- if ((image->progress_monitor != (MagickProgressMonitor) NULL) &&
- (image->previous == (Image *) NULL))
- {
- MagickBooleanType
- proceed;
-
- proceed=SetImageProgress(image,LoadImageTag,(MagickOffsetType)
- row,image->rows);
- if (proceed == MagickFalse)
- status=MagickFalse;
- }
- offset=row++;
- }
+ pixels=(unsigned char *) ReadBlobStream(image,extent,
+ GetQuantumPixels(quantum_info),&count);
if (count != (ssize_t) extent)
- status=MagickFalse;
+ break;
+ if ((image->progress_monitor != (MagickProgressMonitor) NULL) &&
+ (image->previous == (Image *) NULL))
+ {
+ MagickBooleanType
+ proceed;
+
+ proceed=SetImageProgress(image,LoadImageTag,(MagickOffsetType)
+ row,image->rows);
+ if (proceed == MagickFalse)
+ break;
+ }
+ offset=row++;
q=QueueAuthenticPixels(image,0,offset,image->columns,1,exception);
if (q == (Quantum *) NULL)
+ break;
+ p=pixels;
+ switch (image->depth)
+ {
+ case 8:
+ case 16:
+ case 32:
{
- status=MagickFalse;
- continue;
+ (void) ImportQuantumPixels(image,(CacheView *) NULL,quantum_info,
+ quantum_type,pixels,exception);
+ break;
}
- p=pixels;
- if ((image->depth == 8) || (image->depth == 16))
- (void) ImportQuantumPixels(image,(CacheView *) NULL,quantum_info,
- quantum_type,pixels,exception);
- else
- switch (quantum_type)
+ default:
{
- case GrayQuantum:
- case GrayAlphaQuantum:
+ switch (quantum_type)
{
- if (image->depth <= 8)
- {
- unsigned char
- pixel;
+ case GrayQuantum:
+ case GrayAlphaQuantum:
+ {
+ unsigned int
+ pixel;
- for (x=0; x < (ssize_t) image->columns; x++)
+ if (image->depth <= 8)
{
- p=PushCharPixel(p,&pixel);
- SetPixelGray(image,ScaleAnyToQuantum(pixel,max_value),q);
- SetPixelAlpha(image,OpaqueAlpha,q);
- if (image->alpha_trait == BlendPixelTrait)
- {
- p=PushCharPixel(p,&pixel);
- SetPixelAlpha(image,ScaleAnyToQuantum(pixel,max_value),q);
- }
- q+=GetPixelChannels(image);
+ unsigned char
+ pixel;
+
+ for (x=0; x < (ssize_t) image->columns; x++)
+ {
+ p=PushCharPixel(p,&pixel);
+ SetPixelGray(image,ScaleAnyToQuantum(pixel,max_value),
+ q);
+ SetPixelAlpha(image,OpaqueAlpha,q);
+ if (image->alpha_trait != UndefinedPixelTrait)
+ {
+ p=PushCharPixel(p,&pixel);
+ if (image->depth != 1)
+ SetPixelAlpha(image,ScaleAnyToQuantum(pixel,
+ max_value),q);
+ else
+ SetPixelAlpha(image,QuantumRange-
+ ScaleAnyToQuantum(pixel,max_value),q);
+ }
+ q+=GetPixelChannels(image);
+ }
+ break;
}
- }
- else
- {
- unsigned short
- pixel;
-
- for (x=0; x < (ssize_t) image->columns; x++)
+ if (image->depth <= 16)
{
- p=PushShortPixel(MSBEndian,p,&pixel);
- SetPixelGray(image,ScaleAnyToQuantum(pixel,max_value),q);
- SetPixelAlpha(image,OpaqueAlpha,q);
- if (image->alpha_trait == BlendPixelTrait)
- {
- p=PushShortPixel(MSBEndian,p,&pixel);
- SetPixelAlpha(image,ScaleAnyToQuantum(pixel,max_value),q);
- }
- q+=GetPixelChannels(image);
+ unsigned short
+ pixel;
+
+ for (x=0; x < (ssize_t) image->columns; x++)
+ {
+ p=PushShortPixel(MSBEndian,p,&pixel);
+ SetPixelGray(image,ScaleAnyToQuantum(pixel,max_value),
+ q);
+ SetPixelAlpha(image,OpaqueAlpha,q);
+ if (image->alpha_trait != UndefinedPixelTrait)
+ {
+ p=PushShortPixel(MSBEndian,p,&pixel);
+ SetPixelAlpha(image,ScaleAnyToQuantum(pixel,
+ max_value),q);
+ }
+ q+=GetPixelChannels(image);
+ }
+ break;
}
- }
- break;
- }
- case CMYKQuantum:
- case CMYKAQuantum:
- {
- if (image->depth <= 8)
+ for (x=0; x < (ssize_t) image->columns; x++)
{
- unsigned char
- pixel;
+ p=PushLongPixel(MSBEndian,p,&pixel);
+ SetPixelGray(image,ScaleAnyToQuantum(pixel,max_value),q);
+ SetPixelAlpha(image,OpaqueAlpha,q);
+ if (image->alpha_trait != UndefinedPixelTrait)
+ {
+ p=PushLongPixel(MSBEndian,p,&pixel);
+ SetPixelAlpha(image,ScaleAnyToQuantum(pixel,max_value),
+ q);
+ }
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case CMYKQuantum:
+ case CMYKAQuantum:
+ {
+ unsigned int
+ pixel;
- for (x=0; x < (ssize_t) image->columns; x++)
+ if (image->depth <= 8)
{
- p=PushCharPixel(p,&pixel);
- SetPixelRed(image,ScaleAnyToQuantum(pixel,max_value),q);
- p=PushCharPixel(p,&pixel);
- SetPixelGreen(image,ScaleAnyToQuantum(pixel,max_value),q);
- p=PushCharPixel(p,&pixel);
- SetPixelBlue(image,ScaleAnyToQuantum(pixel,max_value),q);
- p=PushCharPixel(p,&pixel);
- SetPixelBlack(image,ScaleAnyToQuantum(pixel,max_value),q);
- SetPixelAlpha(image,OpaqueAlpha,q);
- if (image->alpha_trait == BlendPixelTrait)
- {
- p=PushCharPixel(p,&pixel);
- SetPixelAlpha(image,ScaleAnyToQuantum(pixel,max_value),q);
- }
- q+=GetPixelChannels(image);
+ unsigned char
+ pixel;
+
+ for (x=0; x < (ssize_t) image->columns; x++)
+ {
+ p=PushCharPixel(p,&pixel);
+ SetPixelRed(image,ScaleAnyToQuantum(pixel,max_value),q);
+ p=PushCharPixel(p,&pixel);
+ SetPixelGreen(image,ScaleAnyToQuantum(pixel,max_value),
+ q);
+ p=PushCharPixel(p,&pixel);
+ SetPixelBlue(image,ScaleAnyToQuantum(pixel,max_value),
+ q);
+ p=PushCharPixel(p,&pixel);
+ SetPixelBlack(image,ScaleAnyToQuantum(pixel,max_value),
+ q);
+ SetPixelAlpha(image,OpaqueAlpha,q);
+ if (image->alpha_trait != UndefinedPixelTrait)
+ {
+ p=PushCharPixel(p,&pixel);
+ SetPixelAlpha(image,ScaleAnyToQuantum(pixel,
+ max_value),q);
+ }
+ q+=GetPixelChannels(image);
+ }
+ break;
}
- }
- else
- {
- unsigned short
- pixel;
-
- for (x=0; x < (ssize_t) image->columns; x++)
+ if (image->depth <= 16)
{
- p=PushShortPixel(MSBEndian,p,&pixel);
- SetPixelRed(image,ScaleAnyToQuantum(pixel,max_value),q);
- p=PushShortPixel(MSBEndian,p,&pixel);
- SetPixelGreen(image,ScaleAnyToQuantum(pixel,max_value),q);
- p=PushShortPixel(MSBEndian,p,&pixel);
- SetPixelBlue(image,ScaleAnyToQuantum(pixel,max_value),q);
- p=PushShortPixel(MSBEndian,p,&pixel);
- SetPixelBlack(image,ScaleAnyToQuantum(pixel,max_value),q);
- SetPixelAlpha(image,OpaqueAlpha,q);
- if (image->alpha_trait == BlendPixelTrait)
- {
- p=PushShortPixel(MSBEndian,p,&pixel);
- SetPixelAlpha(image,ScaleAnyToQuantum(pixel,max_value),q);
- }
- q+=GetPixelChannels(image);
+ unsigned short
+ pixel;
+
+ for (x=0; x < (ssize_t) image->columns; x++)
+ {
+ p=PushShortPixel(MSBEndian,p,&pixel);
+ SetPixelRed(image,ScaleAnyToQuantum(pixel,max_value),q);
+ p=PushShortPixel(MSBEndian,p,&pixel);
+ SetPixelGreen(image,ScaleAnyToQuantum(pixel,max_value),
+ q);
+ p=PushShortPixel(MSBEndian,p,&pixel);
+ SetPixelBlue(image,ScaleAnyToQuantum(pixel,max_value),
+ q);
+ p=PushShortPixel(MSBEndian,p,&pixel);
+ SetPixelBlack(image,ScaleAnyToQuantum(pixel,max_value),
+ q);
+ SetPixelAlpha(image,OpaqueAlpha,q);
+ if (image->alpha_trait != UndefinedPixelTrait)
+ {
+ p=PushShortPixel(MSBEndian,p,&pixel);
+ SetPixelAlpha(image,ScaleAnyToQuantum(pixel,
+ max_value),q);
+ }
+ q+=GetPixelChannels(image);
+ }
}
- }
- break;
- }
- default:
- {
- if (image->depth <= 8)
+ for (x=0; x < (ssize_t) image->columns; x++)
{
- unsigned char
- pixel;
+ p=PushLongPixel(MSBEndian,p,&pixel);
+ SetPixelRed(image,ScaleAnyToQuantum(pixel,max_value),q);
+ p=PushLongPixel(MSBEndian,p,&pixel);
+ SetPixelGreen(image,ScaleAnyToQuantum(pixel,max_value),q);
+ p=PushLongPixel(MSBEndian,p,&pixel);
+ SetPixelBlue(image,ScaleAnyToQuantum(pixel,max_value),q);
+ p=PushLongPixel(MSBEndian,p,&pixel);
+ SetPixelBlack(image,ScaleAnyToQuantum(pixel,max_value),q);
+ SetPixelAlpha(image,OpaqueAlpha,q);
+ if (image->alpha_trait != UndefinedPixelTrait)
+ {
+ p=PushLongPixel(MSBEndian,p,&pixel);
+ SetPixelAlpha(image,ScaleAnyToQuantum(pixel,max_value),
+ q);
+ }
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ default:
+ {
+ unsigned int
+ pixel;
- for (x=0; x < (ssize_t) image->columns; x++)
+ if (image->depth <= 8)
{
- p=PushCharPixel(p,&pixel);
- SetPixelRed(image,ScaleAnyToQuantum(pixel,max_value),q);
- p=PushCharPixel(p,&pixel);
- SetPixelGreen(image,ScaleAnyToQuantum(pixel,max_value),q);
- p=PushCharPixel(p,&pixel);
- SetPixelBlue(image,ScaleAnyToQuantum(pixel,max_value),q);
- SetPixelAlpha(image,OpaqueAlpha,q);
- if (image->alpha_trait == BlendPixelTrait)
- {
- p=PushCharPixel(p,&pixel);
- SetPixelAlpha(image,ScaleAnyToQuantum(pixel,max_value),q);
- }
- q+=GetPixelChannels(image);
+ unsigned char
+ pixel;
+
+ for (x=0; x < (ssize_t) image->columns; x++)
+ {
+ p=PushCharPixel(p,&pixel);
+ SetPixelRed(image,ScaleAnyToQuantum(pixel,max_value),q);
+ p=PushCharPixel(p,&pixel);
+ SetPixelGreen(image,ScaleAnyToQuantum(pixel,max_value),
+ q);
+ p=PushCharPixel(p,&pixel);
+ SetPixelBlue(image,ScaleAnyToQuantum(pixel,max_value),
+ q);
+ SetPixelAlpha(image,OpaqueAlpha,q);
+ if (image->alpha_trait != UndefinedPixelTrait)
+ {
+ p=PushCharPixel(p,&pixel);
+ SetPixelAlpha(image,ScaleAnyToQuantum(pixel,
+ max_value),q);
+ }
+ q+=GetPixelChannels(image);
+ }
+ break;
}
- }
- else
- {
- unsigned short
- pixel;
-
- for (x=0; x < (ssize_t) image->columns; x++)
+ if (image->depth <= 16)
{
- p=PushShortPixel(MSBEndian,p,&pixel);
- SetPixelRed(image,ScaleAnyToQuantum(pixel,max_value),q);
- p=PushShortPixel(MSBEndian,p,&pixel);
- SetPixelGreen(image,ScaleAnyToQuantum(pixel,max_value),q);
- p=PushShortPixel(MSBEndian,p,&pixel);
- SetPixelBlue(image,ScaleAnyToQuantum(pixel,max_value),q);
- SetPixelAlpha(image,OpaqueAlpha,q);
- if (image->alpha_trait == BlendPixelTrait)
- {
- p=PushShortPixel(MSBEndian,p,&pixel);
- SetPixelAlpha(image,ScaleAnyToQuantum(pixel,max_value),q);
- }
- q+=GetPixelChannels(image);
+ unsigned short
+ pixel;
+
+ for (x=0; x < (ssize_t) image->columns; x++)
+ {
+ p=PushShortPixel(MSBEndian,p,&pixel);
+ SetPixelRed(image,ScaleAnyToQuantum(pixel,max_value),q);
+ p=PushShortPixel(MSBEndian,p,&pixel);
+ SetPixelGreen(image,ScaleAnyToQuantum(pixel,max_value),
+ q);
+ p=PushShortPixel(MSBEndian,p,&pixel);
+ SetPixelBlue(image,ScaleAnyToQuantum(pixel,max_value),
+ q);
+ SetPixelAlpha(image,OpaqueAlpha,q);
+ if (image->alpha_trait != UndefinedPixelTrait)
+ {
+ p=PushShortPixel(MSBEndian,p,&pixel);
+ SetPixelAlpha(image,ScaleAnyToQuantum(pixel,
+ max_value),q);
+ }
+ q+=GetPixelChannels(image);
+ }
+ break;
}
+ for (x=0; x < (ssize_t) image->columns; x++)
+ {
+ p=PushLongPixel(MSBEndian,p,&pixel);
+ SetPixelRed(image,ScaleAnyToQuantum(pixel,max_value),q);
+ p=PushLongPixel(MSBEndian,p,&pixel);
+ SetPixelGreen(image,ScaleAnyToQuantum(pixel,max_value),q);
+ p=PushLongPixel(MSBEndian,p,&pixel);
+ SetPixelBlue(image,ScaleAnyToQuantum(pixel,max_value),q);
+ SetPixelAlpha(image,OpaqueAlpha,q);
+ if (image->alpha_trait != UndefinedPixelTrait)
+ {
+ p=PushLongPixel(MSBEndian,p,&pixel);
+ SetPixelAlpha(image,ScaleAnyToQuantum(pixel,max_value),
+ q);
+ }
+ q+=GetPixelChannels(image);
}
- break;
+ break;
+ }
}
}
+ }
sync=SyncAuthenticPixels(image,exception);
if (sync == MagickFalse)
- status=MagickFalse;
+ break;
}
quantum_info=DestroyQuantumInfo(quantum_info);
- if (status == MagickFalse)
- ThrowReaderException(CorruptImageError,"UnableToReadImageData");
SetQuantumImageType(image,quantum_type);
break;
}
extent=GetQuantumExtent(image,quantum_info,quantum_type);
for (y=0; y < (ssize_t) image->rows; y++)
{
+ const unsigned char
+ *pixels;
+
MagickBooleanType
sync;
register Quantum
- *restrict q;
+ *magick_restrict q;
ssize_t
count,
size_t
length;
- unsigned char
- *pixels;
-
- if (status == MagickFalse)
- continue;
- pixels=GetQuantumPixels(quantum_info);
- {
- count=ReadBlob(image,extent,pixels);
- if ((image->progress_monitor != (MagickProgressMonitor) NULL) &&
- (image->previous == (Image *) NULL))
- {
- MagickBooleanType
- proceed;
+ pixels=(unsigned char *) ReadBlobStream(image,extent,
+ GetQuantumPixels(quantum_info),&count);
+ if (count != (ssize_t) extent)
+ break;
+ if ((image->progress_monitor != (MagickProgressMonitor) NULL) &&
+ (image->previous == (Image *) NULL))
+ {
+ MagickBooleanType
+ proceed;
- proceed=SetImageProgress(image,LoadImageTag,(MagickOffsetType)
- row,image->rows);
- if (proceed == MagickFalse)
- status=MagickFalse;
- }
- offset=row++;
- }
- if ((size_t) count != extent)
- status=MagickFalse;
+ proceed=SetImageProgress(image,LoadImageTag,(MagickOffsetType)
+ row,image->rows);
+ if (proceed == MagickFalse)
+ break;
+ }
+ offset=row++;
q=QueueAuthenticPixels(image,0,(ssize_t) (image->rows-offset-1),
image->columns,1,exception);
if (q == (Quantum *) NULL)
- {
- status=MagickFalse;
- continue;
- }
+ break;
length=ImportQuantumPixels(image,(CacheView *) NULL,quantum_info,
quantum_type,pixels,exception);
if (length != extent)
- status=MagickFalse;
+ break;
sync=SyncAuthenticPixels(image,exception);
if (sync == MagickFalse)
- status=MagickFalse;
+ break;
}
quantum_info=DestroyQuantumInfo(quantum_info);
- if (status == MagickFalse)
- ThrowReaderException(CorruptImageError,"UnableToReadImageData");
SetQuantumImageType(image,quantum_type);
break;
}
default:
ThrowReaderException(CorruptImageError,"ImproperImageHeader");
}
+ if (y < (ssize_t) image->rows)
+ ThrowReaderException(CorruptImageError,"UnableToReadImageData");
if (EOFBlob(image) != MagickFalse)
{
(void) ThrowMagickException(exception,GetMagickModule(),
Skip to end of line.
*/
count=ReadBlob(image,1,(unsigned char *) &format);
- if (count == 0)
+ if (count != 1)
break;
- if ((count != 0) && (format == 'P'))
+ if (format == 'P')
break;
} while (format != '\n');
count=ReadBlob(image,1,(unsigned char *) &format);
MagickInfo
*entry;
- entry=SetMagickInfo("PAM");
+ entry=AcquireMagickInfo("PNM","PAM","Common 2-dimensional bitmap format");
entry->decoder=(DecodeImageHandler *) ReadPNMImage;
entry->encoder=(EncodeImageHandler *) WritePNMImage;
- entry->description=ConstantString("Common 2-dimensional bitmap format");
entry->mime_type=ConstantString("image/x-portable-pixmap");
- entry->module=ConstantString("PNM");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("PBM");
+ entry=AcquireMagickInfo("PNM","PBM",
+ "Portable bitmap format (black and white)");
entry->decoder=(DecodeImageHandler *) ReadPNMImage;
entry->encoder=(EncodeImageHandler *) WritePNMImage;
- entry->description=ConstantString("Portable bitmap format (black and white)");
entry->mime_type=ConstantString("image/x-portable-bitmap");
- entry->module=ConstantString("PNM");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("PFM");
+ entry=AcquireMagickInfo("PNM","PFM","Portable float format");
entry->decoder=(DecodeImageHandler *) ReadPNMImage;
entry->encoder=(EncodeImageHandler *) WritePNMImage;
- entry->endian_support=MagickTrue;
- entry->description=ConstantString("Portable float format");
- entry->module=ConstantString("PFM");
+ entry->flags|=CoderEndianSupportFlag;
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("PGM");
+ entry=AcquireMagickInfo("PNM","PGM","Portable graymap format (gray scale)");
entry->decoder=(DecodeImageHandler *) ReadPNMImage;
entry->encoder=(EncodeImageHandler *) WritePNMImage;
- entry->description=ConstantString("Portable graymap format (gray scale)");
entry->mime_type=ConstantString("image/x-portable-greymap");
- entry->module=ConstantString("PNM");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("PNM");
+ entry=AcquireMagickInfo("PNM","PNM","Portable anymap");
entry->decoder=(DecodeImageHandler *) ReadPNMImage;
entry->encoder=(EncodeImageHandler *) WritePNMImage;
entry->magick=(IsImageFormatHandler *) IsPNM;
- entry->description=ConstantString("Portable anymap");
entry->mime_type=ConstantString("image/x-portable-pixmap");
- entry->module=ConstantString("PNM");
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("PPM");
+ entry=AcquireMagickInfo("PNM","PPM","Portable pixmap format (color)");
entry->decoder=(DecodeImageHandler *) ReadPNMImage;
entry->encoder=(EncodeImageHandler *) WritePNMImage;
- entry->description=ConstantString("Portable pixmap format (color)");
entry->mime_type=ConstantString("image/x-portable-pixmap");
- entry->module=ConstantString("PNM");
(void) RegisterMagickInfo(entry);
return(MagickImageCoderSignature);
}
ExceptionInfo *exception)
{
char
- buffer[MaxTextExtent],
+ buffer[MagickPathExtent],
format,
- magick[MaxTextExtent];
+ magick[MagickPathExtent];
const char
*value;
Open output image file.
*/
assert(image_info != (const ImageInfo *) NULL);
- assert(image_info->signature == MagickSignature);
+ assert(image_info->signature == MagickCoreSignature);
assert(image != (Image *) NULL);
- assert(image->signature == MagickSignature);
+ assert(image->signature == MagickCoreSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
assert(exception != (ExceptionInfo *) NULL);
- assert(exception->signature == MagickSignature);
+ assert(exception->signature == MagickCoreSignature);
status=OpenBlob(image_info,image,WriteBinaryBlobMode,exception);
if (status == MagickFalse)
return(status);
*/
packet_size=3;
quantum_type=RGBQuantum;
- (void) CopyMagickString(magick,image_info->magick,MaxTextExtent);
+ (void) CopyMagickString(magick,image_info->magick,MagickPathExtent);
max_value=GetQuantumRange(image->depth);
switch (magick[1])
{
case 'f':
{
format='F';
- if (IsImageGray(image,exception) != MagickFalse)
+ if (SetImageGray(image,exception) != MagickFalse)
format='f';
break;
}
case 'n':
{
if ((image_info->type != TrueColorType) &&
- (IsImageGray(image,exception) != MagickFalse))
+ (SetImageGray(image,exception) != MagickFalse))
{
format='5';
if (image_info->compression == NoCompression)
format='2';
- if (IsImageMonochrome(image,exception) != MagickFalse)
+ if (SetImageMonochrome(image,exception) != MagickFalse)
{
format='4';
if (image_info->compression == NoCompression)
break;
}
}
- (void) FormatLocaleString(buffer,MaxTextExtent,"P%c\n",format);
+ (void) FormatLocaleString(buffer,MagickPathExtent,"P%c\n",format);
(void) WriteBlobString(image,buffer);
value=GetImageProperty(image,"comment",exception);
if (value != (const char *) NULL)
}
if (format != '7')
{
- (void) FormatLocaleString(buffer,MaxTextExtent,"%.20g %.20g\n",
+ (void) FormatLocaleString(buffer,MagickPathExtent,"%.20g %.20g\n",
(double) image->columns,(double) image->rows);
(void) WriteBlobString(image,buffer);
}
else
{
char
- type[MaxTextExtent];
+ type[MagickPathExtent];
/*
PAM header.
*/
- (void) FormatLocaleString(buffer,MaxTextExtent,
+ (void) FormatLocaleString(buffer,MagickPathExtent,
"WIDTH %.20g\nHEIGHT %.20g\n",(double) image->columns,(double)
image->rows);
(void) WriteBlobString(image,buffer);
case CMYKAQuantum:
{
packet_size=4;
- (void) CopyMagickString(type,"CMYK",MaxTextExtent);
+ (void) CopyMagickString(type,"CMYK",MagickPathExtent);
break;
}
case GrayQuantum:
case GrayAlphaQuantum:
{
packet_size=1;
- (void) CopyMagickString(type,"GRAYSCALE",MaxTextExtent);
+ (void) CopyMagickString(type,"GRAYSCALE",MagickPathExtent);
+ if (IsImageMonochrome(image) != MagickFalse)
+ (void) CopyMagickString(type,"BLACKANDWHITE",MagickPathExtent);
break;
}
default:
{
quantum_type=RGBQuantum;
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
quantum_type=RGBAQuantum;
packet_size=3;
- (void) CopyMagickString(type,"RGB",MaxTextExtent);
+ (void) CopyMagickString(type,"RGB",MagickPathExtent);
break;
}
}
- if (image->alpha_trait == BlendPixelTrait)
+ if (image->alpha_trait != UndefinedPixelTrait)
{
packet_size++;
- (void) ConcatenateMagickString(type,"_ALPHA",MaxTextExtent);
+ (void) ConcatenateMagickString(type,"_ALPHA",MagickPathExtent);
}
- if (image->depth > 16)
- image->depth=16;
- (void) FormatLocaleString(buffer,MaxTextExtent,
+ if (image->depth > 32)
+ image->depth=32;
+ (void) FormatLocaleString(buffer,MagickPathExtent,
"DEPTH %.20g\nMAXVAL %.20g\n",(double) packet_size,(double)
((MagickOffsetType) GetQuantumRange(image->depth)));
(void) WriteBlobString(image,buffer);
- (void) FormatLocaleString(buffer,MaxTextExtent,"TUPLTYPE %s\nENDHDR\n",
- type);
+ (void) FormatLocaleString(buffer,MagickPathExtent,
+ "TUPLTYPE %s\nENDHDR\n",type);
(void) WriteBlobString(image,buffer);
}
/*
/*
Convert image to a PBM image.
*/
+ (void) SetImageType(image,BilevelType,exception);
q=pixels;
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register ssize_t
x;
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
- pixel=ClampToQuantum(GetPixelLuma(image,p));
- *q++=(unsigned char) (pixel >= (Quantum) (QuantumRange/2) ?
+ *q++=(unsigned char) (GetPixelLuma(image,p) >= (QuantumRange/2.0) ?
'0' : '1');
*q++=' ';
- if ((q-pixels+2) >= 80)
+ if ((q-pixels+1) >= (ssize_t) sizeof(pixels))
{
*q++='\n';
(void) WriteBlob(image,q-pixels,pixels);
}
p+=GetPixelChannels(image);
}
+ *q++='\n';
+ (void) WriteBlob(image,q-pixels,pixels);
+ q=pixels;
if (image->previous == (Image *) NULL)
{
status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
if (image->depth <= 8)
(void) WriteBlobString(image,"255\n");
else
- (void) WriteBlobString(image,"65535\n");
+ if (image->depth <= 16)
+ (void) WriteBlobString(image,"65535\n");
+ else
+ (void) WriteBlobString(image,"4294967295\n");
q=pixels;
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register ssize_t
x;
{
index=ClampToQuantum(GetPixelLuma(image,p));
if (image->depth <= 8)
- count=(ssize_t) FormatLocaleString(buffer,MaxTextExtent,"%u ",
+ count=(ssize_t) FormatLocaleString(buffer,MagickPathExtent,"%u ",
ScaleQuantumToChar(index));
else
- count=(ssize_t) FormatLocaleString(buffer,MaxTextExtent,"%u ",
- ScaleQuantumToShort(index));
+ if (image->depth <= 16)
+ count=(ssize_t) FormatLocaleString(buffer,MagickPathExtent,
+ "%u ",ScaleQuantumToShort(index));
+ else
+ count=(ssize_t) FormatLocaleString(buffer,MagickPathExtent,
+ "%u ",ScaleQuantumToLong(index));
extent=(size_t) count;
(void) strncpy((char *) q,buffer,extent);
q+=extent;
- if ((q-pixels+extent) >= 80)
+ if ((q-pixels+extent+1) >= sizeof(pixels))
{
*q++='\n';
(void) WriteBlob(image,q-pixels,pixels);
}
p+=GetPixelChannels(image);
}
+ *q++='\n';
+ (void) WriteBlob(image,q-pixels,pixels);
+ q=pixels;
if (image->previous == (Image *) NULL)
{
status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
/*
Convert image to a PNM image.
*/
- if (IssRGBCompatibleColorspace(image->colorspace) == MagickFalse)
- (void) TransformImageColorspace(image,sRGBColorspace,exception);
+ (void) TransformImageColorspace(image,sRGBColorspace,exception);
if (image->depth <= 8)
(void) WriteBlobString(image,"255\n");
else
- (void) WriteBlobString(image,"65535\n");
+ if (image->depth <= 16)
+ (void) WriteBlobString(image,"65535\n");
+ else
+ (void) WriteBlobString(image,"4294967295\n");
q=pixels;
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register ssize_t
x;
for (x=0; x < (ssize_t) image->columns; x++)
{
if (image->depth <= 8)
- count=(ssize_t) FormatLocaleString(buffer,MaxTextExtent,
+ count=(ssize_t) FormatLocaleString(buffer,MagickPathExtent,
"%u %u %u ",ScaleQuantumToChar(GetPixelRed(image,p)),
ScaleQuantumToChar(GetPixelGreen(image,p)),
ScaleQuantumToChar(GetPixelBlue(image,p)));
else
- count=(ssize_t) FormatLocaleString(buffer,MaxTextExtent,
- "%u %u %u ",ScaleQuantumToShort(GetPixelRed(image,p)),
- ScaleQuantumToShort(GetPixelGreen(image,p)),
- ScaleQuantumToShort(GetPixelBlue(image,p)));
+ if (image->depth <= 16)
+ count=(ssize_t) FormatLocaleString(buffer,MagickPathExtent,
+ "%u %u %u ",ScaleQuantumToShort(GetPixelRed(image,p)),
+ ScaleQuantumToShort(GetPixelGreen(image,p)),
+ ScaleQuantumToShort(GetPixelBlue(image,p)));
+ else
+ count=(ssize_t) FormatLocaleString(buffer,MagickPathExtent,
+ "%u %u %u ",ScaleQuantumToLong(GetPixelRed(image,p)),
+ ScaleQuantumToLong(GetPixelGreen(image,p)),
+ ScaleQuantumToLong(GetPixelBlue(image,p)));
extent=(size_t) count;
(void) strncpy((char *) q,buffer,extent);
q+=extent;
- if ((q-pixels+extent) >= 80)
+ if ((q-pixels+extent+1) >= sizeof(pixels))
{
*q++='\n';
(void) WriteBlob(image,q-pixels,pixels);
}
p+=GetPixelChannels(image);
}
+ *q++='\n';
+ (void) WriteBlob(image,q-pixels,pixels);
+ q=pixels;
if (image->previous == (Image *) NULL)
{
status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
/*
Convert image to a PBM image.
*/
+ (void) SetImageType(image,BilevelType,exception);
image->depth=1;
- quantum_info=AcquireQuantumInfo((const ImageInfo *) NULL,image);
+ quantum_info=AcquireQuantumInfo(image_info,image);
if (quantum_info == (QuantumInfo *) NULL)
ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
+ (void) SetQuantumEndian(image,quantum_info,MSBEndian);
quantum_info->min_is_white=MagickTrue;
pixels=GetQuantumPixels(quantum_info);
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
p=GetVirtualPixels(image,0,y,image->columns,1,exception);
if (p == (const Quantum *) NULL)
/*
Convert image to a PGM image.
*/
- if (image->depth > 8)
- image->depth=16;
- (void) FormatLocaleString(buffer,MaxTextExtent,"%.20g\n",(double)
+ if (image->depth > 32)
+ image->depth=32;
+ (void) FormatLocaleString(buffer,MagickPathExtent,"%.20g\n",(double)
((MagickOffsetType) GetQuantumRange(image->depth)));
(void) WriteBlobString(image,buffer);
- quantum_info=AcquireQuantumInfo((const ImageInfo *) NULL,image);
+ quantum_info=AcquireQuantumInfo(image_info,image);
if (quantum_info == (QuantumInfo *) NULL)
ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
+ (void) SetQuantumEndian(image,quantum_info,MSBEndian);
quantum_info->min_is_white=MagickTrue;
pixels=GetQuantumPixels(quantum_info);
extent=GetQuantumExtent(image,quantum_info,GrayQuantum);
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register ssize_t
x;
if (p == (const Quantum *) NULL)
break;
q=pixels;
- if ((image->depth == 8) || (image->depth == 16))
- extent=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
- GrayQuantum,pixels,exception);
- else
+ switch (image->depth)
+ {
+ case 8:
+ case 16:
+ case 32:
+ {
+ extent=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
+ GrayQuantum,pixels,exception);
+ break;
+ }
+ default:
{
if (image->depth <= 8)
- for (x=0; x < (ssize_t) image->columns; x++)
{
- if (IsPixelGray(image,p) == MagickFalse)
- pixel=ScaleQuantumToAny(ClampToQuantum(GetPixelLuma(
- image,p)),max_value);
- else
- {
- if (image->depth == 8)
- pixel=ScaleQuantumToChar(GetPixelRed(image,p));
- else
- pixel=ScaleQuantumToAny(GetPixelRed(image,p),max_value);
- }
- q=PopCharPixel((unsigned char) pixel,q);
- p+=GetPixelChannels(image);
+ for (x=0; x < (ssize_t) image->columns; x++)
+ {
+ if (IsPixelGray(image,p) == MagickFalse)
+ pixel=ScaleQuantumToAny(ClampToQuantum(GetPixelLuma(
+ image,p)),max_value);
+ else
+ {
+ if (image->depth == 8)
+ pixel=ScaleQuantumToChar(GetPixelRed(image,p));
+ else
+ pixel=ScaleQuantumToAny(GetPixelRed(image,p),
+ max_value);
+ }
+ q=PopCharPixel((unsigned char) pixel,q);
+ p+=GetPixelChannels(image);
+ }
+ extent=(size_t) (q-pixels);
+ break;
}
- else
- for (x=0; x < (ssize_t) image->columns; x++)
+ if (image->depth <= 16)
{
- if (IsPixelGray(image,p) == MagickFalse)
- pixel=ScaleQuantumToAny(ClampToQuantum(GetPixelLuma(
- image,p)),max_value);
- else
- {
- if (image->depth == 16)
- pixel=ScaleQuantumToShort(GetPixelRed(image,p));
- else
- pixel=ScaleQuantumToAny(GetPixelRed(image,p),max_value);
- }
- q=PopShortPixel(MSBEndian,(unsigned short) pixel,q);
- p+=GetPixelChannels(image);
+ for (x=0; x < (ssize_t) image->columns; x++)
+ {
+ if (IsPixelGray(image,p) == MagickFalse)
+ pixel=ScaleQuantumToAny(ClampToQuantum(GetPixelLuma(image,
+ p)),max_value);
+ else
+ {
+ if (image->depth == 16)
+ pixel=ScaleQuantumToShort(GetPixelRed(image,p));
+ else
+ pixel=ScaleQuantumToAny(GetPixelRed(image,p),
+ max_value);
+ }
+ q=PopShortPixel(MSBEndian,(unsigned short) pixel,q);
+ p+=GetPixelChannels(image);
+ }
+ extent=(size_t) (q-pixels);
+ break;
}
+ for (x=0; x < (ssize_t) image->columns; x++)
+ {
+ if (IsPixelGray(image,p) == MagickFalse)
+ pixel=ScaleQuantumToAny(ClampToQuantum(GetPixelLuma(image,p)),
+ max_value);
+ else
+ {
+ if (image->depth == 16)
+ pixel=ScaleQuantumToLong(GetPixelRed(image,p));
+ else
+ pixel=ScaleQuantumToAny(GetPixelRed(image,p),max_value);
+ }
+ q=PopLongPixel(MSBEndian,(unsigned int) pixel,q);
+ p+=GetPixelChannels(image);
+ }
extent=(size_t) (q-pixels);
+ break;
}
+ }
count=WriteBlob(image,extent,pixels);
if (count != (ssize_t) extent)
break;
/*
Convert image to a PNM image.
*/
- if (IssRGBCompatibleColorspace(image->colorspace) == MagickFalse)
- (void) TransformImageColorspace(image,sRGBColorspace,exception);
- if (image->depth > 8)
- image->depth=16;
- (void) FormatLocaleString(buffer,MaxTextExtent,"%.20g\n",(double)
+ (void) TransformImageColorspace(image,sRGBColorspace,exception);
+ if (image->depth > 32)
+ image->depth=32;
+ (void) FormatLocaleString(buffer,MagickPathExtent,"%.20g\n",(double)
((MagickOffsetType) GetQuantumRange(image->depth)));
(void) WriteBlobString(image,buffer);
- quantum_info=AcquireQuantumInfo((const ImageInfo *) NULL,image);
+ quantum_info=AcquireQuantumInfo(image_info,image);
if (quantum_info == (QuantumInfo *) NULL)
ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
(void) SetQuantumEndian(image,quantum_info,MSBEndian);
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register ssize_t
x;
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,exception);
- else
+ switch (image->depth)
+ {
+ case 8:
+ case 16:
+ case 32:
+ {
+ extent=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
+ quantum_type,pixels,exception);
+ break;
+ }
+ default:
{
if (image->depth <= 8)
- for (x=0; x < (ssize_t) image->columns; x++)
{
- pixel=ScaleQuantumToAny(GetPixelRed(image,p),max_value);
- q=PopCharPixel((unsigned char) pixel,q);
- pixel=ScaleQuantumToAny(GetPixelGreen(image,p),max_value);
- q=PopCharPixel((unsigned char) pixel,q);
- pixel=ScaleQuantumToAny(GetPixelBlue(image,p),max_value);
- q=PopCharPixel((unsigned char) pixel,q);
- p+=GetPixelChannels(image);
+ for (x=0; x < (ssize_t) image->columns; x++)
+ {
+ pixel=ScaleQuantumToAny(GetPixelRed(image,p),max_value);
+ q=PopCharPixel((unsigned char) pixel,q);
+ pixel=ScaleQuantumToAny(GetPixelGreen(image,p),max_value);
+ q=PopCharPixel((unsigned char) pixel,q);
+ pixel=ScaleQuantumToAny(GetPixelBlue(image,p),max_value);
+ q=PopCharPixel((unsigned char) pixel,q);
+ p+=GetPixelChannels(image);
+ }
+ extent=(size_t) (q-pixels);
+ break;
}
- else
- for (x=0; x < (ssize_t) image->columns; x++)
+ if (image->depth <= 16)
{
- pixel=ScaleQuantumToAny(GetPixelRed(image,p),max_value);
- q=PopShortPixel(MSBEndian,(unsigned short) pixel,q);
- pixel=ScaleQuantumToAny(GetPixelGreen(image,p),max_value);
- q=PopShortPixel(MSBEndian,(unsigned short) pixel,q);
- pixel=ScaleQuantumToAny(GetPixelBlue(image,p),max_value);
- q=PopShortPixel(MSBEndian,(unsigned short) pixel,q);
- p+=GetPixelChannels(image);
+ for (x=0; x < (ssize_t) image->columns; x++)
+ {
+ pixel=ScaleQuantumToAny(GetPixelRed(image,p),max_value);
+ q=PopShortPixel(MSBEndian,(unsigned short) pixel,q);
+ pixel=ScaleQuantumToAny(GetPixelGreen(image,p),max_value);
+ q=PopShortPixel(MSBEndian,(unsigned short) pixel,q);
+ pixel=ScaleQuantumToAny(GetPixelBlue(image,p),max_value);
+ q=PopShortPixel(MSBEndian,(unsigned short) pixel,q);
+ p+=GetPixelChannels(image);
+ }
+ extent=(size_t) (q-pixels);
+ break;
}
+ for (x=0; x < (ssize_t) image->columns; x++)
+ {
+ pixel=ScaleQuantumToAny(GetPixelRed(image,p),max_value);
+ q=PopLongPixel(MSBEndian,(unsigned int) pixel,q);
+ pixel=ScaleQuantumToAny(GetPixelGreen(image,p),max_value);
+ q=PopLongPixel(MSBEndian,(unsigned int) pixel,q);
+ pixel=ScaleQuantumToAny(GetPixelBlue(image,p),max_value);
+ q=PopLongPixel(MSBEndian,(unsigned int) pixel,q);
+ p+=GetPixelChannels(image);
+ }
extent=(size_t) (q-pixels);
+ break;
}
+ }
count=WriteBlob(image,extent,pixels);
if (count != (ssize_t) extent)
break;
/*
Convert image to a PAM.
*/
- if (image->depth > 16)
- image->depth=16;
- quantum_info=AcquireQuantumInfo((const ImageInfo *) NULL,image);
+ if (image->depth > 32)
+ image->depth=32;
+ quantum_info=AcquireQuantumInfo(image_info,image);
+ if (quantum_info == (QuantumInfo *) NULL)
+ ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
+ (void) SetQuantumEndian(image,quantum_info,MSBEndian);
pixels=GetQuantumPixels(quantum_info);
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
register ssize_t
x;
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,exception);
- else
+ switch (image->depth)
+ {
+ case 8:
+ case 16:
+ case 32:
+ {
+ extent=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
+ quantum_type,pixels,exception);
+ break;
+ }
+ default:
{
switch (quantum_type)
{
case GrayAlphaQuantum:
{
if (image->depth <= 8)
- for (x=0; x < (ssize_t) image->columns; x++)
{
- pixel=ScaleQuantumToAny(ClampToQuantum(GetPixelLuma(
- image,p)),max_value);
- q=PopCharPixel((unsigned char) pixel,q);
- if (image->alpha_trait == BlendPixelTrait)
- {
- pixel=(unsigned char) ScaleQuantumToAny(
- GetPixelAlpha(image,p),max_value);
- q=PopCharPixel((unsigned char) pixel,q);
- }
- p+=GetPixelChannels(image);
+ for (x=0; x < (ssize_t) image->columns; x++)
+ {
+ pixel=ScaleQuantumToAny(ClampToQuantum(GetPixelLuma(
+ image,p)),max_value);
+ q=PopCharPixel((unsigned char) pixel,q);
+ if (image->alpha_trait != UndefinedPixelTrait)
+ {
+ pixel=(unsigned char) ScaleQuantumToAny(
+ GetPixelAlpha(image,p),max_value);
+ q=PopCharPixel((unsigned char) pixel,q);
+ }
+ p+=GetPixelChannels(image);
+ }
+ break;
}
- else
- for (x=0; x < (ssize_t) image->columns; x++)
+ if (image->depth <= 16)
{
- pixel=ScaleQuantumToAny(ClampToQuantum(GetPixelLuma(
- image,p)),max_value);
- q=PopShortPixel(MSBEndian,(unsigned short) pixel,q);
- if (image->alpha_trait == BlendPixelTrait)
- {
- pixel=(unsigned char) ScaleQuantumToAny(
- GetPixelAlpha(image,p),max_value);
- q=PopShortPixel(MSBEndian,(unsigned short) pixel,q);
- }
- p+=GetPixelChannels(image);
+ for (x=0; x < (ssize_t) image->columns; x++)
+ {
+ pixel=ScaleQuantumToAny(ClampToQuantum(GetPixelLuma(
+ image,p)),max_value);
+ q=PopShortPixel(MSBEndian,(unsigned short) pixel,q);
+ if (image->alpha_trait != UndefinedPixelTrait)
+ {
+ pixel=(unsigned char) ScaleQuantumToAny(
+ GetPixelAlpha(image,p),max_value);
+ q=PopShortPixel(MSBEndian,(unsigned short) pixel,q);
+ }
+ p+=GetPixelChannels(image);
+ }
+ break;
}
+ for (x=0; x < (ssize_t) image->columns; x++)
+ {
+ pixel=ScaleQuantumToAny(ClampToQuantum(GetPixelLuma(image,
+ p)),max_value);
+ q=PopLongPixel(MSBEndian,(unsigned int) pixel,q);
+ if (image->alpha_trait != UndefinedPixelTrait)
+ {
+ pixel=(unsigned char) ScaleQuantumToAny(
+ GetPixelAlpha(image,p),max_value);
+ q=PopLongPixel(MSBEndian,(unsigned int) pixel,q);
+ }
+ p+=GetPixelChannels(image);
+ }
break;
}
case CMYKQuantum:
case CMYKAQuantum:
{
if (image->depth <= 8)
- for (x=0; x < (ssize_t) image->columns; x++)
{
- pixel=ScaleQuantumToAny(GetPixelRed(image,p),max_value);
- q=PopCharPixel((unsigned char) pixel,q);
- pixel=ScaleQuantumToAny(GetPixelGreen(image,p),max_value);
- q=PopCharPixel((unsigned char) pixel,q);
- pixel=ScaleQuantumToAny(GetPixelBlue(image,p),max_value);
- q=PopCharPixel((unsigned char) pixel,q);
- pixel=ScaleQuantumToAny(GetPixelBlack(image,p),max_value);
- q=PopCharPixel((unsigned char) pixel,q);
- if (image->alpha_trait == BlendPixelTrait)
- {
- pixel=ScaleQuantumToAny(GetPixelAlpha(image,p),
- max_value);
- q=PopCharPixel((unsigned char) pixel,q);
- }
- p+=GetPixelChannels(image);
+ for (x=0; x < (ssize_t) image->columns; x++)
+ {
+ pixel=ScaleQuantumToAny(GetPixelRed(image,p),max_value);
+ q=PopCharPixel((unsigned char) pixel,q);
+ pixel=ScaleQuantumToAny(GetPixelGreen(image,p),
+ max_value);
+ q=PopCharPixel((unsigned char) pixel,q);
+ pixel=ScaleQuantumToAny(GetPixelBlue(image,p),
+ max_value);
+ q=PopCharPixel((unsigned char) pixel,q);
+ pixel=ScaleQuantumToAny(GetPixelBlack(image,p),
+ max_value);
+ q=PopCharPixel((unsigned char) pixel,q);
+ if (image->alpha_trait != UndefinedPixelTrait)
+ {
+ pixel=ScaleQuantumToAny(GetPixelAlpha(image,p),
+ max_value);
+ q=PopCharPixel((unsigned char) pixel,q);
+ }
+ p+=GetPixelChannels(image);
+ }
+ break;
}
- else
- for (x=0; x < (ssize_t) image->columns; x++)
+ if (image->depth <= 16)
{
- pixel=ScaleQuantumToAny(GetPixelRed(image,p),max_value);
- q=PopShortPixel(MSBEndian,(unsigned short) pixel,q);
- pixel=ScaleQuantumToAny(GetPixelGreen(image,p),max_value);
- q=PopShortPixel(MSBEndian,(unsigned short) pixel,q);
- pixel=ScaleQuantumToAny(GetPixelBlue(image,p),max_value);
- q=PopShortPixel(MSBEndian,(unsigned short) pixel,q);
- pixel=ScaleQuantumToAny(GetPixelBlack(image,p),max_value);
- q=PopShortPixel(MSBEndian,(unsigned short) pixel,q);
- if (image->alpha_trait == BlendPixelTrait)
- {
- pixel=ScaleQuantumToAny(GetPixelAlpha(image,p),
- max_value);
- q=PopShortPixel(MSBEndian,(unsigned short) pixel,q);
- }
- p+=GetPixelChannels(image);
+ for (x=0; x < (ssize_t) image->columns; x++)
+ {
+ pixel=ScaleQuantumToAny(GetPixelRed(image,p),max_value);
+ q=PopShortPixel(MSBEndian,(unsigned short) pixel,q);
+ pixel=ScaleQuantumToAny(GetPixelGreen(image,p),
+ max_value);
+ q=PopShortPixel(MSBEndian,(unsigned short) pixel,q);
+ pixel=ScaleQuantumToAny(GetPixelBlue(image,p),
+ max_value);
+ q=PopShortPixel(MSBEndian,(unsigned short) pixel,q);
+ pixel=ScaleQuantumToAny(GetPixelBlack(image,p),
+ max_value);
+ q=PopShortPixel(MSBEndian,(unsigned short) pixel,q);
+ if (image->alpha_trait != UndefinedPixelTrait)
+ {
+ pixel=ScaleQuantumToAny(GetPixelAlpha(image,p),
+ max_value);
+ q=PopShortPixel(MSBEndian,(unsigned short) pixel,q);
+ }
+ p+=GetPixelChannels(image);
+ }
+ break;
}
+ for (x=0; x < (ssize_t) image->columns; x++)
+ {
+ pixel=ScaleQuantumToAny(GetPixelRed(image,p),max_value);
+ q=PopLongPixel(MSBEndian,(unsigned int) pixel,q);
+ pixel=ScaleQuantumToAny(GetPixelGreen(image,p),max_value);
+ q=PopLongPixel(MSBEndian,(unsigned int) pixel,q);
+ pixel=ScaleQuantumToAny(GetPixelBlue(image,p),max_value);
+ q=PopLongPixel(MSBEndian,(unsigned int) pixel,q);
+ pixel=ScaleQuantumToAny(GetPixelBlack(image,p),max_value);
+ q=PopLongPixel(MSBEndian,(unsigned int) pixel,q);
+ if (image->alpha_trait != UndefinedPixelTrait)
+ {
+ pixel=ScaleQuantumToAny(GetPixelAlpha(image,p),
+ max_value);
+ q=PopLongPixel(MSBEndian,(unsigned int) pixel,q);
+ }
+ p+=GetPixelChannels(image);
+ }
break;
}
default:
{
if (image->depth <= 8)
- for (x=0; x < (ssize_t) image->columns; x++)
{
- pixel=ScaleQuantumToAny(GetPixelRed(image,p),max_value);
- q=PopCharPixel((unsigned char) pixel,q);
- pixel=ScaleQuantumToAny(GetPixelGreen(image,p),max_value);
- q=PopCharPixel((unsigned char) pixel,q);
- pixel=ScaleQuantumToAny(GetPixelBlue(image,p),max_value);
- q=PopCharPixel((unsigned char) pixel,q);
- if (image->alpha_trait == BlendPixelTrait)
- {
- pixel=ScaleQuantumToAny(GetPixelAlpha(image,p),
- max_value);
- q=PopCharPixel((unsigned char) pixel,q);
- }
- p+=GetPixelChannels(image);
+ for (x=0; x < (ssize_t) image->columns; x++)
+ {
+ pixel=ScaleQuantumToAny(GetPixelRed(image,p),max_value);
+ q=PopCharPixel((unsigned char) pixel,q);
+ pixel=ScaleQuantumToAny(GetPixelGreen(image,p),
+ max_value);
+ q=PopCharPixel((unsigned char) pixel,q);
+ pixel=ScaleQuantumToAny(GetPixelBlue(image,p),
+ max_value);
+ q=PopCharPixel((unsigned char) pixel,q);
+ if (image->alpha_trait != UndefinedPixelTrait)
+ {
+ pixel=ScaleQuantumToAny(GetPixelAlpha(image,p),
+ max_value);
+ q=PopCharPixel((unsigned char) pixel,q);
+ }
+ p+=GetPixelChannels(image);
+ }
+ break;
}
- else
- for (x=0; x < (ssize_t) image->columns; x++)
+ if (image->depth <= 16)
{
- pixel=ScaleQuantumToAny(GetPixelRed(image,p),max_value);
- q=PopShortPixel(MSBEndian,(unsigned short) pixel,q);
- pixel=ScaleQuantumToAny(GetPixelGreen(image,p),max_value);
- q=PopShortPixel(MSBEndian,(unsigned short) pixel,q);
- pixel=ScaleQuantumToAny(GetPixelBlue(image,p),max_value);
- q=PopShortPixel(MSBEndian,(unsigned short) pixel,q);
- if (image->alpha_trait == BlendPixelTrait)
- {
- pixel=ScaleQuantumToAny(GetPixelAlpha(image,p),
- max_value);
- q=PopShortPixel(MSBEndian,(unsigned short) pixel,q);
- }
- p+=GetPixelChannels(image);
+ for (x=0; x < (ssize_t) image->columns; x++)
+ {
+ pixel=ScaleQuantumToAny(GetPixelRed(image,p),max_value);
+ q=PopShortPixel(MSBEndian,(unsigned short) pixel,q);
+ pixel=ScaleQuantumToAny(GetPixelGreen(image,p),
+ max_value);
+ q=PopShortPixel(MSBEndian,(unsigned short) pixel,q);
+ pixel=ScaleQuantumToAny(GetPixelBlue(image,p),
+ max_value);
+ q=PopShortPixel(MSBEndian,(unsigned short) pixel,q);
+ if (image->alpha_trait != UndefinedPixelTrait)
+ {
+ pixel=ScaleQuantumToAny(GetPixelAlpha(image,p),
+ max_value);
+ q=PopShortPixel(MSBEndian,(unsigned short) pixel,q);
+ }
+ p+=GetPixelChannels(image);
+ }
+ break;
}
+ for (x=0; x < (ssize_t) image->columns; x++)
+ {
+ pixel=ScaleQuantumToAny(GetPixelRed(image,p),max_value);
+ q=PopLongPixel(MSBEndian,(unsigned int) pixel,q);
+ pixel=ScaleQuantumToAny(GetPixelGreen(image,p),max_value);
+ q=PopLongPixel(MSBEndian,(unsigned int) pixel,q);
+ pixel=ScaleQuantumToAny(GetPixelBlue(image,p),max_value);
+ q=PopLongPixel(MSBEndian,(unsigned int) pixel,q);
+ if (image->alpha_trait != UndefinedPixelTrait)
+ {
+ pixel=ScaleQuantumToAny(GetPixelAlpha(image,p),
+ max_value);
+ q=PopLongPixel(MSBEndian,(unsigned int) pixel,q);
+ }
+ p+=GetPixelChannels(image);
+ }
break;
}
}
extent=(size_t) (q-pixels);
+ break;
}
+ }
count=WriteBlob(image,extent,pixels);
if (count != (ssize_t) extent)
break;
"1.0\n");
image->depth=32;
quantum_type=format == 'f' ? GrayQuantum : RGBQuantum;
- quantum_info=AcquireQuantumInfo((const ImageInfo *) NULL,image);
+ quantum_info=AcquireQuantumInfo(image_info,image);
if (quantum_info == (QuantumInfo *) NULL)
ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
status=SetQuantumFormat(image,quantum_info,FloatingPointQuantumFormat);
for (y=(ssize_t) image->rows-1; y >= 0; y--)
{
register const Quantum
- *restrict p;
+ *magick_restrict p;
p=GetVirtualPixels(image,0,y,image->columns,1,exception);
if (p == (const Quantum *) NULL)
projects / imagemagick / blobdiff