/*

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%                                                                             %

%                                                                             %

%                                                                             %

%                            PPPP   SSSSS  33333                              %

%                            P   P  SS        33                              %

%                            PPPP    SSS    333                               %

%                            P         SS     33                              %

%                            P      SSSSS  33333                              %

%                                                                             %

%                                                                             %

%                     Write Postscript Level III Format                       %

%                                                                             %

%                              Software Design                                %

%                                   Cristy                                    %

%                              Lars Ruben Skyum                               %

%                                 July 1992                                   %

%                                                                             %

%                                                                             %

%  Copyright @ 1999 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                                            %

%                                                                             %

%    https://imagemagick.org/license/                                         %

%                                                                             %

%  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 "MagickCore/studio.h"

#include "MagickCore/artifact.h"

#include "MagickCore/attribute.h"

#include "MagickCore/blob.h"

#include "MagickCore/blob-private.h"

#include "MagickCore/cache.h"

#include "MagickCore/channel.h"

#include "MagickCore/color.h"

#include "MagickCore/color-private.h"

#include "MagickCore/colorspace-private.h"

#include "MagickCore/compress.h"

#include "MagickCore/constitute.h"

#include "MagickCore/draw.h"

#include "MagickCore/exception.h"

#include "MagickCore/exception-private.h"

#include "MagickCore/geometry.h"

#include "MagickCore/image.h"

#include "MagickCore/image-private.h"

#include "MagickCore/list.h"

#include "MagickCore/magick.h"

#include "MagickCore/memory_.h"

#include "MagickCore/module.h"

#include "MagickCore/monitor.h"

#include "MagickCore/monitor-private.h"

#include "MagickCore/option.h"

#include "MagickCore/pixel-accessor.h"

#include "MagickCore/property.h"

#include "MagickCore/quantum-private.h"

#include "MagickCore/resource_.h"

#include "MagickCore/static.h"

#include "MagickCore/string_.h"

#include "MagickCore/module.h"

#include "MagickCore/timer-private.h"

#include "MagickCore/token.h"

#include "MagickCore/utility.h"

#include "coders/coders-private.h"

/*

  Define declarations.

*/

#define PS3_NoCompression "0"

#define PS3_FaxCompression "1"

#define PS3_JPEGCompression "2"

#define PS3_LZWCompression "3"

#define PS3_RLECompression "4"

#define PS3_ZipCompression "5"

#define PS3_RGBColorspace "0"

#define PS3_CMYKColorspace "1"

#define PS3_DirectClass "0"

#define PS3_PseudoClass "1"

#if defined(MAGICKCORE_TIFF_DELEGATE)

#define CCITTParam  "-1"

#else

#define CCITTParam  "0"

#endif

/*

  Forward declarations.

*/

static MagickBooleanType

  WritePS3Image(const ImageInfo *,Image *,ExceptionInfo *);

/*

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%                                                                             %

%                                                                             %

%                                                                             %

%   R e g i s t e r P S 3 I m a g e                                           %

%                                                                             %

%                                                                             %

%                                                                             %

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%

%  RegisterPS3Image() adds properties for the PS3 image format to the list of

%  supported formats.  The properties 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 same file or blob, whether the format supports native

%  in-memory I/O, and a brief description of the format.

%

%  The format of the RegisterPS3Image method is:

%

%      size_t RegisterPS3Image(void)

%

*/

ModuleExport size_t RegisterPS3Image(void)

{

  MagickInfo

    *entry;

  entry=AcquireMagickInfo("PS3","EPS3","Level III Encapsulated PostScript");

  entry->encoder=(EncodeImageHandler *) WritePS3Image;

  entry->mime_type=ConstantString("application/postscript");

  entry->flags|=CoderEncoderSeekableStreamFlag;

  entry->flags^=CoderBlobSupportFlag;

  (void) RegisterMagickInfo(entry);

  entry=AcquireMagickInfo("PS3","PS3","Level III PostScript");

  entry->encoder=(EncodeImageHandler *) WritePS3Image;

  entry->mime_type=ConstantString("application/postscript");

  entry->flags|=CoderEncoderSeekableStreamFlag;

  entry->flags^=CoderBlobSupportFlag;

  (void) RegisterMagickInfo(entry);

  return(MagickImageCoderSignature);

}

