| /* |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % % |
| % % |
| % % |
| % PPPP CCCC L % |
| % P P C L % |
| % PPPP C L % |
| % P C L % |
| % P CCCC LLLLL % |
| % % |
| % % |
| % Read/Write HP PCL Printer Format % |
| % % |
| % Software Design % |
| % John Cristy % |
| % July 1992 % |
| % % |
| % % |
| % Copyright 1999-2011 ImageMagick Studio LLC, a non-profit organization % |
| % dedicated to making software imaging solutions freely available. % |
| % % |
| % You may not use this file except in compliance with the License. You may % |
| % obtain a copy of the License at % |
| % % |
| % http://www.imagemagick.org/script/license.php % |
| % % |
| % Unless required by applicable law or agreed to in writing, software % |
| % distributed under the License is distributed on an "AS IS" BASIS, % |
| % WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. % |
| % See the License for the specific language governing permissions and % |
| % limitations under the License. % |
| % % |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % |
| % |
| */ |
| |
| /* |
| Include declarations. |
| */ |
| #include "magick/studio.h" |
| #include "magick/property.h" |
| #include "magick/blob.h" |
| #include "magick/blob-private.h" |
| #include "magick/cache.h" |
| #include "magick/color.h" |
| #include "magick/color-private.h" |
| #include "magick/colorspace.h" |
| #include "magick/constitute.h" |
| #include "magick/delegate.h" |
| #include "magick/draw.h" |
| #include "magick/exception.h" |
| #include "magick/exception-private.h" |
| #include "magick/geometry.h" |
| #include "magick/image.h" |
| #include "magick/image-private.h" |
| #include "magick/list.h" |
| #include "magick/magick.h" |
| #include "magick/memory_.h" |
| #include "magick/monitor.h" |
| #include "magick/monitor-private.h" |
| #include "magick/option.h" |
| #include "magick/profile.h" |
| #include "magick/resource_.h" |
| #include "magick/quantum-private.h" |
| #include "magick/static.h" |
| #include "magick/string_.h" |
| #include "magick/module.h" |
| #include "magick/token.h" |
| #include "magick/transform.h" |
| #include "magick/utility.h" |
| |
| /* |
| Forward declarations. |
| */ |
| static MagickBooleanType |
| WritePCLImage(const ImageInfo *,Image *); |
| |
| /* |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % % |
| % % |
| % % |
| % I s P C L % |
| % % |
| % % |
| % % |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % |
| % IsPCL() returns MagickTrue if the image format type, identified by the |
| % magick string, is PCL. |
| % |
| % The format of the IsPCL method is: |
| % |
| % MagickBooleanType IsPCL(const unsigned char *magick,const size_t length) |
| % |
| % A description of each parameter follows: |
| % |
| % o magick: compare image format pattern against these bytes. |
| % |
| % o length: Specifies the length of the magick string. |
| % |
| */ |
| static MagickBooleanType IsPCL(const unsigned char *magick,const size_t length) |
| { |
| if (length < 4) |
| return(MagickFalse); |
| if (memcmp(magick,"\033E\033&",4) == 0) |
| return(MagickFalse); |
| if (memcmp(magick,"\033E\033",3) == 0) |
| return(MagickTrue); |
| return(MagickFalse); |
| } |
| |
| /* |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % % |
| % % |
| % % |
| % R e a d P C L I m a g e % |
| % % |
| % % |
| % % |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % |
| % ReadPCLImage() reads a Printer Control Language 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 ReadPCLImage method is: |
| % |
| % Image *ReadPCLImage(const ImageInfo *image_info,ExceptionInfo *exception) |
| % |
| % A description of each parameter follows: |
| % |
| % o image_info: the image info. |
| % |
| % o exception: return any errors or warnings in this structure. |
| % |
| */ |
| static Image *ReadPCLImage(const ImageInfo *image_info,ExceptionInfo *exception) |
| { |
| #define CropBox "CropBox" |
| #define DeviceCMYK "DeviceCMYK" |
| #define MediaBox "MediaBox" |
| #define RenderPCLText " Rendering PCL... " |
| |
| char |
| command[MaxTextExtent], |
| density[MaxTextExtent], |
| filename[MaxTextExtent], |
| geometry[MaxTextExtent], |
| options[MaxTextExtent], |
| input_filename[MaxTextExtent]; |
| |
| const DelegateInfo |
| *delegate_info; |
| |
| Image |
| *image, |
| *next_image; |
| |
| ImageInfo |
| *read_info; |
| |
| MagickBooleanType |
| cmyk, |
| status; |
| |
| PointInfo |
| delta; |
| |
| RectangleInfo |
| bounding_box, |
| page; |
| |
| register char |
| *p; |
| |
| register ssize_t |
| c; |
| |
| SegmentInfo |
| bounds; |
| |
| size_t |
| height, |
| width; |
| |
| ssize_t |
| count; |
| |
| assert(image_info != (const ImageInfo *) NULL); |
| assert(image_info->signature == MagickSignature); |
| if (image_info->debug != MagickFalse) |
| (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s", |
| image_info->filename); |
| assert(exception != (ExceptionInfo *) NULL); |
| assert(exception->signature == MagickSignature); |
| /* |
| Open image file. |
| */ |
| image=AcquireImage(image_info); |
| status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception); |
| if (status == MagickFalse) |
| { |
| image=DestroyImageList(image); |
| return((Image *) NULL); |
| } |
| status=AcquireUniqueSymbolicLink(image_info->filename,input_filename); |
| if (status == MagickFalse) |
| { |
| ThrowFileException(exception,FileOpenError,"UnableToCreateTemporaryFile", |
| image_info->filename); |
| image=DestroyImageList(image); |
| return((Image *) NULL); |
| } |
| /* |
| Set the page density. |
| */ |
| delta.x=DefaultResolution; |
| delta.y=DefaultResolution; |
| if ((image->x_resolution == 0.0) || (image->y_resolution == 0.0)) |
| { |
| GeometryInfo |
| geometry_info; |
| |
| MagickStatusType |
| flags; |
| |
| flags=ParseGeometry(PSDensityGeometry,&geometry_info); |
| image->x_resolution=geometry_info.rho; |
| image->y_resolution=geometry_info.sigma; |
| if ((flags & SigmaValue) == 0) |
| image->y_resolution=image->x_resolution; |
| } |
| /* |
| Determine page geometry from the PCL media box. |
| */ |
| cmyk=image->colorspace == CMYKColorspace ? MagickTrue : MagickFalse; |
| count=0; |
| (void) ResetMagickMemory(&bounding_box,0,sizeof(bounding_box)); |
| (void) ResetMagickMemory(&bounds,0,sizeof(bounds)); |
| (void) ResetMagickMemory(&page,0,sizeof(page)); |
| (void) ResetMagickMemory(command,0,sizeof(command)); |
| p=command; |
| for (c=ReadBlobByte(image); c != EOF; c=ReadBlobByte(image)) |
| { |
| if (image_info->page != (char *) NULL) |
| continue; |
| /* |
| Note PCL elements. |
| */ |
| *p++=(char) c; |
| if ((c != (int) '/') && (c != '\n') && |
| ((size_t) (p-command) < (MaxTextExtent-1))) |
| continue; |
| *p='\0'; |
| p=command; |
| /* |
| Is this a CMYK document? |
| */ |
| if (LocaleNCompare(DeviceCMYK,command,strlen(DeviceCMYK)) == 0) |
| cmyk=MagickTrue; |
| if (LocaleNCompare(CropBox,command,strlen(CropBox)) == 0) |
| { |
| /* |
| Note region defined by crop box. |
| */ |
| count=(ssize_t) sscanf(command,"CropBox [%lf %lf %lf %lf", |
| &bounds.x1,&bounds.y1,&bounds.x2,&bounds.y2); |
| if (count != 4) |
| count=(ssize_t) sscanf(command,"CropBox[%lf %lf %lf %lf", |
| &bounds.x1,&bounds.y1,&bounds.x2,&bounds.y2); |
| } |
| if (LocaleNCompare(MediaBox,command,strlen(MediaBox)) == 0) |
| { |
| /* |
| Note region defined by media box. |
| */ |
| count=(ssize_t) sscanf(command,"MediaBox [%lf %lf %lf %lf", |
| &bounds.x1,&bounds.y1,&bounds.x2,&bounds.y2); |
| if (count != 4) |
| count=(ssize_t) sscanf(command,"MediaBox[%lf %lf %lf %lf", |
| &bounds.x1,&bounds.y1,&bounds.x2,&bounds.y2); |
| } |
| if (count != 4) |
| continue; |
| /* |
| Set PCL render geometry. |
| */ |
| width=(size_t) floor(bounds.x2-bounds.x1+0.5); |
| height=(size_t) floor(bounds.y2-bounds.y1+0.5); |
| if (width > page.width) |
| page.width=width; |
| if (height > page.height) |
| page.height=height; |
| } |
| (void) CloseBlob(image); |
| /* |
| Render PCL with the GhostPCL delegate. |
| */ |
| if ((page.width == 0) || (page.height == 0)) |
| (void) ParseAbsoluteGeometry(PSPageGeometry,&page); |
| if (image_info->page != (char *) NULL) |
| (void) ParseAbsoluteGeometry(image_info->page,&page); |
| (void) FormatLocaleString(geometry,MaxTextExtent,"%.20gx%.20g",(double) |
| page.width,(double) page.height); |
| if (image_info->monochrome != MagickFalse) |
| delegate_info=GetDelegateInfo("pcl:mono",(char *) NULL,exception); |
| else |
| if (cmyk != MagickFalse) |
| delegate_info=GetDelegateInfo("pcl:cmyk",(char *) NULL,exception); |
| else |
| delegate_info=GetDelegateInfo("pcl:color",(char *) NULL,exception); |
| if (delegate_info == (const DelegateInfo *) NULL) |
| return((Image *) NULL); |
| *options='\0'; |
| if ((page.width == 0) || (page.height == 0)) |
| (void) ParseAbsoluteGeometry(PSPageGeometry,&page); |
| if (image_info->page != (char *) NULL) |
| (void) ParseAbsoluteGeometry(image_info->page,&page); |
| (void) FormatLocaleString(density,MaxTextExtent,"%gx%g", |
| image->x_resolution,image->y_resolution); |
| page.width=(size_t) floor(page.width*image->x_resolution/delta.x+0.5); |
| page.height=(size_t) floor(page.height*image->y_resolution/delta.y+ |
| 0.5); |
| (void) FormatLocaleString(options,MaxTextExtent,"-g%.20gx%.20g ",(double) |
| page.width,(double) page.height); |
| image=DestroyImage(image); |
| read_info=CloneImageInfo(image_info); |
| *read_info->magick='\0'; |
| if (read_info->number_scenes != 0) |
| { |
| if (read_info->number_scenes != 1) |
| (void) FormatLocaleString(options,MaxTextExtent,"-dLastPage=%.20g", |
| (double) (read_info->scene+read_info->number_scenes)); |
| else |
| (void) FormatLocaleString(options,MaxTextExtent, |
| "-dFirstPage=%.20g -dLastPage=%.20g",(double) read_info->scene+1, |
| (double) (read_info->scene+read_info->number_scenes)); |
| read_info->number_scenes=0; |
| if (read_info->scenes != (char *) NULL) |
| *read_info->scenes='\0'; |
| } |
| if (read_info->authenticate != (char *) NULL) |
| (void) FormatLocaleString(options+strlen(options),MaxTextExtent, |
| " -sPCLPassword=%s",read_info->authenticate); |
| (void) CopyMagickString(filename,read_info->filename,MaxTextExtent); |
| (void) AcquireUniqueFilename(read_info->filename); |
| (void) FormatLocaleString(command,MaxTextExtent, |
| GetDelegateCommands(delegate_info), |
| read_info->antialias != MagickFalse ? 4 : 1, |
| read_info->antialias != MagickFalse ? 4 : 1,density,options, |
| read_info->filename,input_filename); |
| status=SystemCommand(MagickFalse,read_info->verbose,command,exception) != 0 ? |
| MagickTrue : MagickFalse; |
| image=ReadImage(read_info,exception); |
| (void) RelinquishUniqueFileResource(read_info->filename); |
| (void) RelinquishUniqueFileResource(input_filename); |
| read_info=DestroyImageInfo(read_info); |
| if (image == (Image *) NULL) |
| ThrowReaderException(DelegateError,"PCLDelegateFailed"); |
| if (LocaleCompare(image->magick,"BMP") == 0) |
| { |
| Image |
| *cmyk_image; |
| |
| cmyk_image=ConsolidateCMYKImages(image,&image->exception); |
| if (cmyk_image != (Image *) NULL) |
| { |
| image=DestroyImageList(image); |
| image=cmyk_image; |
| } |
| } |
| do |
| { |
| (void) CopyMagickString(image->filename,filename,MaxTextExtent); |
| image->page=page; |
| next_image=SyncNextImageInList(image); |
| if (next_image != (Image *) NULL) |
| image=next_image; |
| } while (next_image != (Image *) NULL); |
| return(GetFirstImageInList(image)); |
| } |
| |
| /* |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % % |
| % % |
| % % |
| % R e g i s t e r P C L I m a g e % |
| % % |
| % % |
| % % |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % |
| % RegisterPCLImage() adds attributes for the PCL image format to |
| % the list of supported formats. The attributes include the image format |
| % tag, a method to read and/or write the format, whether the format |
| % supports the saving of more than one frame to the i file or blob, |
| % whether the format supports native in-memory I/O, and a brief |
| % description of the format. |
| % |
| % The format of the RegisterPCLImage method is: |
| % |
| % size_t RegisterPCLImage(void) |
| % |
| */ |
| ModuleExport size_t RegisterPCLImage(void) |
| { |
| MagickInfo |
| *entry; |
| |
| entry=SetMagickInfo("PCL"); |
| entry->decoder=(DecodeImageHandler *) ReadPCLImage; |
| entry->encoder=(EncodeImageHandler *) WritePCLImage; |
| entry->magick=(IsImageFormatHandler *) IsPCL; |
| entry->blob_support=MagickFalse; |
| entry->seekable_stream=MagickTrue; |
| entry->thread_support=EncoderThreadSupport; |
| entry->description=ConstantString("Printer Control Language"); |
| entry->module=ConstantString("PCL"); |
| (void) RegisterMagickInfo(entry); |
| return(MagickImageCoderSignature); |
| } |
| |
| /* |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % % |
| % % |
| % % |
| % U n r e g i s t e r P C L I m a g e % |
| % % |
| % % |
| % % |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % |
| % UnregisterPCLImage() removes format registrations made by the PCL module |
| % from the list of supported formats. |
| % |
| % The format of the UnregisterPCLImage method is: |
| % |
| % UnregisterPCLImage(void) |
| % |
| */ |
| ModuleExport void UnregisterPCLImage(void) |
| { |
| (void) UnregisterMagickInfo("PCL"); |
| } |
| |
| /* |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % % |
| % % |
| % % |
| % W r i t e P C L I m a g e % |
| % % |
| % % |
| % % |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| % |
| % WritePCLImage() writes an image in the Page Control Language encoded |
| % image format. |
| % |
| % The format of the WritePCLImage method is: |
| % |
| % MagickBooleanType WritePCLImage(const ImageInfo *image_info,Image *image) |
| % |
| % A description of each parameter follows. |
| % |
| % o image_info: the image info. |
| % |
| % o image: The image. |
| % |
| */ |
| |
| static size_t PCLDeltaCompressImage(const size_t length, |
| const unsigned char *previous_pixels,const unsigned char *pixels, |
| unsigned char *compress_pixels) |
| { |
| int |
| delta, |
| j, |
| replacement; |
| |
| register ssize_t |
| i, |
| x; |
| |
| register unsigned char |
| *q; |
| |
| q=compress_pixels; |
| for (x=0; x < (ssize_t) length; ) |
| { |
| j=0; |
| for (i=0; x < (ssize_t) length; x++) |
| { |
| if (*pixels++ != *previous_pixels++) |
| { |
| i=1; |
| break; |
| } |
| j++; |
| } |
| while (x < (ssize_t) length) |
| { |
| x++; |
| if (*pixels == *previous_pixels) |
| break; |
| i++; |
| previous_pixels++; |
| pixels++; |
| } |
| if (i == 0) |
| break; |
| replacement=j >= 31 ? 31 : j; |
| j-=replacement; |
| delta=i >= 8 ? 8 : i; |
| *q++=(unsigned char) (((delta-1) << 5) | replacement); |
| if (replacement == 31) |
| { |
| for (replacement=255; j != 0; ) |
| { |
| if (replacement > j) |
| replacement=j; |
| *q++=(unsigned char) replacement; |
| j-=replacement; |
| } |
| if (replacement == 255) |
| *q++='\0'; |
| } |
| for (pixels-=i; i != 0; ) |
| { |
| for (i-=delta; delta != 0; delta--) |
| *q++=(*pixels++); |
| if (i == 0) |
| break; |
| delta=i; |
| if (i >= 8) |
| delta=8; |
| *q++=(unsigned char) ((delta-1) << 5); |
| } |
| } |
| return((size_t) (q-compress_pixels)); |
| } |
| |
| static size_t PCLPackbitsCompressImage(const size_t length, |
| const unsigned char *pixels,unsigned char *compress_pixels) |
| { |
| int |
| count; |
| |
| register ssize_t |
| x; |
| |
| register unsigned char |
| *q; |
| |
| ssize_t |
| j; |
| |
| unsigned char |
| packbits[128]; |
| |
| /* |
| Compress pixels with Packbits encoding. |
| */ |
| q=compress_pixels; |
| for (x=(ssize_t) length; x != 0; ) |
| { |
| switch (x) |
| { |
| case 1: |
| { |
| x--; |
| *q++=0; |
| *q++=(*pixels); |
| break; |
| } |
| case 2: |
| { |
| x-=2; |
| *q++=1; |
| *q++=(*pixels); |
| *q++=pixels[1]; |
| break; |
| } |
| case 3: |
| { |
| x-=3; |
| if ((*pixels == *(pixels+1)) && (*(pixels+1) == *(pixels+2))) |
| { |
| *q++=(unsigned char) ((256-3)+1); |
| *q++=(*pixels); |
| break; |
| } |
| *q++=2; |
| *q++=(*pixels); |
| *q++=pixels[1]; |
| *q++=pixels[2]; |
| break; |
| } |
| default: |
| { |
| if ((*pixels == *(pixels+1)) && (*(pixels+1) == *(pixels+2))) |
| { |
| /* |
| Packed run. |
| */ |
| count=3; |
| while (((ssize_t) count < x) && (*pixels == *(pixels+count))) |
| { |
| count++; |
| if (count >= 127) |
| break; |
| } |
| x-=count; |
| *q++=(unsigned char) ((256-count)+1); |
| *q++=(*pixels); |
| pixels+=count; |
| break; |
| } |
| /* |
| Literal run. |
| */ |
| count=0; |
| while ((*(pixels+count) != *(pixels+count+1)) || |
| (*(pixels+count+1) != *(pixels+count+2))) |
| { |
| packbits[count+1]=pixels[count]; |
| count++; |
| if (((ssize_t) count >= (x-3)) || (count >= 127)) |
| break; |
| } |
| x-=count; |
| *packbits=(unsigned char) (count-1); |
| for (j=0; j <= (ssize_t) count; j++) |
| *q++=packbits[j]; |
| pixels+=count; |
| break; |
| } |
| } |
| } |
| *q++=128; /* EOD marker */ |
| return((size_t) (q-compress_pixels)); |
| } |
| |
| static MagickBooleanType WritePCLImage(const ImageInfo *image_info,Image *image) |
| { |
| char |
| buffer[MaxTextExtent]; |
| |
| const char |
| *option; |
| |
| MagickBooleanType |
| status; |
| |
| MagickOffsetType |
| scene; |
| |
| register const IndexPacket |
| *indexes; |
| |
| register const PixelPacket *p; register ssize_t i, x; register unsigned char *q; size_t density, length, |
| one, |
| packets; |
| |
| ssize_t |
| y; |
| |
| unsigned char |
| bits_per_pixel, |
| *compress_pixels, |
| *pixels, |
| *previous_pixels; |
| |
| /* |
| Open output image file. |
| */ |
| assert(image_info != (const ImageInfo *) NULL); |
| assert(image_info->signature == MagickSignature); |
| assert(image != (Image *) NULL); |
| assert(image->signature == MagickSignature); |
| if (image->debug != MagickFalse) |
| (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename); |
| status=OpenBlob(image_info,image,WriteBinaryBlobMode,&image->exception); |
| if (status == MagickFalse) |
| return(status); |
| density=75; |
| if (image_info->density != (char *) NULL) |
| { |
| GeometryInfo |
| geometry; |
| |
| (void) ParseGeometry(image_info->density,&geometry); |
| density=(size_t) geometry.rho; |
| } |
| scene=0; |
| one=1; |
| do |
| { |
| if (image->colorspace != RGBColorspace) |
| (void) TransformImageColorspace(image,RGBColorspace); |
| /* |
| Initialize the printer. |
| */ |
| (void) WriteBlobString(image,"\033E"); /* printer reset */ |
| (void) WriteBlobString(image,"\033*r3F"); /* set presentation mode */ |
| (void) FormatLocaleString(buffer,MaxTextExtent,"\033*r%.20gs%.20gT", |
| (double) image->columns,(double) image->rows); |
| (void) WriteBlobString(image,buffer); |
| (void) FormatLocaleString(buffer,MaxTextExtent,"\033*t%.20gR",(double) |
| density); |
| (void) WriteBlobString(image,buffer); |
| (void) WriteBlobString(image,"\033&l0E"); /* top margin 0 */ |
| if (IsMonochromeImage(image,&image->exception) != MagickFalse) |
| { |
| /* |
| Monochrome image: use default printer monochrome setup. |
| */ |
| bits_per_pixel=1; |
| } |
| else |
| if (image->storage_class == DirectClass) |
| { |
| /* |
| DirectClass image. |
| */ |
| bits_per_pixel=24; |
| (void) WriteBlobString(image,"\033*v6W"); /* set color mode */ |
| (void) WriteBlobByte(image,0); /* RGB */ |
| (void) WriteBlobByte(image,3); /* direct by pixel */ |
| (void) WriteBlobByte(image,0); /* bits per index (ignored) */ |
| (void) WriteBlobByte(image,8); /* bits per red component */ |
| (void) WriteBlobByte(image,8); /* bits per green component */ |
| (void) WriteBlobByte(image,8); /* bits per blue component */ |
| } |
| else |
| { |
| /* |
| Colormapped image. |
| */ |
| bits_per_pixel=8; |
| (void) WriteBlobString(image,"\033*v6W"); /* set color mode... */ |
| (void) WriteBlobByte(image,0); /* RGB */ |
| (void) WriteBlobByte(image,1); /* indexed by pixel */ |
| (void) WriteBlobByte(image,bits_per_pixel); /* bits per index */ |
| (void) WriteBlobByte(image,8); /* bits per red component */ |
| (void) WriteBlobByte(image,8); /* bits per green component */ |
| (void) WriteBlobByte(image,8); /* bits per blue component */ |
| for (i=0; i < (ssize_t) image->colors; i++) |
| { |
| (void) FormatLocaleString(buffer,MaxTextExtent, |
| "\033*v%da%db%dc%.20gI", |
| ScaleQuantumToChar(image->colormap[i].red), |
| ScaleQuantumToChar(image->colormap[i].green), |
| ScaleQuantumToChar(image->colormap[i].blue),(double) i); |
| (void) WriteBlobString(image,buffer); |
| } |
| for (one=1; i < (ssize_t) (one << bits_per_pixel); i++) |
| { |
| (void) FormatLocaleString(buffer,MaxTextExtent,"\033*v%.20gI", |
| (double) i); |
| (void) WriteBlobString(image,buffer); |
| } |
| } |
| option=GetImageOption(image_info,"pcl:fit-to-page"); |
| if ((option != (const char *) NULL) && |
| (IsMagickTrue(option) != MagickFalse)) |
| (void) WriteBlobString(image,"\033*r3A"); |
| else |
| (void) WriteBlobString(image,"\033*r1A"); /* start raster graphics */ |
| (void) WriteBlobString(image,"\033*b0Y"); /* set y offset */ |
| length=(image->columns*bits_per_pixel+7)/8; |
| pixels=(unsigned char *) AcquireQuantumMemory(length+1,sizeof(*pixels)); |
| if (pixels == (unsigned char *) NULL) |
| ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed"); |
| (void) ResetMagickMemory(pixels,0,(length+1)*sizeof(*pixels)); |
| compress_pixels=(unsigned char *) NULL; |
| previous_pixels=(unsigned char *) NULL; |
| switch (image->compression) |
| { |
| case NoCompression: |
| { |
| (void) FormatLocaleString(buffer,MaxTextExtent,"\033*b0M"); |
| (void) WriteBlobString(image,buffer); |
| break; |
| } |
| case RLECompression: |
| { |
| compress_pixels=(unsigned char *) AcquireQuantumMemory(length+256, |
| sizeof(*compress_pixels)); |
| if (compress_pixels == (unsigned char *) NULL) |
| { |
| pixels=(unsigned char *) RelinquishMagickMemory(pixels); |
| ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed"); |
| } |
| (void) ResetMagickMemory(compress_pixels,0,(length+256)* |
| sizeof(*compress_pixels)); |
| (void) FormatLocaleString(buffer,MaxTextExtent,"\033*b2M"); |
| (void) WriteBlobString(image,buffer); |
| break; |
| } |
| default: |
| { |
| compress_pixels=(unsigned char *) AcquireQuantumMemory(3*length+256, |
| sizeof(*compress_pixels)); |
| if (compress_pixels == (unsigned char *) NULL) |
| { |
| pixels=(unsigned char *) RelinquishMagickMemory(pixels); |
| ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed"); |
| } |
| (void) ResetMagickMemory(compress_pixels,0,(3*length+256)* |
| sizeof(*compress_pixels)); |
| previous_pixels=(unsigned char *) AcquireQuantumMemory(length+1, |
| sizeof(*previous_pixels)); |
| if (previous_pixels == (unsigned char *) NULL) |
| { |
| compress_pixels=(unsigned char *) RelinquishMagickMemory( |
| compress_pixels); |
| pixels=(unsigned char *) RelinquishMagickMemory(pixels); |
| ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed"); |
| } |
| (void) ResetMagickMemory(previous_pixels,0,(length+1)* |
| sizeof(*previous_pixels)); |
| (void) FormatLocaleString(buffer,MaxTextExtent,"\033*b3M"); |
| (void) WriteBlobString(image,buffer); |
| break; |
| } |
| } |
| for (y=0; y < (ssize_t) image->rows; y++) |
| { |
| p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception); |
| if (p == (const PixelPacket *) NULL) |
| break; |
| indexes=GetAuthenticIndexQueue(image); |
| q=pixels; |
| switch (bits_per_pixel) |
| { |
| case 1: |
| { |
| register unsigned char |
| bit, |
| byte; |
| |
| /* |
| Monochrome image. |
| */ |
| bit=0; |
| byte=0; |
| for (x=0; x < (ssize_t) image->columns; x++) |
| { |
| byte<<=1; |
| if (PixelIntensity(p) < ((MagickRealType) QuantumRange/2.0)) |
| byte|=0x01; |
| bit++; |
| if (bit == 8) |
| { |
| *q++=byte; |
| bit=0; |
| byte=0; |
| } |
| p++; |
| } |
| if (bit != 0) |
| *q++=byte << (8-bit); |
| break; |
| } |
| case 8: |
| { |
| /* |
| Colormapped image. |
| */ |
| for (x=0; x < (ssize_t) image->columns; x++) |
| *q++=(unsigned char) GetIndexPixelComponent(indexes+x); |
| break; |
| } |
| case 24: |
| case 32: |
| { |
| /* |
| Truecolor image. |
| */ |
| for (x=0; x < (ssize_t) image->columns; x++) |
| { |
| *q++=ScaleQuantumToChar(GetRedPixelComponent(p)); |
| *q++=ScaleQuantumToChar(GetGreenPixelComponent(p)); |
| *q++=ScaleQuantumToChar(GetBluePixelComponent(p)); |
| p++; |
| } |
| break; |
| } |
| } |
| switch (image->compression) |
| { |
| case NoCompression: |
| { |
| (void) FormatLocaleString(buffer,MaxTextExtent,"\033*b%.20gW", |
| (double) length); |
| (void) WriteBlobString(image,buffer); |
| (void) WriteBlob(image,length,pixels); |
| break; |
| } |
| case RLECompression: |
| { |
| packets=PCLPackbitsCompressImage(length,pixels,compress_pixels); |
| (void) FormatLocaleString(buffer,MaxTextExtent,"\033*b%.20gW", |
| (double) packets); |
| (void) WriteBlobString(image,buffer); |
| (void) WriteBlob(image,packets,compress_pixels); |
| break; |
| } |
| default: |
| { |
| if (y == 0) |
| for (i=0; i < (ssize_t) length; i++) |
| previous_pixels[i]=(~pixels[i]); |
| packets=PCLDeltaCompressImage(length,previous_pixels,pixels, |
| compress_pixels); |
| (void) FormatLocaleString(buffer,MaxTextExtent,"\033*b%.20gW", |
| (double) packets); |
| (void) WriteBlobString(image,buffer); |
| (void) WriteBlob(image,packets,compress_pixels); |
| (void) CopyMagickMemory(previous_pixels,pixels,length* |
| sizeof(*pixels)); |
| break; |
| } |
| } |
| } |
| (void) WriteBlobString(image,"\033*rB"); /* end graphics */ |
| switch (image->compression) |
| { |
| case NoCompression: |
| break; |
| case RLECompression: |
| { |
| compress_pixels=(unsigned char *) RelinquishMagickMemory( |
| compress_pixels); |
| break; |
| } |
| default: |
| { |
| previous_pixels=(unsigned char *) RelinquishMagickMemory( |
| previous_pixels); |
| compress_pixels=(unsigned char *) RelinquishMagickMemory( |
| compress_pixels); |
| break; |
| } |
| } |
| pixels=(unsigned char *) RelinquishMagickMemory(pixels); |
| if (GetNextImageInList(image) == (Image *) NULL) |
| break; |
| image=SyncNextImageInList(image); |
| status=SetImageProgress(image,SaveImagesTag,scene++, |
| GetImageListLength(image)); |
| if (status == MagickFalse) |
| break; |
| } while (image_info->adjoin != MagickFalse); |
| (void) WriteBlobString(image,"\033E"); |
| (void) CloseBlob(image); |
| return(MagickTrue); |
| } |