/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % W r i t e V I C A R I m a g e % % % % % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % Method WriteVICARImage writes an image in the VICAR rasterfile format. % Vicar files contain a text header, followed by one or more planes of binary % grayscale image data. Vicar files are designed to allow many planes to be % stacked together to form image cubes. This method only writes a single % grayscale plane. % % Method WriteVICARImage was written contributed by % [email protected]. % % The format of the WriteVICARImage method is: % % unsigned int WriteVICARImage(const ImageInfo *image_info,Image *image) % % A description of each parameter follows. % % o status: Method WriteVICARImage return True if the image is written. % False is returned is there is a memory shortage or if the image file % fails to write. % % o image_info: Specifies a pointer to a ImageInfo structure. % % o image: A pointer to an Image structure. % % */ static unsigned int WriteVICARImage(const ImageInfo *image_info,Image *image) { char header[MaxTextExtent]; int y; unsigned char *scanline; unsigned int status; /* Open output image file. */ assert(image_info != (const ImageInfo *) NULL); assert(image_info->signature == MagickSignature); assert(image != (Image *) NULL); assert(image->signature == MagickSignature); status=OpenBlob(image_info,image,WriteBinaryBlobMode,&image->exception); if (status == False) ThrowWriterException(FileOpenError,UnableToOpenFile,image); (void) TransformColorspace(image,RGBColorspace); /* Write header. */ (void) memset(header,' ',MaxTextExtent); FormatString(header,"LBLSIZE=%u FORMAT='BYTE' TYPE='IMAGE' BUFSIZE=20000 " "DIM=2 EOL=0 RECSIZE=%lu ORG='BSQ' NL=%lu NS=%lu NB=1 N1=0 N2=0 N3=0 N4=0 " "NBB=0 NLB=0 TASK='GraphicsMagick'",MaxTextExtent,image->columns,image->rows, image->columns); (void) WriteBlob(image,MaxTextExtent,header); /* Allocate memory for scanline. */ scanline=MagickAllocateMemory(unsigned char *,image->columns); if (scanline == (unsigned char *) NULL) ThrowWriterException(ResourceLimitError,MemoryAllocationFailed,image); /* Write VICAR scanline. */ for (y=0; y < (long) image->rows; y++) { if (!AcquireImagePixels(image,0,y,image->columns,1,&image->exception)) break; (void) ExportImagePixelArea(image,GrayQuantum,8,scanline,0,0); (void) WriteBlob(image,image->columns,scanline); if (image->previous == (Image *) NULL) if (QuantumTick(y,image->rows)) if (!MagickMonitorFormatted(y,image->rows,&image->exception, SaveImageText,image->filename, image->columns,image->rows)) break; } MagickFreeMemory(scanline); CloseBlob(image); return(True); }
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% W r i t e M A T T E I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% Function WriteMATTEImage writes an image of matte bytes to a file. It
% consists of data from the matte component of the image [0..255].
%
% The format of the WriteMATTEImage method is:
%
% unsigned int WriteMATTEImage(const ImageInfo *image_info,Image *image)
%
% A description of each parameter follows.
%
% o status: Function WriteMATTEImage return True if the image is written.
% False is returned is there is a memory shortage or if the image file
% fails to write.
%
% o image_info: Specifies a pointer to a ImageInfo structure.
%
% o image: A pointer to an Image structure.
%
%
*/
static unsigned int WriteMATTEImage(const ImageInfo *image_info,Image *image)
{
Image
*matte_image;
long
y;
register const PixelPacket
*p;
register long
x;
register PixelPacket
*q;
unsigned int
status;
if (!image->matte)
ThrowWriterException(CoderError,ImageDoesNotHaveAMatteChannel,image);
matte_image=
CloneImage(image,image->columns,image->rows,True,&image->exception);
if (matte_image == (Image *) NULL)
return(False);
(void) (void) SetImageType(matte_image,TrueColorType);
/*
Convert image to matte pixels.
*/
for (y=0; y < (long) image->rows; y++)
{
p=AcquireImagePixels(image,0,y,image->columns,1,&image->exception);
q=SetImagePixels(matte_image,0,y,matte_image->columns,1);
if ((p == (const PixelPacket *) NULL) || (q == (PixelPacket *) NULL))
break;
for (x=0; x < (long) image->columns; x++)
{
q->red=p->opacity;
q->green=p->opacity;
q->blue=p->opacity;
q->opacity=OpaqueOpacity;
p++;
q++;
}
if (!SyncImagePixels(matte_image))
break;
if (image->previous == (Image *) NULL)
if (QuantumTick(y,image->rows))
if (!MagickMonitorFormatted(y,image->rows,&image->exception,
SaveImageText,image->filename,
image->columns,image->rows))
break;
}
(void) FormatString(matte_image->filename,"MIFF:%.1024s",image->filename);
status=WriteImage(image_info,matte_image);
DestroyImage(matte_image);
return(status);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% W r i t e F A X I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% Procedure WriteFAXImage writes an image to a file in 1 dimensional Huffman
% encoded format.
%
% The format of the WriteFAXImage method is:
%
% unsigned int WriteFAXImage(const ImageInfo *image_info,Image *image)
%
% A description of each parameter follows.
%
% o status: Method WriteFAXImage return True if the image is written.
% False is returned is there is a memory shortage or if the image file
% fails to write.
%
% o image_info: Specifies a pointer to a ImageInfo structure.
%
% o image: A pointer to an Image structure.
%
%
*/
static unsigned int WriteFAXImage(const ImageInfo *image_info,Image *image)
{
ImageInfo
*clone_info;
unsigned int
status;
unsigned long
scene;
/*
Open output image file.
*/
assert(image_info != (const ImageInfo *) NULL);
assert(image_info->signature == MagickSignature);
assert(image != (Image *) NULL);
assert(image->signature == MagickSignature);
status=OpenBlob(image_info,image,WriteBinaryBlobMode,&image->exception);
if (status == False)
ThrowWriterException(FileOpenError,UnableToOpenFile,image);
clone_info=CloneImageInfo(image_info);
(void) strcpy(clone_info->magick,"FAX");
scene=0;
do
{
/*
Convert MIFF to monochrome.
*/
(void) TransformColorspace(image,RGBColorspace);
status=HuffmanEncodeImage(clone_info,image);
if (image->next == (Image *) NULL)
break;
image=SyncNextImageInList(image);
status=MagickMonitorFormatted(scene++,GetImageListLength(image),
&image->exception,SaveImagesText,
image->filename);
if (status == False)
break;
} while (clone_info->adjoin);
DestroyImageInfo(clone_info);
if (image_info->adjoin)
while (image->previous != (Image *) NULL)
image=image->previous;
CloseBlob(image);
return(status);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% R e a d S C T I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% Method ReadSCTImage reads a Scitex image file and returns it. It allocates
% the memory necessary for the new Image structure and returns a pointer to
% the new image.
%
% The format of the ReadSCTImage method is:
%
% Image *ReadSCTImage(const ImageInfo *image_info,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image: Method ReadSCTImage returns a pointer to the image after
% reading. A null image is returned if there is a memory shortage or
% if the image cannot be read.
%
% o image_info: Specifies a pointer to a ImageInfo structure.
%
% o exception: return any errors or warnings in this structure.
%
%
*/
static Image *ReadSCTImage(const ImageInfo *image_info,ExceptionInfo *exception)
{
char
buffer[768],
magick[2];
Image
*image;
long
y;
register long
x;
register PixelPacket
*q;
int
c;
unsigned int
status;
/*
Open image file.
*/
assert(image_info != (const ImageInfo *) NULL);
assert(image_info->signature == MagickSignature);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
image=AllocateImage(image_info);
status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
if (status == False)
ThrowReaderException(FileOpenError,UnableToOpenFile,image);
/*
Read control block.
*/
do
{
if (ReadBlob(image,80,(char *) buffer) != 80)
break;
if (ReadBlob(image,2,(char *) magick) != 2)
break;
if ((LocaleNCompare((char *) magick,"CT",2) != 0) &&
(LocaleNCompare((char *) magick,"LW",2) != 0) &&
(LocaleNCompare((char *) magick,"BM",2) != 0) &&
(LocaleNCompare((char *) magick,"PG",2) != 0) &&
(LocaleNCompare((char *) magick,"TX",2) != 0))
ThrowReaderException(CorruptImageError,ImproperImageHeader,image);
if ((LocaleNCompare((char *) magick,"LW",2) == 0) ||
(LocaleNCompare((char *) magick,"BM",2) == 0) ||
(LocaleNCompare((char *) magick,"PG",2) == 0) ||
(LocaleNCompare((char *) magick,"TX",2) == 0))
ThrowReaderException(CoderError,OnlyContinuousTonePictureSupported,image);
if (ReadBlob(image,174,(char *) buffer) != 174)
break;
if (ReadBlob(image,768,(char *) buffer) != 768)
break;
/*
Read parameter block.
*/
if (ReadBlob(image,32,(char *) buffer) != 32)
break;
if (ReadBlob(image,14,(char *) buffer) != 14)
break;
image->rows=MagickAtoL(buffer) & 0x7FFFFFFF;
if (ReadBlob(image,14,(char *) buffer) != 14)
break;
image->columns=MagickAtoL(buffer) & 0x7FFFFFFF;
if (ReadBlob(image,196,(char *) buffer) != 196)
break;
if (ReadBlob(image,768,(char *) buffer) != 768)
break;
image->colorspace=CMYKColorspace;
}
while (0);
if (EOFBlob(image))
ThrowReaderException(CorruptImageError,UnexpectedEndOfFile,image);
if (image_info->ping)
{
CloseBlob(image);
return(image);
}
if (CheckImagePixelLimits(image, exception) != MagickPass)
ThrowReaderException(ResourceLimitError,ImagePixelLimitExceeded,image);
/*
Convert SCT raster image to pixel packets.
*/
for (y=0; y < (long) image->rows; y++)
{
q=SetImagePixelsEx(image,0,y,image->columns,1,exception);
if (q == (PixelPacket *) NULL)
break;
for (x=0; x < (long) image->columns; x++)
{
if ((c = ReadBlobByte(image)) == EOF)
break;
q->red=(Quantum) (MaxRGB-ScaleCharToQuantum(c));
q++;
}
if ((image->columns % 2) != 0)
if (ReadBlobByte(image) == EOF) /* pad */
break;
q=GetImagePixelsEx(image,0,y,image->columns,1,exception);
if (q == (PixelPacket *) NULL)
break;
for (x=0; x < (long) image->columns; x++)
{
if ((c = ReadBlobByte(image)) == EOF)
break;
q->green=(Quantum) (MaxRGB-ScaleCharToQuantum(c));
q++;
}
if ((image->columns % 2) != 0)
if (ReadBlobByte(image) == EOF) /* pad */
break;
q=GetImagePixelsEx(image,0,y,image->columns,1,exception);
if (q == (PixelPacket *) NULL)
break;
for (x=0; x < (long) image->columns; x++)
{
if ((c = ReadBlobByte(image)) == EOF)
break;
q->blue=(Quantum) (MaxRGB-ScaleCharToQuantum(c));
q++;
}
if ((image->columns % 2) != 0)
if (ReadBlobByte(image) == EOF) /* pad */
break;
q=GetImagePixelsEx(image,0,y,image->columns,1,exception);
if (q == (PixelPacket *) NULL)
break;
for (x=0; x < (long) image->columns; x++)
{
if ((c = ReadBlobByte(image)) == EOF)
break;
q->opacity=(Quantum) (MaxRGB-ScaleCharToQuantum(c));
q++;
}
if (!SyncImagePixelsEx(image,exception))
break;
if ((image->columns % 2) != 0)
if (ReadBlobByte(image) == EOF) /* pad */
break;
if (QuantumTick(y,image->rows))
if (!MagickMonitorFormatted(y,image->rows,exception,LoadImageText,
image->filename,
image->columns,image->rows))
break;
if (EOFBlob(image))
break;
}
if (EOFBlob(image))
ThrowException(exception,CorruptImageError,UnexpectedEndOfFile,
image->filename);
CloseBlob(image);
return(image);
}
/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % R e a d T I M I m a g e % % % % % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % Method ReadTIMImage reads a PSX TIM image file and returns it. It % allocates the memory necessary for the new Image structure and returns a % pointer to the new image. % % Contributed by [email protected]. % % The format of the ReadTIMImage method is: % % Image *ReadTIMImage(const ImageInfo *image_info,ExceptionInfo *exception) % % A description of each parameter follows: % % o image: Method ReadTIMImage returns a pointer to the image after % reading. A null image is returned if there is a memory shortage or % if the image cannot be read. % % o image_info: Specifies a pointer to a ImageInfo structure. % % o exception: return any errors or warnings in this structure. % % */ static Image *ReadTIMImage(const ImageInfo *image_info,ExceptionInfo *exception) { typedef struct _TIMInfo { unsigned long id, flag; } TIMInfo; TIMInfo tim_info; Image *image; int bits_per_pixel, has_clut; long y; register IndexPacket *indexes; register long x; register PixelPacket *q; register long i; register unsigned char *p; unsigned char *tim_data, *tim_pixels; unsigned short word; unsigned int status; size_t bytes_per_line, image_size; unsigned long height, pixel_mode, width; /* Open image file. */ assert(image_info != (const ImageInfo *) NULL); assert(image_info->signature == MagickSignature); assert(exception != (ExceptionInfo *) NULL); assert(exception->signature == MagickSignature); image=AllocateImage(image_info); status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception); if (status == False) ThrowReaderException(FileOpenError,UnableToOpenFile,image); /* Determine if this is a TIM file. */ tim_info.id=ReadBlobLSBLong(image); do { /* Verify TIM identifier. */ if (tim_info.id != 0x00000010) ThrowReaderException(CorruptImageError,ImproperImageHeader,image); tim_info.flag=ReadBlobLSBLong(image); has_clut=!!(tim_info.flag & (1 << 3)); pixel_mode=tim_info.flag & 0x07; switch ((int) pixel_mode) { case 0: bits_per_pixel=4; break; case 1: bits_per_pixel=8; break; case 2: bits_per_pixel=16; break; case 3: bits_per_pixel=24; break; default: bits_per_pixel=4; break; } image->depth=8; if (has_clut) { unsigned char *tim_colormap; /* Read TIM raster colormap. */ (void)ReadBlobLSBLong(image); (void)ReadBlobLSBShort(image); (void)ReadBlobLSBShort(image); /* width= */ (void)ReadBlobLSBShort(image); /* height= */ (void)ReadBlobLSBShort(image); if (!AllocateImageColormap(image,pixel_mode == 1 ? 256 : 16)) ThrowReaderException(ResourceLimitError,MemoryAllocationFailed, image); tim_colormap=MagickAllocateMemory(unsigned char *,image->colors*2); if (tim_colormap == (unsigned char *) NULL) ThrowReaderException(ResourceLimitError,MemoryAllocationFailed, image); (void) ReadBlob(image,2*image->colors,(char *) tim_colormap); p=tim_colormap; for (i=0; i < (long) image->colors; i++) { word=(*p++); word|=(unsigned short) (*p++ << 8U); image->colormap[i].blue=ScaleCharToQuantum(ScaleColor5to8((word >> 10U) & 0x1fU)); image->colormap[i].green=ScaleCharToQuantum(ScaleColor5to8((word >> 5U) & 0x1fU)); image->colormap[i].red=ScaleCharToQuantum(ScaleColor5to8(word & 0x1fU)); } MagickFreeMemory(tim_colormap); } /* Read image data. */ (void) ReadBlobLSBLong(image); (void) ReadBlobLSBShort(image); (void) ReadBlobLSBShort(image); if (EOFBlob(image)) ThrowReaderException(CorruptImageError,UnexpectedEndOfFile,image); width=ReadBlobLSBShort(image); height=ReadBlobLSBShort(image); image_size=MagickArraySize(2,MagickArraySize(width,height)); bytes_per_line=MagickArraySize(width,2); width=(unsigned long)(MagickArraySize(width,16))/bits_per_pixel; /* Initialize image structure. */ image->columns=width; image->rows=height; if (image_info->ping && (image_info->subrange != 0)) if (image->scene >= (image_info->subimage+image_info->subrange-1)) break; if (CheckImagePixelLimits(image, exception) != MagickPass) ThrowReaderException(ResourceLimitError,ImagePixelLimitExceeded,image); tim_data=MagickAllocateMemory(unsigned char *,image_size); if (tim_data == (unsigned char *) NULL) ThrowReaderException(ResourceLimitError,MemoryAllocationFailed,image); (void) ReadBlob(image,image_size,(char *) tim_data); tim_pixels=tim_data; /* Convert TIM raster image to pixel packets. */ switch (bits_per_pixel) { case 4: { /* Convert PseudoColor scanline. */ for (y=(long) image->rows-1; y >= 0; y--) { q=SetImagePixelsEx(image,0,y,image->columns,1,exception); if (q == (PixelPacket *) NULL) break; indexes=AccessMutableIndexes(image); p=tim_pixels+y*bytes_per_line; for (x=0; x < ((long) image->columns-1); x+=2) { indexes[x]=(*p) & 0xf; indexes[x+1]=(*p >> 4) & 0xf; p++; } if ((image->columns % 2) != 0) { indexes[x]=(*p >> 4) & 0xf; p++; } if (!SyncImagePixelsEx(image,exception)) break; if (QuantumTick(y,image->rows)) { status=MagickMonitorFormatted(image->rows-y-1,image->rows, exception,LoadImageText, image->filename, image->columns,image->rows); if (status == False) break; } } break; } case 8: { /* Convert PseudoColor scanline. */ for (y=(long) image->rows-1; y >= 0; y--) { q=SetImagePixelsEx(image,0,y,image->columns,1,exception); if (q == (PixelPacket *) NULL) break; indexes=AccessMutableIndexes(image); p=tim_pixels+y*bytes_per_line; for (x=0; x < (long) image->columns; x++) indexes[x]=(*p++); if (!SyncImagePixelsEx(image,exception)) break; if (QuantumTick(y,image->rows)) { status=MagickMonitorFormatted(image->rows-y-1,image->rows, exception,LoadImageText, image->filename, image->columns,image->rows); if (status == False) break; } } break; } case 16: { /* Convert DirectColor scanline. */ for (y=(long) image->rows-1; y >= 0; y--) { p=tim_pixels+y*bytes_per_line; q=SetImagePixelsEx(image,0,y,image->columns,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (long) image->columns; x++) { word=(*p++); word|=(*p++ << 8); q->blue=ScaleCharToQuantum(ScaleColor5to8((word >> 10) & 0x1f)); q->green=ScaleCharToQuantum(ScaleColor5to8((word >> 5) & 0x1f)); q->red=ScaleCharToQuantum(ScaleColor5to8(word & 0x1f)); q++; } if (!SyncImagePixelsEx(image,exception)) break; if (QuantumTick(y,image->rows)) { status=MagickMonitorFormatted(image->rows-y-1,image->rows, exception,LoadImageText, image->filename, image->columns,image->rows); if (status == False) break; } } break; } case 24: { /* Convert DirectColor scanline. */ for (y=(long) image->rows-1; y >= 0; y--) { p=tim_pixels+y*bytes_per_line; q=SetImagePixelsEx(image,0,y,image->columns,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (long) image->columns; x++) { q->red=ScaleCharToQuantum(*p++); q->green=ScaleCharToQuantum(*p++); q->blue=ScaleCharToQuantum(*p++); q++; } if (!SyncImagePixelsEx(image,exception)) break; if (QuantumTick(y,image->rows)) { status=MagickMonitorFormatted(image->rows-y-1,image->rows, exception,LoadImageText, image->filename, image->columns,image->rows); if (status == False) break; } } break; } default: ThrowReaderException(CorruptImageError,ImproperImageHeader,image) } if (image->storage_class == PseudoClass) (void) SyncImage(image); MagickFreeMemory(tim_pixels); if (EOFBlob(image)) { ThrowException(exception,CorruptImageError,UnexpectedEndOfFile, image->filename); break; } /* Proceed to next image. */ tim_info.id=ReadBlobLSBLong(image); if (tim_info.id == 0x00000010) { /* Allocate next image structure. */ AllocateNextImage(image_info,image); if (image->next == (Image *) NULL) { DestroyImageList(image); return((Image *) NULL); } image=SyncNextImageInList(image); status=MagickMonitorFormatted(TellBlob(image),GetBlobSize(image), exception,LoadImagesText, image->filename); if (status == False) break; } } while (tim_info.id == 0x00000010);
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% R e a d M T V I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% Method ReadMTVImage reads a MTV image file and returns it. It allocates
% the memory necessary for the new Image structure and returns a pointer to
% the new image.
%
% The format of the ReadMTVImage method is:
%
% Image *ReadMTVImage(const ImageInfo *image_info,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image: Method ReadMTVImage returns a pointer to the image after
% reading. A null image is returned if there is a memory shortage or
% if the image cannot be read.
%
% o image_info: Specifies a pointer to a ImageInfo structure.
%
% o exception: return any errors or warnings in this structure.
%
%
*/
static Image *ReadMTVImage(const ImageInfo *image_info,ExceptionInfo *exception)
{
char
buffer[MaxTextExtent];
Image
*image;
long
count,
y;
register long
x;
register PixelPacket
*q;
register unsigned char
*p;
unsigned char
*pixels;
unsigned int
status;
unsigned long
columns,
rows;
/*
Open image file.
*/
assert(image_info != (const ImageInfo *) NULL);
assert(image_info->signature == MagickSignature);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
image=AllocateImage(image_info);
status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
if (status == False)
ThrowReaderException(FileOpenError,UnableToOpenFile,image);
/*
Read MTV image.
*/
(void) ReadBlobString(image,buffer);
columns=0;
rows=0;
count=sscanf(buffer,"%lu %lu\n",&columns,&rows);
if (count != 2)
ThrowReaderException(CorruptImageError,ImproperImageHeader,image);
do
{
size_t
row_size;
/*
Initialize image structure.
*/
image->columns=columns;
image->rows=rows;
image->depth=8;
if (image_info->ping && (image_info->subrange != 0))
if (image->scene >= (image_info->subimage+image_info->subrange-1))
break;
/*
Convert MTV raster image to pixel packets.
*/
pixels=MagickAllocateArray(unsigned char *,image->columns,3);
if (pixels == (unsigned char *) NULL)
ThrowReaderException(ResourceLimitError,MemoryAllocationFailed,image);
row_size=image->columns*3;
for (y=0; y < (long) image->rows; y++)
{
if (ReadBlob(image,row_size,pixels) != row_size)
ThrowReaderException(CorruptImageError,UnexpectedEndOfFile,image);
p=pixels;
q=SetImagePixels(image,0,y,image->columns,1);
if (q == (PixelPacket *) NULL)
break;
for (x=0; x < (long) image->columns; x++)
{
q->red=ScaleCharToQuantum(*p++);
q->green=ScaleCharToQuantum(*p++);
q->blue=ScaleCharToQuantum(*p++);
q++;
}
if (!SyncImagePixels(image))
break;
if (image->previous == (Image *) NULL)
if (QuantumTick(y,image->rows))
if (!MagickMonitorFormatted(y,image->rows,exception,LoadImageText,
image->filename,
image->columns,image->rows))
break;
}
MagickFreeMemory(pixels);
if (EOFBlob(image))
{
ThrowException(exception,CorruptImageError,UnexpectedEndOfFile,
image->filename);
break;
}
/*
Proceed to next image.
*/
if (image_info->subrange != 0)
if (image->scene >= (image_info->subimage+image_info->subrange-1))
break;
*buffer='\0';
(void) ReadBlobString(image,buffer);
count=sscanf(buffer,"%lu %lu\n",&columns,&rows);
if (count == 2)
{
/*
Allocate next image structure.
*/
AllocateNextImage(image_info,image);
if (image->next == (Image *) NULL)
{
DestroyImageList(image);
return((Image *) NULL);
}
image=SyncNextImageInList(image);
if (!MagickMonitorFormatted(TellBlob(image),GetBlobSize(image),
exception,LoadImagesText,
image->filename))
break;
}
} while (count == 2);
while (image->previous != (Image *) NULL)
image=image->previous;
CloseBlob(image);
return(image);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% W r i t e C M Y K I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% Method WriteCMYKImage writes an image to a file in red, green, and blue
% rasterfile format.
%
% The format of the WriteCMYKImage method is:
%
% unsigned int WriteCMYKImage(const ImageInfo *image_info,Image *image)
%
% A description of each parameter follows.
%
% o status: Method WriteCMYKImage return True if the image is written.
% False is returned is there is a memory shortage or if the image file
% fails to write.
%
% o image_info: Specifies a pointer to a ImageInfo structure.
%
% o image: A pointer to an Image structure.
%
%
*/
static unsigned int WriteCMYKImage(const ImageInfo *image_info,Image *image)
{
int
y;
register const PixelPacket
*p;
unsigned char
*pixels;
unsigned int
packet_size,
quantum_size,
scene,
status;
ExportPixelAreaOptions
export_options;
ExportPixelAreaInfo
export_info;
if (image->depth <= 8)
quantum_size=8;
else if (image->depth <= 16)
quantum_size=16;
else
quantum_size=32;
/*
Allocate memory for pixels.
*/
assert(image_info != (const ImageInfo *) NULL);
assert(image_info->signature == MagickSignature);
assert(image != (Image *) NULL);
assert(image->signature == MagickSignature);
packet_size=(quantum_size*4)/8;
if (LocaleCompare(image_info->magick,"CMYKA") == 0)
packet_size=(quantum_size*5)/8;
pixels=MagickAllocateArray(unsigned char *,packet_size,image->columns);
if (pixels == (unsigned char *) NULL)
ThrowWriterException(ResourceLimitError,MemoryAllocationFailed,image);
if (image_info->interlace != PartitionInterlace)
{
/*
Open output image file.
*/
status=OpenBlob(image_info,image,WriteBinaryBlobMode,&image->exception);
if (status == False)
ThrowWriterException(FileOpenError,UnableToOpenFile,image);
}
scene=0;
do
{
/*
Convert MIFF to CMYK raster pixels.
*/
(void) TransformColorspace(image,CMYKColorspace);
if (LocaleCompare(image_info->magick,"CMYKA") == 0)
if (!image->matte)
SetImageOpacity(image,OpaqueOpacity);
/*
Initialize export options.
*/
ExportPixelAreaOptionsInit(&export_options);
if (image->endian != UndefinedEndian)
export_options.endian=image->endian;
else if (image_info->endian != UndefinedEndian)
export_options.endian=image_info->endian;
if (image->logging)
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
"Image depth %u bits, Endian %s",quantum_size,
EndianTypeToString(export_options.endian));
switch (image_info->interlace)
{
case NoInterlace:
default:
{
/*
No interlacing: CMYKCMYKCMYKCMYKCMYKCMYK...
*/
for (y=0; y < (long) image->rows; y++)
{
p=AcquireImagePixels(image,0,y,image->columns,1,&image->exception);
if (p == (const PixelPacket *) NULL)
break;
if (LocaleCompare(image_info->magick,"CMYKA") != 0)
{
(void) ExportImagePixelArea(image,CMYKQuantum,quantum_size,pixels,
&export_options,&export_info);
(void) WriteBlob(image,export_info.bytes_exported,pixels);
}
else
{
(void) ExportImagePixelArea(image,CMYKAQuantum,quantum_size,pixels,
&export_options,&export_info);
(void) WriteBlob(image,export_info.bytes_exported,pixels);
}
if (image->previous == (Image *) NULL)
if (QuantumTick(y,image->rows))
if (!MagickMonitorFormatted(y,image->rows,&image->exception,
SaveImageText,image->filename,
image->columns,image->rows))
break;
}
break;
}
case LineInterlace:
{
/*
Line interlacing: CCC...MMM...YYY...KKK...CCC...MMM...YYY...KKK...
*/
for (y=0; y < (long) image->rows; y++)
{
p=AcquireImagePixels(image,0,y,image->columns,1,&image->exception);
if (p == (const PixelPacket *) NULL)
break;
(void) ExportImagePixelArea(image,CyanQuantum,quantum_size,pixels,
&export_options,&export_info);
(void) WriteBlob(image,export_info.bytes_exported,pixels);
(void) ExportImagePixelArea(image,MagentaQuantum,quantum_size,pixels,
&export_options,&export_info);
(void) WriteBlob(image,export_info.bytes_exported,pixels);
(void) ExportImagePixelArea(image,YellowQuantum,quantum_size,pixels,
&export_options,&export_info);
(void) WriteBlob(image,export_info.bytes_exported,pixels);
(void) ExportImagePixelArea(image,BlackQuantum,quantum_size,pixels,
&export_options,&export_info);
(void) WriteBlob(image,export_info.bytes_exported,pixels);
if (LocaleCompare(image_info->magick,"CMYKA") == 0)
{
(void) ExportImagePixelArea(image,AlphaQuantum,quantum_size,pixels,
&export_options,&export_info);
(void) WriteBlob(image,export_info.bytes_exported,pixels);
}
if (QuantumTick(y,image->rows))
if (!MagickMonitorFormatted(y,image->rows,&image->exception,
SaveImageText,image->filename,
image->columns,image->rows))
break;
}
break;
}
case PlaneInterlace:
case PartitionInterlace:
{
/*
Plane interlacing: CCCCCC...MMMMMM...YYYYYY...KKKKKK...
*/
if (image_info->interlace == PartitionInterlace)
{
AppendImageFormat("C",image->filename);
status=
OpenBlob(image_info,image,WriteBinaryBlobMode,&image->exception);
if (status == False)
ThrowWriterException(FileOpenError,UnableToOpenFile,image);
}
for (y=0; y < (long) image->rows; y++)
{
p=AcquireImagePixels(image,0,y,image->columns,1,&image->exception);
if (p == (const PixelPacket *) NULL)
break;
(void) ExportImagePixelArea(image,CyanQuantum,quantum_size,pixels,
&export_options,&export_info);
(void) WriteBlob(image,export_info.bytes_exported,pixels);
}
if (image_info->interlace == PartitionInterlace)
{
CloseBlob(image);
AppendImageFormat("M",image->filename);
status=OpenBlob(image_info,image,WriteBinaryBlobMode,
&image->exception);
if (status == False)
ThrowWriterException(FileOpenError,UnableToOpenFile,image);
}
if (!MagickMonitorFormatted(100,400,&image->exception,
SaveImageText,image->filename,
image->columns,image->rows))
break;
for (y=0; y < (long) image->rows; y++)
{
p=AcquireImagePixels(image,0,y,image->columns,1,&image->exception);
if (p == (const PixelPacket *) NULL)
break;
(void) ExportImagePixelArea(image,MagentaQuantum,quantum_size,pixels,
&export_options,&export_info);
(void) WriteBlob(image,export_info.bytes_exported,pixels);
}
if (image_info->interlace == PartitionInterlace)
{
CloseBlob(image);
AppendImageFormat("Y",image->filename);
status=OpenBlob(image_info,image,WriteBinaryBlobMode,
&image->exception);
if (status == False)
ThrowWriterException(FileOpenError,UnableToOpenFile,image);
}
if (!MagickMonitorFormatted(200,400,&image->exception,
SaveImageText,image->filename,
image->columns,image->rows))
break;
for (y=0; y < (long) image->rows; y++)
{
p=AcquireImagePixels(image,0,y,image->columns,1,&image->exception);
if (p == (const PixelPacket *) NULL)
break;
(void) ExportImagePixelArea(image,YellowQuantum,quantum_size,pixels,
&export_options,&export_info);
(void) WriteBlob(image,export_info.bytes_exported,pixels);
}
if (image_info->interlace == PartitionInterlace)
{
CloseBlob(image);
AppendImageFormat("K",image->filename);
status=OpenBlob(image_info,image,WriteBinaryBlobMode,
&image->exception);
if (status == False)
ThrowWriterException(FileOpenError,UnableToOpenFile,image);
}
if (!MagickMonitorFormatted(200,400,&image->exception,
SaveImageText,image->filename,
image->columns,image->rows))
break;
for (y=0; y < (long) image->rows; y++)
{
p=AcquireImagePixels(image,0,y,image->columns,1,&image->exception);
if (p == (const PixelPacket *) NULL)
break;
(void) ExportImagePixelArea(image,BlackQuantum,quantum_size,pixels,
&export_options,&export_info);
(void) WriteBlob(image,export_info.bytes_exported,pixels);
}
if (LocaleCompare(image_info->magick,"CMYKA") == 0)
{
if (!MagickMonitorFormatted(300,400,&image->exception,
SaveImageText,image->filename,
image->columns,image->rows))
break;
if (image_info->interlace == PartitionInterlace)
{
CloseBlob(image);
AppendImageFormat("A",image->filename);
status=OpenBlob(image_info,image,WriteBinaryBlobMode,
&image->exception);
if (status == False)
ThrowWriterException(FileOpenError,UnableToOpenFile,image);
}
for (y=0; y < (long) image->rows; y++)
{
p=AcquireImagePixels(image,0,y,image->columns,1,
&image->exception);
if (p == (const PixelPacket *) NULL)
break;
(void) ExportImagePixelArea(image,AlphaQuantum,quantum_size,pixels,
&export_options,&export_info);
(void) WriteBlob(image,export_info.bytes_exported,pixels);
}
}
if (image_info->interlace == PartitionInterlace)
(void) strlcpy(image->filename,image_info->filename,MaxTextExtent);
if (!MagickMonitorFormatted(400,400,&image->exception,
SaveImageText,image->filename,
image->columns,image->rows))
break;
break;
}
}
if (image->next == (Image *) NULL)
break;
image=SyncNextImageInList(image);
status=MagickMonitorFormatted(scene++,GetImageListLength(image),
&image->exception,SaveImagesText,
image->filename);
if (status == False)
break;
} while (image_info->adjoin);
MagickFreeMemory(pixels);
if (image_info->adjoin)
while (image->previous != (Image *) NULL)
image=image->previous;
CloseBlob(image);
return(True);
}
/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % W r i t e J P 2 I m a g e % % % % % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % Method WriteJP2Image writes an image in the JPEG 2000 image format. % % JP2 support originally written by Nathan Brown, [email protected] % % The format of the WriteJP2Image method is: % % MagickPassFail WriteJP2Image(const ImageInfo *image_info,Image *image) % % A description of each parameter follows. % % o status: Method WriteJP2Image return MagickTrue if the image is written. % MagickFalse is returned is there is a memory shortage or if the image file % fails to write. % % o image_info: Specifies a pointer to a ImageInfo structure. % % o image: A pointer to an Image structure. % % */ static MagickPassFail WriteJP2Image(const ImageInfo *image_info,Image *image) { char magick[MaxTextExtent], option_keyval[MaxTextExtent], *options = NULL; int format; long y; jas_image_cmptparm_t component_info; jas_image_t *jp2_image; jas_matrix_t *jp2_pixels; jas_stream_t *jp2_stream; register const PixelPacket *p; register int x; unsigned int rate_specified=False, status; int component, number_components; unsigned short *lut; ImageCharacteristics characteristics; /* Open image file. */ assert(image_info != (const ImageInfo *) NULL); assert(image_info->signature == MagickSignature); assert(image != (Image *) NULL); assert(image->signature == MagickSignature); status=OpenBlob(image_info,image,WriteBinaryBlobMode,&image->exception); if (status == False) ThrowWriterException(FileOpenError,UnableToOpenFile,image); /* Ensure that image is in RGB space. */ (void) TransformColorspace(image,RGBColorspace); /* Analyze image to be written. */ if (!GetImageCharacteristics(image,&characteristics, (OptimizeType == image_info->type), &image->exception)) { CloseBlob(image); return MagickFail; } /* Obtain a JP2 stream. */ jp2_stream=JP2StreamManager(image); if (jp2_stream == (jas_stream_t *) NULL) ThrowWriterException(DelegateError,UnableToManageJP2Stream,image); number_components=image->matte ? 4 : 3; if ((image_info->type != TrueColorType) && (characteristics.grayscale)) number_components=1; jp2_image=jas_image_create0(); if (jp2_image == (jas_image_t *) NULL) ThrowWriterException(DelegateError,UnableToCreateImage,image); for (component=0; component < number_components; component++) { (void) memset((void *)&component_info,0,sizeof(jas_image_cmptparm_t)); component_info.tlx=0; /* top left x ordinate */ component_info.tly=0; /* top left y ordinate */ component_info.hstep=1; /* horizontal pixels per step */ component_info.vstep=1; /* vertical pixels per step */ component_info.width=(unsigned int) image->columns; component_info.height=(unsigned int) image->rows; component_info.prec=(unsigned int) Max(2,Min(image->depth,16)); /* bits in range */ component_info.sgnd = false; /* range is signed value? */ if (jas_image_addcmpt(jp2_image, component,&component_info)) { jas_image_destroy(jp2_image); ThrowWriterException(DelegateError,UnableToCreateImageComponent,image); } } /* Allocate and compute LUT. */ { unsigned long i, max_value; double scale_to_component; lut=MagickAllocateArray(unsigned short *,MaxMap+1,sizeof(*lut)); if (lut == (unsigned short *) NULL) { jas_image_destroy(jp2_image); ThrowWriterException(ResourceLimitError,MemoryAllocationFailed,image); } max_value=MaxValueGivenBits(component_info.prec); scale_to_component=max_value/MaxRGBDouble; for(i=0; i <= MaxMap; i++) lut[i]=scale_to_component*i+0.5; } if (number_components == 1) { /* FIXME: If image has an attached ICC profile, then the profile should be transferred and the image colorspace set to JAS_CLRSPC_GENGRAY */ /* sRGB Grayscale */ (void) LogMagickEvent(CoderEvent,GetMagickModule(), "Setting SGRAY colorspace"); jas_image_setclrspc(jp2_image, JAS_CLRSPC_SGRAY); (void) LogMagickEvent(CoderEvent,GetMagickModule(), "Setting GRAY channel to channel 0"); jas_image_setcmpttype(jp2_image,0, JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_GRAY_Y)); } else { /* FIXME: If image has an attached ICC profile, then the profile should be transferred and the image colorspace set to JAS_CLRSPC_GENRGB */ /* sRGB */ (void) LogMagickEvent(CoderEvent,GetMagickModule(), "Setting SRGB colorspace"); jas_image_setclrspc(jp2_image, JAS_CLRSPC_SRGB); (void) LogMagickEvent(CoderEvent,GetMagickModule(), "Setting RED channel to channel 0"); jas_image_setcmpttype(jp2_image,0, JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_R)); (void) LogMagickEvent(CoderEvent,GetMagickModule(), "Setting GREEN channel to channel 1"); jas_image_setcmpttype(jp2_image,1, JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_G)); (void) LogMagickEvent(CoderEvent,GetMagickModule(), "Setting BLUE channel to channel 2"); jas_image_setcmpttype(jp2_image,2, JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_B)); if (number_components == 4 ) { (void) LogMagickEvent(CoderEvent,GetMagickModule(), "Setting OPACITY channel to channel 3"); jas_image_setcmpttype(jp2_image,3, JAS_IMAGE_CT_COLOR(JAS_IMAGE_CT_OPACITY)); } } /* Convert to JPEG 2000 pixels. */ jp2_pixels=jas_matrix_create(1,(unsigned int) image->columns); if (jp2_pixels == (jas_matrix_t *) NULL) { MagickFreeMemory(lut); jas_image_destroy(jp2_image); ThrowWriterException(ResourceLimitError,MemoryAllocationFailed,image); } for (y=0; y < (long) image->rows; y++) { p=AcquireImagePixels(image,0,y,image->columns,1,&image->exception); if (p == (const PixelPacket *) NULL) break; if (number_components == 1) { for (x=0; x < (long) image->columns; x++) jas_matrix_setv(jp2_pixels,x,lut[ScaleQuantumToMap(PixelIntensityToQuantum(&p[x]))]); (void) jas_image_writecmpt(jp2_image,0,0,(unsigned int) y, (unsigned int) image->columns,1,jp2_pixels); } else { for (x=0; x < (long) image->columns; x++) jas_matrix_setv(jp2_pixels,x,lut[ScaleQuantumToMap(p[x].red)]); (void) jas_image_writecmpt(jp2_image,0,0,(unsigned int) y, (unsigned int) image->columns,1,jp2_pixels); for (x=0; x < (long) image->columns; x++) jas_matrix_setv(jp2_pixels,x,lut[ScaleQuantumToMap(p[x].green)]); (void) jas_image_writecmpt(jp2_image,1,0,(unsigned int) y, (unsigned int) image->columns,1,jp2_pixels); for (x=0; x < (long) image->columns; x++) jas_matrix_setv(jp2_pixels,x,lut[ScaleQuantumToMap(p[x].blue)]); (void) jas_image_writecmpt(jp2_image,2,0,(unsigned int) y, (unsigned int) image->columns,1,jp2_pixels); if (number_components > 3) for (x=0; x < (long) image->columns; x++) jas_matrix_setv(jp2_pixels,x,lut[ScaleQuantumToMap(MaxRGB-p[x].opacity)]); (void) jas_image_writecmpt(jp2_image,3,0,(unsigned int) y, (unsigned int) image->columns,1,jp2_pixels); } if (image->previous == (Image *) NULL) if (QuantumTick(y,image->rows)) if (!MagickMonitorFormatted(y,image->rows,&image->exception, SaveImageText,image->filename, image->columns,image->rows)) break; } (void) strlcpy(magick,image_info->magick,MaxTextExtent); /* J2C is an alias for JPC but Jasper only supports "JPC". */ if (LocaleCompare(magick,"j2c") == 0) (void) strlcpy(magick,"jpc",sizeof(magick)); LocaleLower(magick); format=jas_image_strtofmt(magick); /* Support passing Jasper options. */ { const char **option_name; static const char *jasper_options[] = { "imgareatlx", "imgareatly", "tilegrdtlx", "tilegrdtly", "tilewidth", "tileheight", "prcwidth", "prcheight", "cblkwidth", "cblkheight", "mode", "ilyrrates", "prg", "nomct", "numrlvls", "sop", "eph", "lazy", "rate", "termall", "segsym", "vcausal", "pterm", "resetprob", "numgbits", NULL }; for (option_name = jasper_options; *option_name != NULL; option_name++) { const char *value; if ((value=AccessDefinition(image_info,"jp2",*option_name)) != NULL) { if(LocaleCompare(*option_name,"rate") == 0) rate_specified=True; FormatString(option_keyval,"%s=%.1024s ",*option_name,value); ConcatenateString(&options,option_keyval); } } } /* Provide an emulation of IJG JPEG "quality" by default. */ if (rate_specified == False) { double rate=1.0; /* A rough approximation to JPEG v1 quality using JPEG-2000. Default "quality" 75 results in a request for 16:1 compression, which results in image sizes approximating that of JPEG v1. */ if ((image_info->quality < 99.5) && (image->rows*image->columns > 2500)) { double header_size, current_size, target_size, d; d=115-image_info->quality; /* Best number is 110-115 */ rate=100.0/(d*d); header_size=550.0; /* Base file size. */ header_size+=(number_components-1)*142; /* Additional components */ /* FIXME: Need to account for any ICC profiles here */ current_size=(double)((image->rows*image->columns*image->depth)/8)* number_components; target_size=(current_size*rate)+header_size; rate=target_size/current_size; } FormatString(option_keyval,"%s=%g ","rate",rate); ConcatenateString(&options,option_keyval); (void) LogMagickEvent(CoderEvent,GetMagickModule(), "Compression rate: %g (%3.2f:1)",rate,1.0/rate); } if (options) (void) LogMagickEvent(CoderEvent,GetMagickModule(), "Jasper options: \"%s\"", options); (void) LogMagickEvent(CoderEvent,GetMagickModule(),"Encoding image"); status=jas_image_encode(jp2_image,jp2_stream,format,options); (void) jas_stream_close(jp2_stream); MagickFreeMemory(options); MagickFreeMemory(lut); jas_matrix_destroy(jp2_pixels); jas_image_destroy(jp2_image); if (status) ThrowWriterException(DelegateError,UnableToEncodeImageFile,image); return(True); }
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% P i x e l I t e r a t e T r i p l e M o d i f y %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% PixelIterateTripleModify() iterates through pixel regions of three images
% and invokes a user-provided callback function (of type
% PixelIteratorTripleModifyCallback) for each row of pixels. The first two
% images are read-only, while the third image is read-write for update.
% Access of the first two images is done lock-step using the same coordinates.
% This is useful to support operations such as image differencing.
%
% The format of the PixelIterateTripleModify method is:
%
% MagickPassFail PixelIterateTripleModify(
% PixelIteratorTripleModifyCallback call_back,
% const PixelIteratorOptions *options,
% const char *description,
% void *mutable_data,
% const void *immutable_data,
% const unsigned long columns,
% const unsigned long rows,
% const Image *source1_image,
% const Image *source2_image,
% const long source_x,
% const long source_y,
% Image *update_image,
% const long update_x,
% const long update_y,
% ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o call_back: A user-provided C callback function which reads from
% a region of source pixels and updates a region of destination pixels.
%
% o options: Pixel iterator execution options (may be NULL).
%
% o description: textual description of operation being performed.
%
% o mutable_data: User-provided mutable context data.
%
% o immutable_data: User-provided immutable context data.
%
% o columns: Width of pixel region
%
% o rows: Height of pixel region
%
% o source1_image: The address of the constant source 1 Image.
%
% o source2_image: The address of the constant source 2 Image.
%
% o source_x: The horizontal ordinate of the top left corner of the source regions.
%
% o source_y: The vertical ordinate of the top left corner of the source regions.
%
% o update_image: The address of the update Image.
%
% o update_x: The horizontal ordinate of the top left corner of the update region.
%
% o update_y: The vertical ordinate of the top left corner of the update region.
%
% o exception: If an error is reported, this argument is updated with the reason.
%
*/
static MagickPassFail
PixelIterateTripleImplementation(PixelIteratorTripleModifyCallback call_back,
const PixelIteratorOptions *options,
const char *description,
void *mutable_data,
const void *immutable_data,
const unsigned long columns,
const unsigned long rows,
const Image *source1_image,
const Image *source2_image,
const long source_x,
const long source_y,
Image *update_image,
const long update_x,
const long update_y,
ExceptionInfo *exception,
MagickBool set)
{
MagickPassFail
status = MagickPass;
register long
row;
unsigned long
row_count=0;
int
max_threads;
max_threads=omp_get_max_threads();
(void) SetRegionThreads(max_threads,options,columns,rows);
#if defined(HAVE_OPENMP)
# pragma omp parallel for schedule(static,1) shared(row_count, status)
#endif
for (row=0; row < (long) rows; row++)
{
MagickBool
thread_status;
const PixelPacket
*source1_pixels,
*source2_pixels;
const IndexPacket
*source1_indexes,
*source2_indexes;
PixelPacket
*update_pixels;
IndexPacket
*update_indexes;
long
source_row,
update_row;
thread_status=status;
if (thread_status == MagickFail)
continue;
source_row=source_y+row;
update_row=update_y+row;
/*
First image (read only).
*/
source1_pixels=AcquireImagePixels(source1_image, source_x, source_row,
columns, 1, exception);
if (!source1_pixels)
thread_status=MagickFail;
source1_indexes=AccessImmutableIndexes(source1_image);
/*
Second image (read only).
*/
source2_pixels=AcquireImagePixels(source2_image, source_x, source_row,
columns, 1, exception);
if (!source2_pixels)
thread_status=MagickFail;
source2_indexes=AccessImmutableIndexes(source2_image);
/*
Third image (read/write).
*/
if (set)
update_pixels=SetImagePixelsEx(update_image, update_x, update_row,
columns, 1, exception);
else
update_pixels=GetImagePixelsEx(update_image, update_x, update_row,
columns, 1, exception);
if (!update_pixels)
{
thread_status=MagickFail;
CopyException(exception,&update_image->exception);
}
update_indexes=AccessMutableIndexes(update_image);
if (thread_status != MagickFail)
status=(call_back)(mutable_data,immutable_data,
source1_image,source1_pixels,source1_indexes,
source2_image,source2_pixels,source2_indexes,
update_image,update_pixels,update_indexes,
columns,exception);
if (!SyncImagePixelsEx(update_image,exception))
thread_status=MagickFail;
#if defined(HAVE_OPENMP)
# pragma omp critical (GM_PixelIterateTripleImplementation)
#endif
{
row_count++;
if (QuantumTick(row_count,rows))
if (!MagickMonitorFormatted(row_count,rows,exception,description,
source1_image->filename,
source2_image->filename,
update_image->filename))
thread_status=MagickFail;
if (thread_status == MagickFail)
status=MagickFail;
}
}
omp_set_num_threads(max_threads);
return (status);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% P i x e l I t e r a t e M o n o M o d i f y %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% PixelIterateMonoModify() iterates through a region of an image and invokes
% a user-provided callback function (of type PixelIteratorMonoReadCallback)
% for a region of pixels. This is useful to support simple operations such as
% level shifting, colorspace translation, or thresholding.
%
% The format of the PixelIterateMonoModify method is:
%
% MagickPassFail PixelIterateMonoModify(
% PixelIteratorMonoModifyCallback call_back,
% const PixelIteratorOptions *options,
% const char *description,
% void *mutable_data,
% const void *immutable_data,
% const long x,
% const long y,
% const unsigned long columns,
% const unsigned long rows,
% Image *image,
% ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o call_back: A user-provided C callback function which is passed the
% address of pixels from each image.
%
% o options: Pixel iterator execution options (may be NULL).
%
% o description: textual description of operation being performed.
%
% o mutable_data: User-provided mutable context data.
%
% o immutable_data: User-provided immutable context data.
%
% o x: The horizontal ordinate of the top left corner of the region.
%
% o y: The vertical ordinate of the top left corner of the region.
%
% o columns: Width of pixel region
%
% o rows: Height of pixel region
%
% o image: The address of the Image.
%
% o exception: If an error is reported, this argument is updated with the reason.
%
*/
MagickExport MagickPassFail
PixelIterateMonoModify(PixelIteratorMonoModifyCallback call_back,
const PixelIteratorOptions *options,
const char *description,
void *mutable_data,
const void *immutable_data,
const long x,
const long y,
const unsigned long columns,
const unsigned long rows,
Image *image,
ExceptionInfo *exception)
{
MagickPassFail
status = MagickPass;
register long
row;
unsigned long
row_count=0;
int
max_threads;
max_threads=omp_get_max_threads();
(void) SetRegionThreads(max_threads,options,columns,rows);
#if defined(HAVE_OPENMP)
# pragma omp parallel for schedule(static,1) shared(row_count, status)
#endif
for (row=y; row < (long) (y+rows); row++)
{
MagickBool
thread_status;
PixelPacket
*pixels;
IndexPacket
*indexes;
thread_status=status;
if (thread_status == MagickFail)
continue;
pixels=GetImagePixelsEx(image, x, row, columns, 1, exception);
if (!pixels)
thread_status=MagickFail;
indexes=AccessMutableIndexes(image);
if (thread_status != MagickFail)
thread_status=(call_back)(mutable_data,immutable_data,image,pixels,indexes,columns,exception);
if (thread_status != MagickFail)
if (!SyncImagePixelsEx(image,exception))
thread_status=MagickFail;
#if defined(HAVE_OPENMP)
# pragma omp critical (GM_PixelIterateMonoModify)
#endif
{
row_count++;
if (QuantumTick(row_count,rows))
if (!MagickMonitorFormatted(row_count,rows,exception,
description,image->filename))
thread_status=MagickFail;
if (thread_status == MagickFail)
status=MagickFail;
}
}
omp_set_num_threads(max_threads);
return (status);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% W r i t e T X T I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% Method WriteTXTImage writes the pixel values as text numbers.
%
% The format of the WriteTXTImage method is:
%
% unsigned int WriteTXTImage(const ImageInfo *image_info,Image *image)
%
% A description of each parameter follows.
%
% o status: Method WriteTXTImage return True if the image is written.
% False is returned is there is a memory shortage or if the image file
% fails to write.
%
% o image_info: Specifies a pointer to a ImageInfo structure.
%
% o image: A pointer to an Image structure.
%
%
*/
static unsigned int WriteTXTImage(const ImageInfo *image_info,Image *image)
{
char
buffer[MaxTextExtent],
tuple[MaxTextExtent];
long
y;
register const PixelPacket
*p;
register long
x;
unsigned int
status;
unsigned long
scene;
/*
Open output image file.
*/
assert(image_info != (const ImageInfo *) NULL);
assert(image_info->signature == MagickSignature);
assert(image != (Image *) NULL);
assert(image->signature == MagickSignature);
status=OpenBlob(image_info,image,WriteBlobMode,&image->exception);
if (status == False)
ThrowWriterException(FileOpenError,UnableToOpenFile,image);
scene=0;
do
{
/*
Convert MIFF to TXT raster pixels.
*/
unsigned int
depth;
(void) TransformColorspace(image,RGBColorspace);
if (image->depth <= 8)
depth=8;
else if (image->depth <= 16)
depth=16;
else
depth=32;
for (y=0; y < (long) image->rows; y++)
{
p=AcquireImagePixels(image,0,y,image->columns,1,&image->exception);
if (p == (const PixelPacket *) NULL)
break;
for (x=0; x < (long) image->columns; x++)
{
FormatString(buffer,"%ld,%ld: ",x,y);
(void) WriteBlobString(image,buffer);
GetColorTuple(p,depth,image->matte,MagickFalse,tuple);
(void) strcat(tuple," ");
(void) WriteBlobString(image,tuple);
/* (void) QueryColorname(image,p,SVGCompliance,tuple,&image->exception); */
GetColorTuple(p,depth,image->matte,MagickTrue,tuple);
(void) WriteBlobString(image,tuple);
(void) WriteBlobString(image,"\n");
p++;
}
}
if (image->next == (Image *) NULL)
break;
image=SyncNextImageInList(image);
status=MagickMonitorFormatted(scene++,GetImageListLength(image),
&image->exception,SaveImagesText,
image->filename);
if (status == False)
break;
} while (image_info->adjoin);
if (image_info->adjoin)
while (image->previous != (Image *) NULL)
image=image->previous;
CloseBlob(image);
return(True);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% R e a d T X T I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% Method ReadTXTImage reads a text file and returns it as an image. It
% allocates the memory necessary for the new Image structure and returns a
% pointer to the new image.
%
% The format of the ReadTXTImage method is:
%
% Image *ReadTXTImage(const ImageInfo *image_info,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image: Method ReadTXTImage returns a pointer to the image after
% reading. A null image is returned if there is a memory shortage or if
% the image cannot be read.
%
% o image_info: Specifies a pointer to a ImageInfo structure.
%
% o exception: return any errors or warnings in this structure.
%
%
*/
static Image *ReadTXTImage(const ImageInfo *image_info,ExceptionInfo *exception)
{
char
filename[MaxTextExtent],
geometry[MaxTextExtent],
*p,
text[MaxTextExtent];
double
dx_resolution,
dy_resolution;
DrawInfo
*draw_info;
Image
*image,
*texture;
long
count,
offset;
RectangleInfo
page;
TypeMetric
metrics;
unsigned int
status;
int logging;
/*
Open image file.
*/
assert(image_info != (const ImageInfo *) NULL);
assert(image_info->signature == MagickSignature);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
logging = LogMagickEvent(CoderEvent,GetMagickModule(),"enter");
image=AllocateImage(image_info);
status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
if (status == False)
ThrowReaderException(FileOpenError,UnableToOpenFile,image);
p = ReadBlobString(image,text);
status = IsTXT((unsigned char *)p,strlen(p));
if (logging) (void)LogMagickEvent(CoderEvent,GetMagickModule(),
"File type: %d", status);
if(status)
{
unsigned x,y;
unsigned x_min,x_max,y_curr;
int ch;
unsigned long max,i;
char NumOfPlanes;
unsigned char *BImgBuff;
magick_uint16_t *WImgBuff;
magick_uint32_t *DImgBuff;
magick_uint32_t R,G,B,A;
const PixelPacket *q;
ImportPixelAreaOptions import_options;
(void) SeekBlob(image,0,SEEK_SET);
A=0;
x=0;
y=0;
max=0;
switch(status)
{
case TXT_GM8B_HEX:
case TXT_GM8B_HEX_Q: max=255; break;
case TXT_GM16B_HEX:
case TXT_GM16B_HEX_Q: max=65535; break;
case TXT_GM32B_HEX:
case TXT_GM32B_HEX_Q: max=65536; break;
}
if(!strncmp(p,"# ImageMagick pixel enumeration:",32))
{
if(sscanf(p+32,"%u,%u,%u",&x_min,&y_curr,&x_max)==3)
{
if(strstr(p+32,",rgb")!=NULL)
{
x = x_min-1;
y = y_curr-1;
max = x_max;
}
if(strstr(p+32,",rgba")!=NULL)
{
status = IMAGEMAGICK_TXT_Q;
}
}
}
ch=0;
if(x==0 && y==0) while(!EOFBlob(image)) /* auto detect sizes and num of planes */
{
while(!(ch>='0' && ch<='9'))
{ /* go to the begin of number */
ch = ReadBlobByte(image);
if(ch==EOF) goto EndReading;
if(ch=='#')
{readln(image,&ch); continue;}
if(ch==0 || ch>128 || (ch>='a' && ch<='z') || (ch>='A' && ch<='Z'))
{
TXT_FAIL: /* not a text data */
ThrowReaderException(CoderError,ImageTypeNotSupported,image);
}
}
/* x,y: (R,G,B) */
i = ReadInt(image,&ch); /* x */
if(i>x) x=i;
while(ch!=',')
{
ch = ReadBlobByte(image);
if(ch==EOF) break;
if(ch==10 || ch==13) goto TXT_FAIL;
}
ch=0;
i=ReadInt(image,&ch); /* y */
if(i>y) y=i;
while(ch!=':')
{
ch = ReadBlobByte(image);
if(ch==10 || ch==13) goto TXT_FAIL;
if(ch==EOF) break;
}
if(status!=TXT_GM8B_PLAIN2_Q)
while(ch!='(')
{
ch = ReadBlobByte(image);
if(ch==10 || ch==13) goto TXT_FAIL;
if(ch==EOF) break;
}
ch=0;
R = ReadInt(image,&ch); /* R */
if(R>max) max=R;
while(ch!=',')
{
ch = ReadBlobByte(image);
if(ch==10 || ch==13) goto TXT_FAIL;
if(ch==EOF) break;
}
ch=0;
G = ReadInt(image,&ch); /* G */
if(G>max) max=G;
while(ch!=',')
{
ch = ReadBlobByte(image);
if(ch==10 || ch==13) goto TXT_FAIL;
if(ch==EOF) break;
}
ch=0;
B = ReadInt(image,&ch); /* B */
if(B>max) max=B;
if(status>16)
{
while(ch!=',')
{
ch = ReadBlobByte(image);
if(ch==10 || ch==13) goto TXT_FAIL;
if(ch==EOF) break;
}
ch=0;
A = ReadInt(image,&ch); /* A */
if(A>max) max=A;
}
if(status!=TXT_GM8B_PLAIN2_Q)
while(ch!=')')
{
ch = ReadBlobByte(image);
if(ch==10 || ch==13) goto TXT_FAIL;
if(ch==EOF) break;
}
readln(image,&ch);
}
EndReading:
x_min = 1; x_max = 0;
y_curr = 0;
NumOfPlanes=8;
/* if(max>= 2) i=2; */
/* if(max>= 4) i=4; */
/* if(max>= 16) i=8; */
if(max>= 256) NumOfPlanes=16;
if(max>=65536) NumOfPlanes=32;
if (logging) (void)LogMagickEvent(CoderEvent,GetMagickModule(),
"Image detected [%u * %u]: %d", x, y, NumOfPlanes);
image->depth = Min(QuantumDepth,NumOfPlanes);
ImportPixelAreaOptionsInit(&import_options);
import_options.endian = NativeEndian;
BImgBuff = MagickAllocateMemory(unsigned char *,
(size_t)(x+1) * ( ((status>16)?4:3) * NumOfPlanes/8));
WImgBuff = (magick_uint16_t *)BImgBuff;
DImgBuff = (magick_uint32_t *)BImgBuff;
if(BImgBuff==NULL)
ThrowReaderException(ResourceLimitError,MemoryAllocationFailed,image);
image->columns = x+1;
image->rows = y+1;
(void) SeekBlob(image,0,SEEK_SET);
while(!EOFBlob(image)) /* load picture data */
{
x=0;
while(!(ch >= '0' && ch <= '9'))
{ /* move to the beginning of number */
if(EOFBlob(image)) goto FINISH;
ch = ReadBlobByte(image);
if(ch=='#')
{readln(image,&ch); continue;}
}
x = ReadInt(image,&ch); /* x */
while(ch!=',')
{
ch = ReadBlobByte(image);
if(ch==EOF) break;
}
ch = 0;
y = ReadInt(image,&ch); /* y */
while(ch!=':')
{
ch = ReadBlobByte(image);
if(ch==EOF) break;
}
while(ch!='(')
{
ch = ReadBlobByte(image);
if(ch==EOF) break;
}
ch=0;
R = ReadInt(image,&ch); /* R */
while(ch!=',')
{
ch = ReadBlobByte(image);
if(ch==EOF) break;
}
ch=0;
G = ReadInt(image,&ch); /* G */
while(ch!=',')
{
ch = ReadBlobByte(image);
if(ch==EOF) break;
}
ch=0;
B = ReadInt(image,&ch); /* B */
if(status>16)
{
while(ch!=',')
{
ch = ReadBlobByte(image);
if(ch==EOF) break;
}
ch=0;
A = ReadInt(image,&ch); /* A */
if(A>max) max=A;
}
while(ch!=')')
{
ch = ReadBlobByte(image);
if(ch==EOF) break;
}
/* a new line has been detected */
if(y!=y_curr)
{
q = SetImagePixels(image,x_min,y_curr,x_max-x_min+1,1);
if (q == (PixelPacket *)NULL) break;
if(status>16)
(void)ImportImagePixelArea(image,RGBAQuantum,NumOfPlanes,
BImgBuff + 4*x_min*(NumOfPlanes/8),&import_options,0);
else
(void)ImportImagePixelArea(image,RGBQuantum,NumOfPlanes,
BImgBuff + 3*x_min*(NumOfPlanes/8),&import_options,0);
if (!SyncImagePixels(image)) break;
x_min = 1; x_max = 0;
y_curr=y;
}
if(x<image->columns)
{
if(status>16)
{
switch(NumOfPlanes)
{
case 8: BImgBuff[0+4*x] = R;
BImgBuff[1+4*x] = G;
BImgBuff[2+4*x] = B;
BImgBuff[3+4*x] = A;
break;
case 16:WImgBuff[0+4*x] = R;
WImgBuff[1+4*x] = G;
WImgBuff[2+4*x] = B;
WImgBuff[3+4*x] = A;
break;
case 32:DImgBuff[0+4*x] = R;
DImgBuff[1+4*x] = G;
DImgBuff[2+4*x] = B;
DImgBuff[3+4*x] = A;
break;
}
}
else
{
switch(NumOfPlanes)
{
case 8: BImgBuff[0+3*x] = R;
BImgBuff[1+3*x] = G;
BImgBuff[2+3*x] = B;
break;
case 16:WImgBuff[0+3*x] = R;
WImgBuff[1+3*x] = G;
WImgBuff[2+3*x] = B;
break;
case 32:DImgBuff[0+3*x] = R;
DImgBuff[1+3*x] = G;
DImgBuff[2+3*x] = B;
break;
}
}
if(x_min>x_max)
x_max=x_min=x;
else
{
if(x<x_min) x_min=x;
if(x>x_max) x_max=x;
}
}
readln(image,&ch);
}
FINISH:
if(x_min<=x_max)
{
q = SetImagePixels(image,x_min,y_curr,x_max-x_min+1,1);
if (q != (PixelPacket *)NULL)
{
if(status>16)
(void)ImportImagePixelArea(image, RGBAQuantum, NumOfPlanes,
BImgBuff + 4*x_min*(NumOfPlanes/8), &import_options, 0);
else
(void)ImportImagePixelArea(image, RGBQuantum, NumOfPlanes,
BImgBuff + 3*x_min*(NumOfPlanes/8), &import_options, 0);
if(!SyncImagePixels(image))
{
if (logging) (void)LogMagickEvent(CoderEvent,GetMagickModule(),
" TXT failed to sync image pixels for a row %u", y_curr);
}
}
}
MagickFreeMemory(BImgBuff);
goto TXT_FINISH;
}
/*
Set the page geometry.
*/
dx_resolution=72.0;
dy_resolution=72.0;
if ((image->x_resolution == 0.0) || (image->y_resolution == 0.0))
{
char
density[MaxTextExtent];
(void) strcpy(density,PSDensityGeometry);
count=GetMagickDimension(density,&image->x_resolution,
&image->y_resolution,NULL,NULL);
if (count != 2)
image->y_resolution=image->x_resolution;
}
SetGeometry(image,&page);
page.width=612;
page.height=792;
(void) GetGeometry("612x792+43+43",&page.x,&page.y,&page.width,&page.height);
if (image_info->page != (char *) NULL)
(void) GetGeometry(image_info->page,&page.x,&page.y,&page.width,
&page.height);
/*
Initialize Image structure.
*/
image->columns=(unsigned long)
ceil(((page.width*image->x_resolution)/dx_resolution)-0.5);
image->rows=(unsigned long)
ceil(((page.height*image->y_resolution)/dy_resolution)-0.5);
texture=(Image *) NULL;
if (image_info->texture != (char *) NULL)
{
ImageInfo
*clone_info;
clone_info=CloneImageInfo(image_info);
clone_info->blob=(void *) NULL;
clone_info->length=0;
(void) strlcpy(clone_info->filename,image_info->texture,MaxTextExtent);
texture=ReadImage(clone_info,exception);
DestroyImageInfo(clone_info);
}
/*
Annotate the text image.
*/
(void) SetImage(image,OpaqueOpacity);
draw_info=CloneDrawInfo(image_info,(DrawInfo *) NULL);
draw_info->fill=image_info->pen;
(void) CloneString(&draw_info->text,image_info->filename);
FormatString(geometry,"0x0%+ld%+ld",page.x,page.y);
(void) CloneString(&draw_info->geometry,geometry);
status=GetTypeMetrics(image,draw_info,&metrics);
if (status == False)
ThrowReaderException(TypeError,UnableToGetTypeMetrics,image);
(void) strlcpy(filename,image_info->filename,MaxTextExtent);
if (draw_info->text != '\0')
*draw_info->text='\0';
for (offset=2*page.y; p != (char *) NULL; )
{
/*
Annotate image with text.
*/
(void) ConcatenateString(&draw_info->text,text);
(void) ConcatenateString(&draw_info->text,"\\n");
offset+=(long) (metrics.ascent-metrics.descent);
if (image->previous == (Image *) NULL)
if (QuantumTick(offset,image->rows))
if (!MagickMonitorFormatted(offset,image->rows,&image->exception,
LoadImageText,image->filename,
image->columns,image->rows))
break;
p=ReadBlobString(image,text);
if ((offset < (long) image->rows) && (p != (char *) NULL))
continue;
if (texture != (Image *) NULL)
{
MonitorHandler
handler;
handler=SetMonitorHandler((MonitorHandler) NULL);
(void) TextureImage(image,texture);
(void) SetMonitorHandler(handler);
}
(void) AnnotateImage(image,draw_info);
if (p == (char *) NULL)
break;
/*
Page is full-- allocate next image structure.
*/
*draw_info->text='\0';
offset=2*page.y;
AllocateNextImage(image_info,image);
if (image->next == (Image *) NULL)
{
DestroyImageList(image);
return((Image *) NULL);
}
image->next->columns=image->columns;
image->next->rows=image->rows;
image=SyncNextImageInList(image);
(void) strlcpy(image->filename,filename,MaxTextExtent);
(void) SetImage(image,OpaqueOpacity);
if (!MagickMonitorFormatted(TellBlob(image),GetBlobSize(image),exception,
LoadImagesText,image->filename))
break;
}
if (texture != (Image *) NULL)
{
MonitorHandler
handler;
handler=SetMonitorHandler((MonitorHandler) NULL);
(void) TextureImage(image,texture);
(void) SetMonitorHandler(handler);
}
(void) AnnotateImage(image,draw_info);
if (texture != (Image *) NULL)
DestroyImage(texture);
DestroyDrawInfo(draw_info);
while (image->previous != (Image *) NULL)
image=image->previous;
TXT_FINISH:
CloseBlob(image);
return(image);
}
static void XShearImage(Image *image,const double degrees,
const unsigned long width,const unsigned long height,
const long x_offset,long y_offset)
{
#define XShearImageText "[%s] X Shear: %+g degrees, region %lux%lu%+ld%+ld... "
long
y;
unsigned long
row_count=0;
unsigned int
is_grayscale;
MagickPassFail
status=MagickPass;
assert(image != (Image *) NULL);
is_grayscale=image->is_grayscale;
#if defined(HAVE_OPENMP)
# pragma omp parallel for schedule(dynamic,8) shared(row_count, status)
#endif
for (y=0; y < (long) height; y++)
{
double
alpha,
displacement;
long
step;
PixelPacket
pixel;
register long
i;
register PixelPacket
*p,
*q;
enum
{
LEFT,
RIGHT
} direction;
MagickPassFail
thread_status;
thread_status=status;
if (thread_status == MagickFail)
continue;
displacement=degrees*(y-height/2.0);
if (displacement == 0.0)
continue;
if (displacement > 0.0)
direction=RIGHT;
else
{
displacement*=(-1.0);
direction=LEFT;
}
step=(long) floor(displacement);
alpha=MaxRGBDouble*(displacement-step);
if (alpha == 0.0)
{
/*
No fractional displacement-- just copy.
*/
switch (direction)
{
case LEFT:
{
/*
Transfer pixels left-to-right.
*/
if (step > x_offset)
break;
p=GetImagePixelsEx(image,0,y+y_offset,image->columns,1,&image->exception);
if (p == (PixelPacket *) NULL)
{
thread_status=MagickFail;
break;
}
p+=x_offset;
q=p-step;
(void) memcpy(q,p,width*sizeof(PixelPacket));
q+=width;
for (i=0; i < (long) step; i++)
*q++=image->background_color;
break;
}
case RIGHT:
{
/*
Transfer pixels right-to-left.
*/
p=GetImagePixelsEx(image,0,y+y_offset,image->columns,1,&image->exception);
if (p == (PixelPacket *) NULL)
{
thread_status=MagickFail;
break;
}
p+=x_offset+width;
q=p+step;
for (i=0; i < (long) width; i++)
*--q=(*--p);
for (i=0; i < (long) step; i++)
*--q=image->background_color;
break;
}
}
if (!SyncImagePixelsEx(image,&image->exception))
thread_status=MagickFail;
#if defined(HAVE_OPENMP)
# pragma omp critical (GM_XShearImage)
#endif
{
row_count++;
if (QuantumTick(row_count,height))
if (!MagickMonitorFormatted(row_count,height,&image->exception,
XShearImageText,image->filename,
degrees,width,height,
x_offset,y_offset))
thread_status=MagickFail;
if (thread_status == MagickFail)
status=MagickFail;
}
continue;
}
/*
Fractional displacement.
*/
step++;
pixel=image->background_color;
switch (direction)
{
case LEFT:
{
/*
Transfer pixels left-to-right.
*/
if (step > x_offset)
break;
p=GetImagePixelsEx(image,0,y+y_offset,image->columns,1,&image->exception);
if (p == (PixelPacket *) NULL)
{
thread_status=MagickFail;
break;
}
p+=x_offset;
q=p-step;
for (i=0; i < (long) width; i++)
{
if ((x_offset+i) < step)
{
pixel=(*++p);
q++;
continue;
}
BlendCompositePixel(q,&pixel,p,alpha);
q++;
pixel=(*p++);
}
BlendCompositePixel(q,&pixel,&image->background_color,alpha);
q++;
for (i=0; i < (step-1); i++)
*q++=image->background_color;
break;
}
case RIGHT:
{
/*
Transfer pixels right-to-left.
*/
p=GetImagePixelsEx(image,0,y+y_offset,image->columns,1,&image->exception);
if (p == (PixelPacket *) NULL)
{
thread_status=MagickFail;
break;
}
p+=x_offset+width;
q=p+step;
for (i=0; i < (long) width; i++)
{
p--;
q--;
if ((x_offset+width+step-i) >= image->columns)
continue;
BlendCompositePixel(q,&pixel,p,alpha);
pixel=(*p);
}
--q;
BlendCompositePixel(q,&pixel,&image->background_color,alpha);
for (i=0; i < (step-1); i++)
*--q=image->background_color;
break;
}
}
if (!SyncImagePixelsEx(image,&image->exception))
thread_status=MagickFail;
#if defined(HAVE_OPENMP)
# pragma omp critical (GM_XShearImage)
#endif
{
row_count++;
if (QuantumTick(row_count,height))
if (!MagickMonitorFormatted(row_count,height,&image->exception,
XShearImageText,image->filename,
degrees,width,height,
x_offset,y_offset))
thread_status=MagickFail;
if (thread_status == MagickFail)
status=MagickFail;
}
}
if (is_grayscale && IsGray(image->background_color))
image->is_grayscale=True;
}
static Image *IntegralRotateImage(const Image *image,unsigned int rotations,
ExceptionInfo *exception)
{
char
message[MaxTextExtent];
Image
*rotate_image;
RectangleInfo
page;
long
tile_width_max,
tile_height_max;
MagickPassFail
status=MagickPass;
/*
Initialize rotated image attributes.
*/
assert(image != (Image *) NULL);
page=image->page;
rotations%=4;
{
/*
Clone appropriately to create rotate image.
*/
unsigned long
clone_columns=0,
clone_rows=0;
switch (rotations)
{
case 0:
clone_columns=0;
clone_rows=0;
break;
case 2:
clone_columns=image->columns;
clone_rows=image->rows;
break;
case 1:
case 3:
clone_columns=image->rows;
clone_rows=image->columns;
break;
}
rotate_image=CloneImage(image,clone_columns,clone_rows,True,exception);
if (rotate_image == (Image *) NULL)
return((Image *) NULL);
if (rotations != 0)
if (ModifyCache(rotate_image,exception) != MagickPass)
{
DestroyImage(rotate_image);
return (Image *) NULL;
}
}
tile_height_max=tile_width_max=2048/sizeof(PixelPacket); /* 2k x 2k = 4MB */
if ((rotations == 1) || (rotations == 3))
{
/*
Allow override of tile geometry for testing.
*/
const char *
value;
if (!GetPixelCacheInCore(image) || !GetPixelCacheInCore(rotate_image))
tile_height_max=tile_width_max=8192/sizeof(PixelPacket); /* 8k x 8k = 64MB */
if ((value=getenv("MAGICK_ROTATE_TILE_GEOMETRY")))
{
double
width,
height;
if (GetMagickDimension(value,&width,&height,NULL,NULL) == 2)
{
tile_height_max=(unsigned long) height;
tile_width_max=(unsigned long) width;
}
}
}
/*
Integral rotate the image.
*/
switch (rotations)
{
case 0:
{
/*
Rotate 0 degrees (nothing more to do).
*/
(void) strlcpy(message,"[%s] Rotate: 0 degrees...",sizeof(message));
if (!MagickMonitorFormatted(image->rows-1,image->rows,exception,
message,image->filename))
status=MagickFail;
break;
}
case 1:
{
/*
Rotate 90 degrees.
*/
magick_int64_t
tile;
magick_uint64_t
total_tiles;
long
tile_y;
(void) strlcpy(message,"[%s] Rotate: 90 degrees...",sizeof(message));
total_tiles=(((image->rows/tile_height_max)+1)*
((image->columns/tile_width_max)+1));
tile=0;
#if defined(IntegralRotateImageUseOpenMP)
# if defined(HAVE_OPENMP)
# pragma omp parallel for schedule(static,1) shared(status, tile)
# endif
#endif
for (tile_y=0; tile_y < (long) image->rows; tile_y+=tile_height_max)
{
long
tile_x;
MagickPassFail
thread_status;
thread_status=status;
if (thread_status == MagickFail)
continue;
for (tile_x=0; tile_x < (long) image->columns; tile_x+=tile_width_max)
{
long
dest_tile_x,
dest_tile_y;
long
tile_width,
tile_height;
const PixelPacket
*tile_pixels;
long
y;
/*
Compute image region corresponding to tile.
*/
if ((unsigned long) tile_x+tile_width_max > image->columns)
tile_width=(tile_width_max-(tile_x+tile_width_max-image->columns));
else
tile_width=tile_width_max;
if ((unsigned long) tile_y+tile_height_max > image->rows)
tile_height=(tile_height_max-(tile_y+tile_height_max-image->rows));
else
tile_height=tile_height_max;
/*
Acquire tile
*/
tile_pixels=AcquireImagePixels(image,tile_x,tile_y,
tile_width,tile_height,exception);
if (tile_pixels == (const PixelPacket *) NULL)
{
thread_status=MagickFail;
break;
}
/*
Compute destination tile coordinates.
*/
dest_tile_x=rotate_image->columns-(tile_y+tile_height);
dest_tile_y=tile_x;
/*
Rotate tile
*/
for (y=0; y < tile_width; y++)
{
register const PixelPacket
*p;
register PixelPacket
*q;
register const IndexPacket
*indexes;
IndexPacket
*rotate_indexes;
register long
x;
q=SetImagePixelsEx(rotate_image,dest_tile_x,dest_tile_y+y,
tile_height,1,exception);
if (q == (PixelPacket *) NULL)
{
thread_status=MagickFail;
break;
}
/*
DirectClass pixels
*/
p=tile_pixels+(tile_height-1)*tile_width + y;
for (x=tile_height; x != 0; x--)
{
*q = *p;
q++;
p-=tile_width;
}
/*
Indexes
*/
indexes=AccessImmutableIndexes(image);
if (indexes != (IndexPacket *) NULL)
{
rotate_indexes=AccessMutableIndexes(rotate_image);
if (rotate_indexes != (IndexPacket *) NULL)
{
register IndexPacket
*iq;
register const IndexPacket
*ip;
iq=rotate_indexes;
ip=indexes+(tile_height-1)*tile_width + y;
for (x=tile_height; x != 0; x--)
{
*iq = *ip;
iq++;
ip -= tile_width;
}
}
}
if (!SyncImagePixelsEx(rotate_image,exception))
{
thread_status=MagickFail;
break;
}
}
#if defined(IntegralRotateImageUseOpenMP)
# if defined(HAVE_OPENMP)
# pragma omp critical (GM_IntegralRotateImage)
# endif
#endif
{
tile++;
if (QuantumTick(tile,total_tiles))
if (!MagickMonitorFormatted(tile,total_tiles,exception,
message,image->filename))
thread_status=MagickFail;
if (thread_status == MagickFail)
status=MagickFail;
}
}
}
Swap(page.width,page.height);
Swap(page.x,page.y);
page.x=(long) (page.width-rotate_image->columns-page.x);
break;
}
case 2:
{
/*
Rotate 180 degrees.
*/
long
y;
unsigned long
row_count=0;
(void) strlcpy(message,"[%s] Rotate: 180 degrees...",sizeof(message));
#if defined(IntegralRotateImageUseOpenMP)
# if defined(HAVE_OPENMP)
# pragma omp parallel for schedule(static,8) shared(row_count, status)
# endif
#endif
for (y=0; y < (long) image->rows; y++)
{
register const PixelPacket
*p;
register PixelPacket
*q;
register const IndexPacket
*indexes;
IndexPacket
*rotate_indexes;
register long
x;
MagickPassFail
thread_status;
thread_status=status;
if (thread_status == MagickFail)
continue;
p=AcquireImagePixels(image,0,y,image->columns,1,exception);
q=SetImagePixelsEx(rotate_image,0,(long) (image->rows-y-1),
image->columns,1,exception);
if ((p == (const PixelPacket *) NULL) || (q == (PixelPacket *) NULL))
thread_status=MagickFail;
if (thread_status != MagickFail)
{
q+=image->columns;
indexes=AccessImmutableIndexes(image);
rotate_indexes=AccessMutableIndexes(rotate_image);
if ((indexes != (IndexPacket *) NULL) &&
(rotate_indexes != (IndexPacket *) NULL))
for (x=0; x < (long) image->columns; x++)
rotate_indexes[image->columns-x-1]=indexes[x];
for (x=0; x < (long) image->columns; x++)
*--q=(*p++);
if (!SyncImagePixelsEx(rotate_image,exception))
thread_status=MagickFail;
}
#if defined(IntegralRotateImageUseOpenMP)
# if defined(HAVE_OPENMP)
# pragma omp critical (GM_IntegralRotateImage)
# endif
#endif
{
row_count++;
if (QuantumTick(row_count,image->rows))
if (!MagickMonitorFormatted(row_count,image->rows,exception,
message,image->filename))
thread_status=MagickFail;
if (thread_status == MagickFail)
status=MagickFail;
}
}
page.x=(long) (page.width-rotate_image->columns-page.x);
page.y=(long) (page.height-rotate_image->rows-page.y);
break;
}
case 3:
{
/*
Rotate 270 degrees.
*/
magick_int64_t
tile;
magick_uint64_t
total_tiles;
long
tile_y;
(void) strlcpy(message,"[%s] Rotate: 270 degrees...",sizeof(message));
total_tiles=(((image->rows/tile_height_max)+1)*
((image->columns/tile_width_max)+1));
tile=0;
#if defined(IntegralRotateImageUseOpenMP)
# if defined(HAVE_OPENMP)
# pragma omp parallel for schedule(static,1) shared(status, tile)
# endif
#endif
for (tile_y=0; tile_y < (long) image->rows; tile_y+=tile_height_max)
{
long
tile_x;
MagickPassFail
thread_status;
thread_status=status;
if (thread_status == MagickFail)
continue;
for (tile_x=0; tile_x < (long) image->columns; tile_x+=tile_width_max)
{
long
tile_width,
tile_height;
long
dest_tile_x,
dest_tile_y;
long
y;
const PixelPacket
*tile_pixels;
/*
Compute image region corresponding to tile.
*/
if ((unsigned long) tile_x+tile_width_max > image->columns)
tile_width=(tile_width_max-(tile_x+tile_width_max-image->columns));
else
tile_width=tile_width_max;
if ((unsigned long) tile_y+tile_height_max > image->rows)
tile_height=(tile_height_max-(tile_y+tile_height_max-image->rows));
else
tile_height=tile_height_max;
/*
Acquire tile
*/
tile_pixels=AcquireImagePixels(image,tile_x,tile_y,
tile_width,tile_height,exception);
if (tile_pixels == (const PixelPacket *) NULL)
{
thread_status=MagickFail;
break;
}
/*
Compute destination tile coordinates.
*/
dest_tile_x=tile_y;
dest_tile_y=rotate_image->rows-(tile_x+tile_width);
/*
Rotate tile
*/
for (y=0; y < tile_width; y++)
{
register const PixelPacket
*p;
register PixelPacket
*q;
register const IndexPacket
*indexes;
register long
x;
IndexPacket
*rotate_indexes;
q=SetImagePixelsEx(rotate_image,dest_tile_x,dest_tile_y+y,
tile_height,1,exception);
if (q == (PixelPacket *) NULL)
{
thread_status=MagickFail;
break;
}
/*
DirectClass pixels
*/
p=tile_pixels+(tile_width-1-y);
for (x=tile_height; x != 0; x--)
{
*q = *p;
q++;
p += tile_width;
}
/*
Indexes
*/
indexes=AccessImmutableIndexes(image);
if (indexes != (IndexPacket *) NULL)
{
rotate_indexes=AccessMutableIndexes(rotate_image);
if (rotate_indexes != (IndexPacket *) NULL)
{
register IndexPacket
*iq;
register const IndexPacket
*ip;
iq=rotate_indexes;
ip=indexes+(tile_width-1-y);
for (x=tile_height; x != 0; x--)
{
*iq = *ip;
iq++;
ip += tile_width;
}
}
}
if (!SyncImagePixelsEx(rotate_image,exception))
{
thread_status=MagickFail;
break;
}
}
#if defined(IntegralRotateImageUseOpenMP)
# if defined(HAVE_OPENMP)
# pragma omp critical (GM_IntegralRotateImage)
# endif
#endif
{
tile++;
if (QuantumTick(tile,total_tiles))
if (!MagickMonitorFormatted(tile,total_tiles,exception,
message,image->filename))
thread_status=MagickFail;
}
if (thread_status == MagickFail)
{
status=MagickFail;
break;
}
}
}
Swap(page.width,page.height);
Swap(page.x,page.y);
page.y=(long) (page.height-rotate_image->rows-page.y);
break;
}
}
rotate_image->page=page;
rotate_image->is_grayscale=image->is_grayscale;
rotate_image->is_monochrome=image->is_monochrome;
return(rotate_image);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
+ Y S h e a r I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% Procedure YShearImage shears the image in the Y direction with a shear
% angle of 'degrees'. Positive angles shear counter-clockwise (right-hand
% rule), and negative angles shear clockwise. Angles are measured relative
% to a horizontal X-axis. Y shears will increase the height of an image
% creating 'empty' triangles on the top and bottom of the source image.
%
% The format of the YShearImage method is:
%
% void YShearImage(Image *image,const double degrees,
% const unsigned long width,const unsigned long height,long x_offset,
% const long y_offset)
%
% A description of each parameter follows.
%
% o image: The image.
%
% o degrees: A double representing the shearing angle along the Y axis.
%
% o width, height, x_offset, y_offset: Defines a region of the image
% to shear.
%
%
*/
static void YShearImage(Image *image,const double degrees,
const unsigned long width,const unsigned long height,long x_offset,
const long y_offset)
{
#define YShearImageText "[%s] Y Shear: %+g degrees, region %lux%lu%+ld%+ld... "
long
y;
unsigned long
row_count=0;
unsigned int
is_grayscale;
MagickPassFail
status=MagickPass;
assert(image != (Image *) NULL);
is_grayscale=image->is_grayscale;
#if defined(HAVE_OPENMP)
# pragma omp parallel for schedule(dynamic,8) shared(row_count, status)
#endif
for (y=0; y < (long) width; y++)
{
double
alpha,
displacement;
enum
{
UP,
DOWN
} direction;
long
step;
register PixelPacket
*p,
*q;
register long
i;
PixelPacket
pixel;
MagickPassFail
thread_status;
thread_status=status;
if (thread_status == MagickFail)
continue;
displacement=degrees*(y-width/2.0);
if (displacement == 0.0)
continue;
if (displacement > 0.0)
direction=DOWN;
else
{
displacement*=(-1.0);
direction=UP;
}
step=(long) floor(displacement);
alpha=(double) MaxRGB*(displacement-step);
if (alpha == 0.0)
{
/*
No fractional displacement-- just copy the pixels.
*/
switch (direction)
{
case UP:
{
/*
Transfer pixels top-to-bottom.
*/
if (step > y_offset)
break;
p=GetImagePixelsEx(image,y+x_offset,0,1,image->rows,&image->exception);
if (p == (PixelPacket *) NULL)
{
thread_status=MagickFail;
break;
}
p+=y_offset;
q=p-step;
(void) memcpy(q,p,height*sizeof(PixelPacket));
q+=height;
for (i=0; i < (long) step; i++)
*q++=image->background_color;
break;
}
case DOWN:
{
/*
Transfer pixels bottom-to-top.
*/
p=GetImagePixelsEx(image,y+x_offset,0,1,image->rows,&image->exception);
if (p == (PixelPacket *) NULL)
{
thread_status=MagickFail;
break;
}
p+=y_offset+height;
q=p+step;
for (i=0; i < (long) height; i++)
*--q=(*--p);
for (i=0; i < (long) step; i++)
*--q=image->background_color;
break;
}
}
if (!SyncImagePixelsEx(image,&image->exception))
thread_status=MagickFail;
#if defined(HAVE_OPENMP)
# pragma omp critical (GM_YShearImage)
#endif
{
row_count++;
if (QuantumTick(row_count,width))
if (!MagickMonitorFormatted(row_count,width,&image->exception,
YShearImageText,image->filename,
degrees,width,height,
x_offset,y_offset))
thread_status=MagickFail;
if (thread_status == MagickFail)
status=MagickFail;
}
continue;
}
/*
Fractional displacment.
*/
step++;
pixel=image->background_color;
switch (direction)
{
case UP:
{
/*
Transfer pixels top-to-bottom.
*/
if (step > y_offset)
break;
p=GetImagePixelsEx(image,y+x_offset,0,1,image->rows,&image->exception);
if (p == (PixelPacket *) NULL)
{
thread_status=MagickFail;
break;
}
p+=y_offset;
q=p-step;
for (i=0; i < (long) height; i++)
{
if ((y_offset+i) < step)
{
pixel=(*++p);
q++;
continue;
}
BlendCompositePixel(q,&pixel,p,alpha);
q++;
pixel=(*p++);
}
BlendCompositePixel(q,&pixel,&image->background_color,alpha);
q++;
for (i=0; i < (step-1); i++)
*q++=image->background_color;
break;
}
case DOWN:
{
/*
Transfer pixels bottom-to-top.
*/
p=GetImagePixelsEx(image,y+x_offset,0,1,image->rows,&image->exception);
if (p == (PixelPacket *) NULL)
{
thread_status=MagickFail;
break;
}
p+=y_offset+height;
q=p+step;
for (i=0; i < (long) height; i++)
{
p--;
q--;
if ((y_offset+height+step-i) >= image->rows)
continue;
BlendCompositePixel(q,&pixel,p,alpha);
pixel=(*p);
}
--q;
BlendCompositePixel(q,&pixel,&image->background_color,alpha);
for (i=0; i < (step-1); i++)
*--q=image->background_color;
break;
}
}
if (!SyncImagePixelsEx(image,&image->exception))
thread_status=MagickFail;
#if defined(HAVE_OPENMP)
# pragma omp critical (GM_YShearImage)
#endif
{
row_count++;
if (QuantumTick(row_count,width))
if (!MagickMonitorFormatted(row_count,width,&image->exception,
YShearImageText,image->filename,
degrees,width,height,
x_offset,y_offset))
thread_status=MagickFail;
if (thread_status == MagickFail)
status=MagickFail;
}
}
if (is_grayscale && IsGray(image->background_color))
image->is_grayscale=True;
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% R e a d P W P I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% Method ReadPWPImage reads a Seattle Film Works multi-image file and returns
% it. It allocates the memory necessary for the new Image structure and
% returns a pointer to the new image.
%
% The format of the ReadPWPImage method is:
%
% Image *ReadPWPImage(const ImageInfo *image_info,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image: Method ReadPWPImage returns a pointer to the image after
% reading. A null image is returned if there is a memory shortage or
% if the image cannot be read.
%
% o image_info: Specifies a pointer to a ImageInfo structure.
%
% o exception: return any errors or warnings in this structure.
%
%
*/
static Image *ReadPWPImage(const ImageInfo *image_info,ExceptionInfo *exception)
{
FILE
*file;
Image
*image,
*next_image,
*pwp_image;
ImageInfo
*clone_info;
int
c;
MonitorHandler
handler;
register Image
*p;
register unsigned long
i;
size_t
count;
unsigned char
magick[MaxTextExtent];
unsigned int
status;
unsigned long
filesize;
/*
Open image file.
*/
assert(image_info != (const ImageInfo *) NULL);
assert(image_info->signature == MagickSignature);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
image=(Image *) NULL;
pwp_image=AllocateImage(image_info);
status=OpenBlob(image_info,pwp_image,ReadBinaryBlobMode,exception);
if (status == False)
ThrowReaderException(FileOpenError,UnableToOpenFile,pwp_image);
count=ReadBlob(pwp_image,5,(char *) magick);
if ((count == 0) || (LocaleNCompare((char *) magick,"SFW95",5) != 0))
ThrowReaderException(CorruptImageError,ImproperImageHeader,pwp_image);
clone_info=CloneImageInfo(image_info);
clone_info->blob=(void *) NULL;
clone_info->length=0;
for ( ; ; )
{
for (c=ReadBlobByte(pwp_image); c != EOF; c=ReadBlobByte(pwp_image))
{
for (i=0; i < 17; i++)
magick[i]=magick[i+1];
magick[17]=(unsigned char) c;
if (LocaleNCompare((char *) (magick+12),"SFW94A",6) == 0)
break;
}
if (c == EOF)
break;
if (LocaleNCompare((char *) (magick+12),"SFW94A",6) != 0)
{
ThrowReaderException(CorruptImageError,ImproperImageHeader,pwp_image);
}
/*
Dump SFW image to a temporary file.
*/
file=AcquireTemporaryFileStream(clone_info->filename,BinaryFileIOMode);
if (file == (FILE *) NULL)
{
char
filename[MaxTextExtent];
(void) strcpy(filename,clone_info->filename);
DestroyImageInfo(clone_info);
ThrowReaderTemporaryFileException(filename);
}
(void) fwrite("SFW94A",1,6,file);
filesize=(65535L*magick[2]+256L*magick[1]+magick[0]) & 0xFFFFFFFF;
for (i=0; i < filesize; i++)
{
if ((c=ReadBlobByte(pwp_image)) == EOF)
break;
(void) fputc(c,file);
}
(void) fclose(file);
if (c == EOF)
break;
handler=SetMonitorHandler((MonitorHandler) NULL);
next_image=ReadImage(clone_info,exception);
(void) LiberateTemporaryFile(clone_info->filename);
(void) SetMonitorHandler(handler);
if (next_image == (Image *) NULL)
break;
FormatString(next_image->filename,"slide_%02ld.sfw",next_image->scene);
if (image == (Image *) NULL)
image=next_image;
else
{
/*
Link image into image list.
*/
for (p=image; p->next != (Image *) NULL; p=p->next);
next_image->previous=p;
next_image->scene=p->scene+1;
p->next=next_image;
}
if (image_info->subrange != 0)
if (next_image->scene >= (image_info->subimage+image_info->subrange-1))
break;
if (!MagickMonitorFormatted(TellBlob(pwp_image),GetBlobSize(image),
&image->exception,LoadImagesText,
image->filename))
break;
}
DestroyImageInfo(clone_info);
CloseBlob(pwp_image);
DestroyImage(pwp_image);
if (EOFBlob(image))
ThrowException(exception,CorruptImageError,UnexpectedEndOfFile,
image->filename);
CloseBlob(image);
return(image);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% W r i t e P C L I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% Method WritePCLImage writes an image in the Page Control Language encoded
% image format.
%
% The format of the WritePCLImage method is:
%
% unsigned int WritePCLImage(const ImageInfo *image_info,Image *image)
%
% A description of each parameter follows.
%
% o status: Method WritePCLImage return True if the image is written.
% False is returned is there is a memory shortage or if the image file
% fails to write.
%
% o image_info: Specifies a pointer to a ImageInfo structure.
%
% o image: A pointer to an Image structure.
%
%
%
*/
static unsigned int WritePCLImage(const ImageInfo *image_info,Image *image)
{
char
buffer[MaxTextExtent];
long
sans,
y;
register const PixelPacket
*p;
register const IndexPacket
*indexes;
register long
i,
x;
register unsigned char
*q;
unsigned char
*pixels,
*last_row_pixels,
*output_row;
unsigned int
status;
long
zero_rows;
unsigned long
bytes_to_write,
scene,
density,
bytes_per_line;
unsigned char
bits_per_pixel;
ImageCharacteristics
characteristics;
PCL_CompressionType
compression,
last_row_compression;
/*
Open output image file.
*/
assert(image_info != (const ImageInfo *) NULL);
assert(image_info->signature == MagickSignature);
assert(image != (Image *) NULL);
assert(image->signature == MagickSignature);
status=OpenBlob(image_info,image,WriteBinaryBlobMode,&image->exception);
if (status == False)
ThrowWriterException(FileOpenError,UnableToOpenFile,image);
(void) GetGeometry("75x75",&sans,&sans,&density,&density);
if (image_info->density != (char *) NULL)
(void) GetGeometry(image_info->density,&sans,&sans,&density,&density);
scene = 0;
output_row = (unsigned char *) NULL;
last_row_pixels = (unsigned char *) NULL;
do
{
/*
Ensure that image is in an RGB space.
*/
(void) TransformColorspace(image,RGBColorspace);
/*
Analyze image to be written.
*/
if (!GetImageCharacteristics(image,&characteristics,
(OptimizeType == image_info->type),
&image->exception))
{
CloseBlob(image);
return MagickFail;
}
/*
Initialize the printer
*/
(void) WriteBlobString(image,"\033E"); /* printer reset */
(void) WriteBlobString(image,"\033*r3F"); /* set presentation mode */
/* define columns and rows in image */
FormatString(buffer,"\033*r%lus%luT",image->columns,image->rows);
(void) WriteBlobString(image,buffer);
FormatString(buffer,"\033*t%luR",density); /* set resolution */
(void) WriteBlobString(image,buffer);
(void) WriteBlobString(image,"\033&l0E"); /* top margin 0 */
/*
Determine output type and initialize further accordingly
*/
if (image->storage_class == DirectClass)
{
/*
Full color
*/
bits_per_pixel=24;
(void) WriteBlobString(image,"\033*v6W"); /* set color mode... */
(void) WriteBlobByte(image,0); /* RGB */
(void) WriteBlobByte(image,3); /* direct by pixel */
(void) WriteBlobByte(image,0); /* bits per index (ignored) */
(void) WriteBlobByte(image,8); /* bits per red component */
(void) WriteBlobByte(image,8); /* bits per green component */
(void) WriteBlobByte(image,8); /* bits per blue component */
}
else
if (characteristics.monochrome)
{
/*
Use default printer monochrome setup - NB white = 0, black = 1
*/
bits_per_pixel=1;
}
else
{
/*
PseudoClass
*/
bits_per_pixel=8;
(void) WriteBlobString(image,"\033*v6W"); /* set color mode... */
(void) WriteBlobByte(image,0); /* RGB */
(void) WriteBlobByte(image,1); /* indexed by pixel */
(void) WriteBlobByte(image,bits_per_pixel); /* bits per index */
(void) WriteBlobByte(image,8); /* bits per red component (implicit) */
(void) WriteBlobByte(image,8); /* bits per green component (implicit) */
(void) WriteBlobByte(image,8); /* bits per blue component (implicit) */
/*
Write colormap to file.
*/
for (i=0; i < (long)(image->colors); i++)
{
FormatString(buffer,"\033*v%da%db%dc%ldI",
ScaleQuantumToChar(image->colormap[i].red),
ScaleQuantumToChar(image->colormap[i].green),
ScaleQuantumToChar(image->colormap[i].blue),
i);
WriteBlobString(image,buffer);
}
/*
Initialize rest of palette with empty entries
*/
for ( ; i < (1L << bits_per_pixel); i++)
{
FormatString(buffer,"\033*v%luI",i);
/* set index to current component values */
(void) WriteBlobString(image,buffer);
}
}
/*
Start raster image
*/
if ((AccessDefinition(image_info,"pcl","fit-to-page") != NULL) ||
(AccessDefinition(image_info,"pcl","fit_to_page") != NULL))
(void) WriteBlobString(image,"\033*r3A"); /* start raster graphics with scaling */
else
(void) WriteBlobString(image,"\033*r1A"); /* start raster graphics */
(void) WriteBlobString(image,"\033*b0Y"); /* set y offset */
/*
Assign row buffer
*/
bytes_per_line=(image->columns*bits_per_pixel+7)/8;
pixels=MagickAllocateMemory(unsigned char *,bytes_per_line);
if (pixels == (unsigned char *) NULL)
ThrowWriterException(ResourceLimitError,MemoryAllocationFailed,image);
/*
Set up for compression if desired
*/
last_row_compression = PCL_UndefinedCompression;
if (image_info->compression != NoCompression)
{
MagickFreeMemory(last_row_pixels);
last_row_pixels=MagickAllocateMemory(unsigned char *,bytes_per_line);
if (last_row_pixels == (unsigned char *) NULL)
{
MagickFreeMemory(pixels);
ThrowWriterException(ResourceLimitError,MemoryAllocationFailed,image);
}
MagickFreeMemory(output_row);
output_row=MagickAllocateMemory(unsigned char *,bytes_per_line);
if (output_row == (unsigned char *) NULL)
{
MagickFreeMemory(pixels);
MagickFreeMemory(last_row_pixels);
ThrowWriterException(ResourceLimitError,MemoryAllocationFailed,image);
}
memset(last_row_pixels,0,bytes_per_line);
}
/*
Convert MIFF to PCL raster pixels.
*/
zero_rows=0;
for (y=0; y < (long) image->rows; y++)
{
p=AcquireImagePixels(image,0,y,image->columns,1,&image->exception);
if (p == (const PixelPacket *) NULL)
break;
q=pixels;
if (characteristics.monochrome)
{
register unsigned char
bit,
byte;
int
blk_ind;
/*
Monochrome row
*/
blk_ind = ((image->colormap == NULL) || (image->colormap[0].red == 0)) ? 0 : 1;
indexes=AccessImmutableIndexes(image);
bit=0;
byte=0;
for (x=0; x < (long) image->columns; x++)
{
byte<<=1;
if (indexes[x] == blk_ind) byte |= 1;
bit++;
if (bit == 8)
{
*q++=byte;
bit=0;
byte=0;
}
}
if (bit != 0)
*q++=byte << (8-bit);
}
else
if (bits_per_pixel == 8)
{
/*
8 bit PseudoClass row
*/
indexes=AccessImmutableIndexes(image);
for (x=0; x < (long) image->columns; x++)
{
*q++=indexes[x];
}
}
else
if ((bits_per_pixel == 24) || (bits_per_pixel == 32))
{
/*
DirectClass/RGB row
*/
for (x=0; x < (long) image->columns; x++)
{
*q++=ScaleQuantumToChar(p->red);
*q++=ScaleQuantumToChar(p->green);
*q++=ScaleQuantumToChar(p->blue);
p++;
}
}
if (image_info->compression == NoCompression)
{
FormatString(buffer,"\033*b%luW",bytes_per_line); /* send row */
(void) WriteBlobString(image,buffer);
(void) WriteBlob(image,bytes_per_line,pixels);
}
else
{
compression=PCL_ChooseCompression(bytes_per_line,pixels,last_row_pixels);
if (compression == PCL_ZeroRowCompression)
{
zero_rows++;
}
else
{
/*
Skip any omitted zero rows now
*/
if (zero_rows > 0)
{
i = 32767;
do
{
if (zero_rows < i)
i=zero_rows;
FormatString(buffer,"\033*b%ldY",i); /* Y Offset */
(void) WriteBlobString(image,buffer);
zero_rows -= i;
} while (zero_rows > 0);
}
switch (compression)
{
case PCL_DeltaCompression:
{
if (compression != last_row_compression)
{
FormatString(buffer,"\033*b3M"); /* delta compression */
(void) WriteBlobString(image,buffer);
last_row_compression=compression;
}
bytes_to_write=PCL_DeltaCompress(bytes_per_line,pixels,
last_row_pixels,output_row);
FormatString(buffer,"\033*b%luW",bytes_to_write);
(void) WriteBlobString(image,buffer);
WriteBlob(image,bytes_to_write,output_row);
break;
}
case PCL_TiffRLECompression:
{
if (compression != last_row_compression)
{
FormatString(buffer,"\033*b2M"); /* Tiff RLE compression */
(void) WriteBlobString(image,buffer);
last_row_compression=compression;
}
bytes_to_write=PCL_TiffRLECompress(bytes_per_line,pixels,output_row);
FormatString(buffer,"\033*b%luW",bytes_to_write);
(void) WriteBlobString(image,buffer);
WriteBlob(image,bytes_to_write,output_row);
break;
}
case PCL_RLECompression:
{
if (compression != last_row_compression)
{
FormatString(buffer,"\033*b1M"); /* RLE compression */
(void) WriteBlobString(image,buffer);
last_row_compression=compression;
}
bytes_to_write=PCL_RLECompress(bytes_per_line,pixels,output_row);
FormatString(buffer,"\033*b%luW",bytes_to_write);
(void) WriteBlobString(image,buffer);
WriteBlob(image,bytes_to_write,output_row);
break;
}
case PCL_RepeatedRowCompression:
{
compression=PCL_DeltaCompression;
if (compression != last_row_compression)
{
FormatString(buffer,"\033*b3M"); /* delta row compression */
(void) WriteBlobString(image,buffer);
last_row_compression=compression;
}
FormatString(buffer,"\033*b0W"); /* no data -> replicate row */
(void) WriteBlobString(image,buffer);
break;
}
case PCL_NoCompression:
{
if (compression != last_row_compression)
{
FormatString(buffer,"\033*b0M"); /* no compression */
(void) WriteBlobString(image,buffer);
last_row_compression=compression;
}
FormatString(buffer,"\033*b%luW",bytes_per_line); /* send row */
(void) WriteBlobString(image,buffer);
(void) WriteBlob(image,bytes_per_line,pixels);
break;
}
case PCL_ZeroRowCompression:
{
break;
}
case PCL_UndefinedCompression:
{
break;
}
}
}
/*
Swap row with last row
*/
q=last_row_pixels;
last_row_pixels=pixels;
pixels=q;
}
if (image->previous == (Image *) NULL)
if (QuantumTick(y,image->rows))
if (!MagickMonitorFormatted(y,image->rows,&image->exception,
SaveImageText,image->filename,
image->columns,image->rows))
break;
}
(void) WriteBlobString(image,"\033*rB"); /* end graphics */
MagickFreeMemory(pixels);
MagickFreeMemory(last_row_pixels);
MagickFreeMemory(output_row);
if (image->next == (Image *) NULL)
break;
image=SyncNextImageInList(image);
if ((status &= MagickMonitorFormatted(scene++,
GetImageListLength(image),
&image->exception,
SaveImagesText,
image->filename)) == MagickFail)
break;
} while (image_info->adjoin);
MagickExport MagickPassFail GradientImage(Image *image,
const PixelPacket *start_color,
const PixelPacket *stop_color)
{
const unsigned long
image_rows=image->rows,
image_columns=image->columns;
long
y;
unsigned long
row_count=0;
MagickPassFail
status=MagickPass;
/*
Determine (Hue, Saturation, Brightness) gradient.
*/
assert(image != (const Image *) NULL);
assert(image->signature == MagickSignature);
assert(start_color != (const PixelPacket *) NULL);
assert(stop_color != (const PixelPacket *) NULL);
/*
Generate gradient pixels.
*/
#if defined(HAVE_OPENMP)
# pragma omp parallel for shared(row_count, status)
#endif
for (y=0; y < (long) image->rows; y++)
{
MagickPassFail
thread_status;
register long
x;
register PixelPacket
*q;
#if defined(HAVE_OPENMP)
# pragma omp critical (GM_GradientImage)
#endif
thread_status=status;
if (thread_status == MagickFail)
continue;
q=SetImagePixelsEx(image,0,y,image->columns,1,&image->exception);
if (q == (PixelPacket *) NULL)
thread_status=MagickFail;
if (q != (PixelPacket *) NULL)
{
for (x=0; x < (long) image->columns; x++)
{
BlendCompositePixel(&q[x],start_color,stop_color,(double)
MaxRGB*(y*image_columns+x)/(image_columns*image_rows));
}
if (!SyncImagePixelsEx(image,&image->exception))
thread_status=MagickFail;
}
#if defined(HAVE_OPENMP)
# pragma omp critical (GM_GradientImage)
#endif
{
row_count++;
if (QuantumTick(row_count,image->rows))
if (!MagickMonitorFormatted(row_count,image->rows,&image->exception,
GradientImageText,image->filename))
thread_status=MagickFail;
if (thread_status == MagickFail)
status=MagickFail;
}
}
if (IsGray(*start_color) && IsGray(*stop_color))
image->is_grayscale=MagickTrue;
if (IsMonochrome(*start_color) && ColorMatch(start_color,stop_color))
image->is_monochrome=MagickTrue;
return(status);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% A v e r a g e I m a g e s %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% The Average() method takes a set of images and averages them together.
% Each image in the set must have the same width and height. Average()
% returns a single image with each corresponding pixel component of
% each image averaged. On failure, a NULL image is returned and
% exception describes the reason for the failure.
%
% The format of the AverageImage method is:
%
% Image *AverageImages(Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image: The image sequence.
%
% o exception: Return any errors or warnings in this structure.
%
%
*/
MagickExport Image *AverageImages(const Image *image,ExceptionInfo *exception)
{
ThreadViewDataSet
*pixels_sums;
Image
*average_image;
const Image
*last_image;
long
y;
unsigned long
row_count=0;
double
number_scenes;
unsigned long
number_pixels;
MagickPassFail
status=MagickPass;
/*
Ensure the image are the same size.
*/
assert(image != (Image *) NULL);
assert(image->signature == MagickSignature);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
if (image->next == (Image *) NULL)
ThrowImageException3(ImageError,ImageSequenceIsRequired,
UnableToAverageImage);
{
const Image
*next;
for (next=image; next != (Image *) NULL; next=next->next)
{
if ((next->columns != image->columns) || (next->rows != image->rows))
ThrowImageException3(OptionError,UnableToAverageImageSequence,
ImageWidthsOrHeightsDiffer);
}
}
/*
Allocate sum accumulation buffer.
*/
number_pixels=image->columns;
pixels_sums=AllocateThreadViewDataArray(image,exception,number_pixels,
sizeof(DoublePixelPacket));
if (pixels_sums == (ThreadViewDataSet *) NULL)
ThrowImageException3(ResourceLimitError,MemoryAllocationFailed,
UnableToAverageImageSequence);
/*
Initialize average next attributes.
*/
average_image=CloneImage(image,image->columns,image->rows,True,exception);
if (average_image == (Image *) NULL)
{
DestroyThreadViewDataSet(pixels_sums);
return((Image *) NULL);
}
average_image->storage_class=DirectClass;
number_scenes=(double) GetImageListLength(image);
last_image=GetLastImageInList(image);
#if defined(HAVE_OPENMP)
# pragma omp parallel for schedule(dynamic) shared(row_count, status)
#endif
for (y=0; y < (long) image->rows; y++)
{
register DoublePixelPacket
*pixels_sum;
const Image
*next;
register const PixelPacket
*p;
register long
x;
MagickBool
thread_status;
thread_status=status;
if (thread_status == MagickFail)
continue;
pixels_sum=AccessThreadViewData(pixels_sums);
/*
Compute sum over each pixel color component.
*/
for (next=image; next != (Image *) NULL; next=next->next)
{
ViewInfo
*next_view;
next_view=OpenCacheView((Image *) next);
if (next_view == (ViewInfo *) NULL)
thread_status=MagickFail;
if (next_view != (ViewInfo *) NULL)
{
p=AcquireCacheViewPixels(next_view,0,y,next->columns,1,exception);
if (p == (const PixelPacket *) NULL)
thread_status=MagickFail;
if (p != (const PixelPacket *) NULL)
{
if (next == image)
{
for (x=0; x < (long) next->columns; x++)
{
pixels_sum[x].red=p[x].red;
pixels_sum[x].green=p[x].green;
pixels_sum[x].blue=p[x].blue;
pixels_sum[x].opacity=p[x].opacity;
}
}
else
{
for (x=0; x < (long) next->columns; x++)
{
pixels_sum[x].red+=p[x].red;
pixels_sum[x].green+=p[x].green;
pixels_sum[x].blue+=p[x].blue;
pixels_sum[x].opacity+=p[x].opacity;
}
}
}
CloseCacheView(next_view);
}
}
/*
Average next pixels.
*/
if (thread_status != MagickFail)
{
register PixelPacket
*q;
q=SetImagePixelsEx(average_image,0,y,average_image->columns,1,exception);
if (q == (PixelPacket *) NULL)
thread_status=MagickFail;
if (q != (PixelPacket *) NULL)
{
for (x=0; x < (long) average_image->columns; x++)
{
q[x].red=(Quantum) (pixels_sum[x].red/number_scenes+0.5);
q[x].green=(Quantum) (pixels_sum[x].green/number_scenes+0.5);
q[x].blue=(Quantum) (pixels_sum[x].blue/number_scenes+0.5);
q[x].opacity=(Quantum) (pixels_sum[x].opacity/number_scenes+0.5);
}
if (!SyncImagePixelsEx(average_image,exception))
thread_status=MagickFail;
}
}
#if defined(HAVE_OPENMP)
# pragma omp critical (GM_AverageImages)
#endif
{
row_count++;
if (QuantumTick(row_count,average_image->rows))
if (!MagickMonitorFormatted(row_count,average_image->rows,exception,
"[%s,...,%s] Average image sequence...",
image->filename,last_image->filename))
thread_status=MagickFail;
if (thread_status == MagickFail)
status=MagickFail;
}
}
DestroyThreadViewDataSet(pixels_sums);
if (status == MagickFail)
{
DestroyImage(average_image);
average_image=(Image *) NULL;
}
return(average_image);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% P i x e l I t e r a t e D u a l R e a d %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% PixelIterateDualRead() iterates through pixel regions of two images and
% invokes a user-provided callback function (of type
% PixelIteratorDualReadCallback) for each row of pixels. This is useful to
% support operations such as image comparison.
%
% The format of the PixelIterateDualModify method is:
%
% MagickPassFail PixelIterateDualRead(
% PixelIteratorDualReadCallback call_back,
% const PixelIteratorOptions *options,
% const char *description,
% void *mutable_data,
% const void *immutable_data,
% const unsigned long columns,
% const unsigned long rows,
% const Image *first_image,
% const long first_x,
% const long first_y,
% const Image *second_image,
% const long second_x,
% const long second_y,
% ExceptionInfo *exception);
%
% A description of each parameter follows:
%
% o call_back: A user-provided C callback function which is passed the
% address of pixels from each image.
%
% o options: Pixel iterator execution options (may be NULL).
%
% o description: textual description of operation being performed.
%
% o mutable_data: User-provided mutable context data.
%
% o immutable_data: User-provided immutable context data.
%
% o columns: Width of pixel region
%
% o rows: Height of pixel region
%
% o first_image: The address of the first Image.
%
% o first_x: The horizontal ordinate of the top left corner of the first region.
%
% o first_y: The vertical ordinate of the top left corner of the first region.
%
% o second_image: The address of the second Image.
%
% o second_x: The horizontal ordinate of the top left corner of the second region.
%
% o second_y: The vertical ordinate of the top left corner of the second region.
%
% o exception: If an error is reported, this argument is updated with the reason.
%
*/
MagickExport MagickPassFail
PixelIterateDualRead(PixelIteratorDualReadCallback call_back,
const PixelIteratorOptions *options,
const char *description,
void *mutable_data,
const void *immutable_data,
const unsigned long columns,
const unsigned long rows,
const Image *first_image,
const long first_x,
const long first_y,
const Image *second_image,
const long second_x,
const long second_y,
ExceptionInfo *exception)
{
MagickPassFail
status = MagickPass;
register long
row;
unsigned long
row_count=0;
int
max_threads;
max_threads=omp_get_max_threads();
(void) SetRegionThreads(max_threads,options,columns,rows);
#if defined(HAVE_OPENMP)
# pragma omp parallel for schedule(static,1) shared(row_count, status)
#endif
for (row=0; row < (long) rows; row++)
{
MagickBool
thread_status;
long
first_row,
second_row;
const PixelPacket
*first_pixels,
*second_pixels;
const IndexPacket
*first_indexes,
*second_indexes;
thread_status=status;
if (thread_status == MagickFail)
continue;
first_row=first_y+row;
second_row=second_y+row;
first_pixels=AcquireImagePixels(first_image, first_x, first_row,
columns, 1, exception);
if (!first_pixels)
thread_status=MagickFail;
first_indexes=AccessImmutableIndexes(first_image);
second_pixels=AcquireImagePixels(second_image, second_x, second_row,
columns, 1, exception);
if (!second_pixels)
thread_status=MagickFail;
second_indexes=AccessImmutableIndexes(second_image);
if (thread_status != MagickFail)
thread_status=(call_back)(mutable_data,immutable_data,
first_image,first_pixels,first_indexes,
second_image,second_pixels,second_indexes,
columns, exception);
#if defined(HAVE_OPENMP)
# pragma omp critical (GM_PixelIterateDualRead)
#endif
{
row_count++;
if (QuantumTick(row_count,rows))
if (!MagickMonitorFormatted(row_count,rows,exception,
description,first_image->filename,
second_image->filename))
thread_status=MagickFail;
if (thread_status == MagickFail)
status=MagickFail;
}
}
omp_set_num_threads(max_threads);
return (status);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% R e a d V I C A R I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% Method ReadVICARImage reads a VICAR image file and returns it. It
% allocates the memory necessary for the new Image structure and returns a
% pointer to the new image.
%
% The format of the ReadVICARImage method is:
%
% Image *ReadVICARImage(const ImageInfo *image_info,
% ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image: Method ReadVICARImage returns a pointer to the image after
% reading. A null image is returned if there is a memory shortage or if
% the image cannot be read.
%
% o image_info: Specifies a pointer to a ImageInfo structure.
%
% o exception: return any errors or warnings in this structure.
%
%
*/
static Image *ReadVICARImage(const ImageInfo *image_info,
ExceptionInfo *exception)
{
char
keyword[MaxTextExtent],
value[MaxTextExtent];
Image
*image;
int
c,
y;
long
count;
unsigned char
*scanline;
unsigned int
status,
value_expected;
unsigned long
length;
/*
Open image file.
*/
assert(image_info != (const ImageInfo *) NULL);
assert(image_info->signature == MagickSignature);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
image=AllocateImage(image_info);
status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
if (status == False)
ThrowReaderException(FileOpenError,UnableToOpenFile,image);
/*
Decode image header.
*/
c=ReadBlobByte(image);
count=1;
if (c == EOF)
{
DestroyImage(image);
return((Image *) NULL);
}
length=0;
image->columns=0;
image->rows=0;
while (isgraph(c) && ((image->columns == 0) || (image->rows == 0)))
{
if (!isalnum(c))
{
c=ReadBlobByte(image);
count++;
}
else
{
register char
*p;
/*
Determine a keyword and its value.
*/
p=keyword;
do
{
if ((p-keyword) < (MaxTextExtent-1))
*p++=c;
c=ReadBlobByte(image);
count++;
} while (isalnum(c) || (c == '_'));
*p='\0';
value_expected=False;
while (isspace(c) || (c == '='))
{
if (c == '=')
value_expected=True;
c=ReadBlobByte(image);
count++;
}
if (value_expected == False)
continue;
p=value;
while (isalnum(c))
{
if ((p-value) < (MaxTextExtent-1))
*p++=c;
c=ReadBlobByte(image);
count++;
}
*p='\0';
/*
Assign a value to the specified keyword.
*/
if (LocaleCompare(keyword,"Label_RECORDS") == 0)
length=MagickAtoL(value);
if (LocaleCompare(keyword,"LBLSIZE") == 0)
length=MagickAtoL(value);
if (LocaleCompare(keyword,"RECORD_BYTES") == 0)
image->columns= MagickAtoL(value);
if (LocaleCompare(keyword,"NS") == 0)
image->columns= MagickAtoL(value);
if (LocaleCompare(keyword,"LINES") == 0)
image->rows= MagickAtoL(value);
if (LocaleCompare(keyword,"NL") == 0)
image->rows= MagickAtoL(value);
}
while (isspace(c))
{
c=ReadBlobByte(image);
count++;
}
}
while (count < (long) length)
{
c=ReadBlobByte(image);
count++;
}
if ((image->columns == 0) || (image->rows == 0))
ThrowReaderException(CorruptImageError,NegativeOrZeroImageSize,image);
image->depth=8;
if (!AllocateImageColormap(image,256))
ThrowReaderException(ResourceLimitError,MemoryAllocationFailed,image);
if (image_info->ping)
{
CloseBlob(image);
return(image);
}
/*
Read VICAR pixels.
*/
scanline=MagickAllocateMemory(unsigned char *,image->columns);
if (scanline == (unsigned char *) NULL)
ThrowReaderException(CorruptImageError,UnableToReadImageData,image);
for (y=0; y < (long) image->rows; y++)
{
if (!SetImagePixels(image,0,y,image->columns,1))
break;
(void) ReadBlob(image,image->columns,scanline);
(void) ImportImagePixelArea(image,GrayQuantum,image->depth,scanline,0,0);
if (!SyncImagePixels(image))
break;
if (QuantumTick(y,image->rows))
if (!MagickMonitorFormatted(y,image->rows,exception,LoadImageText,
image->filename,
image->columns,image->rows))
break;
}
MagickFreeMemory(scanline);
if (EOFBlob(image))
ThrowException(exception,CorruptImageError,UnexpectedEndOfFile,
image->filename);
CloseBlob(image);
return(image);
}
static Image *ReadJP2Image(const ImageInfo *image_info,
ExceptionInfo *exception)
{
Image
*image;
long
y;
jas_image_t
*jp2_image;
jas_matrix_t
*pixels;
jas_stream_t
*jp2_stream;
register long
x;
register PixelPacket
*q;
int
component,
components[4],
number_components;
Quantum
*channel_lut[4];
unsigned int
status;
/*
Open image file.
*/
assert(image_info != (const ImageInfo *) NULL);
assert(image_info->signature == MagickSignature);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
image=AllocateImage(image_info);
status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
if (status == False)
ThrowReaderException(FileOpenError,UnableToOpenFile,image);
/*
Obtain a JP2 Stream.
*/
jp2_stream=JP2StreamManager(image);
if (jp2_stream == (jas_stream_t *) NULL)
ThrowReaderException(DelegateError,UnableToManageJP2Stream,image);
jp2_image=jas_image_decode(jp2_stream,-1,0);
if (jp2_image == (jas_image_t *) NULL)
{
(void) jas_stream_close(jp2_stream);
ThrowReaderException(DelegateError,UnableToDecodeImageFile,image);
}
/*
Validate that we can handle the image and obtain component
indexes.
*/
switch (jas_clrspc_fam(jas_image_clrspc(jp2_image)))
{
case JAS_CLRSPC_FAM_RGB:
{
if (((components[0]=
jas_image_getcmptbytype(jp2_image,
JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_R))) < 0) ||
((components[1]=
jas_image_getcmptbytype(jp2_image,
JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_G))) < 0) ||
((components[2]=
jas_image_getcmptbytype(jp2_image,
JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_B))) < 0))
{
(void) jas_stream_close(jp2_stream);
jas_image_destroy(jp2_image);
ThrowReaderException(CorruptImageError,MissingImageChannel,image);
}
number_components=3;
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
"Image is in RGB colorspace family");
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
"RED is in channel %d, GREEN is in channel %d, BLUE is in channel %d",
components[0],components[1],components[2]);
if((components[3]=jas_image_getcmptbytype(jp2_image,
JAS_IMAGE_CT_COLOR(JAS_IMAGE_CT_OPACITY))) > 0)
{
image->matte=MagickTrue;
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
"OPACITY is in channel %d",components[3]);
number_components++;
}
break;
}
case JAS_CLRSPC_FAM_GRAY:
{
if ((components[0]=
jas_image_getcmptbytype(jp2_image,
JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_GRAY_Y))) < 0)
{
(void) jas_stream_close(jp2_stream);
jas_image_destroy(jp2_image);
ThrowReaderException(CorruptImageError,MissingImageChannel,image);
}
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
"Image is in GRAY colorspace family");
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
"GRAY is in channel %d",components[0]);
number_components=1;
break;
}
case JAS_CLRSPC_FAM_YCBCR:
{
components[0]=jas_image_getcmptbytype(jp2_image,JAS_IMAGE_CT_YCBCR_Y);
components[1]=jas_image_getcmptbytype(jp2_image,JAS_IMAGE_CT_YCBCR_CB);
components[2]=jas_image_getcmptbytype(jp2_image,JAS_IMAGE_CT_YCBCR_CR);
if ((components[0] < 0) || (components[1] < 0) || (components[2] < 0))
{
(void) jas_stream_close(jp2_stream);
jas_image_destroy(jp2_image);
ThrowReaderException(CorruptImageError,MissingImageChannel,image);
}
number_components=3;
components[3]=jas_image_getcmptbytype(jp2_image,JAS_IMAGE_CT_OPACITY);
if (components[3] > 0)
{
image->matte=True;
number_components++;
}
image->colorspace=YCbCrColorspace;
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
"Image is in YCBCR colorspace family");
break;
}
default:
{
(void) jas_stream_close(jp2_stream);
jas_image_destroy(jp2_image);
ThrowReaderException(CoderError,ColorspaceModelIsNotSupported,image);
}
}
image->columns=jas_image_width(jp2_image);
image->rows=jas_image_height(jp2_image);
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
"columns=%lu rows=%lu components=%d",image->columns,image->rows,
number_components);
for (component=0; component < number_components; component++)
{
if(((unsigned long) jas_image_cmptwidth(jp2_image,components[component]) != image->columns) ||
((unsigned long) jas_image_cmptheight(jp2_image,components[component]) != image->rows) ||
(jas_image_cmpttlx(jp2_image, components[component]) != 0) ||
(jas_image_cmpttly(jp2_image, components[component]) != 0) ||
(jas_image_cmpthstep(jp2_image, components[component]) != 1) ||
(jas_image_cmptvstep(jp2_image, components[component]) != 1) ||
(jas_image_cmptsgnd(jp2_image, components[component]) != false))
{
(void) jas_stream_close(jp2_stream);
jas_image_destroy(jp2_image);
ThrowReaderException(CoderError,IrregularChannelGeometryNotSupported,image);
}
}
image->matte=number_components > 3;
for (component=0; component < number_components; component++)
{
unsigned int
component_depth;
component_depth=jas_image_cmptprec(jp2_image,components[component]);
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
"Component[%d] depth is %u",component,component_depth);
if (0 == component)
image->depth=component_depth;
else
image->depth=Max(image->depth,component_depth);
}
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
"Image depth is %u",image->depth);
if (image_info->ping)
{
(void) jas_stream_close(jp2_stream);
jas_image_destroy(jp2_image);
return(image);
}
/*
Allocate Jasper pixels.
*/
pixels=jas_matrix_create(1,(unsigned int) image->columns);
if (pixels == (jas_matrix_t *) NULL)
{
jas_image_destroy(jp2_image);
ThrowReaderException(ResourceLimitError,MemoryAllocationFailed,image);
}
/*
Allocate and populate channel LUTs
*/
for (component=0; component < (long) number_components; component++)
{
unsigned long
component_depth,
i,
max_value;
double
scale_to_quantum;
component_depth=jas_image_cmptprec(jp2_image,components[component]);
max_value=MaxValueGivenBits(component_depth);
scale_to_quantum=MaxRGBDouble/max_value;
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
"Channel %d scale is %g", component, scale_to_quantum);
channel_lut[component]=MagickAllocateArray(Quantum *,max_value+1,sizeof(Quantum));
if (channel_lut[component] == (Quantum *) NULL)
{
for ( --component; component >= 0; --component)
MagickFreeMemory(channel_lut[component]);
jas_matrix_destroy(pixels);
jas_image_destroy(jp2_image);
ThrowReaderException(ResourceLimitError,MemoryAllocationFailed,image);
}
for(i=0; i <= max_value; i++)
(channel_lut[component])[i]=scale_to_quantum*i+0.5;
}
/*
Convert JPEG 2000 pixels.
*/
for (y=0; y < (long) image->rows; y++)
{
q=GetImagePixels(image,0,y,image->columns,1);
if (q == (PixelPacket *) NULL)
break;
if (1 == number_components)
{
/* Grayscale */
(void) jas_image_readcmpt(jp2_image,(short) components[0],0,
(unsigned int) y,
(unsigned int) image->columns,1,pixels);
for (x=0; x < (long) image->columns; x++)
{
q->red=q->green=q->blue=(channel_lut[0])[jas_matrix_getv(pixels,x)];
q->opacity=OpaqueOpacity;
q++;
}
}
else
{
/* Red */
(void) jas_image_readcmpt(jp2_image,(short) components[0],0,
(unsigned int) y,
(unsigned int) image->columns,1,pixels);
for (x=0; x < (long) image->columns; x++)
q[x].red=(channel_lut[0])[jas_matrix_getv(pixels,x)];
/* Green */
(void) jas_image_readcmpt(jp2_image,(short) components[1],0,
(unsigned int) y,
(unsigned int) image->columns,1,pixels);
for (x=0; x < (long) image->columns; x++)
q[x].green=(channel_lut[1])[jas_matrix_getv(pixels,x)];
/* Blue */
(void) jas_image_readcmpt(jp2_image,(short) components[2],0,
(unsigned int) y,
(unsigned int) image->columns,1,pixels);
for (x=0; x < (long) image->columns; x++)
q[x].blue=(channel_lut[2])[jas_matrix_getv(pixels,x)];
/* Opacity */
if (number_components > 3)
{
(void) jas_image_readcmpt(jp2_image,(short) components[3],0,
(unsigned int) y,
(unsigned int) image->columns,1,pixels);
for (x=0; x < (long) image->columns; x++)
q[x].opacity=MaxRGB-(channel_lut[3])[jas_matrix_getv(pixels,x)];
}
else
{
for (x=0; x < (long) image->columns; x++)
q[x].opacity=OpaqueOpacity;
}
}
if (!SyncImagePixels(image))
break;
if (image->previous == (Image *) NULL)
if (QuantumTick(y,image->rows))
if (!MagickMonitorFormatted(y,image->rows,exception,LoadImageText,
image->filename,
image->columns,image->rows))
break;
}
if (number_components == 1)
image->is_grayscale=MagickTrue;
{
/*
Obtain ICC ICM color profile
*/
jas_cmprof_t
*cm_profile;
/* Obtain a pointer to the existing jas_cmprof_t profile handle. */
cm_profile=jas_image_cmprof(jp2_image);
if (cm_profile != (jas_cmprof_t *) NULL)
{
jas_iccprof_t
*icc_profile;
/* Obtain a copy of the jas_iccprof_t ICC profile handle */
icc_profile=jas_iccprof_createfromcmprof(cm_profile);
/* or maybe just icc_profile=cm_profile->iccprof */
if (icc_profile != (jas_iccprof_t *) NULL)
{
jas_stream_t
*icc_stream;
icc_stream=jas_stream_memopen(NULL,0);
if ((icc_stream != (jas_stream_t *) NULL) &&
(jas_iccprof_save(icc_profile,icc_stream) == 0) &&
(jas_stream_flush(icc_stream) == 0))
{
jas_stream_memobj_t
*blob;
blob=(jas_stream_memobj_t *) icc_stream->obj_;
if (image->logging)
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
"ICC profile: %lu bytes",(unsigned long) blob->len_);
SetImageProfile(image,"ICM",blob->buf_,blob->len_);
(void) jas_stream_close(icc_stream);
jas_iccprof_destroy(icc_profile);
}
}
}
}
for (component=0; component < (long) number_components; component++)
MagickFreeMemory(channel_lut[component]);
jas_matrix_destroy(pixels);
(void) jas_stream_close(jp2_stream);
jas_image_destroy(jp2_image);
return(image);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% R e a d S U N I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% Method ReadSUNImage reads a SUN image file and returns it. It allocates
% the memory necessary for the new Image structure and returns a pointer to
% the new image.
%
% The format of the ReadSUNImage method is:
%
% Image *ReadSUNImage(const ImageInfo *image_info,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image: Method ReadSUNImage returns a pointer to the image after
% reading. A null image is returned if there is a memory shortage or
% if the image cannot be read.
%
% o image_info: Specifies a pointer to a ImageInfo structure.
%
% o exception: return any errors or warnings in this structure.
%
%
*/
static Image *ReadSUNImage(const ImageInfo *image_info,ExceptionInfo *exception)
{
Image
*image;
int
bit;
long
y;
register IndexPacket
*indexes;
register long
x;
register PixelPacket
*q;
register long
i;
register unsigned char
*p;
size_t
bytes_per_image,
bytes_per_line,
count,
sun_data_length;
SUNInfo
sun_info;
unsigned char
*sun_data,
*sun_pixels;
unsigned int
index;
unsigned int
status;
/*
Open image file.
*/
assert(image_info != (const ImageInfo *) NULL);
assert(image_info->signature == MagickSignature);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
image=AllocateImage(image_info);
status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
if (status == False)
ThrowReaderException(FileOpenError,UnableToOpenFile,image);
/*
Read SUN raster header.
*/
(void) memset(&sun_info,0,sizeof(sun_info));
sun_info.magic=ReadBlobMSBLong(image);
do
{
/*
Verify SUN identifier.
*/
if (sun_info.magic != 0x59a66a95)
ThrowReaderException(CorruptImageError,ImproperImageHeader,image);
sun_info.width=ReadBlobMSBLong(image);
sun_info.height=ReadBlobMSBLong(image);
sun_info.depth=ReadBlobMSBLong(image);
sun_info.length=ReadBlobMSBLong(image);
sun_info.type=ReadBlobMSBLong(image);
sun_info.maptype=ReadBlobMSBLong(image);
sun_info.maplength=ReadBlobMSBLong(image);
LogSUNInfo(&sun_info);
if (EOFBlob(image))
ThrowReaderException(CorruptImageError,UnexpectedEndOfFile,image);
/*
Verify that header values are in positive numeric range of a
32-bit 'int' even though we store them in an unsigned value.
*/
if ((sun_info.magic | sun_info.width | sun_info.height | sun_info.depth |
sun_info.type | sun_info.maptype | sun_info.maplength) & (1U << 31))
ThrowReaderException(CorruptImageError,ImproperImageHeader,image);
/*
Verify that we support the image sub-type
*/
if ((sun_info.type != RT_STANDARD) &&
(sun_info.type != RT_ENCODED) &&
(sun_info.type != RT_FORMAT_RGB))
ThrowReaderException(CoderError,DataEncodingSchemeIsNotSupported,image);
/*
Verify that we support the colormap type
*/
if ((sun_info.maptype != RMT_NONE) &&
(sun_info.maptype != RMT_EQUAL_RGB))
ThrowReaderException(CoderError,ColormapTypeNotSupported,image);
/*
Insist that map length is zero if there is no colormap.
*/
if ((sun_info.maptype == RMT_NONE) && (sun_info.maplength != 0))
ThrowReaderException(CorruptImageError,ImproperImageHeader,image);
/*
Insist on a supported depth
*/
if ((sun_info.depth != 1) &&
(sun_info.depth != 8) &&
(sun_info.depth != 24) &&
(sun_info.depth != 32))
ThrowReaderException(CorruptImageError,ImproperImageHeader,image);
image->columns=sun_info.width;
image->rows=sun_info.height;
if (((unsigned long) ((long) image->columns) != image->columns) ||
((unsigned long) ((long) image->rows) != image->rows))
ThrowReaderException(CoderError,ImageColumnOrRowSizeIsNotSupported,image);
if (CheckImagePixelLimits(image, exception) != MagickPass)
ThrowReaderException(ResourceLimitError,ImagePixelLimitExceeded,image);
image->depth=sun_info.depth <= 8 ? 8 : QuantumDepth;
if (sun_info.depth < 24)
{
image->colors=sun_info.maplength;
if (sun_info.maptype == RMT_NONE)
image->colors=1 << sun_info.depth;
if (sun_info.maptype == RMT_EQUAL_RGB)
image->colors=sun_info.maplength/3;
}
switch (sun_info.maptype)
{
case RMT_NONE:
{
if (sun_info.depth < 24)
{
/*
Create linear color ramp.
*/
if (!AllocateImageColormap(image,image->colors))
ThrowReaderException(ResourceLimitError,MemoryAllocationFailed,
image);
}
break;
}
case RMT_EQUAL_RGB:
{
unsigned char
*sun_colormap;
/*
Read SUN raster colormap.
*/
if (!AllocateImageColormap(image,image->colors))
ThrowReaderException(ResourceLimitError,MemoryAllocationFailed,
image);
sun_colormap=MagickAllocateMemory(unsigned char *,image->colors);
if (sun_colormap == (unsigned char *) NULL)
ThrowReaderException(ResourceLimitError,MemoryAllocationFailed,
image);
do
{
if (ReadBlob(image,image->colors,(char *) sun_colormap) !=
image->colors)
{
status = MagickFail;
break;
}
for (i=0; i < (long) image->colors; i++)
image->colormap[i].red=ScaleCharToQuantum(sun_colormap[i]);
if (ReadBlob(image,image->colors,(char *) sun_colormap) !=
image->colors)
{
status = MagickFail;
break;
}
for (i=0; i < (long) image->colors; i++)
image->colormap[i].green=ScaleCharToQuantum(sun_colormap[i]);
if (ReadBlob(image,image->colors,(char *) sun_colormap) !=
image->colors)
{
status = MagickFail;
break;
}
for (i=0; i < (long) image->colors; i++)
image->colormap[i].blue=ScaleCharToQuantum(sun_colormap[i]);
break;
} while (1);
MagickFreeMemory(sun_colormap);
if (MagickFail == status)
ThrowReaderException(CorruptImageError,UnexpectedEndOfFile,image);
break;
}
case RMT_RAW:
{
unsigned char
*sun_colormap;
/*
Read SUN raster colormap.
*/
if (!AllocateImageColormap(image,image->colors))
ThrowReaderException(ResourceLimitError,MemoryAllocationFailed,
image);
sun_colormap=MagickAllocateMemory(unsigned char *,sun_info.maplength);
if (sun_colormap == (unsigned char *) NULL)
ThrowReaderException(ResourceLimitError,MemoryAllocationFailed,
image);
if (ReadBlob(image,sun_info.maplength,(char *) sun_colormap) !=
sun_info.maplength)
status = MagickFail;
MagickFreeMemory(sun_colormap);
if (MagickFail == status)
ThrowReaderException(CorruptImageError,UnexpectedEndOfFile,image);
break;
}
default:
ThrowReaderException(CoderError,ColormapTypeNotSupported,image)
}
image->matte=(sun_info.depth == 32);
image->columns=sun_info.width;
image->rows=sun_info.height;
image->depth=8;
if (sun_info.depth < 8)
image->depth=sun_info.depth;
/*
Compute bytes per line and bytes per image for an unencoded
image.
"The width of a scan line is always 16-bits, padded when necessary."
*/
bytes_per_line=MagickArraySize(sun_info.width,sun_info.depth)/8;
if ((bytes_per_line != 0) && (sun_info.depth == 1))
bytes_per_line += sun_info.width % 8 ? 1 : 0;
if (bytes_per_line != 0)
bytes_per_line=RoundUpToAlignment(bytes_per_line,2);
bytes_per_image=MagickArraySize(sun_info.height,bytes_per_line);
if (bytes_per_line == 0)
ThrowReaderException(CorruptImageError,ImproperImageHeader,image);
if (bytes_per_image == 0)
ThrowReaderException(CorruptImageError,ImproperImageHeader,image);
if ((sun_info.type == RT_STANDARD) || (sun_info.type == RT_FORMAT_RGB))
if (bytes_per_image > sun_info.length)
ThrowReaderException(CorruptImageError,ImproperImageHeader,image);
if (image_info->ping)
{
CloseBlob(image);
return(image);
}
if (sun_info.type == RT_ENCODED)
sun_data_length=(size_t) sun_info.length;
else
sun_data_length=bytes_per_image;
sun_data=MagickAllocateMemory(unsigned char *,sun_data_length);
if (sun_data == (unsigned char *) NULL)
ThrowReaderException(ResourceLimitError,MemoryAllocationFailed,image);
if ((count=ReadBlob(image,sun_data_length,(char *) sun_data))
!= sun_data_length)
{
MagickFreeMemory(sun_data);
ThrowReaderException(CorruptImageError,UnableToReadImageData,image);
}
sun_pixels=sun_data;
if (sun_info.type == RT_ENCODED)
{
/*
Read run-length encoded raster pixels (padded to 16-bit boundary).
*/
sun_pixels=MagickAllocateMemory(unsigned char *,bytes_per_image);
if (sun_pixels == (unsigned char *) NULL)
ThrowReaderException(ResourceLimitError,MemoryAllocationFailed,
image);
status &= DecodeImage(sun_data,sun_data_length,sun_pixels,bytes_per_image);
MagickFreeMemory(sun_data);
if (status != MagickPass)
{
MagickFreeMemory(sun_pixels);
ThrowReaderException(CorruptImageError,UnableToRunlengthDecodeImage,image);
}
}
/*
Convert SUN raster image to pixel packets.
*/
p=sun_pixels;
if (sun_info.depth == 1)
/*
Bilevel
*/
for (y=0; y < (long) image->rows; y++)
{
q=SetImagePixels(image,0,y,image->columns,1);
if (q == (PixelPacket *) NULL)
break;
indexes=AccessMutableIndexes(image);
for (x=0; x < ((long) image->columns-7); x+=8)
{
for (bit=7; bit >= 0; bit--)
{
index=((*p) & (0x01 << bit) ? 0x01 : 0x00);
indexes[x+7-bit]=index;
q[x+7-bit]=image->colormap[index];
}
p++;
}
if ((image->columns % 8) != 0)
{
for (bit=7; bit >= (long) (8-(image->columns % 8)); bit--)
{
index=((*p) & (0x01 << bit) ? 0x01 : 0x00);
indexes[x+7-bit]=index;
q[x+7-bit]=image->colormap[index];
}
p++;
}
if ((((image->columns/8)+(image->columns % 8 ? 1 : 0)) % 2) != 0)
p++;
if (!SyncImagePixels(image))
break;
if (image->previous == (Image *) NULL)
if (QuantumTick(y,image->rows))
if (!MagickMonitorFormatted(y,image->rows,exception,
LoadImageText,image->filename,
image->columns,image->rows))
break;
}
else
if (image->storage_class == PseudoClass)
{
/*
Colormapped
*/
for (y=0; y < (long) image->rows; y++)
{
q=SetImagePixels(image,0,y,image->columns,1);
if (q == (PixelPacket *) NULL)
break;
indexes=AccessMutableIndexes(image);
for (x=0; x < (long) image->columns; x++)
{
index=(*p++);
VerifyColormapIndex(image,index);
indexes[x]=index;
q[x]=image->colormap[index];
}
if ((image->columns % 2) != 0)
p++;
if (!SyncImagePixels(image))
break;
if (image->previous == (Image *) NULL)
if (QuantumTick(y,image->rows))
if (!MagickMonitorFormatted(y,image->rows,exception,
LoadImageText,image->filename,
image->columns,image->rows))
break;
}
}
else
{
/*
(A)BGR or (A)RGB
*/
for (y=0; y < (long) image->rows; y++)
{
q=SetImagePixels(image,0,y,image->columns,1);
if (q == (PixelPacket *) NULL)
break;
for (x=0; x < (long) image->columns; x++)
{
if (image->matte)
q->opacity=(Quantum) (MaxRGB-ScaleCharToQuantum(*p++));
if (sun_info.type == RT_STANDARD)
{
q->blue=ScaleCharToQuantum(*p++);
q->green=ScaleCharToQuantum(*p++);
q->red=ScaleCharToQuantum(*p++);
}
else
{
q->red=ScaleCharToQuantum(*p++);
q->green=ScaleCharToQuantum(*p++);
q->blue=ScaleCharToQuantum(*p++);
}
if (image->colors != 0)
{
q->red=image->colormap[q->red].red;
q->green=image->colormap[q->green].green;
q->blue=image->colormap[q->blue].blue;
}
q++;
}
if (((image->columns % 2) != 0) && (image->matte == False))
p++;
if (!SyncImagePixels(image))
break;
if (image->previous == (Image *) NULL)
if (QuantumTick(y,image->rows))
if (!MagickMonitorFormatted(y,image->rows,exception,
LoadImageText,image->filename,
image->columns,image->rows))
break;
}
}
MagickFreeMemory(sun_pixels);
if (EOFBlob(image))
{
ThrowException(exception,CorruptImageError,UnexpectedEndOfFile,
image->filename);
break;
}
/*
Proceed to next image.
*/
if (image_info->subrange != 0)
if (image->scene >= (image_info->subimage+image_info->subrange-1))
break;
sun_info.magic=ReadBlobMSBLong(image);
if (sun_info.magic == 0x59a66a95)
{
/*
Allocate next image structure.
*/
AllocateNextImage(image_info,image);
if (image->next == (Image *) NULL)
{
DestroyImageList(image);
return((Image *) NULL);
}
image=SyncNextImageInList(image);
if (!MagickMonitorFormatted(TellBlob(image),GetBlobSize(image),
exception,LoadImagesText,
image->filename))
break;
}
} while (sun_info.magic == 0x59a66a95);
unsigned long *HalfImage(unsigned long *image,int colums,int rows)
{
#define Minify(weight) \
total.red+=(weight)*(r->red); \
total.green+=(weight)*(r->green); \
total.blue+=(weight)*(r->blue); \
total.opacity+=(weight)*(r->opacity); \
r++;
unsigned long *minify_image;
long y;
/*
Initialize minified image.
*/
minify_image= image;
/*
Reduce each row.
*/
{
unsigned long row_count=0,zero=0;
float red,green,blue,opacity;
zero=0;
for (y=0; y < (long) minify_image->rows; y++)
{
DoublePixelPacket
total;
register const PixelPacket
*p,
*r;
register long
x;
register PixelPacket
*q;
MagickBool
thread_status;
p=AcquireImagePixels(image,-2,2*(y-1),image->columns+4,4,exception);
q=SetImagePixelsEx(minify_image,0,y,minify_image->columns,1,exception);
for (x=0; x < columns/2; x++)
{
/*
Compute weighted average of target pixel color components.
*/
total=zero;
r=p;
Minify(3.0); Minify(7.0); Minify(7.0); Minify(3.0);
r=p+(image->columns+4);
Minify(7.0); Minify(15.0); Minify(15.0); Minify(7.0);
r=p+2*(image->columns+4);
Minify(7.0); Minify(15.0); Minify(15.0); Minify(7.0);
r=p+3*(image->columns+4);
Minify(3.0); Minify(7.0); Minify(7.0); Minify(3.0);
q->red=(Quantum) (total.red/128.0+0.5);
q->green=(Quantum) (total.green/128.0+0.5);
q->blue=(Quantum) (total.blue/128.0+0.5);
q->opacity=(Quantum) (total.opacity/128.0+0.5);
p+=2;
q++;
}
if (!SyncImagePixelsEx(minify_image,exception))
thread_status=MagickFail;
#if defined(HAVE_OPENMP)
# pragma omp critical (GM_MinifyImage)
#endif
{
row_count++;
if (QuantumTick(row_count,image->rows))
if (!MagickMonitorFormatted(row_count,image->rows,exception,
MinifyImageText,image->filename))
thread_status=MagickFail;
if (thread_status == MagickFail)
status=MagickFail;
}
}
}
minify_image->is_grayscale=image->is_grayscale;
return(minify_image);
}
static Image *ReadIdentityImage(const ImageInfo *image_info,
ExceptionInfo *exception)
{
#define IdentityImageText "[%s] Generating Hald CLUT identity image..."
Image
*image;
unsigned long
cube_size;
long
order,
y;
unsigned long
row_count=0;
unsigned int
status=MagickPass;
/*
Initialize Image structure.
*/
assert(image_info != (const ImageInfo *) NULL);
assert(image_info->signature == MagickSignature);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
image=(Image *) NULL;
order=8;
if (image_info->filename[0] != '\0')
order=MagickAtoL(image_info->filename);
if (order < 2)
order=8;
image=AllocateImage(image_info);
cube_size=order*order;
image->columns=image->rows=order*order*order;
#if defined(HAVE_OPENMP)
# if defined(TUNE_OPENMP)
# pragma omp parallel for schedule(runtime) shared(row_count, status)
# else
# pragma omp parallel for shared(row_count, status)
# endif
#endif
for (y=0; y < (long) image->rows; y += order)
{
MagickPassFail
thread_status;
register PixelPacket
*q;
#if defined(HAVE_OPENMP)
# pragma omp critical (GM_IdentityImage)
#endif
thread_status=status;
if (thread_status == MagickFail)
continue;
q=SetImagePixelsEx(image,0,y,image->columns,order,&image->exception);
if (q == (PixelPacket *) NULL)
thread_status=MagickFail;
if (q != (PixelPacket *) NULL)
{
double
value;
unsigned int
red,
green,
blue;
blue=y/order;
for(green = 0; green < cube_size; green++)
{
for(red = 0; red < cube_size; red++)
{
value=MaxRGBDouble * (double)red / (double)(cube_size - 1);
q->red = RoundDoubleToQuantum(value);
value = MaxRGBDouble * (double)green / (double)(cube_size - 1);
q->green = RoundDoubleToQuantum(value);
value = MaxRGBDouble * (double)blue / (double)(cube_size - 1);
q->blue = RoundDoubleToQuantum(value);
q->opacity = OpaqueOpacity;
q++;
}
}
if (!SyncImagePixelsEx(image,&image->exception))
thread_status=MagickFail;
}
#if defined(HAVE_OPENMP)
# pragma omp critical (GM_IdentityImage)
#endif
{
row_count++;
if (QuantumTick(row_count,image->rows))
if (!MagickMonitorFormatted(row_count,image->rows,&image->exception,
IdentityImageText,image->filename))
thread_status=MagickFail;
if (thread_status == MagickFail)
status=MagickFail;
}
}
if (status == MagickFail)
{
DestroyImage(image);
image=(Image *) NULL;
}
return(image);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% R e a d C M Y K I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% Method ReadCMYKImage reads an image of raw cyan, magenta, yellow, and black
% samples and returns it. It allocates the memory necessary for the new
% Image structure and returns a pointer to the new image.
%
% The format of the ReadCMYKImage method is:
%
% Image *ReadCMYKImage(const ImageInfo *image_info,
% ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image: Method ReadCMYKImage returns a pointer to the image after
% reading. A null image is returned if there is a memory shortage or
% if the image cannot be read.
%
% o image_info: Specifies a pointer to a ImageInfo structure.
%
% o exception: return any errors or warnings in this structure.
%
%
*/
static Image *ReadCMYKImage(const ImageInfo *image_info,
ExceptionInfo *exception)
{
Image
*image;
long
y;
register long
i,
x;
register PixelPacket
*q;
size_t
count;
unsigned char
*scanline;
unsigned int
status;
unsigned int
packet_size,
quantum_size;
ImportPixelAreaOptions
import_options;
assert(image_info != (const ImageInfo *) NULL);
assert(image_info->signature == MagickSignature);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
image=AllocateImage(image_info);
if ((image->columns == 0) || (image->rows == 0))
ThrowReaderException(OptionError,MustSpecifyImageSize,image);
if (image_info->interlace != PartitionInterlace)
{
/*
Open image file.
*/
status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
if (status == False)
ThrowReaderException(FileOpenError,UnableToOpenFile,image);
for (i=0; i < image->offset; i++)
{
if (EOF == ReadBlobByte(image))
ThrowException(exception,CorruptImageError,UnexpectedEndOfFile,
image->filename);
}
}
if (image->logging)
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
"Tile %lux%lu%+ld%+ld",
image->tile_info.width,image->tile_info.height,
image->tile_info.x,image->tile_info.y);
/*
Allocate memory for a scanline.
*/
if (image->depth <= 8)
quantum_size=8;
else if (image->depth <= 16)
quantum_size=16;
else
quantum_size=32;
packet_size=(quantum_size*4)/8;
if (LocaleCompare(image_info->magick,"CMYKA") == 0)
{
image->matte=True;
packet_size=(quantum_size*5)/8;
}
scanline=MagickAllocateArray(unsigned char *,
packet_size,image->tile_info.width);
if (scanline == (unsigned char *) NULL)
ThrowReaderException(ResourceLimitError,MemoryAllocationFailed,image);
/*
Initialize import options.
*/
ImportPixelAreaOptionsInit(&import_options);
if (image_info->endian != UndefinedEndian)
import_options.endian=image_info->endian;
if (image->logging)
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
"Depth %u bits, Endian %s, Interlace %s",
quantum_size,
EndianTypeToString(import_options.endian),
InterlaceTypeToString(image_info->interlace));
/*
Support starting at intermediate image frame.
*/
if (image_info->subrange != 0)
while (image->scene < image_info->subimage)
{
/*
Skip to next image.
*/
image->scene++;
for (y=0; y < (long) image->rows; y++)
(void) ReadBlob(image,packet_size*image->tile_info.width,scanline);
}
x=(long) (packet_size*image->tile_info.x);
do
{
/*
Convert raster image to pixel packets.
*/
image->colorspace=CMYKColorspace;
if (image_info->ping && (image_info->subrange != 0))
if (image->scene >= (image_info->subimage+image_info->subrange-1))
break;
switch (image_info->interlace)
{
case NoInterlace:
default:
{
/*
No interlacing: CMYKCMYKCMYKCMYKCMYKCMYK...
*/
for (y=0; y < image->tile_info.y; y++)
(void) ReadBlob(image,packet_size*image->tile_info.width,scanline);
for (y=0; y < (long) image->rows; y++)
{
if ((y > 0) || (image->previous == (Image *) NULL))
(void) ReadBlob(image,packet_size*image->tile_info.width,scanline);
q=SetImagePixels(image,0,y,image->columns,1);
if (q == (PixelPacket *) NULL)
break;
if (!image->matte)
(void) ImportImagePixelArea(image,CMYKQuantum,quantum_size,scanline+x,
&import_options,0);
else
(void) ImportImagePixelArea(image,CMYKAQuantum,quantum_size,scanline+x,
&import_options,0);
if (!SyncImagePixels(image))
break;
if (image->previous == (Image *) NULL)
if (QuantumTick(y,image->rows))
if (!MagickMonitorFormatted(y,image->rows,exception,
LoadImageText,image->filename,
image->columns,image->rows))
break;
}
count=image->tile_info.height-image->rows-image->tile_info.y;
for (i=0; i < (long) count; i++)
(void) ReadBlob(image,packet_size*image->tile_info.width,scanline);
break;
}
case LineInterlace:
{
/*
Line interlacing: CCC...MMM...YYY...KKK...CCC...MMM...YYY...KKK...
*/
packet_size=(quantum_size)/8;
for (y=0; y < image->tile_info.y; y++)
(void) ReadBlob(image,packet_size*image->tile_info.width,scanline);
for (y=0; y < (long) image->rows; y++)
{
if ((y > 0) || (image->previous == (Image *) NULL))
(void) ReadBlob(image,packet_size*image->tile_info.width,scanline);
q=SetImagePixels(image,0,y,image->columns,1);
if (q == (PixelPacket *) NULL)
break;
(void) ImportImagePixelArea(image,CyanQuantum,quantum_size,scanline+x,
&import_options,0);
(void) ReadBlob(image,packet_size*image->tile_info.width,scanline);
(void) ImportImagePixelArea(image,MagentaQuantum,quantum_size,scanline+x,
&import_options,0);
(void) ReadBlob(image,packet_size*image->tile_info.width,scanline);
(void) ImportImagePixelArea(image,YellowQuantum,quantum_size,scanline+x,
&import_options,0);
(void) ReadBlob(image,packet_size*image->tile_info.width,scanline);
(void) ImportImagePixelArea(image,BlackQuantum,quantum_size,scanline+x,
&import_options,0);
if (image->matte)
{
(void) ReadBlob(image,packet_size*image->tile_info.width,
scanline);
(void) ImportImagePixelArea(image,AlphaQuantum,quantum_size,scanline+x,
&import_options,0);
}
if (!SyncImagePixels(image))
break;
if (image->previous == (Image *) NULL)
if (QuantumTick(y,image->rows))
if (!MagickMonitorFormatted(y,image->rows,exception,
LoadImageText,image->filename,
image->columns,image->rows))
break;
}
count=image->tile_info.height-image->rows-image->tile_info.y;
for (i=0; i < (long) count; i++)
(void) ReadBlob(image,packet_size*image->tile_info.width,scanline);
break;
}
case PlaneInterlace:
case PartitionInterlace:
{
unsigned long
span;
/*
Plane interlacing: CCCCCC...MMMMMM...YYYYYY...KKKKKK...
*/
if (image_info->interlace == PartitionInterlace)
{
AppendImageFormat("C",image->filename);
status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
if (status == False)
ThrowReaderException(FileOpenError,UnableToOpenFile,image);
}
packet_size=(quantum_size)/8;
for (y=0; y < image->tile_info.y; y++)
(void) ReadBlob(image,packet_size*image->tile_info.width,scanline);
i=0;
span=image->rows*(image->matte ? 5 : 4);
for (y=0; y < (long) image->rows; y++)
{
if ((y > 0) || (image->previous == (Image *) NULL))
(void) ReadBlob(image,packet_size*image->tile_info.width,scanline);
q=SetImagePixels(image,0,y,image->columns,1);
if (q == (PixelPacket *) NULL)
break;
(void) ImportImagePixelArea(image,CyanQuantum,quantum_size,scanline+x,
&import_options,0);
if (!SyncImagePixels(image))
break;
if (image->previous == (Image *) NULL)
if (QuantumTick(i,span))
if (!MagickMonitorFormatted(i,span,&image->exception,
LoadImageText,image->filename,
image->columns,image->rows))
break;
i++;
}
count=image->tile_info.height-image->rows-image->tile_info.y;
for (i=0; i < (long) count; i++)
(void) ReadBlob(image,packet_size*image->tile_info.width,scanline);
if (image_info->interlace == PartitionInterlace)
{
CloseBlob(image);
AppendImageFormat("M",image->filename);
status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
if (status == False)
ThrowReaderException(FileOpenError,UnableToOpenFile,image);
}
for (y=0; y < image->tile_info.y; y++)
(void) ReadBlob(image,packet_size*image->tile_info.width,scanline);
for (y=0; y < (long) image->rows; y++)
{
(void) ReadBlob(image,packet_size*image->tile_info.width,scanline);
q=GetImagePixels(image,0,y,image->columns,1);
if (q == (PixelPacket *) NULL)
break;
(void) ImportImagePixelArea(image,MagentaQuantum,quantum_size,scanline+x,
&import_options,0);
if (!SyncImagePixels(image))
break;
if (image->previous == (Image *) NULL)
if (QuantumTick(i,span))
if (!MagickMonitorFormatted(i,span,&image->exception,
LoadImageText,image->filename,
image->columns,image->rows))
break;
i++;
}
count=image->tile_info.height-image->rows-image->tile_info.y;
for (i=0; i < (long) count; i++)
(void) ReadBlob(image,packet_size*image->tile_info.width,scanline);
if (image_info->interlace == PartitionInterlace)
{
CloseBlob(image);
AppendImageFormat("Y",image->filename);
status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
if (status == False)
ThrowReaderException(FileOpenError,UnableToOpenFile,image);
}
for (y=0; y < image->tile_info.y; y++)
(void) ReadBlob(image,packet_size*image->tile_info.width,scanline);
for (y=0; y < (long) image->rows; y++)
{
(void) ReadBlob(image,packet_size*image->tile_info.width,scanline);
q=GetImagePixels(image,0,y,image->columns,1);
if (q == (PixelPacket *) NULL)
break;
(void) ImportImagePixelArea(image,YellowQuantum,quantum_size,scanline+x,
&import_options,0);
if (!SyncImagePixels(image))
break;
if (image->previous == (Image *) NULL)
if (QuantumTick(i,span))
if (!MagickMonitorFormatted(i,span,&image->exception,
LoadImageText,image->filename,
image->columns,image->rows))
break;
i++;
}
count=image->tile_info.height-image->rows-image->tile_info.y;
for (i=0; i < (long) count; i++)
(void) ReadBlob(image,packet_size*image->tile_info.width,scanline);
if (image_info->interlace == PartitionInterlace)
{
CloseBlob(image);
AppendImageFormat("K",image->filename);
status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
if (status == False)
ThrowReaderException(FileOpenError,UnableToOpenFile,image);
}
for (y=0; y < image->tile_info.y; y++)
(void) ReadBlob(image,packet_size*image->tile_info.width,scanline);
for (y=0; y < (long) image->rows; y++)
{
(void) ReadBlob(image,packet_size*image->tile_info.width,scanline);
q=GetImagePixels(image,0,y,image->columns,1);
if (q == (PixelPacket *) NULL)
break;
(void) ImportImagePixelArea(image,BlackQuantum,quantum_size,scanline+x,
&import_options,0);
if (!SyncImagePixels(image))
break;
if (image->previous == (Image *) NULL)
if (QuantumTick(i,span))
if (!MagickMonitorFormatted(i,span,&image->exception,
LoadImageText,image->filename,
image->columns,image->rows))
break;
i++;
}
count=image->tile_info.height-image->rows-image->tile_info.y;
for (i=0; i < (long) count; i++)
(void) ReadBlob(image,packet_size*image->tile_info.width,scanline);
if (image->matte)
{
/*
Read matte channel.
*/
if (image_info->interlace == PartitionInterlace)
{
CloseBlob(image);
AppendImageFormat("A",image->filename);
status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
if (status == False)
ThrowReaderException(FileOpenError,UnableToOpenFile,image);
}
for (y=0; y < image->tile_info.y; y++)
(void) ReadBlob(image,packet_size*image->tile_info.width,
scanline);
for (y=0; y < (long) image->rows; y++)
{
(void) ReadBlob(image,packet_size*image->tile_info.width,
scanline);
q=GetImagePixels(image,0,y,image->columns,1);
if (q == (PixelPacket *) NULL)
break;
(void) ImportImagePixelArea(image,AlphaQuantum,quantum_size,scanline+x,
&import_options,0);
if (!SyncImagePixels(image))
break;
if (image->previous == (Image *) NULL)
if (QuantumTick(i,span))
if (!MagickMonitorFormatted(i,span,&image->exception,
LoadImageText,image->filename,
image->columns,image->rows))
break;
i++;
}
count=image->tile_info.height-image->rows-image->tile_info.y;
for (i=0; i < (long) count; i++)
(void) ReadBlob(image,packet_size*image->tile_info.width,
scanline);
}
if (image_info->interlace == PartitionInterlace)
(void) strlcpy(image->filename,image_info->filename,MaxTextExtent);
break;
}
}
if (EOFBlob(image))
{
ThrowException(exception,CorruptImageError,UnexpectedEndOfFile,
image->filename);
break;
}
/*
Proceed to next image.
*/
if (image_info->subrange != 0)
if (image->scene >= (image_info->subimage+image_info->subrange-1))
break;
if (image_info->interlace == PartitionInterlace)
break;
count=ReadBlob(image,packet_size*image->tile_info.width,scanline);
if (count != 0)
{
/*
Allocate next image structure.
*/
AllocateNextImage(image_info,image);
if (image->next == (Image *) NULL)
{
DestroyImageList(image);
return((Image *) NULL);
}
image=SyncNextImageInList(image);
status=MagickMonitorFormatted(TellBlob(image),GetBlobSize(image),
exception,LoadImagesText,
image->filename);
if (status == False)
break;
}
} while (count != 0);
MagickFreeMemory(scanline);
while (image->previous != (Image *) NULL)
image=image->previous;
CloseBlob(image);
return(image);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% W r i t e M T V I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% Method WriteMTVImage writes an image to a file in red, green, and blue
% MTV rasterfile format.
%
% The format of the WriteMTVImage method is:
%
% unsigned int WriteMTVImage(const ImageInfo *image_info,Image *image)
%
% A description of each parameter follows.
%
% o status: Method WriteMTVImage return True if the image is written.
% False is returned is there is a memory shortage or if the image file
% fails to write.
%
% o image_info: Specifies a pointer to a ImageInfo structure.
%
% o image: A pointer to an Image structure.
%
%
*/
static unsigned int WriteMTVImage(const ImageInfo *image_info,Image *image)
{
char
buffer[MaxTextExtent];
int
y;
register const PixelPacket
*p;
register long
x;
register unsigned char
*q;
unsigned char
*pixels;
unsigned int
status;
unsigned long
scene;
/*
Open output image file.
*/
assert(image_info != (const ImageInfo *) NULL);
assert(image_info->signature == MagickSignature);
assert(image != (Image *) NULL);
assert(image->signature == MagickSignature);
status=OpenBlob(image_info,image,WriteBinaryBlobMode,&image->exception);
if (status == False)
ThrowWriterException(FileOpenError,UnableToOpenFile,image);
scene=0;
do
{
/*
Allocate memory for pixels.
*/
(void) TransformColorspace(image,RGBColorspace);
pixels=MagickAllocateMemory(unsigned char *,
image->columns*sizeof(PixelPacket));
if (pixels == (unsigned char *) NULL)
ThrowWriterException(ResourceLimitError,MemoryAllocationFailed,image);
/*
Initialize raster file header.
*/
FormatString(buffer,"%lu %lu\n",image->columns,image->rows);
(void) WriteBlobString(image,buffer);
for (y=0; y < (long) image->rows; y++)
{
p=AcquireImagePixels(image,0,y,image->columns,1,&image->exception);
if (p == (const PixelPacket *) NULL)
break;
q=pixels;
for (x=0; x < (long) image->columns; x++)
{
*q++=ScaleQuantumToChar(p->red);
*q++=ScaleQuantumToChar(p->green);
*q++=ScaleQuantumToChar(p->blue);
p++;
}
(void) WriteBlob(image,q-pixels,(char *) pixels);
if (image->previous == (Image *) NULL)
if (QuantumTick(y,image->rows))
if (!MagickMonitorFormatted(y,image->rows,&image->exception,
SaveImageText,image->filename,
image->columns,image->rows))
break;
}
MagickFreeMemory(pixels);
if (image->next == (Image *) NULL)
break;
image=SyncNextImageInList(image);
status=MagickMonitorFormatted(scene++,GetImageListLength(image),
&image->exception,SaveImagesText,
image->filename);
if (status == False)
break;
} while (image_info->adjoin);
if (image_info->adjoin)
while (image->previous != (Image *) NULL)
image=image->previous;
CloseBlob(image);
return(True);
}