/*

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%                                                                             %

%                                                                             %

%                                                                             %

%   U n r e g i s t e r P S 3 I m a g e                                       %

%                                                                             %

%                                                                             %

%                                                                             %

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%

%  UnregisterPS3Image() removes format registrations made by the PS3 module

%  from the list of supported formats.

%

%  The format of the UnregisterPS3Image method is:

%

%      UnregisterPS3Image(void)

%

*/

ModuleExport void UnregisterPS3Image(void)

{

  (void) UnregisterMagickInfo("EPS3");

  (void) UnregisterMagickInfo("PS3");

}

/*

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%                                                                             %

%                                                                             %

%                                                                             %

%   W r i t e P S 3 I m a g e                                                 %

%                                                                             %

%                                                                             %

%                                                                             %

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%

%  WritePS3Image() translates an image to encapsulated Postscript Level III

%  for printing.  If the supplied geometry is null, the image is centered on

%  the Postscript page.  Otherwise, the image is positioned as specified by the

%  geometry.

%

%  The format of the WritePS3Image method is:

%

%      MagickBooleanType WritePS3Image(const ImageInfo *image_info,

%        Image *image,ExceptionInfo *exception)

%

%  A description of each parameter follows:

%

%    o image_info: Specifies a pointer to a ImageInfo structure.

%

%    o image: the image.

%

%    o exception: return any errors or warnings in this structure.

%

*/

static inline void FilenameToTitle(const char *filename,char *title,

  const size_t extent)

{

  int

    depth = 0;

  ssize_t

    i,

    offset = 0;

  if (extent == 0)

    return;

  for (i=0; (filename[i] != '\0') && ((offset+1) < (ssize_t) extent); i++)

  {

    unsigned char

      c = filename[i];

    /*

      Only allow printable ASCII.

    */

    if ((c < 32) || (c > 126))

      {

        title[offset++]='_';

        continue;

      }

    /*

      Percent signs break DSC parsing.

    */

    if (c == '%')

      {

        title[offset++]='_';

        continue;

      }

    /*

      Parentheses must remain balanced.

    */

    if (c == '(')

      {

        depth++;

        title[offset++] = '(';

        continue;

      }

    if (c == ')')

      {

        if (depth <= 0)

          title[offset++]='_';

        else

          {

            depth--;

            title[offset++]=')';

          }

         continue;

     }

    /*

      Everything else is allowed.

    */

    title[offset++]=c;

  }

  /*

    If parentheses remain unbalanced, close them.

  */

  while ((depth > 0) && ((offset+1) < (ssize_t) extent)) {

    title[offset++]=')';

    depth--;

  }

  title[offset]='\0';

  /*

    Ensure non-empty result.

  */

  if (offset == 0)

    {

      (void) CopyMagickString(title,"Untitled",extent-1);

      title[extent-1]='\0';

    }

}

static MagickBooleanType Huffman2DEncodeImage(const ImageInfo *image_info,

  Image *image,Image *inject_image,ExceptionInfo *exception)

{

  Image

    *group4_image;

  ImageInfo

    *write_info;

  MagickBooleanType

    status;

  size_t

    length;

  unsigned char

    *group4;

  group4_image=CloneImage(inject_image,0,0,MagickTrue,exception);

  if (group4_image == (Image *) NULL)

    return(MagickFalse);

  status=MagickTrue;

  write_info=CloneImageInfo(image_info);

  (void) CopyMagickString(write_info->filename,"GROUP4:",MagickPathExtent);

  (void) CopyMagickString(write_info->magick,"GROUP4",MagickPathExtent);

  group4=(unsigned char *) ImageToBlob(write_info,group4_image,&length,

    exception);

  group4_image=DestroyImage(group4_image);

  write_info=DestroyImageInfo(write_info);

  if (group4 == (unsigned char *) NULL)

    return(MagickFalse);

  if (WriteBlob(image,length,group4) != (ssize_t) length)

    status=MagickFalse;

  group4=(unsigned char *) RelinquishMagickMemory(group4);

  return(status);

}

