if (count != (ssize_t) length)
ThrowWriterException(CorruptImageError,"UnableToWriteImageData");
count=WriteBlob(image,(size_t) (-(ssize_t) length) & 0x01,pixels);
- if (SetImageProgress(image,SaveImageTag,y,image->rows) == MagickFalse)
+ if (SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,image->rows) == MagickFalse)
break;
}
quantum_info=DestroyQuantumInfo(quantum_info);
if (count != (ssize_t) (q-pixels))
break;
if ((image->previous == (Image *) NULL) &&
- (SetImageProgress(image,SaveImageTag,y,image->rows) == MagickFalse))
+ (SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,image->rows) == MagickFalse))
break;
}
pixels=(unsigned char *) RelinquishMagickMemory(pixels);
*/
*q++=(unsigned char) 0x00;
*q++=(unsigned char) 0x00;
- status=SetImageProgress(image,SaveImageTag,y,image->rows);
+ status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
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;
}
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;
}
offset=(MagickOffsetType) (image->rows-y-1);
if (image->previous == (Image *) NULL)
{
- status=SetImageProgress(image,LoadImageTag,y,image->rows);
+ status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
offset=(MagickOffsetType) (image->rows-y-1);
if (image->previous == (Image *) NULL)
{
- status=SetImageProgress(image,LoadImageTag,y,image->rows);
+ status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
offset=(MagickOffsetType) (image->rows-y-1);
if (image->previous == (Image *) NULL)
{
- status=SetImageProgress(image,LoadImageTag,y,image->rows);
+ status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
offset=(MagickOffsetType) (image->rows-y-1);
if (image->previous == (Image *) NULL)
{
- status=SetImageProgress(image,LoadImageTag,y,image->rows);
+ status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
*q++=0x00;
if (image->previous == (Image *) NULL)
{
- status=SetImageProgress(image,SaveImageTag,y,image->rows);
+ status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
*q++=0x00;
if (image->previous == (Image *) NULL)
{
- status=SetImageProgress(image,SaveImageTag,y,image->rows);
+ status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
*q++=0x00;
if (image->previous == (Image *) NULL)
{
- status=SetImageProgress(image,SaveImageTag,y,image->rows);
+ status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
*q++=0x00;
if (image->previous == (Image *) NULL)
{
- status=SetImageProgress(image,SaveImageTag,y,image->rows);
+ status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
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;
}
}
if (!iso_11548_1)
(void) WriteBlobByte(image,'\n');
- status=SetImageProgress(image,SaveImageTag,y,image->rows);
+ status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
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;
}
count=WriteBlob(image,length,pixels);
if (count != (ssize_t) length)
break;
- status=SetImageProgress(image,SaveImageTag,y,image->rows);
+ status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
(void) FormatMagickString(buffer,MaxTextExtent,"%02x",~byte);
(void) WriteBlobString(image,buffer);
}
- status=SetImageProgress(image,SaveImageTag,y,image->rows);
+ status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
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;
}
}
if (image->previous == (Image *) NULL)
{
- status=SetImageProgress(image,LoadImageTag,y,image->rows);
+ status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
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;
}
}
if (image->previous == (Image *) NULL)
{
- status=SetImageProgress(image,SaveImageTag,y,image->rows);
+ status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
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;
}
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;
}
}
for (x=(ssize_t) (image->columns+7)/8; x < (ssize_t) bytes_per_line; x++)
*q++=0x00;
- status=SetImageProgress(image,SaveImageTag,y,image->rows);
+ status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
*q++=(unsigned char) indexes[x];
for ( ; x < (ssize_t) bytes_per_line; x++)
*q++=0x00;
- status=SetImageProgress(image,SaveImageTag,y,image->rows);
+ status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
}
for (x=2L*image->columns; x < (ssize_t) bytes_per_line; x++)
*q++=0x00;
- status=SetImageProgress(image,SaveImageTag,y,image->rows);
+ status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
if (dib_info.bits_per_pixel == 24)
for (x=3L*image->columns; x < (ssize_t) bytes_per_line; x++)
*q++=0x00;
- status=SetImageProgress(image,SaveImageTag,y,image->rows);
+ status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
MagickBooleanType
proceed;
- proceed=SetImageProgress(image,LoadImageTag,row,image->rows);
+ proceed=SetImageProgress(image,LoadImageTag,(MagickOffsetType) row,
+ image->rows);
if (proceed == MagickFalse)
status=MagickFalse;
}
count=WriteBlob(image,extent,pixels);
if (count != (ssize_t) extent)
break;
- status=SetImageProgress(image,SaveImageTag,y,image->rows);
+ status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
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;
}
count=WriteBlob(image,length,pixels);
if (count != (ssize_t) length)
break;
- status=SetImageProgress(image,SaveImageTag,y,image->rows);
+ status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
- status=SetImageProgress(image,LoadImageTag,y,image->rows);
+ status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
fpx_status=FPX_WriteImageLine(flashpix,&fpx_info);
if (fpx_status != FPX_OK)
break;
- status=SetImageProgress(image,SaveImageTag,y,image->rows);
+ status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
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;
}
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;
}
(void) WriteBlob(image, image->columns*image->depth/8, pixels);
if (image->previous == (Image *) NULL)
{
- status=SetImageProgress(image,SaveImageTag,y,image->rows);
+ status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
- status=SetImageProgress(image,LoadImageTag,y,image->rows);
+ status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
*q++=byte << (8-bit);
if (image->previous == (Image *) NULL)
{
- status=SetImageProgress(image,SaveImageTag,y,image->rows);
+ status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
- status=SetImageProgress(image,LoadImageTag,y,image->rows);
+ status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
for (i=0; i < (ssize_t) number_components; i++)
(void) jas_image_writecmpt(jp2_image,(short) i,0,(unsigned int) y,
(unsigned int) image->columns,1,pixels[i]);
- status=SetImageProgress(image,SaveImageTag,y,image->rows);
+ status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
p++;
}
(void) jpeg_write_scanlines(&jpeg_info,scanline,1);
- if (SetImageProgress(image,SaveImageTag,y,image->rows) == MagickFalse)
+ if (SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,image->rows) == MagickFalse)
break;
}
else
p++;
}
(void) jpeg_write_scanlines(&jpeg_info,scanline,1);
- if (SetImageProgress(image,SaveImageTag,y,image->rows) == MagickFalse)
+ if (SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,image->rows) == MagickFalse)
break;
}
else
p++;
}
(void) jpeg_write_scanlines(&jpeg_info,scanline,1);
- if (SetImageProgress(image,SaveImageTag,y,image->rows) == MagickFalse)
+ if (SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,image->rows) == MagickFalse)
break;
}
}
p++;
}
(void) jpeg_write_scanlines(&jpeg_info,scanline,1);
- if (SetImageProgress(image,SaveImageTag,y,image->rows) == MagickFalse)
+ if (SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,image->rows) == MagickFalse)
break;
}
else
p++;
}
(void) jpeg_write_scanlines(&jpeg_info,scanline,1);
- status=SetImageProgress(image,SaveImageTag,y,image->rows);
+ status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
p++;
}
(void) jpeg_write_scanlines(&jpeg_info,scanline,1);
- status=SetImageProgress(image,SaveImageTag,y,image->rows);
+ status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
}
if (SyncAuthenticPixels(matte_image,exception) == MagickFalse)
break;
- status=SetImageProgress(image,SaveImageTag,y,image->rows);
+ status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
break;
}
}
- if ((image->previous == (Image *) NULL) &&
- (SetImageProgress(image,SaveImageTag,y,image->rows) == MagickFalse))
- break;
+ if (image->previous == (Image *) NULL)
+ {
+ status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
+ image->rows);
+ if (status == MagickFalse)
+ break;
+ }
}
quantum_info=DestroyQuantumInfo(quantum_info);
compress_pixels=(unsigned char *) RelinquishMagickMemory(compress_pixels);
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
- status=SetImageProgress(image,LoadImageTag,y,image->rows);
+ status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
}
if (bit != 0)
(void) WriteBlobByte(image,(unsigned char) (byte >> (8-bit)));
- status=SetImageProgress(image,SaveImageTag,y,image->rows);
+ status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
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;
}
(void) WriteBlob(image,(size_t) (q-pixels),pixels);
if (image->previous == (Image *) NULL)
{
- status=SetImageProgress(image,SaveImageTag,y,image->rows);
+ status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
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;
}
(void) WriteBlobByte(image,byte);
if (image->previous == (Image *) NULL)
{
- status=SetImageProgress(image,SaveImageTag,y,image->rows);
+ status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
- status=SetImageProgress(image,LoadImageTag,y,image->rows);
+ status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
- status=SetImageProgress(image,LoadImageTag,y,image->rows);
+ status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
- status=SetImageProgress(image,LoadImageTag,y,image->rows);
+ status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
buffer[literal+repeat]=0x00;
}
}
- status=SetImageProgress(image,SaveImageTag,y,image->rows);
+ status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
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;
}
}
if (image->previous == (Image *) NULL)
{
- status=SetImageProgress(image,SaveImageTag,y,image->rows);
+ status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
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;
}
}
if (image->previous == (Image *) NULL)
{
- status=SetImageProgress(image,SaveImageTag,y,image->rows);
+ status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
*q++=(unsigned char) indexes[x];
if (image->previous == (Image *) NULL)
{
- status=SetImageProgress(image,SaveImageTag,y,image->rows);
+ status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
Ascii85Encode(image,(unsigned char) indexes[x]);
if (image->previous == (Image *) NULL)
{
- status=SetImageProgress(image,SaveImageTag,y,image->rows);
+ status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
packed_scanline);
if (image->previous == (Image *) NULL)
{
- status=SetImageProgress(image,SaveImageTag,y,image->rows);
+ status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
packed_scanline);
if (image->previous == (Image *) NULL)
{
- status=SetImageProgress(image,SaveImageTag,y,image->rows);
+ status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
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;
}
#endif
if ((image->previous == (Image *) NULL) && (num_passes == 1))
{
- status=SetImageProgress(image,LoadImageTag,y,image->rows);
+ status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
break;
if ((image->previous == (Image *) NULL) && (num_passes == 1))
{
- status=SetImageProgress(image,LoadImageTag,y,image->rows);
+ status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
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;
}
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;
}
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;
}
MagickBooleanType
proceed;
- proceed=SetImageProgress(image,LoadImageTag,row,image->rows);
+ proceed=SetImageProgress(image,LoadImageTag,(MagickOffsetType)
+ row,image->rows);
if (proceed == MagickFalse)
status=MagickFalse;
}
MagickBooleanType
proceed;
- proceed=SetImageProgress(image,LoadImageTag,row,image->rows);
+ proceed=SetImageProgress(image,LoadImageTag,(MagickOffsetType) row,
+ image->rows);
if (proceed == MagickFalse)
status=MagickFalse;
}
MagickBooleanType
proceed;
- proceed=SetImageProgress(image,LoadImageTag,row,image->rows);
+ proceed=SetImageProgress(image,LoadImageTag,(MagickOffsetType) row,
+ image->rows);
if (proceed == MagickFalse)
status=MagickFalse;
}
MagickBooleanType
proceed;
- proceed=SetImageProgress(image,LoadImageTag,row,image->rows);
+ proceed=SetImageProgress(image,LoadImageTag,(MagickOffsetType) row,
+ image->rows);
if (proceed == MagickFalse)
status=MagickFalse;
}
MagickBooleanType
proceed;
- proceed=SetImageProgress(image,LoadImageTag,row,image->rows);
+ proceed=SetImageProgress(image,LoadImageTag,(MagickOffsetType) row,
+ image->rows);
if (proceed == MagickFalse)
status=MagickFalse;
}
}
if (image->previous == (Image *) NULL)
{
- status=SetImageProgress(image,SaveImageTag,y,image->rows);
+ status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
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;
}
}
if (image->previous == (Image *) NULL)
{
- status=SetImageProgress(image,SaveImageTag,y,image->rows);
+ status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
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;
}
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;
}
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;
}
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;
}
(void) WriteBlob(image,extent,pixels);
if (image->previous == (Image *) NULL)
{
- status=SetImageProgress(image,SaveImageTag,y,image->rows);
+ status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
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;
}
};
if (image->previous == (Image *) NULL)
{
- status=SetImageProgress(image,SaveImageTag,y,image->rows);
+ status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
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;
}
}
if (image->previous == (Image *) NULL)
{
- status=SetImageProgress(image,SaveImageTag,y,image->rows);
+ status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
MagickMin(length,0xff),q);
if (image->previous == (Image *) NULL)
{
- status=SetImageProgress(image,SaveImageTag,y,image->rows);
+ status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
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;
}
*q++=ScaleQuantumToChar(PixelIntensityToQuantum(p));
p++;
}
- progress=SetImageProgress(image,SaveImageTag,y,image->rows);
+ progress=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,image->rows);
if (progress == MagickFalse)
break;
}
ScaleQuantumToChar(PixelIntensityToQuantum(p)));
p++;
}
- progress=SetImageProgress(image,SaveImageTag,y,image->rows);
+ progress=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,image->rows);
if (progress == MagickFalse)
break;
}
}
p++;
}
- progress=SetImageProgress(image,SaveImageTag,y,image->rows);
+ progress=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,image->rows);
if (progress == MagickFalse)
break;
}
}
p++;
}
- progress=SetImageProgress(image,SaveImageTag,y,image->rows);
+ progress=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,image->rows);
if (progress == MagickFalse)
break;
}
indexes=GetVirtualIndexQueue(image);
for (x=0; x < (ssize_t) image->columns; x++)
*q++=(unsigned char) indexes[x];
- progress=SetImageProgress(image,SaveImageTag,y,image->rows);
+ progress=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,image->rows);
if (progress == MagickFalse)
break;
}
indexes=GetVirtualIndexQueue(image);
for (x=0; x < (ssize_t) image->columns; x++)
Ascii85Encode(image,(unsigned char) indexes[x]);
- progress=SetImageProgress(image,SaveImageTag,y,image->rows);
+ progress=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,image->rows);
if (progress == MagickFalse)
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;
}
p++;
}
}
- status=SetImageProgress(image,SaveImageTag,y,image->rows);
+ status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
*q++=(unsigned char) indexes[x];
if (image->previous == (Image *) NULL)
{
- status=SetImageProgress(image,SaveImageTag,y,image->rows);
+ status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
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;
}
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;
}
}
if (image->previous == (Image *) NULL)
{
- status=SetImageProgress(image,LoadImageTag,y,image->rows);
+ status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
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;
}
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;
}
}
if (image->previous == (Image *) NULL)
{
- status=SetImageProgress(image,SaveImageTag,y,image->rows);
+ status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
while (runlength > 0);
}
}
- status=SetImageProgress(image,LoadImageTag,y,image->rows);
+ status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
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;
}
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;
}
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;
}
if ((image->columns % 2) != 0)
(void) ReadBlobByte(image); /* pad */
}
- status=SetImageProgress(image,LoadImageTag,y,image->rows);
+ status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
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;
}
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;
}
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;
}
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;
}
}
if (image->previous == (Image *) NULL)
{
- status=SetImageProgress(image,SaveImageTag,y,image->rows);
+ status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
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;
}
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;
}
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;
}
(void) WriteBlob(image,(size_t) (q-pixels),pixels);
if (image->previous == (Image *) NULL)
{
- status=SetImageProgress(image,SaveImageTag,y,image->rows);
+ status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
(void) WriteBlobByte(image,0); /* pad scanline */
if (image->previous == (Image *) NULL)
{
- status=SetImageProgress(image,SaveImageTag,y,image->rows);
+ status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
(void) WriteBlobByte(image,0); /* pad scanline */
if (image->previous == (Image *) NULL)
{
- status=SetImageProgress(image,SaveImageTag,y,image->rows);
+ status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
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;
}
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;
}
(void) WriteBlob(image,(size_t) (q-targa_pixels),targa_pixels);
if (image->previous == (Image *) NULL)
{
- status=SetImageProgress(image,SaveImageTag,y,image->rows);
+ status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
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;
}
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;
}
}
if (image->previous == (Image *) NULL)
{
- status=SetImageProgress(image,LoadImageTag,y,image->rows);
+ status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
(void) WriteBlobString(image,"\n");
p++;
}
- status=SetImageProgress(image,SaveImageTag,y,image->rows);
+ status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
(void) FormatMagickString(buffer,MaxTextExtent,"\"%s\n",
(y == (ssize_t) (image->rows-1) ? ");" : ","));
(void) WriteBlobString(image,buffer);
- status=SetImageProgress(image,SaveImageTag,y,image->rows);
+ status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
- status=SetImageProgress(image,LoadImageTag,y,image->rows);
+ status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
full=full == MagickFalse ? MagickTrue : MagickFalse;
p++;
}
- status=SetImageProgress(image,LoadImageTag,y,image->rows);
+ status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
quantum_type,pixels,exception);
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
- status=SetImageProgress(image,LoadImageTag,y,image->rows);
+ status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
count=WriteBlob(image,length,pixels);
if (count != (ssize_t) length)
break;
- status=SetImageProgress(image,SaveImageTag,y,image->rows);
+ status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
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;
}
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;
}
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;
}
}
if (image->previous == (Image *) NULL)
{
- status=SetImageProgress(image,SaveImageTag,y,image->rows);
+ status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
*q++=(unsigned char) indexes[x];
if (image->previous == (Image *) NULL)
{
- status=SetImageProgress(image,SaveImageTag,y,image->rows);
+ status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
*q++=byte >> (8-bit);
if (image->previous == (Image *) NULL)
{
- status=SetImageProgress(image,SaveImageTag,y,image->rows);
+ status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
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;
}
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
- status=SetImageProgress(image,LoadImageTag,y,image->rows);
+ status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
}
if (bit != 0)
(void) WriteBlobByte(image,byte);
- status=SetImageProgress(image,SaveImageTag,y,image->rows);
+ status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
- status=SetImageProgress(image,LoadImageTag,y,image->rows);
+ status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
bit=0;
byte=0;
};
- status=SetImageProgress(image,SaveImageTag,y,image->rows);
+ status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
(void) WriteBlobString(image,buffer);
if (image->previous == (Image *) NULL)
{
- status=SetImageProgress(image,SaveImageTag,y,image->rows);
+ status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
size_t
blob_length;
- ssize_t
+ long
lBoundl,
lBoundu;
SAFEARRAY *pSafeArray = (SAFEARRAY *)image->client_data;
if (pSafeArray != NULL)
{
- ssize_t lBoundl, lBoundu, lCount;
+ long lBoundl, lBoundu, lCount;
HRESULT hr = S_OK;
/* First see how big the buffer currently is */
hr = SafeArrayGetLBound(pSafeArray, 1, &lBoundl);
{
unsigned char *pReturnBuffer = NULL;
NewArrayBounds[0].lLbound = 0; /* Start-Index 0 */
- NewArrayBounds[0].cElements = (size_t) (length+lCount); /* # Elemente */
+ NewArrayBounds[0].cElements = (unsigned long) (length+lCount); /* # Elemente */
hr = SafeArrayRedim(pSafeArray, NewArrayBounds);
if (FAILED(hr))
return 0;
hr = SafeArrayAccessData(pSafeArray, (void**)&pReturnBuffer);
if( FAILED(hr) )
return 0;
- (void) CopyMagickMemory( pReturnBuffer+lCount, (unsigned char *)data, length );
+ (void) memcpy( pReturnBuffer+lCount, (unsigned char *)data, length );
hr = SafeArrayUnaccessData(pSafeArray);
if( FAILED(hr) )
return 0;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
- status=SetImageProgress(image,LoadImageTag,y,image->rows);
+ status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
- status=SetImageProgress(image,LoadImageTag,y,image->rows);
+ status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
- status=SetImageProgress(image,LoadImageTag,y,image->rows);
+ status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
for (x=0; x < (ssize_t) scanline_pad; x++)
*q++='\0';
(void) WriteBlob(image,(size_t) (q-pixels),pixels);
- status=SetImageProgress(image,SaveImageTag,y,image->rows);
+ status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
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;
}
}
if (image->previous == (Image *) NULL)
{
- status=SetImageProgress(image,LoadImageTag,y,image->rows);
+ status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
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;
}
}
if (image->previous == (Image *) NULL)
{
- status=SetImageProgress(image,SaveImageTag,y,image->rows);
+ status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
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;
}
}
if (image->previous == (Image *) NULL)
{
- status=SetImageProgress(image,SaveImageTag,y,image->rows);
+ status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
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;
}
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
-License assize_t with GNU Libltdl; see the file COPYING.LIB. If not, a
+License along with GNU Libltdl; see the file COPYING.LIB. If not, a
copy can be downloaded from http://www.gnu.org/licenses/lgpl.html,
or obtained by writing to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
-License assize_t with GNU Libltdl; see the file COPYING.LIB. If not, a
+License along with GNU Libltdl; see the file COPYING.LIB. If not, a
copy can be downloaded from http://www.gnu.org/licenses/lgpl.html,
or obtained by writing to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
-License assize_t with GNU Libltdl; see the file COPYING.LIB. If not, a
+License along with GNU Libltdl; see the file COPYING.LIB. If not, a
copy can be downloaded from http://www.gnu.org/licenses/lgpl.html,
or obtained by writing to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
-License assize_t with GNU Libltdl; see the file COPYING.LIB. If not, a
+License along with GNU Libltdl; see the file COPYING.LIB. If not, a
copy can be downloaded from http://www.gnu.org/licenses/lgpl.html,
or obtained by writing to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
-License assize_t with GNU Libltdl; see the file COPYING.LIB. If not, a
+License along with GNU Libltdl; see the file COPYING.LIB. If not, a
copy can be downloaded from http://www.gnu.org/licenses/lgpl.html,
or obtained by writing to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
-License assize_t with GNU Libltdl; see the file COPYING.LIB. If not, a
+License along with GNU Libltdl; see the file COPYING.LIB. If not, a
copy can be downloaded from http://www.gnu.org/licenses/lgpl.html,
or obtained by writing to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
-License assize_t with GNU Libltdl; see the file COPYING.LIB. If not, a
+License along with GNU Libltdl; see the file COPYING.LIB. If not, a
copy can be downloaded from http://www.gnu.org/licenses/lgpl.html,
or obtained by writing to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
-License assize_t with GNU Libltdl; see the file COPYING.LIB. If not, a
+License along with GNU Libltdl; see the file COPYING.LIB. If not, a
copy can be downloaded from http://www.gnu.org/licenses/lgpl.html,
or obtained by writing to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
}
-/* Call FUNC for each unique extensionless file in SEARCH_PATH, assize_t
+/* Call FUNC for each unique extensionless file in SEARCH_PATH, along
with DATA. The filenames passed to FUNC would be suitable for
passing to lt_dlopenext. The extensions are stripped so that
individual modules do not generate several entries (e.g. libfoo.la,
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
-License assize_t with GNU Libltdl; see the file COPYING.LIB. If not, a
+License along with GNU Libltdl; see the file COPYING.LIB. If not, a
copy can be downloaded from http://www.gnu.org/licenses/lgpl.html,
or obtained by writing to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
-License assize_t with GNU Libltdl; see the file COPYING.LIB. If not, a
+License along with GNU Libltdl; see the file COPYING.LIB. If not, a
copy can be downloaded from http://www.gnu.org/licenses/lgpl.html,
or obtained by writing to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
}
/* Perform a destructive quicksort on the items in SLIST, by repeatedly
- calling COMPARE with a pair of items from SLIST assize_t with USERDATA
+ calling COMPARE with a pair of items from SLIST along with USERDATA
at every iteration. COMPARE is a function as defined above for
slist_sort_merge(). The value of SLIST is undefined after calling
this function.
right = slist->next;
/* Skip two items with RIGHT and one with SLIST, until RIGHT falls off
- the end. SLIST must be about half way assize_t. */
+ the end. SLIST must be about half way along. */
while (right && (right = right->next))
{
if (!right || !(right = right->next))
*/
context_values.background=pixel.background_color.pixel;
context_values.foreground=pixel.foreground_color.pixel;
- pixel.annotate_context=XCreateGC(display,window_info.id,(size_t)
- GCBackground | GCForeground,&context_values);
+ pixel.annotate_context=XCreateGC(display,window_info.id,(unsigned long)
+ (GCBackground | GCForeground),&context_values);
if (pixel.annotate_context == (GC) NULL)
ThrowXWindowFatalException(XServerFatalError,"UnableToCreateGraphicContext",
images->filename);
*/
if (event.xclient.message_type != windows->wm_protocols)
break;
- if (*event.xclient.data.l == (ssize_t) windows->wm_take_focus)
+ if (*event.xclient.data.l == (long) windows->wm_take_focus)
{
(void) XSetInputFocus(display,event.xclient.window,RevertToParent,
(Time) event.xclient.data.l[1]);
break;
}
- if (*event.xclient.data.l != (ssize_t) windows->wm_delete_window)
+ if (*event.xclient.data.l != (long) windows->wm_delete_window)
break;
(void) XWithdrawWindow(display,event.xclient.window,
visual_info->screen);
Display image named by the remote command protocol.
*/
status=XGetWindowProperty(display,event.xproperty.window,
- event.xproperty.atom,0L,(ssize_t) MaxTextExtent,MagickFalse,(Atom)
+ event.xproperty.atom,0L,(long) MaxTextExtent,MagickFalse,(Atom)
AnyPropertyType,&type,&format,&length,&after,&data);
if ((status != Success) || (length == 0))
break;
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp critical (MagickCore_CompositeImage)
#endif
- proceed=SetImageProgress(image,CompositeImageTag,y,image->rows);
+ proceed=SetImageProgress(image,CompositeImageTag,
+ (MagickOffsetType) y,image->rows);
if (proceed == MagickFalse)
status=MagickFalse;
}
#if defined(MAGICKCORE_OPENMP_SUPPORT) && defined(MAGICKCORE_FUTURE)
#pragma omp critical (MagickCore_TextureImage)
#endif
- proceed=SetImageProgress(image,TextureImageTag,y,image->rows);
+ proceed=SetImageProgress(image,TextureImageTag,(MagickOffsetType)
+ y,image->rows);
if (proceed == MagickFalse)
status=MagickFalse;
}
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp critical (MagickCore_TextureImage)
#endif
- proceed=SetImageProgress(image,TextureImageTag,y,image->rows);
+ proceed=SetImageProgress(image,TextureImageTag,(MagickOffsetType) y,
+ image->rows);
if (proceed == MagickFalse)
status=MagickFalse;
}
}
if (SyncAuthenticPixels(image,&image->exception) == MagickFalse)
break;
- proceed=SetImageProgress(image,OpaqueImageTag,y,image->rows);
+ proceed=SetImageProgress(image,OpaqueImageTag,(MagickOffsetType) y,
+ image->rows);
if (proceed == MagickFalse)
break;
}
}
if (SyncAuthenticPixels(image,&image->exception) == MagickFalse)
break;
- proceed=SetImageProgress(image,TransparentImageTag,y,image->rows);
+ proceed=SetImageProgress(image,TransparentImageTag,(MagickOffsetType) y,
+ image->rows);
if (proceed == MagickFalse)
break;
}
"",
" Meta-I Press to implode image pixels about the center.",
"",
- " Meta-W Press to alter an image assize_t a sine wave.",
+ " Meta-W Press to alter an image along a sine wave.",
"",
" Meta-P Press to simulate an oil painting.",
"",
if (*geometry == '\0')
break;
/*
- Alter an image assize_t a sine wave.
+ Alter an image along a sine wave.
*/
XSetCursorState(display,windows,MagickTrue);
XCheckRefreshWindows(display,windows);
d.x = (coeff[2]-coeff[3])*ca;
d.y = (coeff[2]-coeff[3])*sa;
ExpandBounds(d);
- /* Orthogonal points assize_t top of arc */
+ /* Orthogonal points along top of arc */
for( a=ceil((coeff[0]-coeff[1]/2.0)/MagickPI2)*MagickPI2;
a<(coeff[0]+coeff[1]/2.0); a+=MagickPI2 ) {
ca = cos(a); sa = sin(a);
{
fprintf(stderr, "Arc Distort, Internal Coefficients:\n");
for ( i=0; i<5; i++ )
- fprintf(stderr, " c%ld = %+lf\n", i, coeff[i]);
+ fprintf(stderr, " c%ld = %+lf\n", (long) i, coeff[i]);
fprintf(stderr, "Arc Distort, FX Equivelent:\n");
fprintf(stderr, "%s", image_gen);
fprintf(stderr, " -fx 'ii=i+page.x; jj=j+page.y;\n");
{
fprintf(stderr, "Polar Distort, Internal Coefficents\n");
for ( i=0; i<8; i++ )
- fprintf(stderr, " c%ld = %+lf\n", i, coeff[i]);
+ fprintf(stderr, " c%ld = %+lf\n", (long) i, coeff[i]);
fprintf(stderr, "Polar Distort, FX Equivelent:\n");
fprintf(stderr, "%s", image_gen);
fprintf(stderr, " -fx 'ii=i+page.x%+lf; jj=j+page.y%+lf;\n",
{
fprintf(stderr, "DePolar Distort, Internal Coefficents\n");
for ( i=0; i<8; i++ )
- fprintf(stderr, " c%ld = %+lf\n", i, coeff[i]);
+ fprintf(stderr, " c%ld = %+lf\n", (long) i, coeff[i]);
fprintf(stderr, "DePolar Distort, FX Equivelent:\n");
fprintf(stderr, "%s", image_gen);
fprintf(stderr, " -fx 'aa=(i+.5)*%lf %+lf;\n", coeff[6], -coeff[4] );
**restrict resample_filter;
ssize_t
- j,
- y;
+ j;
status=MagickTrue;
progress=0;
return((Image *) NULL);
}
{ /* ----- MAIN CODE ----- */
- ssize_t
- j,
- progress;
+ CacheView
+ *sparse_view;
MagickBooleanType
status;
- CacheView
- *sparse_view;
+ MagickOffsetType
+ progress;
+
+ ssize_t
+ j;
status=MagickTrue;
progress=0;
static PolygonInfo *ConvertPathToPolygon(
const DrawInfo *magick_unused(draw_info),const PathInfo *path_info)
{
- ssize_t
+ long
direction,
next_direction;
const FillRule fill_rule,const double x,const double y,
MagickRealType *stroke_opacity)
{
- int
- winding_number;
-
- ssize_t
- j;
-
MagickRealType
alpha,
beta,
register ssize_t
i;
+ ssize_t
+ j,
+ winding_number;
+
/*
Compute fill & stroke opacity for this (x,y) point.
*/
%
% o sigma: the standard deviation of the Gaussian, in pixels.
%
-% o angle: Apply the effect assize_t this angle.
+% o angle: Apply the effect along this angle.
%
% o exception: return any errors or warnings in this structure.
%
%
% ClutImage() replaces each color value in the given image, by using it as an
% index to lookup a replacement color value in a Color Look UP Table in the
-% form of an image. The values are extracted assize_t a diagonal of the CLUT
+% form of an image. The values are extracted along a diagonal of the CLUT
% image so either a horizontal or vertial gradient image can be used.
%
% Typically this is used to either re-color a gray-scale image according to a
%
% o draw_info: the draw info.
%
-% o angle: Apply the effect assize_t this angle.
+% o angle: Apply the effect along this angle.
%
% o exception: return any errors or warnings in this structure.
%
%
% o sigma: the standard deviation of the Gaussian, in pixels.
%
-% o angle: Apply the effect assize_t this angle.
+% o angle: Apply the effect along this angle.
%
% o exception: return any errors or warnings in this structure.
%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% WaveImage() creates a "ripple" effect in the image by shifting the pixels
-% vertically assize_t a sine wave whose amplitude and wavelength is specified
+% vertically along a sine wave whose amplitude and wavelength is specified
% by the given parameters.
%
% The format of the WaveImage method is:
next->next=list_info->head;
while (next->next != (ElementInfo *) NULL)
{
- i=compare(value,next->next->value);
+ i=(ssize_t) compare(value,next->next->value);
if ((i < 0) || ((replace != (void **) NULL) && (i == 0)))
{
if (i == 0)
*root;
ssize_t
- x,
+ x;
+
+ MagickOffsetType
progress;
size_t
}
p++;
}
- proceed=SetImageProgress(image,EvaluateImageTag,y,image->rows);
+ proceed=SetImageProgress(image,EvaluateImageTag,(MagickOffsetType) y,
+ image->rows);
if (proceed == MagickFalse)
break;
}
MagickBooleanType
proceed;
- proceed=SetImageProgress(image,HistogramImageTag,i,number_colors);
+ proceed=SetImageProgress(image,HistogramImageTag,(MagickOffsetType) i,
+ number_colors);
if (proceed == MagickFalse)
status=MagickFalse;
}
if ((image->page.width != 0) || (image->page.height != 0) ||
(image->page.x != 0) || (image->page.y != 0))
(void) fprintf(file,"%lux%lu%+ld%+ld ",image->page.width,
- image->page.height,image->page.x,image->page.y);
+ image->page.height,(long) image->page.x,(long) image->page.y);
(void) fprintf(file,"%lu-bit ",image->depth);
if (image->type != UndefinedType)
(void) fprintf(file,"%s ",MagickOptionToMnemonic(MagickTypeOptions,
(void) fprintf(file,"PseudoClass %lu=>%luc ",image->total_colors,
image->colors);
if (image->error.mean_error_per_pixel != 0.0)
- (void) fprintf(file,"%ld/%f/%fdb ",(ssize_t)
+ (void) fprintf(file,"%ld/%f/%fdb ",(long)
(image->error.mean_error_per_pixel+0.5),
image->error.normalized_mean_error,
image->error.normalized_maximum_error);
(void) FormatMagickSize(GetBlobSize(image),MagickFalse,format);
(void) fprintf(file,"%sB ",format);
}
- (void) fprintf(file,"%0.3fu %ld:%02ld.%03ld",user_time,(ssize_t)
- (elapsed_time/60.0),(ssize_t) floor(fmod(elapsed_time,60.0)),
- (ssize_t) (1000.0*(elapsed_time-floor(elapsed_time))));
+ (void) fprintf(file,"%0.3fu %ld:%02ld.%03ld",user_time,(long)
+ (elapsed_time/60.0),(long) floor(fmod(elapsed_time,60.0)),
+ (long) (1000.0*(elapsed_time-floor(elapsed_time))));
(void) fprintf(file,"\n");
(void) fflush(file);
return(ferror(file) != 0 ? MagickFalse : MagickTrue);
(void) fprintf(file," Class: %s\n",MagickOptionToMnemonic(MagickClassOptions,
(ssize_t) image->storage_class));
(void) fprintf(file," Geometry: %lux%lu%+ld%+ld\n",image->columns,
- image->rows,image->tile_offset.x,image->tile_offset.y);
+ image->rows,(long) image->tile_offset.x,(long) image->tile_offset.y);
if ((image->magick_columns != 0) || (image->magick_rows != 0))
if ((image->magick_columns != image->columns) ||
(image->magick_rows != image->rows))
(void) QueryMagickColorname(image,&pixel,SVGCompliance,color,
&image->exception);
GetColorTuple(&pixel,MagickTrue,hex);
- (void) fprintf(file," %8ld: %s %s %s\n",i,tuple,hex,color);
+ (void) fprintf(file," %8ld: %s %s %s\n",(long) i,tuple,hex,color);
p++;
}
}
if ((image->extract_info.width*image->extract_info.height) != 0)
(void) fprintf(file," Tile geometry: %lux%lu%+ld%+ld\n",
image->extract_info.width,image->extract_info.height,
- image->extract_info.x,image->extract_info.y);
+ (long) image->extract_info.x,(long) image->extract_info.y);
(void) fprintf(file," Interlace: %s\n",MagickOptionToMnemonic(
MagickInterlaceOptions,(ssize_t) image->interlace));
(void) QueryColorname(image,&image->background_color,SVGCompliance,color,
if ((image->page.width != 0) || (image->page.height != 0) ||
(image->page.x != 0) || (image->page.y != 0))
(void) fprintf(file," Page geometry: %lux%lu%+ld%+ld\n",image->page.width,
- image->page.height,image->page.x,image->page.y);
+ image->page.height,(long) image->page.x,(long) image->page.y);
if ((image->page.x != 0) || (image->page.y != 0))
- (void) fprintf(file," Origin geometry: %+ld%+ld\n",image->page.x,
- image->page.y);
+ (void) fprintf(file," Origin geometry: %+ld%+ld\n",(long) image->page.x,
+ (long) image->page.y);
(void) fprintf(file," Dispose: %s\n",MagickOptionToMnemonic(
MagickDisposeOptions,(ssize_t) image->dispose));
if (image->delay != 0)
(void) fprintf(file," Delay: %lux%ld\n",image->delay,
- image->ticks_per_second);
+ (long) image->ticks_per_second);
if (image->iterations != 1)
(void) fprintf(file," Iterations: %lu\n",image->iterations);
if ((image->next != (Image *) NULL) || (image->previous != (Image *) NULL))
const char
*tag;
- ssize_t
+ long
dataset,
record,
sentinel;
elapsed_time+0.5),MagickFalse,format);
(void) fprintf(file," Pixels per second: %s\n",format);
(void) fprintf(file," User time: %0.3fu\n",user_time);
- (void) fprintf(file," Elapsed time: %ld:%02ld.%03ld\n",(ssize_t)
- (elapsed_time/60.0),(ssize_t) ceil(fmod(elapsed_time,60.0)),(ssize_t)
+ (void) fprintf(file," Elapsed time: %ld:%02ld.%03ld\n",(long)
+ (elapsed_time/60.0),(long) ceil(fmod(elapsed_time,60.0)),(long)
(1000.0*(elapsed_time-floor(elapsed_time))));
(void) fprintf(file," Version: %s\n",GetMagickVersion((size_t *)
NULL));
break;
for (x=0; x < (ssize_t) bounds->width; x++)
{
- if ((p->opacity <= (ssize_t) (QuantumRange/2)) &&
- (q->opacity > (ssize_t) (QuantumRange/2)))
+ if ((p->opacity <= (Quantum) (QuantumRange/2)) &&
+ (q->opacity > (Quantum) (QuantumRange/2)))
break;
p++;
q++;
MagickBooleanType
proceed;
- MagickOffsetType
- scene;
-
RectangleInfo
page;
- size_t
- width,
- height;
-
register const Image
*next;
size_t
- number_images;
+ number_images,
+ height,
+ width;
+
+ ssize_t
+ scene;
assert(image != (Image *) NULL);
assert(image->signature == MagickSignature);
{
(void) CompositeImage(canvas,image->compose,image,image->page.x-
canvas->page.x,image->page.y-canvas->page.y);
- proceed=SetImageProgress(image,MergeLayersTag,scene,number_images);
+ proceed=SetImageProgress(image,MergeLayersTag,(MagickOffsetType) scene,
+ number_images);
if (proceed == MagickFalse)
break;
image=GetNextImageInList(image);
*clone_images,
*image;
- ssize_t
+ long
first,
last,
step;
i=0;
for (next=images; next != (Image *) NULL; next=GetNextImageInList(next))
{
- if (i == first)
+ if (i == (ssize_t) first)
{
image=CloneImage(next,0,0,MagickTrue,exception);
if (image == (Image *) NULL)
Image
*image;
- ssize_t
+ long
first,
last;
}
if (first > last)
continue;
- for (i=first; i <= last; i++)
+ for (i=(ssize_t) first; i <= (ssize_t) last; i++)
if ((i >= 0) && (i < (ssize_t) length))
delete_list[i]=MagickTrue;
}
(void) fprintf(file,"%s",magic_info[i]->name);
for (j=(ssize_t) strlen(magic_info[i]->name); j <= 9; j++)
(void) fprintf(file," ");
- (void) fprintf(file,"%6ld ",(ssize_t) magic_info[i]->offset);
+ (void) fprintf(file,"%6ld ",(long) magic_info[i]->offset);
if (magic_info[i]->target != (char *) NULL)
{
register ssize_t
EndianType
endian;
- ssize_t
+ long
value;
register const MimeInfo
ExceptionInfo
*exception;
+ MagickBooleanType
+ status;
+
AcquireSemaphoreInfo(&module_semaphore);
exception=AcquireExceptionInfo();
- InitializeModuleList(exception);
+ status=InitializeModuleList(exception);
exception=DestroyExceptionInfo(exception);
- return(MagickTrue);
+ return(status);
}
\f
/*
if (kernel->values == (double *) NULL)
return(DestroyKernelInfo(kernel));
- /* set all kernel values assize_t axises to given scale */
+ /* set all kernel values along axises to given scale */
for ( i=0, v=-kernel->y; v <= (ssize_t)kernel->y; v++)
for ( u=-kernel->x; u <= (ssize_t)kernel->x; u++, i++)
kernel->values[i] = (u == 0 || v == 0) ? args->sigma : nan;
if (kernel->values == (double *) NULL)
return(DestroyKernelInfo(kernel));
- /* set all kernel values assize_t axises to given scale */
+ /* set all kernel values along axises to given scale */
for ( i=0, v=-kernel->y; v <= (ssize_t)kernel->y; v++)
for ( u=-kernel->x; u <= (ssize_t)kernel->x; u++, i++)
kernel->values[i] = (u == v || u == -v) ? args->sigma : nan;
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% GradientImage() applies a continuously smooth color transitions assize_t a
+% GradientImage() applies a continuously smooth color transitions along a
% vector from one color to another.
%
% Note, the interface of this method will change in the future to support
ResetImageProfileIterator(image);
for (name=GetNextImageProfile(image); name != (const char *) NULL; )
{
- for (i=1; i < number_arguments; i++)
+ for (i=1; i < (ssize_t) number_arguments; i++)
{
if ((*arguments[i] == '!') &&
(LocaleCompare(name,arguments[i]+1) == 0))
}
name=GetNextImageProfile(image);
}
- for (i=0; i < number_arguments; i++)
+ for (i=0; i < (ssize_t) number_arguments; i++)
arguments[i]=DestroyString(arguments[i]);
arguments=(char **) RelinquishMagickMemory(arguments);
return(MagickTrue);
}
if (length < 16)
return(MagickFalse);
- id=(int) ReadProfileShort(LSBEndian,exif);
+ id=(ssize_t) ReadProfileShort(LSBEndian,exif);
endian=LSBEndian;
if (id == 0x4949)
endian=LSBEndian;
const StringInfo
*profile;
- ssize_t
+ long
count,
dataset,
record;
continue;
length=(size_t) (GetStringInfoDatum(profile)[i+3] << 8);
length|=GetStringInfoDatum(profile)[i+4];
- if (((ssize_t) GetStringInfoDatum(profile)[i+1] == dataset) &&
- ((ssize_t) GetStringInfoDatum(profile)[i+2] == record))
+ if (((long) GetStringInfoDatum(profile)[i+1] == dataset) &&
+ ((long) GetStringInfoDatum(profile)[i+2] == record))
{
message=(char *) NULL;
if (~length >= 1)
const unsigned char
*info;
- ssize_t
- id,
+ long
start,
- stop,
- sub_number;
+ stop;
MagickBooleanType
status;
i;
ssize_t
- count;
+ count,
+ id,
+ sub_number;
size_t
length;
if (ReadPropertyByte(&info,&length) != (unsigned char) 'M')
continue;
id=(ssize_t) ReadPropertyMSBShort(&info,&length);
- if (id < start)
+ if (id < (ssize_t) start)
continue;
- if (id > stop)
+ if (id > (ssize_t) stop)
continue;
if (resource != (char *) NULL)
resource=DestroyString(resource);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
break;
- proceed=SetImageProgress(image,AssignImageTag,y,image->rows);
+ proceed=SetImageProgress(image,AssignImageTag,(MagickOffsetType) y,
+ image->rows);
if (proceed == MagickFalse)
break;
}
/*
Start at the root and descend the color cube tree.
*/
- for (count=1; (x+count) < image->columns; count++)
+ for (count=1; (x+count) < (ssize_t) image->columns; count++)
if (IsSameColor(image,p,p+count) == MagickFalse)
break;
AssociateAlphaPixel(cube_info,p,&pixel);
PruneToCubeDepth(image,cube_info,cube_info->root);
break;
}
- proceed=SetImageProgress(image,ClassifyImageTag,y,image->rows);
+ proceed=SetImageProgress(image,ClassifyImageTag,(MagickOffsetType) y,
+ image->rows);
if (proceed == MagickFalse)
break;
}
/*
Start at the root and descend the color cube tree.
*/
- for (count=1; (x+count) < image->columns; count++)
+ for (count=1; (x+count) < (ssize_t) image->columns; count++)
if (IsSameColor(image,p,p+count) == MagickFalse)
break;
AssociateAlphaPixel(cube_info,p,&pixel);
node_info->total_color.opacity+=count*QuantumScale*pixel.opacity;
p+=count;
}
- proceed=SetImageProgress(image,ClassifyImageTag,y,image->rows);
+ proceed=SetImageProgress(image,ClassifyImageTag,(MagickOffsetType) y,
+ image->rows);
if (proceed == MagickFalse)
break;
}
number_children=cube_info->associate_alpha == MagickFalse ? 8UL : 16UL;
for (i=0; i < (ssize_t) number_children; i++)
if (node_info->child[i] != (NodeInfo *) NULL)
- DefineImageColormap(image,cube_info,node_info->child[i]);
+ (void) DefineImageColormap(image,cube_info,node_info->child[i]);
if (node_info->number_unique != 0)
{
register MagickRealType
indexes=GetCacheViewAuthenticIndexQueue(image_view);
current=scanlines+(y & 0x01)*image->columns;
previous=scanlines+((y+1) & 0x01)*image->columns;
- v=(y & 0x01) ? -1 : 1;
+ v=(ssize_t) ((y & 0x01) ? -1 : 1);
for (x=0; x < (ssize_t) image->columns; x++)
{
u=(y & 0x01) ? (ssize_t) image->columns-1-x : x;
if (cube_info->quantize_info->dither_method == FloydSteinbergDitherMethod)
return(FloydSteinbergDither(image,cube_info));
/*
- Distribute quantization error assize_t a Hilbert curve.
+ Distribute quantization error along a Hilbert curve.
*/
(void) ResetMagickMemory(cube_info->error,0,ErrorQueueLength*
sizeof(*cube_info->error));
for (i=0; i < (ssize_t) length; i++)
cube_info->cache[i]=(-1);
/*
- Distribute weights assize_t a curve of exponential decay.
+ Distribute weights along a curve of exponential decay.
*/
weight=1.0;
for (i=0; i < ErrorQueueLength; i++)
indexes=GetCacheViewAuthenticIndexQueue(image_view);
for (x=0; x < (ssize_t) image->columns; x++)
{
- indexes[x]=i;
+ indexes[x]=(IndexPacket) i;
image->colormap[i++]=(*q++);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
break;
- proceed=SetImageProgress(image,AssignImageTag,y,image->rows);
+ proceed=SetImageProgress(image,AssignImageTag,(MagickOffsetType) y,
+ image->rows);
if (proceed == MagickFalse)
status=MagickFalse;
}
if (status == MagickFalse)
break;
(void) SetImageProgressMonitor(image,progress_monitor,image->client_data);
- proceed=SetImageProgress(image,AssignImageTag,i,number_images);
+ proceed=SetImageProgress(image,AssignImageTag,(MagickOffsetType) i,
+ number_images);
if (proceed == MagickFalse)
break;
image=GetNextImageInList(image);
break;
(void) SetImageProgressMonitor(image,progress_monitor,
image->client_data);
- proceed=SetImageProgress(image,AssignImageTag,i,number_images);
+ proceed=SetImageProgress(image,AssignImageTag,(MagickOffsetType) i,
+ number_images);
if (proceed == MagickFalse)
break;
image=GetNextImageInList(image);
color_2=(PixelPacket *) y;
intensity=PixelIntensityToQuantum(color_1)-(ssize_t)
PixelIntensityToQuantum(color_2);
- return(intensity);
+ return((int) intensity);
}
#if defined(__cplusplus) || defined(c_plusplus)
q=PopCharPixel(pixel,q);
pixel=ScaleQuantumToChar(GetBluePixelComponent(p));
q=PopCharPixel(pixel,q);
- pixel=ScaleQuantumToChar(GetAlphaPixelComponent(p));
+ pixel=ScaleQuantumToChar((Quantum) GetAlphaPixelComponent(p));
q=PopCharPixel(pixel,q);
p++;
q+=quantum_info->pad;
case 0: quantum=p->red; break;
case 1: quantum=p->green; break;
case 2: quantum=p->blue; break;
- case 3: quantum=QuantumRange-p->opacity; break;
+ case 3: quantum=(Quantum) (QuantumRange-p->opacity); break;
}
switch (n % 3)
{
case 0:
{
- pixel|=(size_t) (ScaleQuantumToAny(quantum,
+ pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
range) << 22);
break;
}
case 1:
{
- pixel|=(size_t) (ScaleQuantumToAny(quantum,
+ pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
range) << 12);
break;
}
case 2:
{
- pixel|=(size_t) (ScaleQuantumToAny(quantum,
+ pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
range) << 2);
q=PopLongPixel(endian,pixel,q);
pixel=0;
q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
pixel=(size_t) ScaleQuantumToAny(p->blue,range);
q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
- pixel=(size_t) ScaleQuantumToAny(QuantumRange-p->opacity,
- range);
+ pixel=(size_t) ScaleQuantumToAny((Quantum) (QuantumRange-
+ p->opacity),range);
q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
p++;
q+=quantum_info->pad;
q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
pixel=(size_t) ScaleQuantumToAny(p->blue,range);
q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
- pixel=(size_t) ScaleQuantumToAny(QuantumRange-
- p->opacity,range);
+ pixel=(size_t) ScaleQuantumToAny((Quantum) (QuantumRange-
+ p->opacity),range);
q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
p++;
q+=quantum_info->pad;
q=PopShortPixel(endian,pixel,q);
pixel=ScaleQuantumToShort(GetBluePixelComponent(p));
q=PopShortPixel(endian,pixel,q);
- pixel=ScaleQuantumToShort(GetAlphaPixelComponent(p));
+ pixel=ScaleQuantumToShort((Quantum) GetAlphaPixelComponent(p));
q=PopShortPixel(endian,pixel,q);
p++;
q+=quantum_info->pad;
q=PopFloatPixel(&quantum_state,(float) p->red,q);
q=PopFloatPixel(&quantum_state,(float) p->green,q);
q=PopFloatPixel(&quantum_state,(float) p->blue,q);
- pixel=GetAlphaPixelComponent(p);
+ pixel=(float) GetAlphaPixelComponent(p);
q=PopFloatPixel(&quantum_state,pixel,q);
p++;
q+=quantum_info->pad;
q=PopLongPixel(endian,pixel,q);
pixel=ScaleQuantumToLong(GetBluePixelComponent(p));
q=PopLongPixel(endian,pixel,q);
- pixel=ScaleQuantumToLong(GetAlphaPixelComponent(p));
+ pixel=ScaleQuantumToLong((Quantum) GetAlphaPixelComponent(p));
q=PopLongPixel(endian,pixel,q);
p++;
q+=quantum_info->pad;
q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
GetBluePixelComponent(p),range),q);
q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
- GetAlphaPixelComponent(p),range),q);
+ (Quantum) GetAlphaPixelComponent(p),range),q);
p++;
q+=quantum_info->pad;
}
if (random_info == (RandomInfo *) NULL)
random_info=AcquireRandomInfo();
file=(-1);
- for (i=0; i < TMP_MAX; i++)
+ for (i=0; i < (ssize_t) TMP_MAX; i++)
{
/*
Get temporary pathname.
pagesize=GetMagickPageSize();
pages=(-1);
#if defined(MAGICKCORE_HAVE_SYSCONF) && defined(_SC_PHYS_PAGES)
- pages=sysconf(_SC_PHYS_PAGES);
+ pages=(ssize_t) sysconf(_SC_PHYS_PAGES);
#endif
memory=(MagickSizeType) pages*pagesize;
if ((pagesize <= 0) || (pages <= 0))
}
files=(-1);
#if defined(MAGICKCORE_HAVE_SYSCONF) && defined(_SC_OPEN_MAX)
- files=sysconf(_SC_OPEN_MAX);
+ files=(ssize_t) sysconf(_SC_OPEN_MAX);
#endif
#if defined(MAGICKCORE_HAVE_GETRLIMIT) && defined(RLIMIT_NOFILE)
if (files < 0)
(void) fprintf(stdout,"\n\nNumber of Vectors Per Cluster\n");
(void) fprintf(stdout,"=============================\n\n");
for (cluster=head; cluster != (Cluster *) NULL; cluster=cluster->next)
- (void) fprintf(stdout,"Cluster #%ld = %ld\n",cluster->id,
- cluster->count);
+ (void) fprintf(stdout,"Cluster #%ld = %ld\n",(long) cluster->id,
+ (long) cluster->count);
/*
Print the cluster extents.
*/
(void) fprintf(stdout,"================");
for (cluster=head; cluster != (Cluster *) NULL; cluster=cluster->next)
{
- (void) fprintf(stdout,"\n\nCluster #%ld\n\n",cluster->id);
- (void) fprintf(stdout,"%ld-%ld %ld-%ld %ld-%ld\n",cluster->red.left,
- cluster->red.right,cluster->green.left,cluster->green.right,
- cluster->blue.left,cluster->blue.right);
+ (void) fprintf(stdout,"\n\nCluster #%ld\n\n",(long) cluster->id);
+ (void) fprintf(stdout,"%ld-%ld %ld-%ld %ld-%ld\n",(long)
+ cluster->red.left,(long) cluster->red.right,(long)
+ cluster->green.left,(long) cluster->green.right,(long)
+ cluster->blue.left,(long) cluster->blue.right);
}
/*
Print the cluster center values.
(void) fprintf(stdout,"=====================");
for (cluster=head; cluster != (Cluster *) NULL; cluster=cluster->next)
{
- (void) fprintf(stdout,"\n\nCluster #%ld\n\n",cluster->id);
+ (void) fprintf(stdout,"\n\nCluster #%ld\n\n",(long) cluster->id);
(void) fprintf(stdout,"%g %g %g\n",(double)
cluster->red.center,(double) cluster->green.center,(double)
cluster->blue.center);
if (((count % 2) == 0) && (right != k))
correct=right;
}
- l=zero_crossing[i].crossings[j];
+ l=(ssize_t) zero_crossing[i].crossings[j];
zero_crossing[i].crossings[j]=0;
if (correct != -1)
zero_crossing[i].crossings[correct]=(short) l;
}
p++;
}
- proceed=SetImageProgress(image,SegmentImageTag,y,2*image->rows);
+ proceed=SetImageProgress(image,SegmentImageTag,(MagickOffsetType) y,
+ 2*image->rows);
if (proceed == MagickFalse)
break;
}
%
% o image: the image.
%
-% o degrees: A MagickRealType representing the shearing angle assize_t the X
+% o degrees: A MagickRealType representing the shearing angle along the X
% axis.
%
% o width, height, x_offset, y_offset: Defines a region of the image
%
% o image: the image.
%
-% o degrees: A MagickRealType representing the shearing angle assize_t the Y
+% o degrees: A MagickRealType representing the shearing angle along the Y
% axis.
%
% o width, height, x_offset, y_offset: Defines a region of the image
height=image->columns;
}
y_width=width+(ssize_t) floor(fabs(shear.x)*height+0.5);
- x_offset=(ssize_t) ceil(width+((fabs(shear.y)*height)-width)/2.0-0.5);
- y_offset=(ssize_t) ceil(height+((fabs(shear.y)*y_width)-height)/2.0-0.5);
+ x_offset=(ssize_t) ceil((double) width+((fabs(shear.y)*height)-width)/2.0-
+ 0.5);
+ y_offset=(ssize_t) ceil((double) height+((fabs(shear.y)*y_width)-height)/2.0-
+ 0.5);
/*
Surround image with a border.
*/
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% ShearImage() creates a new image that is a shear_image copy of an existing
-% one. Shearing slides one edge of an image assize_t the X or Y axis, creating
-% a parallelogram. An X direction shear slides an edge assize_t the X axis,
-% while a Y direction shear slides an edge assize_t the Y axis. The amount of
+% one. Shearing slides one edge of an image along the X or Y axis, creating
+% a parallelogram. An X direction shear slides an edge along the X axis,
+% while a Y direction shear slides an edge along the Y axis. The amount of
% the shear is controlled by a shear angle. For X direction shears, x_shear
% is measured relative to the Y axis, and similarly, for Y direction shears
% y_shear is measured relative to the X axis. Empty triangles left over from
Compute image size.
*/
y_width=image->columns+(ssize_t) floor(fabs(shear.x)*image->rows+0.5);
- x_offset=(ssize_t) ceil(image->columns+((fabs(shear.x)*image->rows)-
+ x_offset=(ssize_t) ceil((double) image->columns+((fabs(shear.x)*image->rows)-
image->columns)/2.0-0.5);
- y_offset=(ssize_t) ceil(image->rows+((fabs(shear.y)*y_width)-image->rows)/2.0-
- 0.5);
+ y_offset=(ssize_t) ceil((double) image->rows+((fabs(shear.y)*y_width)-
+ image->rows)/2.0-0.5);
/*
Surround image with border.
*/
if ( map->levels == (ssize_t *)NULL )
ThrowFatalException(ResourceLimitFatalError,"UnableToAcquireThresholdMap");
{ /* parse levels into integer array */
- int i;
+ ssize_t i;
char *p;
for( i=0; i< (ssize_t) (map->width*map->height); i++) {
- map->levels[i] = (int)strtol(content, &p, 10);
+ map->levels[i] = (ssize_t)strtol(content, &p, 10);
if ( p == content ) {
(void) ThrowMagickException(exception,GetMagickModule(),OptionError,
"XmlInvalidContent", "<level> too few values, map \"%s\"", map_id);
#endif
{ /* Do the posterized ordered dithering of the image */
- int
+ ssize_t
d;
/* d = number of psuedo-level divisions added between color levels */
indexes=GetCacheViewAuthenticIndexQueue(image_view);
for (x=0; x < (ssize_t) image->columns; x++)
{
- register int
+ register ssize_t
threshold,
t,
l;
Opacity is inverted so 'off' represents transparent.
*/
if (levels.red) {
- t = (int) (QuantumScale*q->red*(levels.red*d+1));
+ t = (ssize_t) (QuantumScale*q->red*(levels.red*d+1));
l = t/d; t = t-l*d;
q->red=(Quantum) ((l+(t >= threshold))*QuantumRange/levels.red);
}
if (levels.green) {
- t = (int) (QuantumScale*q->green*(levels.green*d+1));
+ t = (ssize_t) (QuantumScale*q->green*(levels.green*d+1));
l = t/d; t = t-l*d;
q->green=(Quantum) ((l+(t >= threshold))*QuantumRange/levels.green);
}
if (levels.blue) {
- t = (int) (QuantumScale*q->blue*(levels.blue*d+1));
+ t = (ssize_t) (QuantumScale*q->blue*(levels.blue*d+1));
l = t/d; t = t-l*d;
q->blue=(Quantum) ((l+(t >= threshold))*QuantumRange/levels.blue);
}
if (levels.opacity) {
- t = (int) ((1.0-QuantumScale*q->opacity)*(levels.opacity*d+1));
+ t = (ssize_t) ((1.0-QuantumScale*q->opacity)*(levels.opacity*d+1));
l = t/d; t = t-l*d;
q->opacity=(Quantum) ((1.0-l-(t >= threshold))*QuantumRange/
levels.opacity);
}
if (levels.index) {
- t = (int) (QuantumScale*indexes[x]*(levels.index*d+1));
+ t = (ssize_t) (QuantumScale*indexes[x]*(levels.index*d+1));
l = t/d; t = t-l*d;
indexes[x]=(IndexPacket) ((l+(t>=threshold))*QuantumRange/
levels.index);
for (p=string; *p != '\0'; p++)
if (c == (int) (*p))
- return(p-string);
+ return((ssize_t) (p-string));
return(-1);
}
errno=EPERM;
(void) ThrowMagickException(exception,GetMagickModule(),PolicyError,
"NotAuthorized","`%s'",arguments[1]);
- for (i=0; i < number_arguments; i++)
+ for (i=0; i < (ssize_t) number_arguments; i++)
arguments[i]=DestroyString(arguments[i]);
arguments=(char **) RelinquishMagickMemory(arguments);
return(-1);
"`%s' (%d)",command,status);
if (shell_command != command)
shell_command=DestroyString(shell_command);
- for (i=0; i < number_arguments; i++)
+ for (i=0; i < (ssize_t) number_arguments; i++)
arguments[i]=DestroyString(arguments[i]);
arguments=(char **) RelinquishMagickMemory(arguments);
return(status);
for (l=0; (*p != '\0') && (((l == 0) && (*p != '>')) ||
((l != 0) && ((*p != ']') ||
(*(p+strspn(p+1,XMLWhitespace)+1) != '>'))));
- l=(*p == '[') ? 1 : l)
+ l=(ssize_t) (*p == '[') ? 1 : l)
p+=strcspn(p+1,"[]>")+1;
if ((*p == '\0') && (terminal != '>'))
{
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% PruneTagFromXMLTree() prunes a tag from the xml-tree assize_t with all its
+% PruneTagFromXMLTree() prunes a tag from the xml-tree along with all its
% subtags.
%
% The format of the PruneTagFromXMLTree method is:
*/
FireImageStack(MagickFalse,MagickFalse,pend);
filename=option;
- if ((LocaleCompare(filename,"--") == 0) && (i < (argc-1)))
+ if ((LocaleCompare(filename,"--") == 0) && (i < (ssize_t) (argc-1)))
{
option=argv[++i];
filename=option;
*/
FireImageStack(MagickFalse,MagickFalse,pend);
filename=argv[i];
- if ((LocaleCompare(filename,"--") == 0) && (i < (argc-1)))
+ if ((LocaleCompare(filename,"--") == 0) && (i < (ssize_t) (argc-1)))
filename=argv[++i];
(void) CopyMagickString(image_info->filename,filename,MaxTextExtent);
images=ReadImages(image_info,exception);
(double) distortion);
if ((reconstruct_image->columns != image->columns) ||
(reconstruct_image->rows != image->rows))
- (void) fprintf(stderr," @ %ld,%ld",difference_image->page.x,
- difference_image->page.y);
+ (void) fprintf(stderr," @ %ld,%ld",(long)
+ difference_image->page.x,(long) difference_image->page.y);
(void) fprintf(stderr,"\n");
break;
}
(void) fprintf(stderr,"%g",distortion);
if ((reconstruct_image->columns != image->columns) ||
(reconstruct_image->rows != image->rows))
- (void) fprintf(stderr," @ %ld,%ld",difference_image->page.x,
- difference_image->page.y);
+ (void) fprintf(stderr," @ %ld,%ld",(long)
+ difference_image->page.x,(long) difference_image->page.y);
(void) fprintf(stderr,"\n");
break;
}
image->error.normalized_maximum_error);
if ((reconstruct_image->columns != image->columns) ||
(reconstruct_image->rows != image->rows))
- (void) fprintf(stderr," @ %ld,%ld",difference_image->page.x,
- difference_image->page.y);
+ (void) fprintf(stderr," @ %ld,%ld",(long)
+ difference_image->page.x,(long) difference_image->page.y);
(void) fprintf(stderr,"\n");
break;
}
(void) fprintf(stderr,"Image: %s\n",image->filename);
if ((reconstruct_image->columns != image->columns) ||
(reconstruct_image->rows != image->rows))
- (void) fprintf(stderr,"Offset: %ld,%ld\n",difference_image->page.x,
- difference_image->page.y);
+ (void) fprintf(stderr,"Offset: %ld,%ld\n",(long)
+ difference_image->page.x,(long) difference_image->page.y);
(void) fprintf(stderr," Channel distortion: %s\n",
MagickOptionToMnemonic(MagickMetricOptions,(ssize_t) metric));
switch (metric)
*/
FireImageStack(MagickFalse,MagickFalse,pend);
filename=argv[i];
- if ((LocaleCompare(filename,"--") == 0) && (i < (argc-1)))
+ if ((LocaleCompare(filename,"--") == 0) && (i < (ssize_t) (argc-1)))
filename=argv[++i];
(void) CopyMagickString(image_info->filename,filename,MaxTextExtent);
images=ReadImages(image_info,exception);
status=image != (Image *) NULL ? MagickTrue : MagickFalse;
number_images++;
}
- if (i != argc)
+ if (i != (ssize_t) argc)
ThrowConjureException(OptionError,"MissingAnImageFilename",argv[i]);
if (number_images == 0)
ThrowConjureException(OptionError,"MissingAnImageFilename",argv[argc-1]);
"-charcoal radius simulate a charcoal drawing",
"-chop geometry remove pixels from the image interior",
"-clamp restrict pixel range from 0 to the quantum depth",
- "-clip clip assize_t the first path from the 8BIM profile",
+ "-clip clip along the first path from the 8BIM profile",
"-clip-mask filename associate a clip mask with the image",
- "-clip-path id clip assize_t a named path from the 8BIM profile",
+ "-clip-path id clip along a named path from the 8BIM profile",
"-colorize value colorize the image with the fill color",
"-color-matrix matrix apply color correction to the image",
"-contrast enhance or reduce the image contrast",
"-shadow geometry simulate an image shadow",
"-sharpen geometry sharpen the image",
"-shave geometry shave pixels from the image edges",
- "-shear geometry slide one edge of the image assize_t the X or Y axis",
+ "-shear geometry slide one edge of the image along the X or Y axis",
"-sigmoidal-contrast geometry",
" increase the contrast without saturating highlights or shadows",
"-sketch geometry simulate a pencil sketch",
"-unique-colors discard all but one of any pixel color",
"-unsharp geometry sharpen the image",
"-vignette geometry soften the edges of the image in vignette style",
- "-wave geometry alter an image assize_t a sine wave",
+ "-wave geometry alter an image along a sine wave",
"-white-threshold value",
" force all pixels above the threshold into white",
(char *) NULL
*/
FireImageStack(MagickTrue,MagickTrue,pend);
filename=argv[i];
- if ((LocaleCompare(filename,"--") == 0) && (i < (argc-1)))
+ if ((LocaleCompare(filename,"--") == 0) && (i < (ssize_t) (argc-1)))
filename=argv[++i];
(void) CopyMagickString(image_info->filename,filename,MaxTextExtent);
if (image_info->ping != MagickFalse)
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% MagickClipPathImage() clips assize_t the named paths from the 8BIM profile, if
+% MagickClipPathImage() clips along the named paths from the 8BIM profile, if
% present. Later operations take effect inside the path. Id may be a number
% if preceded with #, to work on a numbered path, e.g., "#1" to use the first
% path.
{
"-auto-orient automagically orient image",
"-border geometry surround image with a border of color",
- "-clip clip assize_t the first path from the 8BIM profile",
- "-clip-path id clip assize_t a named path from the 8BIM profile",
+ "-clip clip along the first path from the 8BIM profile",
+ "-clip-path id clip along a named path from the 8BIM profile",
"-colors value preferred number of colors in the image",
"-contrast enhance or reduce the image contrast",
"-crop geometry preferred size and location of the cropped image",
if (image_marker == (size_t *) NULL)
ThrowDisplayException(ResourceLimitError,"MemoryAllocationFailed",
GetExceptionMessage(errno));
- for (i=0; i <= argc; i++)
+ for (i=0; i <= (ssize_t) argc; i++)
image_marker[i]=(size_t) argc;
/*
Check for server name specified on the command line.
*/
FireImageStack(MagickFalse,MagickFalse,pend);
filename=option;
- if ((LocaleCompare(filename,"--") == 0) && (i < (argc-1)))
+ if ((LocaleCompare(filename,"--") == 0) && (i < (ssize_t) (argc-1)))
{
option=argv[++i];
filename=option;
AppendImageStack(images);
FinalizeImageSettings(image_info,image,MagickFalse);
iterations=0;
- if (i == (argc-1))
+ if (i == (ssize_t) (argc-1))
iterations=image->iterations;
do
{
Proceed to next/previous image.
*/
if ((state & FormerImageState) != 0)
- for (l=0; l < resource_info.quantum; l++)
+ for (l=0; l < (ssize_t) resource_info.quantum; l++)
{
image=GetPreviousImageInList(image);
if (image == (Image *) NULL)
break;
}
else
- for (l=0; l < resource_info.quantum; l++)
+ for (l=0; l < (ssize_t) resource_info.quantum; l++)
{
image=GetNextImageInList(image);
if (image == (Image *) NULL)
if ((state & FormerImageState) != 0)
{
- for (i=1; i < (argc-2); i++)
+ for (i=1; i < (ssize_t) (argc-2); i++)
if (last_image == image_marker[i])
break;
image_number=(ssize_t) image_marker[i]+1;
if ((wand->filter_off != MagickFalse) ||
(CurrentContext->opacity != quantum_opacity))
{
- CurrentContext->opacity=opacity;
+ CurrentContext->opacity=(Quantum) opacity;
(void) MvgPrintf(wand,"opacity %g\n",opacity);
}
}
char
*p;
- ssize_t
+ long
value;
value=strtol(point,&p,10);
identify_info=CloneImageInfo(image_info);
identify_info->verbose=MagickFalse;
filename=argv[i];
- if ((LocaleCompare(filename,"--") == 0) && (i < (argc-1)))
+ if ((LocaleCompare(filename,"--") == 0) && (i < (ssize_t) (argc-1)))
filename=argv[++i];
(void) CopyMagickString(identify_info->filename,filename,MaxTextExtent);
if (identify_info->ping != MagickFalse)
}
if (k != 0)
ThrowIdentifyException(OptionError,"UnbalancedParenthesis",argv[i]);
- if (i != argc)
+ if (i != (ssize_t) argc)
ThrowIdentifyException(OptionError,"MissingAnImageFilename",argv[i]);
DestroyIdentify();
return(status != 0 ? MagickTrue : MagickFalse);
}
if (k != 0)
ThrowImportException(OptionError,"UnbalancedParenthesis",argv[i]);
- if (i-- != argc)
+ if (i-- != (ssize_t) argc)
ThrowImportException(OptionError,"MissingAnImageFilename",argv[i]);
if (image == (Image *) NULL)
ThrowImportException(OptionError,"MissingAnImageFilename",argv[argc-1]);
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% MagickClipImage() clips assize_t the first path from the 8BIM profile, if
+% MagickClipImage() clips along the first path from the 8BIM profile, if
% present.
%
% The format of the MagickClipImage method is:
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% MagickClipImagePath() clips assize_t the named paths from the 8BIM profile, if
+% MagickClipImagePath() clips along the named paths from the 8BIM profile, if
% present. Later operations take effect inside the path. Id may be a number
% if preceded with #, to work on a numbered path, e.g., "#1" to use the first
% path.
%
% o sigma: the standard deviation of the Gaussian, in pixels.
%
-% o angle: Apply the effect assize_t this angle.
+% o angle: Apply the effect along this angle.
%
*/
%
% o drawing_wand: the draw wand.
%
-% o angle: Apply the effect assize_t this angle.
+% o angle: Apply the effect along this angle.
%
*/
WandExport MagickBooleanType MagickPolaroidImage(MagickWand *wand,
%
% o dither: A value other than zero distributes the difference between an
% original image and the corresponding color reduced image to
-% neighboring pixels assize_t a Hilbert curve.
+% neighboring pixels along a Hilbert curve.
%
% o measure_error: A value other than zero measures the difference between
% the original and quantized images. This difference is the total
%
% o dither: A value other than zero distributes the difference between an
% original image and the corresponding color reduced algorithm to
-% neighboring pixels assize_t a Hilbert curve.
+% neighboring pixels along a Hilbert curve.
%
% o measure_error: A value other than zero measures the difference between
% the original and quantized images. This difference is the total
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% MagickShearImage() slides one edge of an image assize_t the X or Y axis,
-% creating a parallelogram. An X direction shear slides an edge assize_t the X
-% axis, while a Y direction shear slides an edge assize_t the Y axis. The amount
+% MagickShearImage() slides one edge of an image along the X or Y axis,
+% creating a parallelogram. An X direction shear slides an edge along the X
+% axis, while a Y direction shear slides an edge along the Y axis. The amount
% of the shear is controlled by a shear angle. For X direction shears, x_shear
% is measured relative to the Y axis, and similarly, for Y direction shears
% y_shear is measured relative to the X axis. Empty triangles left over from
%
% o sigma: the standard deviation of the Gaussian, in pixels.
%
-% o angle: Apply the effect assize_t this angle.
+% o angle: Apply the effect along this angle.
%
*/
WandExport MagickBooleanType MagickSketchImage(MagickWand *wand,
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% MagickWaveImage() creates a "ripple" effect in the image by shifting
-% the pixels vertically assize_t a sine wave whose amplitude and wavelength
+% the pixels vertically along a sine wave whose amplitude and wavelength
% is specified by the given parameters.
%
% The format of the MagickWaveImage method is:
} \
}
#define FireImageStack(postfix,advance,fire) \
- if ((j <= i) && (i < argc)) \
+ if ((j <= i) && (i < (ssize_t) argc)) \
{ \
if (image_stack[k].image == (Image *) NULL) \
status&=MogrifyImageInfo(image_stack[k].image_info,(int) (i-j+1), \
user_time=GetUserTime(timer);
(void) fprintf(stderr,
"Performance: %lui %gips %0.3fu %ld:%02ld.%03ld\n",
- iterations,1.0*iterations/elapsed_time,user_time,(ssize_t)
- (elapsed_time/60.0),(ssize_t) floor(fmod(elapsed_time,60.0)),
- (ssize_t) (1000.0*(elapsed_time-floor(elapsed_time))));
+ iterations,1.0*iterations/elapsed_time,user_time,(long)
+ (elapsed_time/60.0),(long) floor(fmod(elapsed_time,60.0)),
+ (long) (1000.0*(elapsed_time-floor(elapsed_time))));
}
timer=DestroyTimerInfo(timer);
return(status);
locale_message=tag;
if (p == (char *) NULL)
(void) fprintf(stderr,"%s: %ld of %lu, %02ld%% complete\r",locale_message,
- (ssize_t) offset,(size_t) extent,(ssize_t) (100L*offset/(extent-1)));
+ (long) offset,(size_t) extent,(long) (100L*offset/(extent-1)));
else
(void) fprintf(stderr,"%s[%s]: %ld of %lu, %02ld%% complete\r",
- locale_message,p+1,(ssize_t) offset,(size_t) extent,(ssize_t)
+ locale_message,p+1,(long) offset,(size_t) extent,(long)
(100L*offset/(extent-1)));
if (offset == (MagickOffsetType) (extent-1))
(void) fprintf(stderr,"\n");
continue;
count=MagickMax(ParseMagickOption(MagickCommandOptions,MagickFalse,option),
0L);
- if ((i+count) >= argc)
+ if ((i+count) >= (ssize_t) argc)
break;
- status=MogrifyImageInfo(image_info,count+1,argv+i,exception);
+ status=MogrifyImageInfo(image_info,(int) count+1,argv+i,exception);
switch (*(option+1))
{
case 'a':
"-charcoal radius simulate a charcoal drawing",
"-chop geometry remove pixels from the image interior",
"-clamp restrict pixel range from 0 to the quantum depth",
- "-clip clip assize_t the first path from the 8BIM profile",
+ "-clip clip along the first path from the 8BIM profile",
"-clip-mask filename associate a clip mask with the image",
- "-clip-path id clip assize_t a named path from the 8BIM profile",
+ "-clip-path id clip along a named path from the 8BIM profile",
"-colorize value colorize the image with the fill color",
"-color-matrix matrix apply color correction to the image",
"-contrast enhance or reduce the image contrast",
"-shadow geometry simulate an image shadow",
"-sharpen geometry sharpen the image",
"-shave geometry shave pixels from the image edges",
- "-shear geometry slide one edge of the image assize_t the X or Y axis",
+ "-shear geometry slide one edge of the image along the X or Y axis",
"-sigmoidal-contrast geometry",
" increase the contrast without saturating highlights or shadows",
"-sketch geometry simulate a pencil sketch",
"-unique-colors discard all but one of any pixel color",
"-unsharp geometry sharpen the image",
"-vignette geometry soften the edges of the image in vignette style",
- "-wave geometry alter an image assize_t a sine wave",
+ "-wave geometry alter an image along a sine wave",
"-white-threshold value",
" force all pixels above the threshold into white",
(char *) NULL
*/
FireImageStack(MagickFalse,MagickFalse,pend);
filename=argv[i];
- if ((LocaleCompare(filename,"--") == 0) && (i < (argc-1)))
+ if ((LocaleCompare(filename,"--") == 0) && (i < (ssize_t) (argc-1)))
filename=argv[++i];
(void) CopyMagickString(image_info->filename,filename,MaxTextExtent);
images=ReadImages(image_info,exception);
}
if (k != 0)
ThrowMogrifyException(OptionError,"UnbalancedParenthesis",argv[i]);
- if (i != argc)
+ if (i != (ssize_t) argc)
ThrowMogrifyException(OptionError,"MissingAnImageFilename",argv[i]);
DestroyMogrify();
return(status != 0 ? MagickTrue : MagickFalse);
continue;
count=MagickMax(ParseMagickOption(MagickCommandOptions,MagickFalse,option),
0L);
- if ((i+count) >= argc)
+ if ((i+count) >= (ssize_t) argc)
break;
switch (*(option+1))
{
continue;
count=MagickMax(ParseMagickOption(MagickCommandOptions,MagickFalse,option),
0L);
- if ((i+count) >= argc)
+ if ((i+count) >= (ssize_t) argc)
break;
- status=MogrifyImageInfo(image_info,count+1,argv+i,exception);
+ status=MogrifyImageInfo(image_info,(int) count+1,argv+i,exception);
switch (*(option+1))
{
case 'a':
ImageStack
image_stack[MaxImageStackDepth+1];
- ssize_t
+ long
first_scene,
+ last_scene;
+
+ ssize_t
j,
k,
- last_scene,
scene;
MagickBooleanType
*images;
FireImageStack(MagickFalse,MagickFalse,pend);
- for (scene=first_scene; scene <= last_scene ; scene++)
+ for (scene=(ssize_t) first_scene; scene <= (ssize_t) last_scene ; scene++)
{
char
*filename;
Option is a file name: begin by reading image from specified file.
*/
filename=argv[i];
- if ((LocaleCompare(filename,"--") == 0) && (i < (argc-1)))
+ if ((LocaleCompare(filename,"--") == 0) && (i < (ssize_t) (argc-1)))
filename=argv[++i];
(void) CopyMagickString(image_info->filename,filename,MaxTextExtent);
if (first_scene != last_scene)
ThrowMontageException(OptionError,"MissingArgument",option);
if (IsSceneGeometry(argv[i],MagickFalse) == MagickFalse)
ThrowMontageInvalidArgumentException(option,argv[i]);
- first_scene=StringToLong(argv[i]);
+ first_scene=(int) StringToLong(argv[i]);
last_scene=first_scene;
(void) sscanf(argv[i],"%ld-%ld",&first_scene,&last_scene);
break;
*duplex_image,
*source_image;
- ssize_t
- progress,
- y;
-
MagickBooleanType
status;
+ MagickOffsetType
+ progress;
+
+ ssize_t
+ y;
+
assert(source != (PixelView *) NULL);
assert(source->signature == WandSignature);
if (transfer == (DuplexTransferPixelViewMethod) NULL)
Image
*source_image;
- ssize_t
- progress,
- y;
-
MagickBooleanType
status;
+ MagickOffsetType
+ progress;
+
+ ssize_t
+ y;
+
assert(source != (PixelView *) NULL);
assert(source->signature == WandSignature);
if (get == (GetPixelViewMethod) NULL)
Image
*destination_image;
- ssize_t
- progress,
- y;
-
MagickBooleanType
status;
+ MagickOffsetType
+ progress;
+
+ ssize_t
+ y;
+
assert(destination != (PixelView *) NULL);
assert(destination->signature == WandSignature);
if (set == (SetPixelViewMethod) NULL)
*destination_image,
*source_image;
- ssize_t
- progress,
- y;
-
MagickBooleanType
status;
+ MagickOffsetType
+ progress;
+
+ ssize_t
+ y;
+
assert(source != (PixelView *) NULL);
assert(source->signature == WandSignature);
if (transfer == (TransferPixelViewMethod) NULL)
Image
*source_image;
- ssize_t
- progress,
- y;
-
MagickBooleanType
status;
+ MagickOffsetType
+ progress;
+
+ ssize_t
+ y;
+
assert(source != (PixelView *) NULL);
assert(source->signature == WandSignature);
if (update == (UpdatePixelViewMethod) NULL)
*/
FireImageStack(MagickFalse,MagickFalse,pend);
filename=argv[i];
- if ((LocaleCompare(filename,"--") == 0) && (i < (argc-1)))
+ if ((LocaleCompare(filename,"--") == 0) && (i < (ssize_t) (argc-1)))
filename=argv[++i];
(void) CopyMagickString(image_info->filename,filename,MaxTextExtent);
images=StreamImage(image_info,stream_info,exception);
register ssize_t
i;
- size_t
- length;
-
unsigned char
*profile;
size_t
columns,
delay,
+ length,
number_options,
number_profiles,
number_properties,
(void) fprintf(stdout,"Iterate forward...\n");
MagickResetIterator(magick_wand);
while (MagickNextImage(magick_wand) != MagickFalse)
- (void) fprintf(stdout,"index %ld scene %lu\n",
+ (void) fprintf(stdout,"index %ld scene %lu\n",(long)
MagickGetIteratorIndex(magick_wand),MagickGetImageScene(magick_wand));
(void) fprintf(stdout,"Iterate reverse...\n");
while (MagickPreviousImage(magick_wand) != MagickFalse)
- (void) fprintf(stdout,"index %ld scene %lu\n",
+ (void) fprintf(stdout,"index %ld scene %lu\n",(long)
MagickGetIteratorIndex(magick_wand),MagickGetImageScene(magick_wand));
(void) fprintf(stdout,"Remove scene 1...\n");
(void) MagickSetIteratorIndex(magick_wand,1);
ThrowAPIException(magick_wand);
MagickResetIterator(magick_wand);
while (MagickNextImage(magick_wand) != MagickFalse)
- (void) fprintf(stdout,"index %ld scene %lu\n",
+ (void) fprintf(stdout,"index %ld scene %lu\n",(long)
MagickGetIteratorIndex(magick_wand),MagickGetImageScene(magick_wand));
(void) fprintf(stdout,"Insert scene 1 back in sequence...\n");
(void) MagickSetIteratorIndex(magick_wand,0);
ThrowAPIException(magick_wand);
MagickResetIterator(magick_wand);
while (MagickNextImage(magick_wand) != MagickFalse)
- (void) fprintf(stdout,"index %ld scene %lu\n",
+ (void) fprintf(stdout,"index %ld scene %lu\n",(long)
MagickGetIteratorIndex(magick_wand),MagickGetImageScene(magick_wand));
(void) fprintf(stdout,"Set scene 2 to scene 1...\n");
(void) MagickSetIteratorIndex(magick_wand,2);
ThrowAPIException(magick_wand);
MagickResetIterator(magick_wand);
while (MagickNextImage(magick_wand) != MagickFalse)
- (void) fprintf(stdout,"index %ld scene %lu\n",
+ (void) fprintf(stdout,"index %ld scene %lu\n",(long)
MagickGetIteratorIndex(magick_wand),MagickGetImageScene(magick_wand));
(void) fprintf(stdout,"Apply image processing options...\n");
status=MagickCropImage(magick_wand,60,60,10,10);
MagickResetIterator(magick_wand);
while (MagickNextImage(magick_wand) != MagickFalse)
{
- MagickSetImageDepth(magick_wand,8);
- MagickSetImageCompression(magick_wand,RLECompression);
+ (void) MagickSetImageDepth(magick_wand,8);
+ (void) MagickSetImageCompression(magick_wand,RLECompression);
}
MagickResetIterator(magick_wand);
(void) MagickSetIteratorIndex(magick_wand,4);
projects / imagemagick / commitdiff