granicus.if.org Git - imagemagick/blob - coders/pcl.c

   1 /*
   2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
   3 %                                                                             %
   4 %                                                                             %
   5 %                                                                             %
   6 %                            PPPP    CCCC  L                                  %
   7 %                            P   P  C      L                                  %
   8 %                            PPPP   C      L                                  %
   9 %                            P      C      L                                  %
  10 %                            P       CCCC  LLLLL                              %
  11 %                                                                             %
  12 %                                                                             %
  13 %                      Read/Write HP PCL Printer Format                       %
  14 %                                                                             %
  15 %                              Software Design                                %
  16 %                                John Cristy                                  %
  17 %                                 July 1992                                   %
  18 %                                                                             %
  19 %                                                                             %
  20 %  Copyright 1999-2011 ImageMagick Studio LLC, a non-profit organization      %
  21 %  dedicated to making software imaging solutions freely available.           %
  22 %                                                                             %
  23 %  You may not use this file except in compliance with the License.  You may  %
  24 %  obtain a copy of the License at                                            %
  25 %                                                                             %
  26 %    http://www.imagemagick.org/script/license.php                            %
  27 %                                                                             %
  28 %  Unless required by applicable law or agreed to in writing, software        %
  29 %  distributed under the License is distributed on an "AS IS" BASIS,          %
  30 %  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   %
  31 %  See the License for the specific language governing permissions and        %
  32 %  limitations under the License.                                             %
  33 %                                                                             %
  34 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  35 %
  36 %
  37 */
  38 \f
  39 /*
  40   Include declarations.
  41 */
  42 #include "magick/studio.h"
  43 #include "magick/property.h"
  44 #include "magick/blob.h"
  45 #include "magick/blob-private.h"
  46 #include "magick/cache.h"
  47 #include "magick/color.h"
  48 #include "magick/color-private.h"
  49 #include "magick/colorspace.h"
  50 #include "magick/constitute.h"
  51 #include "magick/delegate.h"
  52 #include "magick/draw.h"
  53 #include "magick/exception.h"
  54 #include "magick/exception-private.h"
  55 #include "magick/geometry.h"
  56 #include "magick/image.h"
  57 #include "magick/image-private.h"
  58 #include "magick/list.h"
  59 #include "magick/magick.h"
  60 #include "magick/memory_.h"
  61 #include "magick/monitor.h"
  62 #include "magick/monitor-private.h"
  63 #include "magick/option.h"
  64 #include "magick/profile.h"
  65 #include "magick/resource_.h"
  66 #include "magick/quantum-private.h"
  67 #include "magick/static.h"
  68 #include "magick/string_.h"
  69 #include "magick/module.h"
  70 #include "magick/token.h"
  71 #include "magick/transform.h"
  72 #include "magick/utility.h"
  73 \f
  74 /*
  75   Forward declarations.
  76 */
  77 static MagickBooleanType
  78   WritePCLImage(const ImageInfo *,Image *);
  79 \f
  80 /*
  81 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  82 %                                                                             %
  83 %                                                                             %
  84 %                                                                             %
  85 %   I s P C L                                                                 %
  86 %                                                                             %
  87 %                                                                             %
  88 %                                                                             %
  89 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  90 %
  91 %  IsPCL() returns MagickTrue if the image format type, identified by the
  92 %  magick string, is PCL.
  93 %
  94 %  The format of the IsPCL method is:
  95 %
  96 %      MagickBooleanType IsPCL(const unsigned char *magick,const size_t length)
  97 %
  98 %  A description of each parameter follows:
  99 %
 100 %    o magick: compare image format pattern against these bytes.
 101 %
 102 %    o length: Specifies the length of the magick string.
 103 %
 104 */
 105 static MagickBooleanType IsPCL(const unsigned char *magick,const size_t length)
 106 {
 107   if (length < 4)
 108     return(MagickFalse);
 109   if (memcmp(magick,"\033E\033&",4) == 0)
 110     return(MagickFalse);
 111   if (memcmp(magick,"\033E\033",3) == 0)
 112     return(MagickTrue);
 113   return(MagickFalse);
 114 }
 115 \f
 116 /*
 117 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 118 %                                                                             %
 119 %                                                                             %
 120 %                                                                             %
 121 %   R e a d P C L I m a g e                                                   %
 122 %                                                                             %
 123 %                                                                             %
 124 %                                                                             %
 125 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 126 %
 127 %  ReadPCLImage() reads a Printer Control Language image file and returns it.
 128 %  It allocates the memory necessary for the new Image structure and returns a
 129 %  pointer to the new image.
 130 %
 131 %  The format of the ReadPCLImage method is:
 132 %
 133 %      Image *ReadPCLImage(const ImageInfo *image_info,ExceptionInfo *exception)
 134 %
 135 %  A description of each parameter follows:
 136 %
 137 %    o image_info: the image info.
 138 %
 139 %    o exception: return any errors or warnings in this structure.
 140 %
 141 */
 142 static Image *ReadPCLImage(const ImageInfo *image_info,ExceptionInfo *exception)
 143 {
 144 #define CropBox  "CropBox"
 145 #define DeviceCMYK  "DeviceCMYK"
 146 #define MediaBox  "MediaBox"
 147 #define RenderPCLText  "  Rendering PCL...  "
 148
 149   char
 150     command[MaxTextExtent],
 151     density[MaxTextExtent],
 152     filename[MaxTextExtent],
 153     geometry[MaxTextExtent],
 154     options[MaxTextExtent],
 155     input_filename[MaxTextExtent];
 156
 157   const DelegateInfo
 158     *delegate_info;
 159
 160   Image
 161     *image,
 162     *next_image;
 163
 164   ImageInfo
 165     *read_info;
 166
 167   MagickBooleanType
 168     cmyk,
 169     status;
 170
 171   PointInfo
 172     delta;
 173
 174   RectangleInfo
 175     bounding_box,
 176     page;
 177
 178   register char
 179     *p;
 180
 181   register ssize_t
 182     c;
 183
 184   SegmentInfo
 185     bounds;
 186
 187   size_t
 188     height,
 189     width;
 190
 191   ssize_t
 192     count;
 193
 194   assert(image_info != (const ImageInfo *) NULL);
 195   assert(image_info->signature == MagickSignature);
 196   if (image_info->debug != MagickFalse)
 197     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
 198       image_info->filename);
 199   assert(exception != (ExceptionInfo *) NULL);
 200   assert(exception->signature == MagickSignature);
 201   /*
 202     Open image file.
 203   */
 204   image=AcquireImage(image_info);
 205   status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
 206   if (status == MagickFalse)
 207     {
 208       image=DestroyImageList(image);
 209       return((Image *) NULL);
 210     }
 211   status=AcquireUniqueSymbolicLink(image_info->filename,input_filename);
 212   if (status == MagickFalse)
 213     {
 214       ThrowFileException(exception,FileOpenError,"UnableToCreateTemporaryFile",
 215         image_info->filename);
 216       image=DestroyImageList(image);
 217       return((Image *) NULL);
 218     }
 219   /*
 220     Set the page density.
 221   */
 222   delta.x=DefaultResolution;
 223   delta.y=DefaultResolution;
 224   if ((image->x_resolution == 0.0) || (image->y_resolution == 0.0))
 225     {
 226       GeometryInfo
 227         geometry_info;
 228
 229       MagickStatusType
 230         flags;
 231
 232       flags=ParseGeometry(PSDensityGeometry,&geometry_info);
 233       image->x_resolution=geometry_info.rho;
 234       image->y_resolution=geometry_info.sigma;
 235       if ((flags & SigmaValue) == 0)
 236         image->y_resolution=image->x_resolution;
 237     }
 238   /*
 239     Determine page geometry from the PCL media box.
 240   */
 241   cmyk=image->colorspace == CMYKColorspace ? MagickTrue : MagickFalse;
 242   count=0;
 243   (void) ResetMagickMemory(&bounding_box,0,sizeof(bounding_box));
 244   (void) ResetMagickMemory(&bounds,0,sizeof(bounds));
 245   (void) ResetMagickMemory(&page,0,sizeof(page));
 246   (void) ResetMagickMemory(command,0,sizeof(command));
 247   p=command;
 248   for (c=ReadBlobByte(image); c != EOF; c=ReadBlobByte(image))
 249   {
 250     if (image_info->page != (char *) NULL)
 251       continue;
 252     /*
 253       Note PCL elements.
 254     */
 255     *p++=(char) c;
 256     if ((c != (int) '/') && (c != '\n') &&
 257         ((size_t) (p-command) < (MaxTextExtent-1)))
 258       continue;
 259     *p='\0';
 260     p=command;
 261     /*
 262       Is this a CMYK document?
 263     */
 264     if (LocaleNCompare(DeviceCMYK,command,strlen(DeviceCMYK)) == 0)
 265       cmyk=MagickTrue;
 266     if (LocaleNCompare(CropBox,command,strlen(CropBox)) == 0)
 267       {
 268         /*
 269           Note region defined by crop box.
 270         */
 271         count=(ssize_t) sscanf(command,"CropBox [%lf %lf %lf %lf",
 272           &bounds.x1,&bounds.y1,&bounds.x2,&bounds.y2);
 273         if (count != 4)
 274           count=(ssize_t) sscanf(command,"CropBox[%lf %lf %lf %lf",
 275             &bounds.x1,&bounds.y1,&bounds.x2,&bounds.y2);
 276       }
 277     if (LocaleNCompare(MediaBox,command,strlen(MediaBox)) == 0)
 278       {
 279         /*
 280           Note region defined by media box.
 281         */
 282         count=(ssize_t) sscanf(command,"MediaBox [%lf %lf %lf %lf",
 283           &bounds.x1,&bounds.y1,&bounds.x2,&bounds.y2);
 284         if (count != 4)
 285           count=(ssize_t) sscanf(command,"MediaBox[%lf %lf %lf %lf",
 286             &bounds.x1,&bounds.y1,&bounds.x2,&bounds.y2);
 287       }
 288     if (count != 4)
 289       continue;
 290     /*
 291       Set PCL render geometry.
 292     */
 293     width=(size_t) floor(bounds.x2-bounds.x1+0.5);
 294     height=(size_t) floor(bounds.y2-bounds.y1+0.5);
 295     if (width > page.width)
 296       page.width=width;
 297     if (height > page.height)
 298       page.height=height;
 299   }
 300   (void) CloseBlob(image);
 301   /*
 302     Render PCL with the GhostPCL delegate.
 303   */
 304   if ((page.width == 0) || (page.height == 0))
 305     (void) ParseAbsoluteGeometry(PSPageGeometry,&page);
 306   if (image_info->page != (char *) NULL)
 307     (void) ParseAbsoluteGeometry(image_info->page,&page);
 308   (void) FormatLocaleString(geometry,MaxTextExtent,"%.20gx%.20g",(double)
 309     page.width,(double) page.height);
 310   if (image_info->monochrome != MagickFalse)
 311     delegate_info=GetDelegateInfo("pcl:mono",(char *) NULL,exception);
 312   else
 313      if (cmyk != MagickFalse)
 314        delegate_info=GetDelegateInfo("pcl:cmyk",(char *) NULL,exception);
 315      else
 316        delegate_info=GetDelegateInfo("pcl:color",(char *) NULL,exception);
 317   if (delegate_info == (const DelegateInfo *) NULL)
 318     return((Image *) NULL);
 319   *options='\0';
 320   if ((page.width == 0) || (page.height == 0))
 321     (void) ParseAbsoluteGeometry(PSPageGeometry,&page);
 322   if (image_info->page != (char *) NULL)
 323     (void) ParseAbsoluteGeometry(image_info->page,&page);
 324   (void) FormatLocaleString(density,MaxTextExtent,"%gx%g",
 325     image->x_resolution,image->y_resolution);
 326   page.width=(size_t) floor(page.width*image->x_resolution/delta.x+0.5);
 327   page.height=(size_t) floor(page.height*image->y_resolution/delta.y+
 328     0.5);
 329   (void) FormatLocaleString(options,MaxTextExtent,"-g%.20gx%.20g ",(double)
 330      page.width,(double) page.height);
 331   image=DestroyImage(image);
 332   read_info=CloneImageInfo(image_info);
 333   *read_info->magick='\0';
 334   if (read_info->number_scenes != 0)
 335     {
 336       if (read_info->number_scenes != 1)
 337         (void) FormatLocaleString(options,MaxTextExtent,"-dLastPage=%.20g",
 338           (double) (read_info->scene+read_info->number_scenes));
 339       else
 340         (void) FormatLocaleString(options,MaxTextExtent,
 341           "-dFirstPage=%.20g -dLastPage=%.20g",(double) read_info->scene+1,
 342           (double) (read_info->scene+read_info->number_scenes));
 343       read_info->number_scenes=0;
 344       if (read_info->scenes != (char *) NULL)
 345         *read_info->scenes='\0';
 346     }
 347   if (read_info->authenticate != (char *) NULL)
 348     (void) FormatLocaleString(options+strlen(options),MaxTextExtent,
 349       " -sPCLPassword=%s",read_info->authenticate);
 350   (void) CopyMagickString(filename,read_info->filename,MaxTextExtent);
 351   (void) AcquireUniqueFilename(read_info->filename);
 352   (void) FormatLocaleString(command,MaxTextExtent,
 353     GetDelegateCommands(delegate_info),
 354     read_info->antialias != MagickFalse ? 4 : 1,
 355     read_info->antialias != MagickFalse ? 4 : 1,density,options,
 356     read_info->filename,input_filename);
 357   status=SystemCommand(MagickFalse,read_info->verbose,command,exception) != 0 ?
 358     MagickTrue : MagickFalse;
 359   image=ReadImage(read_info,exception);
 360   (void) RelinquishUniqueFileResource(read_info->filename);
 361   (void) RelinquishUniqueFileResource(input_filename);
 362   read_info=DestroyImageInfo(read_info);
 363   if (image == (Image *) NULL)
 364     ThrowReaderException(DelegateError,"PCLDelegateFailed");
 365   if (LocaleCompare(image->magick,"BMP") == 0)
 366     {
 367       Image
 368         *cmyk_image;
 369
 370       cmyk_image=ConsolidateCMYKImages(image,&image->exception);
 371       if (cmyk_image != (Image *) NULL)
 372         {
 373           image=DestroyImageList(image);
 374           image=cmyk_image;
 375         }
 376     }
 377   do
 378   {
 379     (void) CopyMagickString(image->filename,filename,MaxTextExtent);
 380     image->page=page;
 381     next_image=SyncNextImageInList(image);
 382     if (next_image != (Image *) NULL)
 383       image=next_image;
 384   } while (next_image != (Image *) NULL);
 385   return(GetFirstImageInList(image));
 386 }
 387 \f
 388 /*
 389 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 390 %                                                                             %
 391 %                                                                             %
 392 %                                                                             %
 393 %   R e g i s t e r P C L I m a g e                                           %
 394 %                                                                             %
 395 %                                                                             %
 396 %                                                                             %
 397 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 398 %
 399 %  RegisterPCLImage() adds attributes for the PCL image format to
 400 %  the list of supported formats.  The attributes include the image format
 401 %  tag, a method to read and/or write the format, whether the format
 402 %  supports the saving of more than one frame to the i file or blob,
 403 %  whether the format supports native in-memory I/O, and a brief
 404 %  description of the format.
 405 %
 406 %  The format of the RegisterPCLImage method is:
 407 %
 408 %      size_t RegisterPCLImage(void)
 409 %
 410 */
 411 ModuleExport size_t RegisterPCLImage(void)
 412 {
 413   MagickInfo
 414     *entry;
 415
 416   entry=SetMagickInfo("PCL");
 417   entry->decoder=(DecodeImageHandler *) ReadPCLImage;
 418   entry->encoder=(EncodeImageHandler *) WritePCLImage;
 419   entry->magick=(IsImageFormatHandler *) IsPCL;
 420   entry->blob_support=MagickFalse;
 421   entry->seekable_stream=MagickTrue;
 422   entry->thread_support=EncoderThreadSupport;
 423   entry->description=ConstantString("Printer Control Language");
 424   entry->module=ConstantString("PCL");
 425   (void) RegisterMagickInfo(entry);
 426   return(MagickImageCoderSignature);
 427 }
 428 \f
 429 /*
 430 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 431 %                                                                             %
 432 %                                                                             %
 433 %                                                                             %
 434 %   U n r e g i s t e r P C L I m a g e                                       %
 435 %                                                                             %
 436 %                                                                             %
 437 %                                                                             %
 438 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 439 %
 440 %  UnregisterPCLImage() removes format registrations made by the PCL module
 441 %  from the list of supported formats.
 442 %
 443 %  The format of the UnregisterPCLImage method is:
 444 %
 445 %      UnregisterPCLImage(void)
 446 %
 447 */
 448 ModuleExport void UnregisterPCLImage(void)
 449 {
 450   (void) UnregisterMagickInfo("PCL");
 451 }
 452 \f
 453 /*
 454 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 455 %                                                                             %
 456 %                                                                             %
 457 %                                                                             %
 458 %   W r i t e P C L I m a g e                                                 %
 459 %                                                                             %
 460 %                                                                             %
 461 %                                                                             %
 462 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 463 %
 464 %  WritePCLImage() writes an image in the Page Control Language encoded
 465 %  image format.
 466 %
 467 %  The format of the WritePCLImage method is:
 468 %
 469 %      MagickBooleanType WritePCLImage(const ImageInfo *image_info,Image *image)
 470 %
 471 %  A description of each parameter follows.
 472 %
 473 %    o image_info: the image info.
 474 %
 475 %    o image:  The image.
 476 %
 477 */
 478
 479 static size_t PCLDeltaCompressImage(const size_t length,
 480   const unsigned char *previous_pixels,const unsigned char *pixels,
 481   unsigned char *compress_pixels)
 482 {
 483   int
 484     delta,
 485     j,
 486     replacement;
 487
 488   register ssize_t
 489     i,
 490     x;
 491
 492   register unsigned char
 493     *q;
 494
 495   q=compress_pixels;
 496   for (x=0; x < (ssize_t) length; )
 497   {
 498     j=0;
 499     for (i=0; x < (ssize_t) length; x++)
 500     {
 501       if (*pixels++ != *previous_pixels++)
 502         {
 503           i=1;
 504           break;
 505         }
 506       j++;
 507     }
 508     while (x < (ssize_t) length)
 509     {
 510       x++;
 511       if (*pixels == *previous_pixels)
 512         break;
 513       i++;
 514       previous_pixels++;
 515       pixels++;
 516     }
 517     if (i == 0)
 518       break;
 519     replacement=j >= 31 ? 31 : j;
 520     j-=replacement;
 521     delta=i >= 8 ? 8 : i;
 522     *q++=(unsigned char) (((delta-1) << 5) | replacement);
 523     if (replacement == 31)
 524       {
 525         for (replacement=255; j != 0; )
 526         {
 527           if (replacement > j)
 528             replacement=j;
 529           *q++=(unsigned char) replacement;
 530           j-=replacement;
 531         }
 532         if (replacement == 255)
 533           *q++='\0';
 534       }
 535     for (pixels-=i; i != 0; )
 536     {
 537       for (i-=delta; delta != 0; delta--)
 538         *q++=(*pixels++);
 539       if (i == 0)
 540         break;
 541       delta=i;
 542       if (i >= 8)
 543         delta=8;
 544       *q++=(unsigned char) ((delta-1) << 5);
 545     }
 546   }
 547   return((size_t) (q-compress_pixels));
 548 }
 549
 550 static size_t PCLPackbitsCompressImage(const size_t length,
 551   const unsigned char *pixels,unsigned char *compress_pixels)
 552 {
 553   int
 554     count;
 555
 556   register ssize_t
 557     x;
 558
 559   register unsigned char
 560     *q;
 561
 562   ssize_t
 563     j;
 564
 565   unsigned char
 566     packbits[128];
 567
 568   /*
 569     Compress pixels with Packbits encoding.
 570   */
 571   q=compress_pixels;
 572   for (x=(ssize_t) length; x != 0; )
 573   {
 574     switch (x)
 575     {
 576       case 1:
 577       {
 578         x--;
 579         *q++=0;
 580         *q++=(*pixels);
 581         break;
 582       }
 583       case 2:
 584       {
 585         x-=2;
 586         *q++=1;
 587         *q++=(*pixels);
 588         *q++=pixels[1];
 589         break;
 590       }
 591       case 3:
 592       {
 593         x-=3;
 594         if ((*pixels == *(pixels+1)) && (*(pixels+1) == *(pixels+2)))
 595           {
 596             *q++=(unsigned char) ((256-3)+1);
 597             *q++=(*pixels);
 598             break;
 599           }
 600         *q++=2;
 601         *q++=(*pixels);
 602         *q++=pixels[1];
 603         *q++=pixels[2];
 604         break;
 605       }
 606       default:
 607       {
 608         if ((*pixels == *(pixels+1)) && (*(pixels+1) == *(pixels+2)))
 609           {
 610             /*
 611               Packed run.
 612             */
 613             count=3;
 614             while (((ssize_t) count < x) && (*pixels == *(pixels+count)))
 615             {
 616               count++;
 617               if (count >= 127)
 618                 break;
 619             }
 620             x-=count;
 621             *q++=(unsigned char) ((256-count)+1);
 622             *q++=(*pixels);
 623             pixels+=count;
 624             break;
 625           }
 626         /*
 627           Literal run.
 628         */
 629         count=0;
 630         while ((*(pixels+count) != *(pixels+count+1)) ||
 631                (*(pixels+count+1) != *(pixels+count+2)))
 632         {
 633           packbits[count+1]=pixels[count];
 634           count++;
 635           if (((ssize_t) count >= (x-3)) || (count >= 127))
 636             break;
 637         }
 638         x-=count;
 639         *packbits=(unsigned char) (count-1);
 640         for (j=0; j <= (ssize_t) count; j++)
 641           *q++=packbits[j];
 642         pixels+=count;
 643         break;
 644       }
 645     }
 646   }
 647   *q++=128; /* EOD marker */
 648   return((size_t) (q-compress_pixels));
 649 }
 650
 651 static MagickBooleanType WritePCLImage(const ImageInfo *image_info,Image *image)
 652 {
 653   char
 654     buffer[MaxTextExtent];
 655
 656   const char
 657     *option;
 658
 659   MagickBooleanType
 660     status;
 661
 662   MagickOffsetType
 663     scene;
 664
 665   register const IndexPacket
 666     *indexes;
 667
 668   register const PixelPacket *p; register ssize_t i, x; register unsigned char *q; size_t density, length,
 669     one,
 670     packets;
 671
 672   ssize_t
 673     y;
 674
 675   unsigned char
 676     bits_per_pixel,
 677     *compress_pixels,
 678     *pixels,
 679     *previous_pixels;
 680
 681   /*
 682     Open output image file.
 683   */
 684   assert(image_info != (const ImageInfo *) NULL);
 685   assert(image_info->signature == MagickSignature);
 686   assert(image != (Image *) NULL);
 687   assert(image->signature == MagickSignature);
 688   if (image->debug != MagickFalse)
 689     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
 690   status=OpenBlob(image_info,image,WriteBinaryBlobMode,&image->exception);
 691   if (status == MagickFalse)
 692     return(status);
 693   density=75;
 694   if (image_info->density != (char *) NULL)
 695     {
 696       GeometryInfo
 697         geometry;
 698
 699       (void) ParseGeometry(image_info->density,&geometry);
 700       density=(size_t) geometry.rho;
 701     }
 702   scene=0;
 703   one=1;
 704   do
 705   {
 706     if (image->colorspace != RGBColorspace)
 707       (void) TransformImageColorspace(image,RGBColorspace);
 708     /*
 709       Initialize the printer.
 710     */
 711     (void) WriteBlobString(image,"\033E");  /* printer reset */
 712     (void) WriteBlobString(image,"\033*r3F");  /* set presentation mode */
 713     (void) FormatLocaleString(buffer,MaxTextExtent,"\033*r%.20gs%.20gT",
 714       (double) image->columns,(double) image->rows);
 715     (void) WriteBlobString(image,buffer);
 716     (void) FormatLocaleString(buffer,MaxTextExtent,"\033*t%.20gR",(double)
 717       density);
 718     (void) WriteBlobString(image,buffer);
 719     (void) WriteBlobString(image,"\033&l0E");  /* top margin 0 */
 720     if (IsMonochromeImage(image,&image->exception) != MagickFalse)
 721       {
 722         /*
 723           Monochrome image: use default printer monochrome setup.
 724         */
 725         bits_per_pixel=1;
 726       }
 727     else
 728       if (image->storage_class == DirectClass)
 729         {
 730           /*
 731             DirectClass image.
 732           */
 733           bits_per_pixel=24;
 734           (void) WriteBlobString(image,"\033*v6W"); /* set color mode */
 735           (void) WriteBlobByte(image,0); /* RGB */
 736           (void) WriteBlobByte(image,3); /* direct by pixel */
 737           (void) WriteBlobByte(image,0); /* bits per index (ignored) */
 738           (void) WriteBlobByte(image,8); /* bits per red component */
 739           (void) WriteBlobByte(image,8); /* bits per green component */
 740           (void) WriteBlobByte(image,8); /* bits per blue component */
 741         }
 742       else
 743         {
 744           /*
 745             Colormapped image.
 746           */
 747           bits_per_pixel=8;
 748           (void) WriteBlobString(image,"\033*v6W"); /* set color mode... */
 749           (void) WriteBlobByte(image,0); /* RGB */
 750           (void) WriteBlobByte(image,1); /* indexed by pixel */
 751           (void) WriteBlobByte(image,bits_per_pixel); /* bits per index */
 752           (void) WriteBlobByte(image,8); /* bits per red component */
 753           (void) WriteBlobByte(image,8); /* bits per green component */
 754           (void) WriteBlobByte(image,8); /* bits per blue component */
 755           for (i=0; i < (ssize_t) image->colors; i++)
 756           {
 757             (void) FormatLocaleString(buffer,MaxTextExtent,
 758               "\033*v%da%db%dc%.20gI",
 759               ScaleQuantumToChar(image->colormap[i].red),
 760               ScaleQuantumToChar(image->colormap[i].green),
 761               ScaleQuantumToChar(image->colormap[i].blue),(double) i);
 762             (void) WriteBlobString(image,buffer);
 763           }
 764           for (one=1; i < (ssize_t) (one << bits_per_pixel); i++)
 765           {
 766             (void) FormatLocaleString(buffer,MaxTextExtent,"\033*v%.20gI",
 767               (double) i);
 768             (void) WriteBlobString(image,buffer);
 769           }
 770         }
 771     option=GetImageOption(image_info,"pcl:fit-to-page");
 772     if ((option != (const char *) NULL) &&
 773         (IsMagickTrue(option) != MagickFalse))
 774       (void) WriteBlobString(image,"\033*r3A");
 775     else
 776       (void) WriteBlobString(image,"\033*r1A");  /* start raster graphics */
 777     (void) WriteBlobString(image,"\033*b0Y");  /* set y offset */
 778     length=(image->columns*bits_per_pixel+7)/8;
 779     pixels=(unsigned char *) AcquireQuantumMemory(length+1,sizeof(*pixels));
 780     if (pixels == (unsigned char *) NULL)
 781       ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
 782     (void) ResetMagickMemory(pixels,0,(length+1)*sizeof(*pixels));
 783     compress_pixels=(unsigned char *) NULL;
 784     previous_pixels=(unsigned char *) NULL;
 785     switch (image->compression)
 786     {
 787       case NoCompression:
 788       {
 789         (void) FormatLocaleString(buffer,MaxTextExtent,"\033*b0M");
 790         (void) WriteBlobString(image,buffer);
 791         break;
 792       }
 793       case RLECompression:
 794       {
 795         compress_pixels=(unsigned char *) AcquireQuantumMemory(length+256,
 796           sizeof(*compress_pixels));
 797         if (compress_pixels == (unsigned char *) NULL)
 798           {
 799             pixels=(unsigned char *) RelinquishMagickMemory(pixels);
 800             ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
 801           }
 802         (void) ResetMagickMemory(compress_pixels,0,(length+256)*
 803           sizeof(*compress_pixels));
 804         (void) FormatLocaleString(buffer,MaxTextExtent,"\033*b2M");
 805         (void) WriteBlobString(image,buffer);
 806         break;
 807       }
 808       default:
 809       {
 810         compress_pixels=(unsigned char *) AcquireQuantumMemory(3*length+256,
 811           sizeof(*compress_pixels));
 812         if (compress_pixels == (unsigned char *) NULL)
 813           {
 814             pixels=(unsigned char *) RelinquishMagickMemory(pixels);
 815             ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
 816           }
 817         (void) ResetMagickMemory(compress_pixels,0,(3*length+256)*
 818           sizeof(*compress_pixels));
 819         previous_pixels=(unsigned char *) AcquireQuantumMemory(length+1,
 820           sizeof(*previous_pixels));
 821         if (previous_pixels == (unsigned char *) NULL)
 822           {
 823             compress_pixels=(unsigned char *) RelinquishMagickMemory(
 824               compress_pixels);
 825             pixels=(unsigned char *) RelinquishMagickMemory(pixels);
 826             ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
 827           }
 828         (void) ResetMagickMemory(previous_pixels,0,(length+1)*
 829           sizeof(*previous_pixels));
 830         (void) FormatLocaleString(buffer,MaxTextExtent,"\033*b3M");
 831         (void) WriteBlobString(image,buffer);
 832         break;
 833       }
 834     }
 835     for (y=0; y < (ssize_t) image->rows; y++)
 836     {
 837       p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
 838       if (p == (const PixelPacket *) NULL)
 839         break;
 840       indexes=GetAuthenticIndexQueue(image);
 841       q=pixels;
 842       switch (bits_per_pixel)
 843       {
 844         case 1:
 845         {
 846           register unsigned char
 847             bit,
 848             byte;
 849
 850           /*
 851             Monochrome image.
 852           */
 853           bit=0;
 854           byte=0;
 855           for (x=0; x < (ssize_t) image->columns; x++)
 856           {
 857             byte<<=1;
 858             if (PixelIntensity(p) < ((MagickRealType) QuantumRange/2.0))
 859               byte|=0x01;
 860             bit++;
 861             if (bit == 8)
 862               {
 863                 *q++=byte;
 864                 bit=0;
 865                 byte=0;
 866               }
 867             p++;
 868           }
 869           if (bit != 0)
 870             *q++=byte << (8-bit);
 871           break;
 872         }
 873         case 8:
 874         {
 875           /*
 876             Colormapped image.
 877           */
 878           for (x=0; x < (ssize_t) image->columns; x++)
 879             *q++=(unsigned char) GetIndexPixelComponent(indexes+x);
 880           break;
 881         }
 882         case 24:
 883         case 32:
 884         {
 885           /*
 886             Truecolor image.
 887           */
 888           for (x=0; x < (ssize_t) image->columns; x++)
 889           {
 890             *q++=ScaleQuantumToChar(GetRedPixelComponent(p));
 891             *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
 892             *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
 893             p++;
 894           }
 895           break;
 896         }
 897       }
 898       switch (image->compression)
 899       {
 900         case NoCompression:
 901         {
 902           (void) FormatLocaleString(buffer,MaxTextExtent,"\033*b%.20gW",
 903             (double) length);
 904           (void) WriteBlobString(image,buffer);
 905           (void) WriteBlob(image,length,pixels);
 906           break;
 907         }
 908         case RLECompression:
 909         {
 910           packets=PCLPackbitsCompressImage(length,pixels,compress_pixels);
 911           (void) FormatLocaleString(buffer,MaxTextExtent,"\033*b%.20gW",
 912             (double) packets);
 913           (void) WriteBlobString(image,buffer);
 914           (void) WriteBlob(image,packets,compress_pixels);
 915           break;
 916         }
 917         default:
 918         {
 919           if (y == 0)
 920             for (i=0; i < (ssize_t) length; i++)
 921               previous_pixels[i]=(~pixels[i]);
 922           packets=PCLDeltaCompressImage(length,previous_pixels,pixels,
 923             compress_pixels);
 924           (void) FormatLocaleString(buffer,MaxTextExtent,"\033*b%.20gW",
 925             (double) packets);
 926           (void) WriteBlobString(image,buffer);
 927           (void) WriteBlob(image,packets,compress_pixels);
 928           (void) CopyMagickMemory(previous_pixels,pixels,length*
 929             sizeof(*pixels));
 930           break;
 931         }
 932       }
 933     }
 934     (void) WriteBlobString(image,"\033*rB");  /* end graphics */
 935     switch (image->compression)
 936     {
 937       case NoCompression:
 938         break;
 939       case RLECompression:
 940       {
 941         compress_pixels=(unsigned char *) RelinquishMagickMemory(
 942           compress_pixels);
 943         break;
 944       }
 945       default:
 946       {
 947         previous_pixels=(unsigned char *) RelinquishMagickMemory(
 948           previous_pixels);
 949         compress_pixels=(unsigned char *) RelinquishMagickMemory(
 950           compress_pixels);
 951         break;
 952       }
 953     }
 954     pixels=(unsigned char *) RelinquishMagickMemory(pixels);
 955     if (GetNextImageInList(image) == (Image *) NULL)
 956       break;
 957     image=SyncNextImageInList(image);
 958     status=SetImageProgress(image,SaveImagesTag,scene++,
 959       GetImageListLength(image));
 960     if (status == MagickFalse)
 961       break;
 962   } while (image_info->adjoin != MagickFalse);
 963   (void) WriteBlobString(image,"\033E");
 964   (void) CloseBlob(image);
 965   return(MagickTrue);
 966 }