static MagickBooleanType SerializeImage(const ImageInfo *image_info,

  Image *image,MemoryInfo **pixel_info,size_t *length,ExceptionInfo *exception)

{

  MagickBooleanType

    status;

  const Quantum

    *p;

  size_t

    channels,

    extent;

  ssize_t

    x,

    y;

  unsigned char

    *q;

  assert(image != (Image *) NULL);

  assert(image->signature == MagickCoreSignature);

  if (IsEventLogging() != MagickFalse)

    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);

  status=MagickTrue;

  channels=(image->colorspace == CMYKColorspace ? 4 : 3);

  if (HeapOverflowSanityCheckGetSize(channels,(size_t) image->columns,&extent) != MagickFalse)

    ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");

  if (HeapOverflowSanityCheckGetSize(extent,image->rows,length) != MagickFalse)

    ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");

  *pixel_info=AcquireVirtualMemory(*length,sizeof(*q));

  if (*pixel_info == (MemoryInfo *) NULL)

    ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");

  q=(unsigned char *) GetVirtualMemoryBlob(*pixel_info);

  (void) memset(q,0,*length*sizeof(*q));

  for (y=0; y < (ssize_t) image->rows; y++)

  {

    p=GetVirtualPixels(image,0,y,image->columns,1,exception);

    if (p == (const Quantum *) NULL)

      break;

    if (image->colorspace != CMYKColorspace)

      for (x=0; x < (ssize_t) image->columns; x++)

      {

        *q++=ScaleQuantumToChar(GetPixelRed(image,p));

        *q++=ScaleQuantumToChar(GetPixelGreen(image,p));

        *q++=ScaleQuantumToChar(GetPixelBlue(image,p));

        p+=(ptrdiff_t) GetPixelChannels(image);

      }

    else

      for (x=0; x < (ssize_t) image->columns; x++)

      {

        *q++=ScaleQuantumToChar(GetPixelRed(image,p));

        *q++=ScaleQuantumToChar(GetPixelGreen(image,p));

        *q++=ScaleQuantumToChar(GetPixelBlue(image,p));

        *q++=ScaleQuantumToChar(GetPixelBlack(image,p));

        p+=(ptrdiff_t) GetPixelChannels(image);

      }

    if (image->previous == (Image *) NULL)

      {

        status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,

          image->rows);

        if (status == MagickFalse)

          break;

      }

  }

  if (status == MagickFalse)

    *pixel_info=RelinquishVirtualMemory(*pixel_info);

  return(status);

}

static MagickBooleanType SerializeImageChannel(const ImageInfo *image_info,

  Image *image,MemoryInfo **pixel_info,size_t *length,ExceptionInfo *exception)

{

  MagickBooleanType

    status;

  const Quantum

    *p;

  ssize_t

    x;

  unsigned char

    *q;

  size_t

    pack,

    padded_columns;

  ssize_t

    y;

  unsigned char

    code,

    bit;

  assert(image != (Image *) NULL);

  assert(image->signature == MagickCoreSignature);

  if (IsEventLogging() != MagickFalse)

    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);

  status=MagickTrue;

  pack=SetImageMonochrome(image,exception) == MagickFalse ? 1UL : 8UL;

  padded_columns=((image->columns+pack-1)/pack)*pack;

  *length=(size_t) padded_columns*image->rows/pack;

  *pixel_info=AcquireVirtualMemory(*length,sizeof(*q));

  if (*pixel_info == (MemoryInfo *) NULL)

    ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");

  q=(unsigned char *) GetVirtualMemoryBlob(*pixel_info);

  for (y=0; y < (ssize_t) image->rows; y++)

  {

    p=GetVirtualPixels(image,0,y,image->columns,1,exception);

    if (p == (const Quantum *) NULL)

      break;

    if (pack == 1)

      for (x=0; x < (ssize_t) image->columns; x++)

      {

        *q++=ScaleQuantumToChar(ClampToQuantum(GetPixelLuma(image,p)));

        p+=(ptrdiff_t) GetPixelChannels(image);

      }

    else

      {

        code='\0';

        for (x=0; x < (ssize_t) padded_columns; x++)

        {

          bit=(unsigned char) 0x00;

          if (x < (ssize_t) image->columns)

            bit=(unsigned char) (GetPixelLuma(image,p) == (double)

              TransparentAlpha ? 0x01 : 0x00);

          code=(code << 1)+bit;

          if (((x+1) % (ssize_t) pack) == 0)

            {

              *q++=code;

              code='\0';

            }

          p+=(ptrdiff_t) GetPixelChannels(image);

        }

      }

    status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,

      image->rows);

    if (status == MagickFalse)

      break;

  }

  if (status == MagickFalse)

    *pixel_info=RelinquishVirtualMemory(*pixel_info);

  return(status);

}

