% July 1992 %
% %
% %
-% Copyright 1999-2009 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 %
*canvas_image,
*image;
- long
- y;
-
MagickBooleanType
status;
QuantumType
quantum_type;
- register long
+ register ssize_t
i;
ssize_t
- count;
+ count,
+ y;
size_t
length;
image=DestroyImageList(image);
return((Image *) NULL);
}
- for (i=0; i < image->offset; i++)
- if (ReadBlobByte(image) == EOF)
- {
- ThrowFileException(exception,CorruptImageError,
- "UnexpectedEndOfFile",image->filename);
- break;
- }
+ if (DiscardBlobBytes(image,image->offset) == MagickFalse)
+ ThrowFileException(exception,CorruptImageError,"UnexpectedEndOfFile",
+ image->filename);
}
/*
Create virtual canvas to support cropping (i.e. image.cmyk[100x100+10+20]).
*/
image->scene++;
length=GetQuantumExtent(canvas_image,quantum_info,quantum_type);
- for (y=0; y < (long) image->rows; y++)
+ for (y=0; y < (ssize_t) image->rows; y++)
{
count=ReadBlob(image,length,pixels);
if (count != (ssize_t) length)
{
length=GetQuantumExtent(canvas_image,quantum_info,quantum_type);
count=ReadBlob(image,length,pixels);
- if (count != (ssize_t) length)
- break;
}
- for (y=0; y < (long) image->extract_info.height; y++)
+ for (y=0; y < (ssize_t) image->extract_info.height; y++)
{
register const IndexPacket
- *__restrict canvas_indexes;
+ *restrict canvas_indexes;
register const PixelPacket
- *__restrict p;
+ *restrict p;
register IndexPacket
- *__restrict indexes;
-
- register long
- x;
+ *restrict indexes;
register PixelPacket
- *__restrict q;
+ *restrict q;
+
+ register ssize_t
+ x;
+ if (count != (ssize_t) length)
+ {
+ ThrowFileException(exception,CorruptImageError,
+ "UnexpectedEndOfFile",image->filename);
+ break;
+ }
q=GetAuthenticPixels(canvas_image,0,0,canvas_image->columns,1,
exception);
if (q == (PixelPacket *) NULL)
if (SyncAuthenticPixels(canvas_image,exception) == MagickFalse)
break;
if (((y-image->extract_info.y) >= 0) &&
- ((y-image->extract_info.y) < (long) image->rows))
+ ((y-image->extract_info.y) < (ssize_t) image->rows))
{
p=GetVirtualPixels(canvas_image,canvas_image->extract_info.x,0,
canvas_image->columns,1,exception);
break;
canvas_indexes=GetVirtualIndexQueue(canvas_image);
indexes=GetAuthenticIndexQueue(image);
- for (x=0; x < (long) image->columns; x++)
+ for (x=0; x < (ssize_t) image->columns; x++)
{
- q->red=p->red;
- q->green=p->green;
- q->blue=p->blue;
+ SetRedPixelComponent(q,GetRedPixelComponent(p));
+ SetGreenPixelComponent(q,GetGreenPixelComponent(p));
+ SetBluePixelComponent(q,GetBluePixelComponent(p));
indexes[x]=canvas_indexes[image->extract_info.x+x];
- q->opacity=OpaqueOpacity;
+ SetOpacityPixelComponent(q,OpaqueOpacity);
if (image->matte != MagickFalse)
- q->opacity=p->opacity;
+ SetOpacityPixelComponent(q,GetOpacityPixelComponent(p));
p++;
q++;
}
}
if (image->previous == (Image *) NULL)
{
- status=SetImageProgress(image,LoadImageTag,y,image->rows);
+ status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
count=ReadBlob(image,length,pixels);
- if (count != (ssize_t) length)
- break;
}
break;
}
{
length=GetQuantumExtent(canvas_image,quantum_info,CyanQuantum);
count=ReadBlob(image,length,pixels);
- if (count != (ssize_t) length)
- break;
}
- for (y=0; y < (long) image->extract_info.height; y++)
+ for (y=0; y < (ssize_t) image->extract_info.height; y++)
{
register const IndexPacket
- *__restrict canvas_indexes;
+ *restrict canvas_indexes;
register const PixelPacket
- *__restrict p;
+ *restrict p;
register IndexPacket
- *__restrict indexes;
-
- register long
- x;
+ *restrict indexes;
register PixelPacket
- *__restrict q;
+ *restrict q;
+
+ register ssize_t
+ x;
+ if (count != (ssize_t) length)
+ {
+ ThrowFileException(exception,CorruptImageError,
+ "UnexpectedEndOfFile",image->filename);
+ break;
+ }
for (i=0; i < (image->matte != MagickFalse ? 5 : 4); i++)
{
quantum_type=quantum_types[i];
if (SyncAuthenticPixels(canvas_image,exception) == MagickFalse)
break;
if (((y-image->extract_info.y) >= 0) &&
- ((y-image->extract_info.y) < (long) image->rows))
+ ((y-image->extract_info.y) < (ssize_t) image->rows))
{
p=GetVirtualPixels(canvas_image,canvas_image->extract_info.x,
0,canvas_image->columns,1,exception);
break;
canvas_indexes=GetVirtualIndexQueue(canvas_image);
indexes=GetAuthenticIndexQueue(image);
- for (x=0; x < (long) image->columns; x++)
+ for (x=0; x < (ssize_t) image->columns; x++)
{
switch (quantum_type)
{
- case CyanQuantum: q->red=p->red; break;
- case MagentaQuantum: q->green=p->green; break;
- case YellowQuantum: q->blue=p->blue; break;
- case BlackQuantum: indexes[x]=
- canvas_indexes[image->extract_info.x+x];; break;
- case OpacityQuantum: q->opacity=p->opacity; break;
- default: break;
+ case CyanQuantum:
+ {
+ SetCyanPixelComponent(q,GetCyanPixelComponent(p));
+ break;
+ }
+ case MagentaQuantum:
+ {
+ SetMagentaPixelComponent(q,GetMagentaPixelComponent(p));
+ break;
+ }
+ case YellowQuantum:
+ {
+ SetYellowPixelComponent(q,GetYellowPixelComponent(p));
+ break;
+ }
+ case BlackQuantum:
+ {
+ indexes[x]=canvas_indexes[image->extract_info.x+x];
+ break;
+ }
+ case OpacityQuantum:
+ {
+ SetOpacityPixelComponent(q,GetOpacityPixelComponent(p));
+ break;
+ }
+ default:
+ break;
}
p++;
q++;
break;
}
count=ReadBlob(image,length,pixels);
- if (count != (ssize_t) length)
- break;
}
if (image->previous == (Image *) NULL)
{
- status=SetImageProgress(image,LoadImageTag,y,image->rows);
+ status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
{
length=GetQuantumExtent(canvas_image,quantum_info,CyanQuantum);
count=ReadBlob(image,length,pixels);
- if (count != (ssize_t) length)
- break;
}
- for (y=0; y < (long) image->extract_info.height; y++)
+ for (y=0; y < (ssize_t) image->extract_info.height; y++)
{
register const PixelPacket
- *__restrict p;
-
- register long
- x;
+ *restrict p;
register PixelPacket
- *__restrict q;
+ *restrict q;
+ register ssize_t
+ x;
+
+ if (count != (ssize_t) length)
+ {
+ ThrowFileException(exception,CorruptImageError,
+ "UnexpectedEndOfFile",image->filename);
+ break;
+ }
q=GetAuthenticPixels(canvas_image,0,0,canvas_image->columns,1,
exception);
if (q == (PixelPacket *) NULL)
if (SyncAuthenticPixels(canvas_image,exception) == MagickFalse)
break;
if (((y-image->extract_info.y) >= 0) &&
- ((y-image->extract_info.y) < (long) image->rows))
+ ((y-image->extract_info.y) < (ssize_t) image->rows))
{
p=GetVirtualPixels(canvas_image,canvas_image->extract_info.x,0,
canvas_image->columns,1,exception);
if ((p == (const PixelPacket *) NULL) ||
(q == (PixelPacket *) NULL))
break;
- for (x=0; x < (long) image->columns; x++)
+ for (x=0; x < (ssize_t) image->columns; x++)
{
- q->red=p->red;
+ SetRedPixelComponent(q,GetRedPixelComponent(p));
p++;
q++;
}
break;
}
count=ReadBlob(image,length,pixels);
- if (count != (ssize_t) length)
- break;
}
if (image->previous == (Image *) NULL)
{
if (status == MagickFalse)
break;
}
- for (y=0; y < (long) image->extract_info.height; y++)
+ for (y=0; y < (ssize_t) image->extract_info.height; y++)
{
register const PixelPacket
- *__restrict p;
-
- register long
- x;
+ *restrict p;
register PixelPacket
- *__restrict q;
+ *restrict q;
+
+ register ssize_t
+ x;
+ if (count != (ssize_t) length)
+ {
+ ThrowFileException(exception,CorruptImageError,
+ "UnexpectedEndOfFile",image->filename);
+ break;
+ }
q=GetAuthenticPixels(canvas_image,0,0,canvas_image->columns,1,
exception);
if (q == (PixelPacket *) NULL)
if (SyncAuthenticPixels(canvas_image,exception) == MagickFalse)
break;
if (((y-image->extract_info.y) >= 0) &&
- ((y-image->extract_info.y) < (long) image->rows))
+ ((y-image->extract_info.y) < (ssize_t) image->rows))
{
p=GetVirtualPixels(canvas_image,canvas_image->extract_info.x,0,
canvas_image->columns,1,exception);
if ((p == (const PixelPacket *) NULL) ||
(q == (PixelPacket *) NULL))
break;
- for (x=0; x < (long) image->columns; x++)
+ for (x=0; x < (ssize_t) image->columns; x++)
{
- q->green=p->green;
+ SetGreenPixelComponent(q,GetGreenPixelComponent(p));
p++;
q++;
}
break;
}
count=ReadBlob(image,length,pixels);
- if (count != (ssize_t) length)
- break;
}
if (image->previous == (Image *) NULL)
{
if (status == MagickFalse)
break;
}
- for (y=0; y < (long) image->extract_info.height; y++)
+ for (y=0; y < (ssize_t) image->extract_info.height; y++)
{
register const PixelPacket
- *__restrict p;
-
- register long
- x;
+ *restrict p;
register PixelPacket
- *__restrict q;
+ *restrict q;
+ register ssize_t
+ x;
+
+ if (count != (ssize_t) length)
+ {
+ ThrowFileException(exception,CorruptImageError,
+ "UnexpectedEndOfFile",image->filename);
+ break;
+ }
q=GetAuthenticPixels(canvas_image,0,0,canvas_image->columns,1,
exception);
if (q == (PixelPacket *) NULL)
if (SyncAuthenticPixels(canvas_image,exception) == MagickFalse)
break;
if (((y-image->extract_info.y) >= 0) &&
- ((y-image->extract_info.y) < (long) image->rows))
+ ((y-image->extract_info.y) < (ssize_t) image->rows))
{
p=GetVirtualPixels(canvas_image,canvas_image->extract_info.x,0,
canvas_image->columns,1,exception);
if ((p == (const PixelPacket *) NULL) ||
(q == (PixelPacket *) NULL))
break;
- for (x=0; x < (long) image->columns; x++)
+ for (x=0; x < (ssize_t) image->columns; x++)
{
- q->blue=p->blue;
+ SetBluePixelComponent(q,GetBluePixelComponent(p));
p++;
q++;
}
break;
}
count=ReadBlob(image,length,pixels);
- if (count != (ssize_t) length)
- break;
}
if (image->previous == (Image *) NULL)
{
if (status == MagickFalse)
break;
}
- for (y=0; y < (long) image->extract_info.height; y++)
+ for (y=0; y < (ssize_t) image->extract_info.height; y++)
{
register const IndexPacket
- *__restrict canvas_indexes;
+ *restrict canvas_indexes;
register const PixelPacket
- *__restrict p;
+ *restrict p;
register IndexPacket
- *__restrict indexes;
-
- register long
- x;
+ *restrict indexes;
register PixelPacket
- *__restrict q;
+ *restrict q;
+
+ register ssize_t
+ x;
+ if (count != (ssize_t) length)
+ {
+ ThrowFileException(exception,CorruptImageError,
+ "UnexpectedEndOfFile",image->filename);
+ break;
+ }
q=GetAuthenticPixels(canvas_image,0,0,canvas_image->columns,1,
exception);
if (q == (PixelPacket *) NULL)
if (SyncAuthenticPixels(canvas_image,exception) == MagickFalse)
break;
if (((y-image->extract_info.y) >= 0) &&
- ((y-image->extract_info.y) < (long) image->rows))
+ ((y-image->extract_info.y) < (ssize_t) image->rows))
{
p=GetVirtualPixels(canvas_image,canvas_image->extract_info.x,0,
canvas_image->columns,1,exception);
break;
canvas_indexes=GetVirtualIndexQueue(canvas_image);
indexes=GetAuthenticIndexQueue(image);
- for (x=0; x < (long) image->columns; x++)
+ for (x=0; x < (ssize_t) image->columns; x++)
{
indexes[x]=canvas_indexes[image->extract_info.x+x];
p++;
break;
}
count=ReadBlob(image,length,pixels);
- if (count != (ssize_t) length)
- break;
}
if (image->previous == (Image *) NULL)
{
}
if (image->matte != MagickFalse)
{
- for (y=0; y < (long) image->extract_info.height; y++)
+ for (y=0; y < (ssize_t) image->extract_info.height; y++)
{
register const PixelPacket
- *__restrict p;
-
- register long
- x;
+ *restrict p;
register PixelPacket
- *__restrict q;
+ *restrict q;
+
+ register ssize_t
+ x;
+ if (count != (ssize_t) length)
+ {
+ ThrowFileException(exception,CorruptImageError,
+ "UnexpectedEndOfFile",image->filename);
+ break;
+ }
q=GetAuthenticPixels(canvas_image,0,0,canvas_image->columns,1,
exception);
if (q == (PixelPacket *) NULL)
if (SyncAuthenticPixels(canvas_image,exception) == MagickFalse)
break;
if (((y-image->extract_info.y) >= 0) &&
- ((y-image->extract_info.y) < (long) image->rows))
+ ((y-image->extract_info.y) < (ssize_t) image->rows))
{
p=GetVirtualPixels(canvas_image,
canvas_image->extract_info.x,0,canvas_image->columns,1,
if ((p == (const PixelPacket *) NULL) ||
(q == (PixelPacket *) NULL))
break;
- for (x=0; x < (long) image->columns; x++)
+ for (x=0; x < (ssize_t) image->columns; x++)
{
- q->opacity=p->opacity;
+ SetOpacityPixelComponent(q,GetOpacityPixelComponent(p));
p++;
q++;
}
break;
}
count=ReadBlob(image,length,pixels);
- if (count != (ssize_t) length)
- break;
}
if (image->previous == (Image *) NULL)
{
image=DestroyImageList(image);
return((Image *) NULL);
}
- for (i=0; i < image->offset; i++)
- if (ReadBlobByte(image) == EOF)
- {
- ThrowFileException(exception,CorruptImageError,
- "UnexpectedEndOfFile",image->filename);
- break;
- }
+ if (DiscardBlobBytes(image,image->offset) == MagickFalse)
+ ThrowFileException(exception,CorruptImageError,"UnexpectedEndOfFile",
+ image->filename);
length=GetQuantumExtent(canvas_image,quantum_info,CyanQuantum);
- for (i=0; i < (long) scene; i++)
- for (y=0; y < (long) image->extract_info.height; y++)
+ for (i=0; i < (ssize_t) scene; i++)
+ for (y=0; y < (ssize_t) image->extract_info.height; y++)
if (ReadBlob(image,length,pixels) != (ssize_t) length)
{
ThrowFileException(exception,CorruptImageError,
break;
}
count=ReadBlob(image,length,pixels);
- if (count != (ssize_t) length)
- break;
- for (y=0; y < (long) image->extract_info.height; y++)
+ for (y=0; y < (ssize_t) image->extract_info.height; y++)
{
register const PixelPacket
- *__restrict p;
-
- register long
- x;
+ *restrict p;
register PixelPacket
- *__restrict q;
+ *restrict q;
+
+ register ssize_t
+ x;
+ if (count != (ssize_t) length)
+ {
+ ThrowFileException(exception,CorruptImageError,
+ "UnexpectedEndOfFile",image->filename);
+ break;
+ }
q=GetAuthenticPixels(canvas_image,0,0,canvas_image->columns,1,
exception);
if (q == (PixelPacket *) NULL)
if (SyncAuthenticPixels(canvas_image,exception) == MagickFalse)
break;
if (((y-image->extract_info.y) >= 0) &&
- ((y-image->extract_info.y) < (long) image->rows))
+ ((y-image->extract_info.y) < (ssize_t) image->rows))
{
p=GetVirtualPixels(canvas_image,canvas_image->extract_info.x,0,
canvas_image->columns,1,exception);
if ((p == (const PixelPacket *) NULL) ||
(q == (PixelPacket *) NULL))
break;
- for (x=0; x < (long) image->columns; x++)
+ for (x=0; x < (ssize_t) image->columns; x++)
{
- q->red=p->red;
+ SetRedPixelComponent(q,GetRedPixelComponent(p));
p++;
q++;
}
break;
}
count=ReadBlob(image,length,pixels);
- if (count != (ssize_t) length)
- break;
}
if (image->previous == (Image *) NULL)
{
return((Image *) NULL);
}
length=GetQuantumExtent(canvas_image,quantum_info,MagentaQuantum);
- for (i=0; i < (long) scene; i++)
- for (y=0; y < (long) image->extract_info.height; y++)
+ for (i=0; i < (ssize_t) scene; i++)
+ for (y=0; y < (ssize_t) image->extract_info.height; y++)
if (ReadBlob(image,length,pixels) != (ssize_t) length)
{
ThrowFileException(exception,CorruptImageError,
break;
}
count=ReadBlob(image,length,pixels);
- if (count != (ssize_t) length)
- break;
- for (y=0; y < (long) image->extract_info.height; y++)
+ for (y=0; y < (ssize_t) image->extract_info.height; y++)
{
register const PixelPacket
- *__restrict p;
-
- register long
- x;
+ *restrict p;
register PixelPacket
- *__restrict q;
+ *restrict q;
+ register ssize_t
+ x;
+
+ if (count != (ssize_t) length)
+ {
+ ThrowFileException(exception,CorruptImageError,
+ "UnexpectedEndOfFile",image->filename);
+ break;
+ }
q=GetAuthenticPixels(canvas_image,0,0,canvas_image->columns,1,
exception);
if (q == (PixelPacket *) NULL)
if (SyncAuthenticPixels(canvas_image,exception) == MagickFalse)
break;
if (((y-image->extract_info.y) >= 0) &&
- ((y-image->extract_info.y) < (long) image->rows))
+ ((y-image->extract_info.y) < (ssize_t) image->rows))
{
p=GetVirtualPixels(canvas_image,canvas_image->extract_info.x,0,
canvas_image->columns,1,exception);
if ((p == (const PixelPacket *) NULL) ||
(q == (PixelPacket *) NULL))
break;
- for (x=0; x < (long) image->columns; x++)
+ for (x=0; x < (ssize_t) image->columns; x++)
{
- q->green=p->green;
+ SetGreenPixelComponent(q,GetGreenPixelComponent(p));
p++;
q++;
}
break;
}
count=ReadBlob(image,length,pixels);
- if (count != (ssize_t) length)
- break;
}
if (image->previous == (Image *) NULL)
{
return((Image *) NULL);
}
length=GetQuantumExtent(canvas_image,quantum_info,YellowQuantum);
- for (i=0; i < (long) scene; i++)
- for (y=0; y < (long) image->extract_info.height; y++)
+ for (i=0; i < (ssize_t) scene; i++)
+ for (y=0; y < (ssize_t) image->extract_info.height; y++)
if (ReadBlob(image,length,pixels) != (ssize_t) length)
{
ThrowFileException(exception,CorruptImageError,
break;
}
count=ReadBlob(image,length,pixels);
- if (count != (ssize_t) length)
- break;
- for (y=0; y < (long) image->extract_info.height; y++)
+ for (y=0; y < (ssize_t) image->extract_info.height; y++)
{
register const PixelPacket
- *__restrict p;
-
- register long
- x;
+ *restrict p;
register PixelPacket
- *__restrict q;
+ *restrict q;
+
+ register ssize_t
+ x;
+ if (count != (ssize_t) length)
+ {
+ ThrowFileException(exception,CorruptImageError,
+ "UnexpectedEndOfFile",image->filename);
+ break;
+ }
q=GetAuthenticPixels(canvas_image,0,0,canvas_image->columns,1,
exception);
if (q == (PixelPacket *) NULL)
if (SyncAuthenticPixels(canvas_image,exception) == MagickFalse)
break;
if (((y-image->extract_info.y) >= 0) &&
- ((y-image->extract_info.y) < (long) image->rows))
+ ((y-image->extract_info.y) < (ssize_t) image->rows))
{
p=GetVirtualPixels(canvas_image,canvas_image->extract_info.x,0,
canvas_image->columns,1,exception);
if ((p == (const PixelPacket *) NULL) ||
(q == (PixelPacket *) NULL))
break;
- for (x=0; x < (long) image->columns; x++)
+ for (x=0; x < (ssize_t) image->columns; x++)
{
- q->blue=p->blue;
+ SetBluePixelComponent(q,GetBluePixelComponent(p));
p++;
q++;
}
break;
}
count=ReadBlob(image,length,pixels);
- if (count != (ssize_t) length)
- break;
}
if (image->previous == (Image *) NULL)
{
return((Image *) NULL);
}
length=GetQuantumExtent(canvas_image,quantum_info,BlackQuantum);
- for (i=0; i < (long) scene; i++)
- for (y=0; y < (long) image->extract_info.height; y++)
+ for (i=0; i < (ssize_t) scene; i++)
+ for (y=0; y < (ssize_t) image->extract_info.height; y++)
if (ReadBlob(image,length,pixels) != (ssize_t) length)
{
ThrowFileException(exception,CorruptImageError,
break;
}
count=ReadBlob(image,length,pixels);
- if (count != (ssize_t) length)
- break;
- for (y=0; y < (long) image->extract_info.height; y++)
+ for (y=0; y < (ssize_t) image->extract_info.height; y++)
{
register const IndexPacket
- *__restrict canvas_indexes;
+ *restrict canvas_indexes;
register const PixelPacket
- *__restrict p;
+ *restrict p;
register IndexPacket
- *__restrict indexes;
-
- register long
- x;
+ *restrict indexes;
register PixelPacket
- *__restrict q;
+ *restrict q;
+
+ register ssize_t
+ x;
+ if (count != (ssize_t) length)
+ {
+ ThrowFileException(exception,CorruptImageError,
+ "UnexpectedEndOfFile",image->filename);
+ break;
+ }
q=GetAuthenticPixels(canvas_image,0,0,canvas_image->columns,1,
exception);
if (q == (PixelPacket *) NULL)
if (SyncAuthenticPixels(canvas_image,exception) == MagickFalse)
break;
if (((y-image->extract_info.y) >= 0) &&
- ((y-image->extract_info.y) < (long) image->rows))
+ ((y-image->extract_info.y) < (ssize_t) image->rows))
{
p=GetVirtualPixels(canvas_image,canvas_image->extract_info.x,0,
canvas_image->columns,1,exception);
break;
canvas_indexes=GetVirtualIndexQueue(canvas_image);
indexes=GetAuthenticIndexQueue(image);
- for (x=0; x < (long) image->columns; x++)
+ for (x=0; x < (ssize_t) image->columns; x++)
{
indexes[x]=canvas_indexes[image->extract_info.x+x];
p++;
break;
}
count=ReadBlob(image,length,pixels);
- if (count != (ssize_t) length)
- break;
}
if (image->previous == (Image *) NULL)
{
return((Image *) NULL);
}
length=GetQuantumExtent(canvas_image,quantum_info,AlphaQuantum);
- for (i=0; i < (long) scene; i++)
- for (y=0; y < (long) image->extract_info.height; y++)
+ for (i=0; i < (ssize_t) scene; i++)
+ for (y=0; y < (ssize_t) image->extract_info.height; y++)
if (ReadBlob(image,length,pixels) != (ssize_t) length)
{
ThrowFileException(exception,CorruptImageError,
break;
}
count=ReadBlob(image,length,pixels);
- if (count != (ssize_t) length)
- break;
- for (y=0; y < (long) image->extract_info.height; y++)
+ for (y=0; y < (ssize_t) image->extract_info.height; y++)
{
register const PixelPacket
- *__restrict p;
-
- register long
- x;
+ *restrict p;
register PixelPacket
- *__restrict q;
+ *restrict q;
+ register ssize_t
+ x;
+
+ if (count != (ssize_t) length)
+ {
+ ThrowFileException(exception,CorruptImageError,
+ "UnexpectedEndOfFile",image->filename);
+ break;
+ }
q=GetAuthenticPixels(canvas_image,0,0,canvas_image->columns,1,
exception);
if (q == (PixelPacket *) NULL)
if (SyncAuthenticPixels(canvas_image,exception) == MagickFalse)
break;
if (((y-image->extract_info.y) >= 0) &&
- ((y-image->extract_info.y) < (long) image->rows))
+ ((y-image->extract_info.y) < (ssize_t) image->rows))
{
p=GetVirtualPixels(canvas_image,canvas_image->extract_info.x,
0,canvas_image->columns,1,exception);
if ((p == (const PixelPacket *) NULL) ||
(q == (PixelPacket *) NULL))
break;
- for (x=0; x < (long) image->columns; x++)
+ for (x=0; x < (ssize_t) image->columns; x++)
{
- q->opacity=p->opacity;
+ SetOpacityPixelComponent(q,GetOpacityPixelComponent(p));
p++;
q++;
}
break;
}
count=ReadBlob(image,length,pixels);
- if (count != (ssize_t) length)
- break;
}
if (image->previous == (Image *) NULL)
{
}
scene++;
} while (count == (ssize_t) length);
- InheritException(exception,&image->exception);
quantum_info=DestroyQuantumInfo(quantum_info);
+ InheritException(&image->exception,&canvas_image->exception);
canvas_image=DestroyImage(canvas_image);
(void) CloseBlob(image);
return(GetFirstImageInList(image));
%
% The format of the RegisterCMYKImage method is:
%
-% unsigned long RegisterCMYKImage(void)
+% size_t RegisterCMYKImage(void)
%
*/
-ModuleExport unsigned long RegisterCMYKImage(void)
+ModuleExport size_t RegisterCMYKImage(void)
{
MagickInfo
*entry;
entry->encoder=(EncodeImageHandler *) WriteCMYKImage;
entry->raw=MagickTrue;
entry->endian_support=MagickTrue;
- entry->format_type=ExplicitFormatType;
entry->description=ConstantString("Raw cyan, magenta, yellow, and black "
"samples");
entry->module=ConstantString("CMYK");
entry->encoder=(EncodeImageHandler *) WriteCMYKImage;
entry->raw=MagickTrue;
entry->endian_support=MagickTrue;
- entry->format_type=ExplicitFormatType;
entry->description=ConstantString("Raw cyan, magenta, yellow, black, and "
"alpha samples");
entry->module=ConstantString("CMYK");
static MagickBooleanType WriteCMYKImage(const ImageInfo *image_info,
Image *image)
{
- long
- y;
-
MagickBooleanType
status;
quantum_type;
ssize_t
- count;
+ count,
+ y;
size_t
length;
/*
No interlacing: CMYKCMYKCMYKCMYKCMYKCMYK...
*/
- for (y=0; y < (long) image->rows; y++)
+ for (y=0; y < (ssize_t) image->rows; y++)
{
register const PixelPacket
- *__restrict p;
+ *restrict p;
p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
if (p == (const PixelPacket *) NULL)
break;
- length=ExportQuantumPixels(image,(const CacheView *) NULL,quantum_info,
- quantum_type,pixels,&image->exception);
+ length=ExportQuantumPixels(image,(const CacheView *) NULL,
+ quantum_info,quantum_type,pixels,&image->exception);
count=WriteBlob(image,length,pixels);
if (count != (ssize_t) length)
break;
if (image->previous == (Image *) NULL)
{
- status=SetImageProgress(image,SaveImageTag,y,image->rows);
+ status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
/*
Line interlacing: CCC...MMM...YYY...KKK...CCC...MMM...YYY...KKK...
*/
- for (y=0; y < (long) image->rows; y++)
+ for (y=0; y < (ssize_t) image->rows; y++)
{
register const PixelPacket
- *__restrict p;
+ *restrict p;
p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
if (p == (const PixelPacket *) NULL)
break;
- length=ExportQuantumPixels(image,(const CacheView *) NULL,quantum_info,
- CyanQuantum,pixels,&image->exception);
+ length=ExportQuantumPixels(image,(const CacheView *) NULL,
+ quantum_info,CyanQuantum,pixels,&image->exception);
count=WriteBlob(image,length,pixels);
if (count != (ssize_t) length)
break;
- length=ExportQuantumPixels(image,(const CacheView *) NULL,quantum_info,
- MagentaQuantum,pixels,&image->exception);
+ length=ExportQuantumPixels(image,(const CacheView *) NULL,
+ quantum_info,MagentaQuantum,pixels,&image->exception);
count=WriteBlob(image,length,pixels);
if (count != (ssize_t) length)
break;
- length=ExportQuantumPixels(image,(const CacheView *) NULL,quantum_info,
- YellowQuantum,pixels,&image->exception);
+ length=ExportQuantumPixels(image,(const CacheView *) NULL,
+ quantum_info,YellowQuantum,pixels,&image->exception);
count=WriteBlob(image,length,pixels);
if (count != (ssize_t) length)
break;
- length=ExportQuantumPixels(image,(const CacheView *) NULL,quantum_info,
- BlackQuantum,pixels,&image->exception);
+ length=ExportQuantumPixels(image,(const CacheView *) NULL,
+ quantum_info,BlackQuantum,pixels,&image->exception);
count=WriteBlob(image,length,pixels);
if (count != (ssize_t) length)
break;
}
if (image->previous == (Image *) NULL)
{
- status=SetImageProgress(image,SaveImageTag,y,image->rows);
+ status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
/*
Plane interlacing: CCCCCC...MMMMMM...YYYYYY...KKKKKK...
*/
- for (y=0; y < (long) image->rows; y++)
+ for (y=0; y < (ssize_t) image->rows; y++)
{
register const PixelPacket
- *__restrict p;
+ *restrict p;
p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
if (p == (const PixelPacket *) NULL)
break;
- length=ExportQuantumPixels(image,(const CacheView *) NULL,quantum_info,
- CyanQuantum,pixels,&image->exception);
+ length=ExportQuantumPixels(image,(const CacheView *) NULL,
+ quantum_info,CyanQuantum,pixels,&image->exception);
count=WriteBlob(image,length,pixels);
if (count != (ssize_t) length)
break;
if (status == MagickFalse)
break;
}
- for (y=0; y < (long) image->rows; y++)
+ for (y=0; y < (ssize_t) image->rows; y++)
{
register const PixelPacket
- *__restrict p;
+ *restrict p;
p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
if (p == (const PixelPacket *) NULL)
break;
- length=ExportQuantumPixels(image,(const CacheView *) NULL,quantum_info,
- MagentaQuantum,pixels,&image->exception);
+ length=ExportQuantumPixels(image,(const CacheView *) NULL,
+ quantum_info,MagentaQuantum,pixels,&image->exception);
count=WriteBlob(image,length,pixels);
if (count != (ssize_t) length)
break;
if (status == MagickFalse)
break;
}
- for (y=0; y < (long) image->rows; y++)
+ for (y=0; y < (ssize_t) image->rows; y++)
{
register const PixelPacket
- *__restrict p;
+ *restrict p;
p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
if (p == (const PixelPacket *) NULL)
break;
- length=ExportQuantumPixels(image,(const CacheView *) NULL,quantum_info,
- YellowQuantum,pixels,&image->exception);
+ length=ExportQuantumPixels(image,(const CacheView *) NULL,
+ quantum_info,YellowQuantum,pixels,&image->exception);
count=WriteBlob(image,length,pixels);
if (count != (ssize_t) length)
break;
if (status == MagickFalse)
break;
}
- for (y=0; y < (long) image->rows; y++)
+ for (y=0; y < (ssize_t) image->rows; y++)
{
register const PixelPacket
- *__restrict p;
+ *restrict p;
p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
if (p == (const PixelPacket *) NULL)
break;
- length=ExportQuantumPixels(image,(const CacheView *) NULL,quantum_info,
- BlackQuantum,pixels,&image->exception);
+ length=ExportQuantumPixels(image,(const CacheView *) NULL,
+ quantum_info,BlackQuantum,pixels,&image->exception);
count=WriteBlob(image,length,pixels);
if (count != (ssize_t) length)
break;
}
if (quantum_type == CMYKAQuantum)
{
- for (y=0; y < (long) image->rows; y++)
+ for (y=0; y < (ssize_t) image->rows; y++)
{
register const PixelPacket
- *__restrict p;
+ *restrict p;
- p=GetVirtualPixels(image,0,y,image->columns,1,
- &image->exception);
+ p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
if (p == (const PixelPacket *) NULL)
break;
length=ExportQuantumPixels(image,(const CacheView *) NULL,
AppendBinaryBlobMode,&image->exception);
if (status == MagickFalse)
return(status);
- for (y=0; y < (long) image->rows; y++)
+ for (y=0; y < (ssize_t) image->rows; y++)
{
register const PixelPacket
- *__restrict p;
+ *restrict p;
p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
if (p == (const PixelPacket *) NULL)
break;
- length=ExportQuantumPixels(image,(const CacheView *) NULL,quantum_info,
- CyanQuantum,pixels,&image->exception);
+ length=ExportQuantumPixels(image,(const CacheView *) NULL,
+ quantum_info,CyanQuantum,pixels,&image->exception);
count=WriteBlob(image,length,pixels);
if (count != (ssize_t) length)
break;
AppendBinaryBlobMode,&image->exception);
if (status == MagickFalse)
return(status);
- for (y=0; y < (long) image->rows; y++)
+ for (y=0; y < (ssize_t) image->rows; y++)
{
register const PixelPacket
- *__restrict p;
+ *restrict p;
p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
if (p == (const PixelPacket *) NULL)
break;
- length=ExportQuantumPixels(image,(const CacheView *) NULL,quantum_info,
- MagentaQuantum,pixels,&image->exception);
+ length=ExportQuantumPixels(image,(const CacheView *) NULL,
+ quantum_info,MagentaQuantum,pixels,&image->exception);
count=WriteBlob(image,length,pixels);
if (count != (ssize_t) length)
break;
AppendBinaryBlobMode,&image->exception);
if (status == MagickFalse)
return(status);
- for (y=0; y < (long) image->rows; y++)
+ for (y=0; y < (ssize_t) image->rows; y++)
{
register const PixelPacket
- *__restrict p;
+ *restrict p;
p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
if (p == (const PixelPacket *) NULL)
break;
- length=ExportQuantumPixels(image,(const CacheView *) NULL,quantum_info,
- YellowQuantum,pixels,&image->exception);
+ length=ExportQuantumPixels(image,(const CacheView *) NULL,
+ quantum_info,YellowQuantum,pixels,&image->exception);
count=WriteBlob(image,length,pixels);
if (count != (ssize_t) length)
break;
AppendBinaryBlobMode,&image->exception);
if (status == MagickFalse)
return(status);
- for (y=0; y < (long) image->rows; y++)
+ for (y=0; y < (ssize_t) image->rows; y++)
{
register const PixelPacket
- *__restrict p;
+ *restrict p;
p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
if (p == (const PixelPacket *) NULL)
break;
- length=ExportQuantumPixels(image,(const CacheView *) NULL,quantum_info,
- BlackQuantum,pixels,&image->exception);
+ length=ExportQuantumPixels(image,(const CacheView *) NULL,
+ quantum_info,BlackQuantum,pixels,&image->exception);
count=WriteBlob(image,length,pixels);
if (count != (ssize_t) length)
break;
AppendBinaryBlobMode,&image->exception);
if (status == MagickFalse)
return(status);
- for (y=0; y < (long) image->rows; y++)
+ for (y=0; y < (ssize_t) image->rows; y++)
{
register const PixelPacket
- *__restrict p;
+ *restrict p;
p=GetVirtualPixels(image,0,y,image->columns,1,
&image->exception);
projects / imagemagick / blobdiff