/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % D e s t r o y D e l e g a t e I n f o % % % % % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % Method DestroyDelegateInfo deallocates memory associated with the delegates % list. % % The format of the DestroyDelegateInfo method is: % % DestroyDelegateInfo(void) % */ MagickExport void DestroyDelegateInfo(void) { DelegateInfo *delegate_info; register DelegateInfo *p; for (p=delegate_list; p != (DelegateInfo *) NULL; ) { delegate_info=p; p=p->next; if (delegate_info->path != (char *) NULL) MagickFreeMemory(delegate_info->path); if (delegate_info->decode != (char *) NULL) MagickFreeMemory(delegate_info->decode); if (delegate_info->encode != (char *) NULL) MagickFreeMemory(delegate_info->encode); if (delegate_info->commands != (char *) NULL) MagickFreeMemory(delegate_info->commands); MagickFreeMemory(delegate_info); } delegate_list=(DelegateInfo *) NULL; DestroySemaphoreInfo(&delegate_semaphore); }
/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % D e s t r o y E x c e p t i o n I n f o % % % % % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % DestroyExceptionInfo() deallocates memory associated with exception. % % The format of the DestroyExceptionInfo method is: % % void DestroyExceptionInfo(ExceptionInfo *exception) % % A description of each parameter follows: % % o exception: The exception info. % % */ MagickExport void DestroyExceptionInfo(ExceptionInfo *exception) { assert(exception != (ExceptionInfo *) NULL); assert(exception->signature == MagickSignature); exception->severity=UndefinedException; MagickFreeMemory(exception->reason); MagickFreeMemory(exception->description); exception->error_number=0; MagickFreeMemory(exception->module); MagickFreeMemory(exception->function); exception->line=0UL; exception->signature=0UL; }
/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % 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 A R T I m a g e % % % % % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % Function WriteARTImage writes an ART image to a file. % % The format of the WriteARTImage method is: % % unsigned int WriteARTImage(const ImageInfo *image_info,Image *image) % % A description of each parameter follows. % % o status: Function WriteARTImage 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 WriteARTImage(const ImageInfo *image_info,Image *image) { long y; unsigned dummy = 0; long DataSize; const PixelPacket *q; unsigned int status; unsigned char Padding; int logging; unsigned char *pixels; /* Open output image file. */ assert(image_info != (const ImageInfo *) NULL); assert(image_info->signature == MagickSignature); assert(image != (Image *) NULL); assert(image->signature == MagickSignature); logging=LogMagickEvent(CoderEvent,GetMagickModule(),"enter ART"); status=OpenBlob(image_info,image,WriteBinaryBlobMode,&image->exception); if (status == False) ThrowWriterException(FileOpenError,UnableToOpenFile,image); DataSize = (long)((image->columns+7) / 8); Padding = (unsigned char)((-DataSize) & 0x01); pixels=MagickAllocateMemory(unsigned char *,(size_t) (DataSize)); if (pixels == (unsigned char *) NULL) ThrowWriterException(ResourceLimitError,MemoryAllocationFailed,image); /* Write ART hader. */ (void) WriteBlobLSBShort(image,0); (void) WriteBlobLSBShort(image,image->columns); (void) WriteBlobLSBShort(image,0); (void) WriteBlobLSBShort(image,image->rows); /* Store image data. */ for(y=0; y<(long)image->rows; y++) { q = AcquireImagePixels(image,0,y,image->columns,1,&image->exception); (void)ExportImagePixelArea(image,GrayQuantum,1,pixels,0,0); (void)WriteBlob(image,DataSize,pixels); (void)WriteBlob(image,Padding,(char *)&dummy); } status=True; CloseBlob(image); MagickFreeMemory(pixels); if (logging) (void)LogMagickEvent(CoderEvent,GetMagickModule(),"return ART"); return(status); }
static int BlobClose(jas_stream_obj_t *object) { StreamManager *source = (StreamManager *) object; CloseBlob(source->image); MagickFreeMemory(source); return (0); }
/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % G e t D e l e g a t e C o m m a n d % % % % % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % Method GetDelegateCommand replaces any embedded formatting characters with % the appropriate image attribute and returns the resulting command. % % The format of the GetDelegateCommand method is: % % char *GetDelegateCommand(const ImageInfo *image_info,Image *image, % const char *decode,const char *encode,ExceptionInfo *exception) % % A description of each parameter follows: % % o command: Method GetDelegateCommand returns the command associated % with specified delegate tag. % % o image_info: The image info. % % o image: The image. % % o decode: Specifies the decode delegate we are searching for as a % character string. % % o encode: Specifies the encode delegate we are searching for as a % character string. % % o exception: Return any errors or warnings in this structure. % % */ MagickExport char *GetDelegateCommand(const ImageInfo *image_info,Image *image, const char *decode,const char *encode,ExceptionInfo *exception) { char *command, **commands; const DelegateInfo *delegate_info; register long i; assert(image_info != (ImageInfo *) NULL); assert(image_info->signature == MagickSignature); assert(image != (Image *) NULL); assert(image->signature == MagickSignature); delegate_info=GetDelegateInfo(decode,encode,exception); if (delegate_info == (const DelegateInfo *) NULL) { ThrowException(exception,DelegateError,NoTagFound, decode ? decode : encode); return((char *) NULL); } commands=StringToList(delegate_info->commands); if (commands == (char **) NULL) { ThrowException(exception,ResourceLimitError,MemoryAllocationFailed, decode ? decode : encode); return((char *) NULL); } command=TranslateText(image_info,image,commands[0]); if (command == (char *) NULL) ThrowException(exception,ResourceLimitError,MemoryAllocationFailed, commands[0]); /* Free resources. */ for (i=0; commands[i] != (char *) NULL; i++) MagickFreeMemory(commands[i]); MagickFreeMemory(commands); return(command); }
/* Delete a thread-specific data key, invoking the registered destructor on any remaining non-NULL key values. */ MagickExport MagickPassFail MagickTsdKeyDelete(MagickTsdKey_t key) { #if defined(HAVE_PTHREAD) return ((pthread_key_delete(key) == 0) ? MagickPass : MagickFail); #elif defined(MSWINDOWS) /* BOOL WINAPI TlsFree(DWORD dwTlsIndex) */ return ((TlsFree(key) != 0) ? MagickPass : MagickFail); #else MagickFreeMemory(key); return MagickPass; #endif }
MagickExport void ThrowException(ExceptionInfo *exception, const ExceptionType severity,const char *reason,const char *description) { assert(exception != (ExceptionInfo *) NULL); assert(exception->signature == MagickSignature); exception->severity=(ExceptionType) severity; MagickFreeMemory(exception->reason); if (reason) exception->reason= AcquireString(GetLocaleExceptionMessage(severity,reason)); MagickFreeMemory(exception->description); if (description) exception->description= AcquireString(GetLocaleExceptionMessage(severity,description)); exception->error_number=errno; MagickFreeMemory(exception->module); MagickFreeMemory(exception->function); exception->line=0UL; exception->signature=0UL; return; }
/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % T h r o w L o g g e d E x c e p t i o n % % % % % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % ThrowLoggedException() throws an exception with the specified severity code, % reason, optional description, source filename, function name, and line % number. If logging is enabled, the exception is also logged. % % The format of the ThrowLoggedException method is: % % void ThrowLoggedException(ExceptionInfo *exception, % const ExceptionType severity,const char *reason, % const char *description,const char *module, % const char *function,const unsigned long line % % A description of each parameter follows: % % o exception: The exception. % % o severity: The severity of the exception. % % o reason: The reason of the exception. % % o description: The exception description. % % o filename: The source module filename. % % o function: The function name. % % o line: The line number of the source module. % % */ MagickExport void ThrowLoggedException(ExceptionInfo *exception, const ExceptionType severity,const char *reason,const char *description, const char *module,const char *function,const unsigned long line) { assert(exception != (ExceptionInfo *) NULL); assert(exception->signature == MagickSignature); exception->severity=(ExceptionType) severity; MagickFreeMemory(exception->reason); if (reason) exception->reason= AcquireString(GetLocaleExceptionMessage(severity,reason)); MagickFreeMemory(exception->description); if (description) exception->description= AcquireString(GetLocaleExceptionMessage(severity,description)); exception->error_number=errno; MagickFreeMemory(exception->module); if (module) exception->module=AcquireString(module); MagickFreeMemory(exception->function); if (function) exception->function=AcquireString(function); exception->line=line; if (exception->reason) { if (exception->description) (void) LogMagickEvent(severity,module,function,line,"%.1024s (%.1024s)", exception->reason,exception->description ); else (void) LogMagickEvent(severity,module,function,line,"%.1024s", exception->reason); } else { (void) LogMagickEvent(severity,module,function,line, "exception contains no reason!"); } return; }
/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % C o p y E x c e p t i o n % % % % % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % CopyException() copies exception data from one ExceptionInfo structure % to another. % % The format of the CopyException method is: % % void CopyException(ExceptionInfo *copy, const ExceptionInfo *original) % % A description of each parameter follows: % % o copy: The exception to copy to. % % o original: The exception to copy from. % */ MagickExport void CopyException(ExceptionInfo *copy, const ExceptionInfo *original) { assert(copy != (ExceptionInfo *) NULL); assert(copy->signature == MagickSignature); assert(original != (ExceptionInfo *) NULL); assert(original->signature == MagickSignature); copy->severity=original->severity; MagickFreeMemory(copy->reason); if (original->reason) copy->reason=AcquireString(original->reason); MagickFreeMemory(copy->description); if (original->description) copy->description=AcquireString(original->description); copy->error_number=original->error_number; MagickFreeMemory(copy->module); if (original->module) copy->module=AcquireString(original->module); MagickFreeMemory(copy->function); if (original->function) copy->function=AcquireString(original->function); copy->line=original->line; return; }
void Magick::Montage::updateMontageInfo ( MontageInfo &montageInfo_ ) const { memset(&montageInfo_,0,sizeof(MontageInfo)); // background_color montageInfo_.background_color = _backgroundColor; // border_color montageInfo_.border_color = Color(); // border_width montageInfo_.border_width = 0; // filename _fileName.copy( montageInfo_.filename, MaxTextExtent - 1 ); montageInfo_.filename[ _fileName.length() ] = 0; // null terminate // fill montageInfo_.fill = _fill; // font if ( _font.length() != 0 ) Magick::CloneString( &montageInfo_.font, _font ); else MagickFreeMemory(montageInfo_.font); // frame MagickFreeMemory(montageInfo_.frame); // geometry if ( _geometry.isValid() ) Magick::CloneString( &montageInfo_.geometry, _geometry ); else MagickFreeMemory(montageInfo_.geometry); // gravity montageInfo_.gravity = _gravity; // matte_color montageInfo_.matte_color = Color(); // pointsize montageInfo_.pointsize = _pointSize; // shadow montageInfo_.shadow = static_cast<int>(_shadow); // signature (validity stamp) montageInfo_.signature = MagickSignature; // stroke montageInfo_.stroke = _stroke; // texture if ( _texture.length() != 0 ) Magick::CloneString( &montageInfo_.texture, _texture ); else MagickFreeMemory(montageInfo_.texture); // tile if ( _tile.isValid() ) Magick::CloneString( &montageInfo_.tile, _tile ); else MagickFreeMemory(montageInfo_.tile); // title if ( _title.length() != 0 ) Magick::CloneString( &montageInfo_.title, _title ); else MagickFreeMemory(montageInfo_.title); }
/* Destroy a thread view data set. */ MagickExport void DestroyThreadViewDataSet(ThreadViewDataSet *data_set) { unsigned int i; if (data_set != (ThreadViewDataSet *) NULL) { if (data_set->view_data != (void *) NULL) { if (data_set->destructor != (MagickFreeFunc) NULL) { for (i=0; i < data_set->nviews; i++) { (data_set->destructor)(data_set->view_data[i]); data_set->view_data[i]=(void *) NULL; } } MagickFreeMemory(data_set->view_data); } data_set->nviews=0; MagickFreeMemory(data_set); } }
/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % D e s t r o y M a g i c k I n f o % % % % % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % DestroyMagickInfo() destroys a MagickInfo structure. % % The format of the DestroyMagickInfoList method is: % % void DestroyMagickInfo(MagickInfo** magick_info) % */ static void DestroyMagickInfo(MagickInfo** magick_info) { MagickInfo *p; p=*magick_info; if (p) { p->name=0; p->description=0; p->version=0; p->note=0; p->module=0; MagickFreeMemory(p); *magick_info=p; } }
/* virtual */ void Magick::MontageFramed::updateMontageInfo ( MontageInfo &montageInfo_ ) const { // Do base updates Montage::updateMontageInfo ( montageInfo_ ); // border_color montageInfo_.border_color = _borderColor; // border_width montageInfo_.border_width = _borderWidth; // frame if ( _frame.isValid() ) Magick::CloneString( &montageInfo_.frame, _frame ); else MagickFreeMemory(montageInfo_.frame); // matte_color montageInfo_.matte_color = _matteColor; }
/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % L i s t M o d u l e M a p % % % % % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % Method ListModuleMap lists the module alias info to a file in the XML % format used by modules.mgk. True is returned on success. % % The format of the ListModuleMap method is: % % MagickPassFail ListModuleMap(FILE *file,ExceptionInfo *exception) % % A description of each parameter follows. % % o file: An pointer to a FILE. % % o exception: Return any errors or warnings in this structure. % % */ MagickExport MagickPassFail ListModuleMap(FILE *file,ExceptionInfo *exception) { MagickInfo **magick_array; int i; if (file == (const FILE *) NULL) file=stdout; magick_array=GetMagickInfoArray(exception); if ((!magick_array) || (exception->severity > UndefinedException)) return MagickFail; (void) fprintf(file, "<?xml version=\"1.0\"?>\n"); (void) fprintf(file, "<!-- %s -->\n",GetMagickCopyright()); (void) fprintf(file, "<!-- Magick Module Alias Map (modules.mgk) -->\n"); (void) fprintf(file, "<modulemap>\n"); for (i=0; magick_array[i] != 0; i++) { if (LocaleCompare(magick_array[i]->name,magick_array[i]->module) != 0) { (void) fprintf(file, " <module magick=\"%s\" name=\"%s\" />\n", magick_array[i]->name, (magick_array[i]->module == NULL ? "(null)" : magick_array[i]->module)); } } (void) fprintf(file, "</modulemap>\n"); (void) fflush(file); MagickFreeMemory(magick_array); return(MagickPass); }
/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % 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); }
static Image *ReadSFWImage(const ImageInfo *image_info,ExceptionInfo *exception) { static unsigned char HuffmanTable[] = { 0xFF, 0xC4, 0x01, 0xA2, 0x00, 0x00, 0x01, 0x05, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x01, 0x00, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x10, 0x00, 0x02, 0x01, 0x03, 0x03, 0x02, 0x04, 0x03, 0x05, 0x05, 0x04, 0x04, 0x00, 0x00, 0x01, 0x7D, 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12, 0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07, 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xA1, 0x08, 0x23, 0x42, 0xB1, 0xC1, 0x15, 0x52, 0xD1, 0xF0, 0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0A, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0x11, 0x00, 0x02, 0x01, 0x02, 0x04, 0x04, 0x03, 0x04, 0x07, 0x05, 0x04, 0x04, 0x00, 0x01, 0x02, 0x77, 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21, 0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71, 0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91, 0xA1, 0xB1, 0xC1, 0x09, 0x23, 0x33, 0x52, 0xF0, 0x15, 0x62, 0x72, 0xD1, 0x0A, 0x16, 0x24, 0x34, 0xE1, 0x25, 0xF1, 0x17, 0x18, 0x19, 0x1A, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA }; FILE *file; Image *flipped_image, *image; ImageInfo *clone_info; register unsigned char *header, *data; size_t count; unsigned char *buffer, *offset; 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 image into a buffer. */ buffer=MagickAllocateMemory(unsigned char *,(size_t) GetBlobSize(image)); if (buffer == (unsigned char *) NULL) ThrowReaderException(ResourceLimitError,MemoryAllocationFailed,image); count=ReadBlob(image,(size_t) GetBlobSize(image),(char *) buffer); if ((count == 0) || (LocaleNCompare((char *) buffer,"SFW",3) != 0)) ThrowReaderException(CorruptImageError,ImproperImageHeader,image); CloseBlob(image); DestroyImage(image); /* Find the start of the JFIF data */ header=SFWScan(buffer,buffer+GetBlobSize(image)-1,(unsigned char *) "\377\310\377\320",4); if (header == (unsigned char *) NULL) { MagickFreeMemory(buffer); ThrowReaderException(CorruptImageError,ImproperImageHeader,image) }
MagickExport unsigned int InvokeDelegate(ImageInfo *image_info,Image *image, const char *decode,const char *encode,ExceptionInfo *exception) { char *command, **commands, filename[MaxTextExtent]; const DelegateInfo *delegate_info; register long i; unsigned int status, temporary_image_filename; /* Get delegate. */ assert(image_info != (ImageInfo *) NULL); assert(image_info->signature == MagickSignature); assert(image != (Image *) NULL); assert(image->signature == MagickSignature); temporary_image_filename=(*image->filename == '\0'); if (temporary_image_filename) { /* Allocate a temporary filename if image is unnamed. */ if(!AcquireTemporaryFileName(image->filename)) { (void) ThrowException(exception,FileOpenError,UnableToCreateTemporaryFile,image->filename); return(False); } } (void) strlcpy(filename,image->filename,MaxTextExtent); delegate_info=GetDelegateInfo(decode,encode,exception); if (delegate_info == (DelegateInfo *) NULL) { if (temporary_image_filename) (void) LiberateTemporaryFile(image->filename); (void) ThrowException(exception,DelegateError,NoTagFound, decode ? decode : encode); return(False); } if (*image_info->filename == '\0') { /* ReadImage will normally have already set image_info->filename to the name of a temporary file. If not, then assign one. Setting image_info->temporary to True indicates that there is a temporary file to be removed later. */ if(!AcquireTemporaryFileName(image_info->filename)) { if (temporary_image_filename) (void) LiberateTemporaryFile(image->filename); (void) ThrowException(exception,FileOpenError,UnableToCreateTemporaryFile,image_info->filename); return(False); } image_info->temporary=True; } if (delegate_info->mode != 0) if ((decode && (delegate_info->encode != (char *) NULL)) || (encode && (delegate_info->decode != (char *) NULL))) { char decode_filename[MaxTextExtent], *magick; ImageInfo *clone_info; register Image *p; /* Delegate requires a particular image format. */ if (!AcquireTemporaryFileName(image_info->unique)) { if (temporary_image_filename) (void) LiberateTemporaryFile(image->filename); (void) ThrowException(exception,FileOpenError,UnableToCreateTemporaryFile,image_info->unique); return(False); } if (!AcquireTemporaryFileName(image_info->zero)) { if (temporary_image_filename) (void) LiberateTemporaryFile(image->filename); (void) LiberateTemporaryFile(image_info->unique); (void) ThrowException(exception,FileOpenError,UnableToCreateTemporaryFile,image_info->zero); return(False); } /* Expand sprintf-style codes in delegate command to command string */ magick=TranslateText(image_info,image,decode != (char *) NULL ? delegate_info->encode : delegate_info->decode); if (magick == (char *) NULL) { (void) LiberateTemporaryFile(image_info->unique); (void) LiberateTemporaryFile(image_info->zero); if (temporary_image_filename) (void) LiberateTemporaryFile(image->filename); (void) ThrowException(exception,DelegateError,DelegateFailed, decode ? decode : encode); return(False); } LocaleUpper(magick); clone_info=CloneImageInfo(image_info); (void) strlcpy((char *) clone_info->magick,magick,MaxTextExtent); (void) strlcpy(image->magick,magick,MaxTextExtent); MagickFreeMemory(magick); (void) strlcpy(decode_filename,image->filename,MaxTextExtent); FormatString(clone_info->filename,"%.1024s:",delegate_info->decode); (void) SetImageInfo(clone_info,True,exception); (void) strlcpy(clone_info->filename,image_info->filename, MaxTextExtent); for (p=image; p != (Image *) NULL; p=p->next) { FormatString(p->filename,"%.1024s:%.1024s",delegate_info->decode, decode_filename); status=WriteImage(clone_info,p); if (status == False) { (void) LiberateTemporaryFile(image_info->unique); (void) LiberateTemporaryFile(image_info->zero); if (temporary_image_filename) (void) LiberateTemporaryFile(image->filename); DestroyImageInfo(clone_info); (void) ThrowException(exception,DelegateError,DelegateFailed, decode ? decode : encode); return(False); } if (clone_info->adjoin) break; } (void) LiberateTemporaryFile(image_info->unique); (void) LiberateTemporaryFile(image_info->zero); DestroyImageInfo(clone_info); } /* Invoke delegate. */ (void) strlcpy(image->filename,filename,MaxTextExtent); commands=StringToList(delegate_info->commands); if (commands == (char **) NULL) { if (temporary_image_filename) (void) LiberateTemporaryFile(image->filename); (void) ThrowException(exception,ResourceLimitError,MemoryAllocationFailed,decode ? decode : encode); return(False); } command=(char *) NULL; status=True; /* For each delegate command ... */ for (i=0; commands[i] != (char *) NULL; i++) { status=True; /* Allocate convenience temporary files */ if (!AcquireTemporaryFileName(image_info->unique)) { (void) ThrowException(exception,FileOpenError,UnableToCreateTemporaryFile,image_info->unique); status=False; goto error_exit; } if (!AcquireTemporaryFileName(image_info->zero)) { (void) ThrowException(exception,FileOpenError,UnableToCreateTemporaryFile,image_info->zero); (void) LiberateTemporaryFile(image_info->unique); status=False; goto error_exit; } #if defined(POSIX) { MagickBool needs_shell; /* Check to see if command template must be executed via shell due to using constructs requiring multiple processes or I/O redirection. */ needs_shell = MagickFalse; { char * p; p = commands[i]; for (p = commands[i]; *p; p++) { if (('&' == *p) || (';' == *p) || ('<' == *p) || ('>' == *p) || ('|' == *p)) { needs_shell = MagickTrue; break; } } } if (MagickFalse == needs_shell) { int arg_count, j; char **arg_array; /* Convert command template into an argument array. Translate each argument array element individually in order to absolutely avoid any possibility that the number of arguments may be altered due to substituted data. */ arg_array = StringToArgv(commands[i],&arg_count); for (j = 0; arg_array[j] != (const char*) NULL; j++) { if (strchr(arg_array[j], '%') != (const char*) NULL) { char *expanded = TranslateText(image_info,image,arg_array[j]); if (expanded != (char *) NULL) { MagickFreeMemory(arg_array[j]); arg_array[j] = expanded; } } } /* Execute delegate using our secure "spawn" facility. */ status = MagickSpawnVP(image_info->verbose,arg_array[1],arg_array+1); } else { /* Expand sprintf-style codes in delegate command to command string, escaping replacement text appropriately */ command=TranslateTextEx(image_info,image,commands[i],UnixShellTextEscape); if (command == (char *) NULL) break; /* Execute delegate using command shell. */ status=SystemCommand(image_info->verbose,command); } } #else { /* Expand sprintf-style codes in delegate command to command string */ command=TranslateText(image_info,image,commands[i]); if (command == (char *) NULL) break; /* Execute delegate using command shell. */ status=SystemCommand(image_info->verbose,command); } #endif MagickFreeMemory(command); /* Liberate convenience temporary files */ (void) LiberateTemporaryFile(image_info->unique); (void) LiberateTemporaryFile(image_info->zero); if (status != False) { (void) ThrowException(exception,DelegateError,DelegateFailed, commands[i]); goto error_exit; } MagickFreeMemory(commands[i]); } /* Free resources. */ error_exit: if (temporary_image_filename) (void) LiberateTemporaryFile(image->filename); for ( ; commands[i] != (char *) NULL; i++) MagickFreeMemory(commands[i]); MagickFreeMemory(commands); return(status != False); }
/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % + I n v o k e P o s t s c r i p t D e l e g a t e % % % % % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % InvokePostscriptDelegate() executes the postscript interpreter with the % specified command. % % The format of the InvokePostscriptDelegate method is: % % MagickPassFail InvokePostscriptDelegate(const unsigned int verbose, % const char *command, ExceptionInfo *exception) % % A description of each parameter follows: % % o status: Method InvokePostscriptDelegate returns MagickPass if the command % is successfully executed, otherwise MagickFail. % % o verbose: A value other than zero displays the command prior to % executing it. % % o command: The address of a character string containing the command to % execute. The command is formulated through direct FormatString() % substitutions rather than using TranslateText. % % */ MagickExport MagickPassFail InvokePostscriptDelegate(const unsigned int verbose, const char *command,ExceptionInfo *exception) { register long i; char **argv; int argc; int status; #if defined(HasGS) || defined(MSWINDOWS) gs_main_instance *interpreter; int pexit_code; #if defined(MSWINDOWS) const GhostscriptVectors *gs_func; gs_func=NTGhostscriptDLLVectors(); #elif defined(HasGS) GhostscriptVectors gs_func_struct; const GhostscriptVectors *gs_func; gs_func=(&gs_func_struct); gs_func_struct.exit=gsapi_exit; gs_func_struct.init_with_args=gsapi_init_with_args; gs_func_struct.new_instance=gsapi_new_instance; gs_func_struct.run_string=gsapi_run_string; gs_func_struct.delete_instance=gsapi_delete_instance; #endif if (gs_func != (GhostscriptVectors *) NULL) { /* Allocate an interpreter. */ interpreter = (gs_main_instance *) NULL; status=(gs_func->new_instance)(&interpreter,(void *) NULL); if (status < 0) { ThrowException(exception,DelegateError, FailedToAllocateGhostscriptInterpreter,command); return(MagickFail); } /* Initialize interpreter with argument list. */ argv=StringToArgv(command,&argc); if (argv == (char **) NULL) { ThrowException(exception,DelegateError,FailedToAllocateArgumentList, command); return(MagickFail); } if (verbose) { char buffer[MaxTextExtent]; #if defined(MSWINDOWS) (void) NTGhostscriptDLL(buffer,sizeof(buffer)); #else (void) strlcpy(buffer,"[ghostscript library]",sizeof(buffer)); #endif (void) fputs(buffer,stderr); for (i=2 ; i < argc ; i++) (void) fprintf(stderr," \"%s\"",argv[i]); (void) fflush(stderr); } status=(gs_func->init_with_args)(interpreter,argc-1,argv+1); if (status == 0) { status=(gs_func->run_string) (interpreter,"systemdict /start get exec\n",0,&pexit_code); if ((status == 0) || (status <= -100)) { char reason[MaxTextExtent]; FormatString(reason,"Ghostscript returns status %d, exit code %d", status,pexit_code); (void) LogMagickEvent(CoderEvent,GetMagickModule(),"%s",reason); ThrowException(exception,DelegateError,PostscriptDelegateFailed,command); } } /* Exit interpreter. */ (gs_func->exit)(interpreter); /* Deallocate interpreter. */ (gs_func->delete_instance)(interpreter); for (i=0; i < argc; i++) MagickFreeMemory(argv[i]); MagickFreeMemory(argv); if ((status == 0) || (status <= -100)) return(MagickFail); return(MagickPass); } #endif /* defined(HasGS) || defined(MSWINDOWS) */ status=MagickFail; #if defined(POSIX) { argv = StringToArgv(command,&argc); if (argv == (char **) NULL) { ThrowException(exception,DelegateError, FailedToAllocateArgumentList, command); } else { if (MagickSpawnVP(verbose,argv[1],argv+1) == 0) status=MagickPass; for (i=0; i < argc; i++) MagickFreeMemory(argv[i]); MagickFreeMemory(argv); } } #else if (SystemCommand(verbose,command) == 0) status=MagickPass; #endif return status; }
/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % L i s t D e l e g a t e I n f o % % % % % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % Method ListDelegateInfo lists the image formats to a file. % % The format of the ListDelegateInfo method is: % % unsigned int ListDelegateInfo(FILE *file,ExceptionInfo *exception) % % A description of each parameter follows. % % o file: An pointer to a FILE. % % o exception: Return any errors or warnings in this structure. % % */ MagickExport unsigned int ListDelegateInfo(FILE *file,ExceptionInfo *exception) { char **commands, delegate[MaxTextExtent]; register long i; register const DelegateInfo *p; if (file == (const FILE *) NULL) file=stdout; (void) GetDelegateInfo("*","*",exception); LockSemaphoreInfo(delegate_semaphore); for (p=delegate_list; p != (const DelegateInfo *) NULL; p=p->next) { if ((p->previous == (DelegateInfo *) NULL) || (LocaleCompare(p->path,p->previous->path) != 0)) { if (p->previous != (DelegateInfo *) NULL) (void) fprintf(file,"\n"); if (p->path != (char *) NULL) (void) fprintf(file,"Path: %.1024s\n\n",p->path); (void) fprintf(file,"Delegate Command\n"); (void) fprintf(file,"-------------------------------------------------" "------------------------------\n"); } if (p->stealth) continue; *delegate='\0'; if (p->encode != (char *) NULL) (void) strlcpy(delegate,p->encode,MaxTextExtent); (void) strcat(delegate," "); delegate[8]='\0'; commands=StringToList(p->commands); if (commands == (char **) NULL) continue; { int command_start_column, command_length, formatted_chars=0, length=0, screen_width=79, strip_length; char *s; /* Format output so that command spans multiple lines if necessary */ if (getenv("COLUMNS")) screen_width=atoi(getenv("COLUMNS"))-1; command_length=strlen(commands[0]); command_start_column=fprintf(file,"%8s%c=%c%s ",p->decode ? p->decode : "", p->mode <= 0 ? '<' : ' ',p->mode >= 0 ? '>' : ' ',delegate); for (s=commands[0]; length < command_length; s+=formatted_chars) { if (s != commands[0]) (void) fprintf(file,"%*s",command_start_column,""); strip_length=screen_width-command_start_column; if (length+strip_length < command_length) { char *e; for(e=s+strip_length; (*e != ' ') && (e > s) ; e--); strip_length=e-s; } formatted_chars=fprintf(file,"%.*s",strip_length,s); length+=formatted_chars; (void) fprintf(file,"\n"); if (formatted_chars <= 0) break; } } for (i=0; commands[i] != (char *) NULL; i++) MagickFreeMemory(commands[i]); MagickFreeMemory(commands); } (void) fflush(file); UnlockSemaphoreInfo(delegate_semaphore); return(True); }
static MagickPassFail WriteCALSImage(const ImageInfo *image_info,Image *image) { char buffer[MaxTextExtent]; int i; long sans; unsigned long density; int orx, ory; MagickPassFail status=MagickPass; /* Validate input image */ assert(image_info != (const ImageInfo *) NULL); assert(image_info->signature == MagickSignature); assert(image != (Image *) NULL); assert(image->signature == MagickSignature); /* Open output image file. */ if (OpenBlob(image_info,image,WriteBinaryBlobMode,&image->exception) == MagickFail) ThrowWriterException(FileOpenError,UnableToOpenFile,image); /* Create standard header */ WriteCALSRecord(image,"srcdocid: NONE"); WriteCALSRecord(image,"dstdocid: NONE"); WriteCALSRecord(image,"txtfilid: NONE"); WriteCALSRecord(image,"figid: NONE"); WriteCALSRecord(image,"srcgph: NONE"); WriteCALSRecord(image,"docls: NONE"); WriteCALSRecord(image,"rtype: 1"); /* orientation based on input or default of upright */ switch (image->orientation) { case TopRightOrientation: orx=180; ory=270; break; case BottomRightOrientation: orx=180; ory=90; break; case BottomLeftOrientation: orx=0; ory=90; break; case LeftTopOrientation: orx=270; ory=0; break; case RightTopOrientation: orx=270; ory=180; break; case RightBottomOrientation: orx=90; ory=180; break; case LeftBottomOrientation: orx=90; ory=0; break; default: orx=0; ory=270; } FormatString(buffer,"rorient: %03d,%03d",orx,ory); WriteCALSRecord(image,buffer); /* pixel counts based on columns/rows of input */ FormatString(buffer,"rpelcnt: %06ld,%06ld",image->columns,image->rows); WriteCALSRecord(image,buffer); /* density based on input density or default of 200 */ density=200; if (image_info->density != (char *) NULL) (void) GetGeometry(image_info->density,&sans,&sans,&density,&density); FormatString(buffer,"rdensty: %04ld",density); WriteCALSRecord(image,buffer); WriteCALSRecord(image,"notes: NONE"); /* Pad header to make 16 records / 2048 bytes */ memset(buffer,' ',128); for (i = 0; i < 5; i++) if (WriteBlob(image,128,buffer) != 128) status=MagickFail; /* Encode data to Group 4 */ if (MagickFail != status) { unsigned char *blob; size_t blob_length; blob=ImageToHuffman2DBlob(image,image_info,&blob_length,&image->exception); if (blob == (unsigned char *) NULL) status=MagickFail; if (MagickFail != status) { if (WriteBlob(image,blob_length,blob) != blob_length) status=MagickFail; } MagickFreeMemory(blob); } /* Close output file and return image */ CloseBlob(image); return status; }
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); }
/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % W r i t e I N F O I m a g e % % % % % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % WriteINFOImage() writes image descriptive info to stdout. % % The format of the WriteINFOImage method is: % % MagickPassFail WriteINFOImage(const ImageInfo *image_info,Image *image) % % A description of each parameter follows. % % o image_info: The image info. % % o image: The image. % % */ static MagickPassFail WriteINFOImage(const ImageInfo *image_info,Image *image) { MagickPassFail status; FILE *file; Image *list_entry; char temporary_filename[MaxTextExtent]; const char *format; assert(image_info != (const ImageInfo *) NULL); assert(image_info->signature == MagickSignature); assert(image != (Image *) NULL); assert(image->signature == MagickSignature); /* Obtain optional 'identify' style output specification. */ format=AccessDefinition(image_info,"info","format"); if (format != (char *) NULL) (void) LogMagickEvent(CoderEvent,GetMagickModule(), "info:format=\"%s\"",format); /* Open blob. */ status=OpenBlob(image_info,image,WriteBinaryBlobMode,&image->exception); if (status == MagickFail) ThrowWriterException(FileOpenError,UnableToOpenFile,image); /* Allocate and open a temporary file to write output to. */ temporary_filename[0]='\0'; if ((file=GetBlobFileHandle(image)) == (FILE *) NULL) { if(!AcquireTemporaryFileName(temporary_filename)) ThrowWriterException(FileOpenError,UnableToCreateTemporaryFile,image); if ((file=fopen(temporary_filename,"w")) == (FILE *) NULL) { (void) LiberateTemporaryFile(temporary_filename); ThrowWriterException(FileOpenError,UnableToCreateTemporaryFile,image); } } list_entry=image; while (list_entry != (Image *) NULL) { /* Avoid convert style output syntax by restoring original filename. */ (void) strlcpy(list_entry->filename,list_entry->magick_filename, sizeof(list_entry->filename)); /* Describe image. */ if (format != (char *) NULL) { char *text; text=TranslateText(image_info,list_entry,format); if (text != (char *) NULL) { (void) fputs(text,file); (void) fputs("\n",file); MagickFreeMemory(text); } } else { if ((status=DescribeImage(list_entry,file,image_info->verbose)) == MagickFail) break; } list_entry=GetNextImageInList(list_entry); } if ('\0' != temporary_filename[0]) { /* Close temporary file. */ (void) fclose(file); /* Send content of temporary file to blob stream. */ if (WriteBlobFile(image,temporary_filename) == MagickFail) status=MagickFail; (void) LiberateTemporaryFile(temporary_filename); } CloseBlob(image); return status; }
/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % R e a d A R T I m a g e % % % % % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % Method ReadARTImage reads an ART X 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 ReadARTImage method is: % % Image *ReadARTImage(const ImageInfo *image_info,ExceptionInfo *exception) % % A description of each parameter follows: % % o image: Method ReadARTImage 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 *ReadARTImage(const ImageInfo *image_info,ExceptionInfo *exception) { Image *image; int i; unsigned width,height,dummy; long ldblk; unsigned char *BImgBuff=NULL; unsigned char Padding; unsigned int status; const PixelPacket *q; /* 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 ART image. */ dummy=ReadBlobLSBShort(image); width=ReadBlobLSBShort(image); dummy=ReadBlobLSBShort(image); height=ReadBlobLSBShort(image); ldblk=(long) ((width+7) / 8); Padding=(unsigned char) ((-ldblk) & 0x01); if(GetBlobSize(image)!=(8+((long)ldblk+Padding)*height)) ThrowReaderException(CorruptImageError,ImproperImageHeader,image); image->columns=width; image->rows=height; image->depth=1; image->colors=1l << image->depth; /* printf("ART header checked OK %d,%d\n",image->colors,image->depth); */ if (!AllocateImageColormap(image,image->colors)) goto NoMemory; /* If ping is true, then only set image size and colors without reading any image data. */ if (image_info->ping) goto DONE_READING; /* ----- Load RLE compressed raster ----- */ BImgBuff=MagickAllocateMemory(unsigned char *,((size_t) ldblk)); /*Ldblk was set in the check phase*/ if(BImgBuff==NULL) NoMemory: ThrowReaderException(ResourceLimitError,MemoryAllocationFailed,image); for(i=0; i<(int)height; i++) { (void) ReadBlob(image,(size_t)ldblk,(char *)BImgBuff); (void) ReadBlob(image,Padding,(char *)&dummy); q=SetImagePixels(image,0,i,image->columns,1); if (q == (PixelPacket *)NULL) break; (void)ImportImagePixelArea(image,GrayQuantum,1,BImgBuff,NULL,0); if (!SyncImagePixels(image)) break; } if(BImgBuff!=NULL) MagickFreeMemory(BImgBuff); if (EOFBlob(image)) ThrowException(exception,CorruptImageError,UnexpectedEndOfFile, image->filename); DONE_READING: 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 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 *p, text[MaxTextExtent]; Image *image; TXT_TYPE txt_subformat; MagickPassFail status; MagickBool logging; /* Open image file. */ assert(image_info != (const ImageInfo *) NULL); assert(image_info->signature == MagickSignature); assert(exception != (ExceptionInfo *) NULL); assert(exception->signature == MagickSignature); logging = IsEventLogging(); image=AllocateImage(image_info); status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception); if (status == False) ThrowReaderException(FileOpenError,UnableToOpenFile,image); p = ReadBlobString(image,text); if (p == NULL) ThrowReaderException(CorruptImageError,ImproperImageHeader,image); txt_subformat = IsTXT((unsigned char *)p,strlen(p)); if (txt_subformat != NO_TXT) { 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; ExtendedSignedIntegralType NextImagePos = 0; ImportPixelAreaOptions import_options; if (logging) (void) LogMagickEvent(CoderEvent,GetMagickModule(), "File RAW TXT type: %d", (int) txt_subformat); do { (void) SeekBlob(image,NextImagePos,SEEK_SET); if(NextImagePos!=0) { /* Allocate next image structure. */ AllocateNextImage(image_info,image); if(image->next == (Image *)NULL) break; image = SyncNextImageInList(image); image->columns = image->rows = 0; image->colors=0; } A=0; x=0; y=0; max=0; switch(txt_subformat) { 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; default: break; } /* Set opacity flag. */ image->matte=MagickFalse; if (txt_subformat >= IMAGEMAGICK_TXT_Q) image->matte=MagickTrue; 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) { txt_subformat = 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) */ x_min = ReadInt(image,&ch); /* x */ if (x_min > x) x = x_min; while (ch != ',') { ch = ReadBlobByte(image); if (ch==EOF) break; if (ch == 10 || ch == 13) goto TXT_FAIL; } ch=0; i=ReadInt(image,&ch); /* y */ /* Check for next image start. */ if(x_min==0 && i==0 && x>0 && y>0) goto EndReading; if (i > y) y=i; while (ch != ':') { ch = ReadBlobByte(image); if (ch == 10 || ch == 13) goto TXT_FAIL; if (ch == EOF) break; } if (txt_subformat != 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 (txt_subformat >= IMAGEMAGICK_TXT_Q) { 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 (txt_subformat != 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) NumOfPlanes=2; */ /* if (max>= 4) NumOfPlanes=4; */ /* if (max>= 16) NumOfPlanes=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 = MagickAllocateArray(unsigned char *, (size_t)(x+1), ( ((image->matte) ? 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,NextImagePos,SEEK_SET); NextImagePos = 0; /* Load picture data */ while (!EOFBlob(image)) { 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 */ /* New image detected. */ if(x==0 && y==0 && y_curr>0 && x_max>0) { NextImagePos = TellBlob(image) - 4; break; } 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 (image->matte) { 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 (image->matte) (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 (image->matte) { switch(NumOfPlanes) { case 8: BImgBuff[0+4*x] = R; BImgBuff[1+4*x] = G; BImgBuff[2+4*x] = B; BImgBuff[3+4*x] = 255U-A; break; case 16: WImgBuff[0+4*x] = R; WImgBuff[1+4*x] = G; WImgBuff[2+4*x] = B; WImgBuff[3+4*x] = 65535U-A; break; case 32: DImgBuff[0+4*x] = R; DImgBuff[1+4*x] = G; DImgBuff[2+4*x] = B; DImgBuff[3+4*x] = 4294967295U-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 (image->matte) (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); } while(!EOFBlob(image) && NextImagePos>0); goto FINISH_TXT; }
/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % 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 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); }
/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % R e a d M A C I m a g e % % % % % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % Method ReadMACImage reads an MAC 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 ReadMACImage method is: % % Image *ReadMACImage(const ImageInfo *image_info,ExceptionInfo *exception) % % A description of each parameter follows: % % o image: Method ReadMACImage 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 *ReadMACImage(const ImageInfo *image_info,ExceptionInfo *exception) { Image *image; unsigned int y; unsigned char x8, rep, b; long ldblk; unsigned char *BImgBuff = NULL; unsigned char *DataPtr; unsigned int status; const PixelPacket *q; /* 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 MAC image. */ ldblk = ReadBlobLSBShort(image); if((ldblk & 0xFF)!=0) ThrowReaderException(CorruptImageError,ImproperImageHeader,image); if(ldblk==0) /* ???? don't know why */ SeekBlob(image,0x200,SEEK_SET); else SeekBlob(image,0x280,SEEK_SET); image->columns = 576; image->rows = 720; image->depth = 1; image->colors = 1l << image->depth; if (!AllocateImageColormap(image,image->colors)) goto NoMemory; /* If ping is true, then only set image size and colors without reading any image data. */ if (image_info->ping) goto DONE_READING; /* ----- Load RLE compressed raster ----- */ ldblk = (image->depth*image->columns) /8; BImgBuff = MagickAllocateMemory(unsigned char *, ((size_t)ldblk)); if(BImgBuff==NULL) NoMemory: ThrowReaderException(ResourceLimitError,MemoryAllocationFailed,image); DataPtr = BImgBuff; x8=0; y=0; while(y<image->rows) { rep = ReadBlobByte(image); if(EOFBlob(image)) break; if( rep>=128 || rep<=0) { b = ~ReadBlobByte(image);; rep = ~rep + 2; while(rep>0) { *DataPtr++ = b; x8++; rep--; if(x8>=ldblk) { x8=0; q = SetImagePixels(image,0,y,image->columns,1); if(q == (PixelPacket *)NULL) break; (void)ImportImagePixelArea(image,GrayQuantum,1,BImgBuff,NULL,0); if(!SyncImagePixels(image)) break; DataPtr = BImgBuff; y++; if(y>=image->rows) { break; } } } } else { rep++; while(rep>0) { b = ~ReadBlobByte(image); *DataPtr++ = b; x8++; rep--; if(x8>=ldblk) { x8=0; q = SetImagePixels(image,0,y,image->columns,1); if(q == (PixelPacket *)NULL) break; (void)ImportImagePixelArea(image,GrayQuantum,1,BImgBuff,NULL,0); if (!SyncImagePixels(image)) break; DataPtr = BImgBuff; y++; if(y>=image->rows) { break; } } } } } if(BImgBuff!=NULL) MagickFreeMemory(BImgBuff); if(EOFBlob(image)) ThrowException(exception,CorruptImageError,UnexpectedEndOfFile,image->filename); DONE_READING: CloseBlob(image); return(image); }
/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % 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); }