static MagickBooleanType SerializeImageIndexes(const ImageInfo *image_info,

  Image *image,MemoryInfo **pixel_info,size_t *length,ExceptionInfo *exception)

{

  MagickBooleanType

    status;

  const Quantum

    *p;

  ssize_t

    x;

  unsigned char

    *q;

  ssize_t

    y;

  assert(image != (Image *) NULL);

  assert(image->signature == MagickCoreSignature);

  if (IsEventLogging() != MagickFalse)

    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);

  status=MagickTrue;

  *length=(size_t) image->columns*image->rows;

  *pixel_info=AcquireVirtualMemory(*length,sizeof(*q));

  if (*pixel_info == (MemoryInfo *) NULL)

    ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");

  q=(unsigned char *) GetVirtualMemoryBlob(*pixel_info);

  for (y=0; y < (ssize_t) image->rows; y++)

  {

    p=GetVirtualPixels(image,0,y,image->columns,1,exception);

    if (p == (const Quantum *) NULL)

      break;

    for (x=0; x < (ssize_t) image->columns; x++)

    {

      *q++=(unsigned char) ((ssize_t) GetPixelIndex(image,p));

      p+=(ptrdiff_t) GetPixelChannels(image);

    }

    if (image->previous == (Image *) NULL)

      {

        status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,

          image->rows);

        if (status == MagickFalse)

          break;

      }

  }

  if (status == MagickFalse)

    *pixel_info=RelinquishVirtualMemory(*pixel_info);

  return(status);

}

static MagickBooleanType WritePS3MaskImage(const ImageInfo *image_info,

  Image *image,const CompressionType compression,ExceptionInfo *exception)

{

  char

    buffer[MagickPathExtent];

  Image

    *mask_image;

  MagickBooleanType

    status;

  MagickOffsetType

    offset,

    start,

    stop;

  MemoryInfo

    *pixel_info;

  ssize_t

    i;

  size_t

    length;

  unsigned char

    *pixels;

  assert(image_info != (ImageInfo *) NULL);

  assert(image_info->signature == MagickCoreSignature);

  assert(image != (Image *) NULL);

  assert(image->signature == MagickCoreSignature);

  assert(image->alpha_trait != UndefinedPixelTrait);

  if (IsEventLogging() != MagickFalse)

    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);

  status=MagickTrue;

  /*

    Note BeginData DSC comment for update later.

  */

  start=TellBlob(image);

  if (start < 0)

    ThrowWriterException(CorruptImageError,"ImproperImageHeader");

  (void) FormatLocaleString(buffer,MagickPathExtent,

    "%%%%BeginData:%13ld %s Bytes\n",0L,compression == NoCompression ?

    "ASCII" : "BINARY");

  (void) WriteBlobString(image,buffer);

  stop=TellBlob(image);

  if (stop < 0)

    ThrowWriterException(CorruptImageError,"ImproperImageHeader");

  /*

    Only lossless compressions for the mask.

  */

  switch (compression)

  {

    case NoCompression:

    default:

    {

      (void) FormatLocaleString(buffer,MagickPathExtent,

        "currentfile %.20g %.20g " PS3_NoCompression

        " ByteStreamDecodeFilter\n",(double) image->columns,(double)

        image->rows);

      break;

    }

    case FaxCompression:

    case Group4Compression:

    {

      (void) FormatLocaleString(buffer,MagickPathExtent,

        "currentfile %.20g %.20g " PS3_FaxCompression

        " ByteStreamDecodeFilter\n",(double) image->columns,(double)

        image->rows);

      break;

    }

    case LZWCompression:

    {

      (void) FormatLocaleString(buffer,MagickPathExtent,

        "currentfile %.20g %.20g " PS3_LZWCompression

        " ByteStreamDecodeFilter\n",(double) image->columns,(double)

        image->rows);

      break;

    }

    case RLECompression:

    {

      (void) FormatLocaleString(buffer,MagickPathExtent,

        "currentfile %.20g %.20g " PS3_RLECompression

        " ByteStreamDecodeFilter\n",(double) image->columns,(double)

        image->rows);

      break;

    }

    case ZipCompression:

    {

      (void) FormatLocaleString(buffer,MagickPathExtent,

        "currentfile %.20g %.20g " PS3_ZipCompression

        " ByteStreamDecodeFilter\n",(double) image->columns,(double)

        image->rows);

      break;

    }

  }

  (void) WriteBlobString(image,buffer);

  (void) WriteBlobString(image,"/ReusableStreamDecode filter\n");

  mask_image=SeparateImage(image,AlphaChannel,exception);

  if (mask_image == (Image *) NULL)

    ThrowWriterException(CoderError,exception->reason);

  (void) SetImageType(mask_image,BilevelType,exception);

  (void) SetImageType(mask_image,PaletteType,exception);

  mask_image->alpha_trait=UndefinedPixelTrait;

  pixels=(unsigned char *) NULL;

  length=0;

  switch (compression)

  {

    case NoCompression:

    default:

    {

      status=SerializeImageChannel(image_info,mask_image,&pixel_info,&length,

        exception);

      if (status == MagickFalse)

        break;

      Ascii85Initialize(image);

      pixels=(unsigned char *) GetVirtualMemoryBlob(pixel_info);

      for (i=0; i < (ssize_t) length; i++)

        Ascii85Encode(image,pixels[i]);

      Ascii85Flush(image);

      pixel_info=RelinquishVirtualMemory(pixel_info);

      break;

    }

    case FaxCompression:

    case Group4Compression:

    {

      if ((compression == FaxCompression) ||

          (LocaleCompare(CCITTParam,"0") == 0))

        status=HuffmanEncodeImage(image_info,image,mask_image,exception);

      else

        status=Huffman2DEncodeImage(image_info,image,mask_image,exception);

      break;

    }

    case LZWCompression:

    {

      status=SerializeImageChannel(image_info,mask_image,&pixel_info,&length,

        exception);

      if (status == MagickFalse)

        break;

      pixels=(unsigned char *) GetVirtualMemoryBlob(pixel_info);

      status=LZWEncodeImage(image,length,pixels,exception);

      pixel_info=RelinquishVirtualMemory(pixel_info);

      break;

    }

    case RLECompression:

    {

      status=SerializeImageChannel(image_info,mask_image,&pixel_info,&length,

        exception);

      if (status == MagickFalse)

        break;

      pixels=(unsigned char *) GetVirtualMemoryBlob(pixel_info);

      status=PackbitsEncodeImage(image,length,pixels,exception);

      pixel_info=RelinquishVirtualMemory(pixel_info);

      break;

    }

    case ZipCompression:

    {

      status=SerializeImageChannel(image_info,mask_image,&pixel_info,&length,

        exception);

      if (status == MagickFalse)

        break;

      pixels=(unsigned char *) GetVirtualMemoryBlob(pixel_info);

      status=ZLIBEncodeImage(image,length,pixels,exception);

      pixel_info=RelinquishVirtualMemory(pixel_info);

      break;

    }

  }

  mask_image=DestroyImage(mask_image);

  (void) WriteBlobByte(image,'\n');

  length=(size_t) (TellBlob(image)-stop);

  stop=TellBlob(image);

  if (stop < 0)

    ThrowWriterException(CorruptImageError,"ImproperImageHeader");

  offset=SeekBlob(image,start,SEEK_SET);

  if (offset < 0)

    ThrowWriterException(CorruptImageError,"ImproperImageHeader");

  (void) FormatLocaleString(buffer,MagickPathExtent,

    "%%%%BeginData:%13ld %s Bytes\n",(long) length,

    compression == NoCompression ? "ASCII" : "BINARY");

  (void) WriteBlobString(image,buffer);

  offset=SeekBlob(image,stop,SEEK_SET);

  if (offset < 0)

    ThrowWriterException(CorruptImageError,"ImproperImageHeader");

  (void) WriteBlobString(image,"%%EndData\n");

  (void) WriteBlobString(image, "/mask_stream exch def\n");

  return(status);

}

static MagickBooleanType WritePS3Image(const ImageInfo *image_info,Image *image,

  ExceptionInfo *exception)

{

  static const char

    PostscriptProlog[] =

      "/ByteStreamDecodeFilter\n"

      "{\n"

      "  /z exch def\n"

      "  /r exch def\n"

      "  /c exch def\n"

      "  z " PS3_NoCompression " eq { /ASCII85Decode filter } if\n"

      "  z " PS3_FaxCompression " eq\n"

      "  {\n"

      "    <<\n"

      "      /K " CCITTParam "\n"

      "      /Columns c\n"

      "      /Rows r\n"

      "    >>\n"

      "    /CCITTFaxDecode filter\n"

      "  } if\n"

      "  z " PS3_JPEGCompression " eq { /DCTDecode filter } if\n"

      "  z " PS3_LZWCompression " eq { /LZWDecode filter } if\n"

      "  z " PS3_RLECompression " eq { /RunLengthDecode filter } if\n"

      "  z " PS3_ZipCompression " eq { /FlateDecode filter } if\n"

      "} bind def\n"

      "\n"

      "/DirectClassImageDict\n"

      "{\n"

      "  colorspace " PS3_RGBColorspace " eq\n"

      "  {\n"

      "    /DeviceRGB setcolorspace\n"

      "    <<\n"

      "      /ImageType 1\n"

      "      /Width columns\n"

      "      /Height rows\n"

      "      /BitsPerComponent 8\n"

      "      /DataSource pixel_stream\n"

      "      /MultipleDataSources false\n"

      "      /ImageMatrix [columns 0 0 rows neg 0 rows]\n"

      "      /Decode [0 1 0 1 0 1]\n"

      "    >>\n"

      "  }\n"

      "  {\n"

      "    /DeviceCMYK setcolorspace\n"

      "    <<\n"

      "      /ImageType 1\n"

      "      /Width columns\n"

      "      /Height rows\n"

      "      /BitsPerComponent 8\n"

      "      /DataSource pixel_stream\n"

      "      /MultipleDataSources false\n"

      "      /ImageMatrix [columns 0 0 rows neg 0 rows]\n"

      "      /Decode\n"

      "        compression " PS3_JPEGCompression " eq\n"

      "        { [1 0 1 0 1 0 1 0] }\n"

      "        { [0 1 0 1 0 1 0 1] }\n"

      "        ifelse\n"

      "    >>\n"

      "  }\n"

      "  ifelse\n"

      "} bind def\n"

      "\n"

      "/PseudoClassImageDict\n"

      "{\n"

      "  % Colors in colormap image.\n"

      "  currentfile buffer readline pop\n"

      "  token pop /colors exch def pop\n"

      "  colors 0 eq\n"

      "  {\n"

      "    % Depth of grayscale image.\n"

      "    currentfile buffer readline pop\n"

      "    token pop /bits exch def pop\n"

      "    /DeviceGray setcolorspace\n"

      "    <<\n"

      "      /ImageType 1\n"

      "      /Width columns\n"

      "      /Height rows\n"

      "      /BitsPerComponent bits\n"

      "      /Decode [0 1]\n"

      "      /ImageMatrix [columns 0 0 rows neg 0 rows]\n"

      "      /DataSource pixel_stream\n"

      "    >>\n"

      "  }\n"

      "  {\n"

      "    % RGB colormap.\n"

      "    /colormap colors 3 mul string def\n"

      "    compression " PS3_NoCompression " eq\n"

      "    { currentfile /ASCII85Decode filter colormap readstring pop pop }\n"

      "    { currentfile colormap readstring pop pop }\n"

      "    ifelse\n"

      "    [ /Indexed /DeviceRGB colors 1 sub colormap ] setcolorspace\n"

      "    <<\n"

      "      /ImageType 1\n"

      "      /Width columns\n"

      "      /Height rows\n"

      "      /BitsPerComponent 8\n"

      "      /Decode [0 255]\n"

      "      /ImageMatrix [columns 0 0 rows neg 0 rows]\n"

      "      /DataSource pixel_stream\n"

      "    >>\n"

      "  }\n"

      "  ifelse\n"

      "} bind def\n"

      "\n"

      "/NonMaskedImageDict\n"

      "{\n"

      "  class " PS3_PseudoClass " eq\n"

      "  { PseudoClassImageDict }\n"

      "  { DirectClassImageDict }\n"

      "  ifelse\n"

      "} bind def\n"

      "\n"

      "/MaskedImageDict\n"

      "{\n"

      "  <<\n"

      "    /ImageType 3\n"

      "    /InterleaveType 3\n"

      "    /DataDict NonMaskedImageDict\n"

      "    /MaskDict\n"

      "    <<\n"

      "      /ImageType 1\n"

      "      /Width columns\n"

      "      /Height rows\n"

      "      /BitsPerComponent 1\n"

      "      /DataSource mask_stream\n"

      "      /MultipleDataSources false\n"

      "      /ImageMatrix [ columns 0 0 rows neg 0 rows]\n"

      "      /Decode [ 0 1 ]\n"

      "    >>\n"

      "  >>\n"

      "} bind def\n"

      "\n"

      "/ClipImage\n"

      "{} def\n"

      "\n"

      "/DisplayImage\n"

      "{\n"

      "  gsave\n"

      "  /buffer 512 string def\n"

      "  % Translation.\n"

      "  currentfile buffer readline pop\n"

      "  token pop /x exch def\n"

      "  token pop /y exch def pop\n"

      "  x y translate\n"

      "  % Image size and font size.\n"

      "  currentfile buffer readline pop\n"

      "  token pop /x exch def\n"

      "  token pop /y exch def pop\n"

      "  currentfile buffer readline pop\n"

      "  token pop /pointsize exch def pop\n";

  static const char

    PostscriptEpilog[] =

      "  x y scale\n"

      "  % Clipping path.\n"

      "  currentfile buffer readline pop\n"

      "  token pop /clipped exch def pop\n"

      "  % Showpage.\n"

      "  currentfile buffer readline pop\n"

      "  token pop /sp exch def pop\n"

      "  % Image pixel size.\n"

      "  currentfile buffer readline pop\n"

      "  token pop /columns exch def\n"

      "  token pop /rows exch def pop\n"

      "  % Colorspace (RGB/CMYK).\n"

      "  currentfile buffer readline pop\n"

      "  token pop /colorspace exch def pop\n"

      "  % Transparency.\n"

      "  currentfile buffer readline pop\n"

      "  token pop /alpha exch def pop\n"

      "  % Stencil mask?\n"

      "  currentfile buffer readline pop\n"

      "  token pop /stencil exch def pop\n"

      "  % Image class (direct/pseudo).\n"

      "  currentfile buffer readline pop\n"

      "  token pop /class exch def pop\n"

      "  % Compression type.\n"

      "  currentfile buffer readline pop\n"

      "  token pop /compression exch def pop\n"

      "  % Clip and render.\n"

      "  /pixel_stream currentfile columns rows compression ByteStreamDecodeFilter def\n"

      "  clipped { ClipImage } if\n"

      "  alpha stencil not and\n"

      "  { MaskedImageDict mask_stream resetfile }\n"

      "  { NonMaskedImageDict }\n"

      "  ifelse\n"

      "  stencil { 0 setgray imagemask } { image } ifelse\n"

      "  grestore\n"

      "  sp { showpage } if\n"

      "} bind def\n";

  char

    buffer[MagickPathExtent],