/*

% Copyright (C) 2003-2025 GraphicsMagick Group

% Copyright (C) 2002 ImageMagick Studio

% Copyright 1991-1999 E. I. du Pont de Nemours and Company

%

% This program is covered by multiple licenses, which are described in

% Copyright.txt. You should have received a copy of Copyright.txt with this

% package; otherwise see http://www.graphicsmagick.org/www/Copyright.html.

%

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

%                                                                             %

%                                                                             %

%                                                                             %

%                            PPPP   DDDD   FFFFF                              %

%                            P   P  D   D  F                                  %

%                            PPPP   D   D  FFF                                %

%                            P      D   D  F                                  %

%                            P      DDDD   F                                  %

%                                                                             %

%                                                                             %

%                  Read/Write Portable Document Format.                       %

%                                                                             %

%                                                                             %

%                              Software Design                                %

%                                John Cristy                                  %

%                                 July 1992                                   %

%                                                                             %

%                                                                             %

%                                                                             %

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

%

%

*/

/*

  Include declarations.

*/

#include "magick/studio.h"

#include "magick/analyze.h"

#include "magick/attribute.h"

#include "magick/blob.h"

#include "magick/compress.h"

#include "magick/constitute.h"

#include "magick/delegate.h"

#include "magick/enum_strings.h"

#include "magick/log.h"

#include "magick/magick.h"

#include "magick/monitor.h"

#include "magick/pixel_cache.h"

#include "magick/resize.h"

#include "magick/shear.h"

#include "magick/tempfile.h"

#include "magick/utility.h"

#include "magick/version.h"

/*

  Forward declarations.

*/

static unsigned int WritePDFImage(const ImageInfo *,Image *);

#if defined(HasZLIB)

static unsigned int ZLIBEncodeImage(Image *,const size_t,const unsigned long,unsigned char *);

#endif

/*

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

%                                                                             %

%                                                                             %

%                                                                             %

%   I s P D F                                                                 %

%                                                                             %

%                                                                             %

%                                                                             %

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

%

%  Method IsPDF returns True if the image format type, identified by the

%  magick string, is PDF.

%

%  The format of the IsPDF method is:

%

%      unsigned int IsPDF(const unsigned char *magick,const size_t offset)

%

%  A description of each parameter follows:

%

%    o status:  Method IsPDF returns True if the image format type is PDF.

%

%    o magick: This string is generally the first few bytes of an image file

%      or blob.

%

%    o offset: Specifies the offset of the magick string.

%

%

*/

static unsigned int IsPDF(const unsigned char *magick,const size_t offset)

{

  if (offset < 5)

    return(False);

  if (LocaleNCompare((char *) magick,"%PDF-",5) == 0)

    return(True);

  return(False);

}

/*

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

%                                                                             %

%                                                                             %

%                                                                             %

%   R e a d P D F I m a g e                                                   %

%                                                                             %

%                                                                             %

%                                                                             %

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

%

%  Method ReadPDFImage reads a Portable Document Format 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 ReadPDFImage method is:

%

%      Image *ReadPDFImage(const ImageInfo *image_info,ExceptionInfo *exception)

%

%  A description of each parameter follows:

%

%    o image:  Method ReadPDFImage returns a pointer to the image after

%      reading.  A null image is returned if there is a memory shortage or

%      if the image cannot be read.

%

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

%

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

%

%

*/

#if defined(HasGS)

static Image *ReadPDFImage(const ImageInfo *image_info,ExceptionInfo *exception)

{

#define MediaBox  "/MediaBox"

#define RenderPostscriptText  "[%s] Rendering postscript..."

  char

    density[MaxTextExtent],

    command[MaxTextExtent],

    filename[MaxTextExtent],

    postscript_filename[MaxTextExtent];

  const char

    *value;

  const DelegateInfo

    *delegate_info;

  double

    dx_resolution,

    dy_resolution;

  FILE

    *file;

  Image

    *image,

    *next_image;

  ImageInfo

    *clone_info;

  int

    count,

    status;

  unsigned int

    antialias=4;

  MagickBool

    use_crop_box = MagickFalse;

  MagickBool

    pdf_stop_on_error = MagickFalse;

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

  assert(image_info->signature == MagickSignature);

  assert(exception != (ExceptionInfo *) NULL);

  assert(exception->signature == MagickSignature);

  if ((value=AccessDefinition(image_info,"pdf","use-cropbox")))

    {

      if (strcmp(value,"true") == 0)

        use_crop_box = True;

    }

   if ((value=AccessDefinition(image_info,"pdf","stop-on-error")))

     {

       if (strcmp(value,"true") == 0)

         pdf_stop_on_error = True;

     }

  /*

    Select Postscript delegate driver

  */

  delegate_info=GetPostscriptDelegateInfo(image_info,&antialias,exception);

  if (delegate_info == (const DelegateInfo *) NULL)

    return((Image *) NULL);

  /*

    Open image file.

  */

  image=AllocateImage(image_info);

  status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);

  if (status == False)

    ThrowReaderException(FileOpenError,UnableToOpenFile,image);

  /*

    Open temporary output file.

  */

  file=AcquireTemporaryFileStream(postscript_filename,BinaryFileIOMode);

  if (file == (FILE *) NULL)

    ThrowReaderTemporaryFileException(postscript_filename);

  /*

    Set the page density.

  */

  dx_resolution=72.0;

  dy_resolution=72.0;

  if ((image->x_resolution == 0.0) || (image->y_resolution == 0.0))

    {

      (void) strlcpy(density,PSDensityGeometry,sizeof(density));

      count=GetMagickDimension(density,&image->x_resolution,&image->y_resolution,NULL,NULL);

      if (count != 2)

        image->y_resolution=image->x_resolution;

    }

  FormatString(density,"%gx%g",image->x_resolution,image->y_resolution);

  {

    /*

      Determine page geometry from the PDF media box.

      Note that we can use Ghostscript to obtain the bounding box info like

      gs -q -dBATCH -dNOPAUSE -sDEVICE=bbox ENV.003.01.pdf

      %%BoundingBox: 70 61 2089 2954

      %%HiResBoundingBox: 70.737537 61.199998 2088.587889 2953.601629

    */

    char

      geometry[MaxTextExtent];

    RectangleInfo

      box,

      page;

    SegmentInfo

      bounds;

    unsigned long

      height,

      width;

    int

      rotate;

    register char

      *p,

      *q;

    register long

      c;

    rotate=0;

    (void) memset(&page,0,sizeof(RectangleInfo));

    (void) memset(&box,0,sizeof(RectangleInfo));

    for (p=command; ; )

      {

        c=ReadBlobByte(image);

        if (c == EOF)

          break;

        (void) fputc(c,file);

        *p++=(char) c;

        if ((c != '\n') && (c != '\r') && ((p-command) < (MaxTextExtent-1)))

          continue;

        *p='\0';

        p=command;

        /*

          Continue unless this is a MediaBox statement.

        */

        if (LocaleNCompare(command,"/Rotate ",8) == 0)

          {

            count=sscanf(command,"/Rotate %d",&rotate);

            if (count > 0)

              {

                (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                                      "Rotate by %d degrees",rotate);

              }

          }

        q=strstr(command,MediaBox);

        if (q == (char *) NULL)

          continue;

        count=sscanf(q,"/MediaBox [%lf %lf %lf %lf",&bounds.x1,&bounds.y1,

                     &bounds.x2,&bounds.y2);

        if (count != 4)

          count=sscanf(q,"/MediaBox[%lf %lf %lf %lf",&bounds.x1,&bounds.y1,

                       &bounds.x2,&bounds.y2);

        if (count == 4)

          {

            (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                                  "Parsed: MediaBox %lf %lf %lf %lf",

                                  bounds.x1,bounds.y1,

                                  bounds.x2,bounds.y2);

          }

        if (count != 4)

          continue;

        if ((bounds.x1 > bounds.x2) || (bounds.y1 > bounds.y2))

          continue;

        /*

          Set Postscript render geometry.

        */

        width=(unsigned long) (bounds.x2-bounds.x1+0.5);

        height=(unsigned long) (bounds.y2-bounds.y1+0.5);

        if ((width <= box.width) && (height <= box.height))

          continue;

        page.width=width;

        page.height=height;

        box=page;

      }

    /*

      If page is rotated right or left, then swap width and height values.

    */

    if ((90 == AbsoluteValue(rotate)) || (270 == AbsoluteValue(rotate)))

      {

        double

          value;

        value=page.width;

        page.width=page.height;

        page.height=value;

      }

    if ((page.width == 0) || (page.height == 0))

      {

        SetGeometry(image,&page);

        (void) GetGeometry(PSPageGeometry,&page.x,&page.y,&page.width,

                           &page.height);

      }

    if (image_info->page != (char *) NULL)

      (void) GetGeometry(image_info->page,&page.x,&page.y,&page.width,

                         &page.height);

    geometry[0]='\0';

    FormatString(geometry,"%lux%lu",

                 (unsigned long) ceil(page.width*image->x_resolution/dx_resolution-0.5),

                 (unsigned long) ceil(page.height*image->y_resolution/dy_resolution-0.5));

    if (ferror(file))

      {

        (void) fclose(file);

        ThrowReaderException(CorruptImageError,AnErrorHasOccurredWritingToFile,

                             image);

      }

  }

  (void) fclose(file);

  CloseBlob(image);

  /*

    Use Ghostscript to convert Postscript image.

  */

  {

    char

      options[MaxTextExtent],

      arg[MaxTextExtent];

    options[0]='\0';

    if (use_crop_box)

      (void) strlcat(options,"-dUseCropBox",sizeof(options));

    if (pdf_stop_on_error)

      {

        if (options[0] != '\0')

          (void) strlcat(options," ",sizeof(options));

        (void) strlcat(options,"-dPDFSTOPONERROR",sizeof(options));

      }

    /*

      Append subrange.

    */

    if (image_info->subrange != 0)

      {

        FormatString(arg,"-dFirstPage=%lu -dLastPage=%lu",

                     image_info->subimage+1,

                     image_info->subimage+image_info->subrange);

        if (options[0] != '\0')

          (void) strlcat(options," ",sizeof(options));

        (void) strlcat(options,arg,sizeof(options));

      }

    /*

      Append authentication string.

    */

    if (image_info->authenticate != (char *) NULL)

      {

        FormatString(arg,"-sPDFPassword=%.1024s", image_info->authenticate);

        if (options[0] != '\0')

          (void) strlcat(options," ",sizeof(options));

        (void) strlcat(options,arg,sizeof(options));

      }

    (void) strlcpy(filename,image_info->filename,MaxTextExtent);

    clone_info=CloneImageInfo(image_info);

    if (!AcquireTemporaryFileName(clone_info->filename))

      {

        DestroyImageInfo(clone_info);

        ThrowReaderTemporaryFileException(clone_info->filename);

      }

    FormatString(command,delegate_info->commands,antialias,

                 antialias,density,options,clone_info->filename,

                 postscript_filename);

  }

  (void) MagickMonitorFormatted(0,8,&image->exception,RenderPostscriptText,

                                image->filename);

  status=InvokePostscriptDelegate(clone_info->verbose,command,exception);

  (void) MagickMonitorFormatted(7,8,&image->exception,RenderPostscriptText,

                                image->filename);

  DestroyImage(image);

  image=(Image *) NULL;

  if (IsAccessibleAndNotEmpty(clone_info->filename))

    {

      /*

        Read Ghostscript output.

      */

      clone_info->blob=(void *) NULL;

      clone_info->length=0;

      clone_info->magick[0]='\0';

      clone_info->subimage=0;

      clone_info->subrange=0;

      MagickFreeMemory(clone_info->tile);

      image=ReadImage(clone_info,exception);

    }

  (void) LiberateTemporaryFile(postscript_filename);

  (void) LiberateTemporaryFile(clone_info->filename);

  DestroyImageInfo(clone_info);

  if (image == (Image *) NULL)

    {

      if (UndefinedException == exception->severity)

        ThrowException(exception,DelegateError,PostscriptDelegateFailed,filename);

    }

  else

    {

      do

        {

          (void) strlcpy(image->magick,"PDF",sizeof(image->magick));

          (void) strlcpy(image->filename,filename,sizeof(image->filename));

          next_image=SyncNextImageInList(image);

          if (next_image != (Image *) NULL)

            image=next_image;

        } while (next_image != (Image *) NULL);

      while (image->previous != (Image *) NULL)

        image=image->previous;

      if (image_info->subimage != 0)

        {

          unsigned long

            scene = image_info->subimage;

          for (next_image=image;

               next_image != (Image *) NULL;

               next_image=next_image->next)

            next_image->scene = scene++;

        }

    }

  return(image);

}

#endif /* if defined(HasGS) */

/*

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

%                                                                             %

%                                                                             %

%                                                                             %

%   R e g i s t e r P D F I m a g e                                           %

%                                                                             %

%                                                                             %

%                                                                             %

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

%

%  Method RegisterPDFImage adds attributes for the PDF 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 same file or blob,

%  whether the format supports native in-memory I/O, and a brief

%  description of the format.

%

%  The format of the RegisterPDFImage method is:

%

%      RegisterPDFImage(void)

%

*/

ModuleExport void RegisterPDFImage(void)

{

  MagickInfo

    *entry;

  entry=SetMagickInfo("EPDF");

#if defined(HasGS)

  entry->decoder=(DecoderHandler) ReadPDFImage;

#endif /* if defined(HasGS) */

  entry->encoder=(EncoderHandler) WritePDFImage;

  entry->adjoin=False;

  entry->blob_support=False;

  entry->seekable_stream=True;

  entry->description="Encapsulated Portable Document Format";

  entry->module="PDF";

  entry->coder_class=PrimaryCoderClass;

  (void) RegisterMagickInfo(entry);

  entry=SetMagickInfo("PDF");

#if defined(HasGS)

  entry->decoder=(DecoderHandler) ReadPDFImage;

#endif /* if defined(HasGS) */

  entry->encoder=(EncoderHandler) WritePDFImage;

  entry->magick=(MagickHandler) IsPDF;

  entry->blob_support=False;

  entry->seekable_stream=True;

  entry->description="Portable Document Format";

  entry->module="PDF";

  entry->coder_class=PrimaryCoderClass;

  (void) RegisterMagickInfo(entry);

}

/*

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

%                                                                             %

%                                                                             %

%                                                                             %

%   U n r e g i s t e r P D F I m a g e                                       %

%                                                                             %

%                                                                             %

%                                                                             %

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

%

%  Method UnregisterPDFImage removes format registrations made by the

%  PDF module from the list of supported formats.

%

%  The format of the UnregisterPDFImage method is:

%

%      UnregisterPDFImage(void)

%

*/

ModuleExport void UnregisterPDFImage(void)

{

  (void) UnregisterMagickInfo("EPDF");

  (void) UnregisterMagickInfo("PDF");

}

/*

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

%                                                                             %

%                                                                             %

%                                                                             %

%   W r i t e P D F I m a g e                                                 %

%                                                                             %

%                                                                             %

%                                                                             %

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

%

%  Method WritePDFImage writes an image in the Portable Document image

%  format.

%

%  The format of the WritePDFImage method is:

%

%      unsigned int WritePDFImage(const ImageInfo *image_info,Image *image)

%

%  A description of each parameter follows.

%

%    o status: Method WritePDFImage return True if the image is written.

%      False is returned is there is a memory shortage or if the image file

%      fails to write.

%

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

%

%    o image:  A pointer to an Image structure.

%

%

*/

static char *EscapeParenthesis(const char *text, char *paren_buffer)

{

  register char

    *p;

  register long

    i;

  unsigned long

    escapes;

  escapes=0;

  p=paren_buffer;

  for (i=0; i < (long) Min(strlen(text),(MaxTextExtent-escapes-1)); i++)

  {

    if ((text[i] == '(') || (text[i] == ')'))

      {

        *p++='\\';

        escapes++;

      }

    *p++=text[i];

  }

  *p='\0';

  return(paren_buffer);

}

#define ThrowPDFWriterException(code_,reason_,image_)                \

  {                                                                  \

    MagickFreeMemory(fax_blob);                                      \

    MagickFreeResourceLimitedMemory(xref);                           \

    ThrowWriterException(code_,reason_,image_);                      \

  }

#define ThrowPDFWriterException2(code_,reason_,image_)                 \

  {                                                                    \

    MagickFreeMemory(fax_blob);                                        \

    MagickFreeResourceLimitedMemory(xref);                             \

    ThrowWriterException2(code_,reason_,image_);                       \

  }

static unsigned int WritePDFImage(const ImageInfo *image_info,Image *image)

{

#define CFormat  "/Filter [ /%.1024s ]\n"

#define ObjectsPerImage  9

  char

    basename[MaxTextExtent],

    buffer[MaxTextExtent],

    date[MaxTextExtent],

    density[MaxTextExtent],

    **labels,

    page_geometry[MaxTextExtent],

    paren_buffer[MaxTextExtent];

  unsigned char

    *fax_blob=(unsigned char *) NULL;

  const ImageAttribute

    *attribute;

  double

    dx_resolution,

    dy_resolution,

    x_resolution,

    x_scale,

    y_resolution,

    y_scale;

  ExtendedSignedIntegralType

    offset;

  long

    count,

    y;

  RectangleInfo

    geometry,

    media_info;

  register const PixelPacket

    *p;

  register const IndexPacket

    *indexes;

  register unsigned char

    *q;

  register long

    i,

    x;

  size_t

    fax_blob_length,

    length;

#if defined(HAVE_LOCALTIME_R)

  struct tm

    tm_buf;

#endif /* if defined(HAVE_LOCALTIME_R) */

  struct tm

    *time_meridian;

  time_t

    seconds;

  unsigned char

    *pixels;

  MagickPassFail

    status;

  unsigned long

    info_id,

    number_pixels,

    object,

    pages_id,

    root_id,

    scene,

    text_size;

  ExtendedSignedIntegralType

    *xref = (ExtendedSignedIntegralType *) NULL;

  size_t

    image_list_length;

  /*

    Open output image file.

  */

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

  assert(image_info->signature == MagickSignature);

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

  assert(image->signature == MagickSignature);

  image_list_length=GetImageListLength(image);

  status=OpenBlob(image_info,image,WriteBinaryBlobMode,&image->exception);

  if (status == False)

    ThrowPDFWriterException(FileOpenError,UnableToOpenFile,image);

  /*

    Allocate X ref memory.

  */

  xref=MagickAllocateResourceLimitedMemory(ExtendedSignedIntegralType *,

                            2048*sizeof(ExtendedSignedIntegralType));

  if (xref == (ExtendedSignedIntegralType *) NULL)

    ThrowPDFWriterException(ResourceLimitError,MemoryAllocationFailed,image);

  (void) memset(xref,0,2048*sizeof(ExtendedSignedIntegralType));

  /*

    Write Documentation Information Dictionary

  */

  object=0;

  (void) WriteBlobString(image,"%PDF-1.2 \n");

  xref[object++]=TellBlob(image);

  info_id=object;

  FormatString(buffer,"%lu 0 obj\n",object);

  (void) WriteBlobString(image,buffer);

  (void) WriteBlobString(image,"<<\n");

  seconds=time((time_t *) NULL);

#if defined(HAVE_LOCALTIME_R)

  time_meridian=localtime_r(&seconds,&tm_buf);

#else

  time_meridian=localtime(&seconds); /* Thread-unsafe version */

#endif  /* if defined(HAVE_LOCALTIME_R) */

  FormatString(date,"D:%04d%02d%02d%02d%02d%02d",time_meridian->tm_year+1900,

               time_meridian->tm_mon+1,time_meridian->tm_mday,time_meridian->tm_hour,

               time_meridian->tm_min,time_meridian->tm_sec);

  GetPathComponent(image->filename,BasePath,basename);

  FormatString(buffer,"/Title (%.1024s)\n",

               EscapeParenthesis(basename,paren_buffer));

  (void) WriteBlobString(image,buffer);

  FormatString(buffer,"/CreationDate (%.1024s)\n",date);

  (void) WriteBlobString(image,buffer);

  FormatString(buffer,"/ModDate (%.1024s)\n",date);

  (void) WriteBlobString(image,buffer);

  FormatString(buffer,"/Producer (%.1024s)\n",

               EscapeParenthesis(GetMagickVersion((unsigned long *) NULL),

                                 paren_buffer));

  (void) WriteBlobString(image,buffer);

  (void) WriteBlobString(image,">>\n");

  (void) WriteBlobString(image,"endobj\n");

  /*

    Write Catalog object.

  */

  xref[object++]=TellBlob(image);

  root_id=object;

  FormatString(buffer,"%lu 0 obj\n",object);

  (void) WriteBlobString(image,buffer);

  (void) WriteBlobString(image,"<<\n");

  (void) WriteBlobString(image,"/Type /Catalog\n");

  FormatString(buffer,"/Pages %lu 0 R\n",object+1);

  (void) WriteBlobString(image,buffer);

  (void) WriteBlobString(image,">>\n");

  (void) WriteBlobString(image,"endobj\n");

  /*

    Write Pages object.

  */

  xref[object++]=TellBlob(image);

  pages_id=object;

  FormatString(buffer,"%lu 0 obj\n",object);

  (void) WriteBlobString(image,buffer);

  (void) WriteBlobString(image,"<<\n");

  (void) WriteBlobString(image,"/Type /Pages\n");

  FormatString(buffer,"/Kids [ %lu 0 R ",object+1);

  (void) WriteBlobString(image,buffer);

  count=(long) (pages_id+ObjectsPerImage+1);

  if (image_info->adjoin)

    {

      Image

        *kid_image;

      ExtendedSignedIntegralType

        *new_xref;

      /*

        Predict page object id's.

      */

      kid_image=image;

      for ( ; kid_image->next != (Image *) NULL; count+=ObjectsPerImage)

        {

          FormatString(buffer,"%ld 0 R ",count);

          (void) WriteBlobString(image,buffer);

          kid_image=kid_image->next;

        }

      new_xref=MagickReallocateResourceLimitedArray(ExtendedSignedIntegralType *,xref,

                                                    (size_t) count+2048,sizeof(ExtendedSignedIntegralType));

      if (new_xref == (ExtendedSignedIntegralType *) NULL)

        {

          MagickFreeResourceLimitedMemory(xref);

          ThrowPDFWriterException(ResourceLimitError,MemoryAllocationFailed,image);

        }

      xref=new_xref;

    }

  (void) WriteBlobString(image,"]\n");

  FormatString(buffer,"/Count %lu\n",(count-pages_id)/ObjectsPerImage);

  (void) WriteBlobString(image,buffer);

  (void) WriteBlobString(image,">>\n");

  (void) WriteBlobString(image,"endobj\n");

  scene=0;

  do

    {

      ImageCharacteristics

        characteristics;

      CompressionType

        compression;

      /*

        Analyze image properties.

      */

      (void) GetImageCharacteristics(image,&characteristics,

                                     (OptimizeType == image_info->type),

                                     &image->exception);

      compression=image->compression;

      if (image_info->compression != UndefinedCompression)

        {

          /*

            ImageInfo compression always prevails if it is set.

          */

          compression=image_info->compression;

        }

      else

        {

          /*

            Default to Zip compression unless the image was JPEG

            compressed and is not now monochrome or colormapped.

          */

          if ((JPEGCompression != compression) ||

              (characteristics.monochrome) ||

              (characteristics.palette))

            {

#if defined(HasZLIB)

              compression=ZipCompression;

#else

              compression=LZWCompression;

#endif

            }

        }

      switch (compression)

        {

#if !defined(HasJPEG)

        case JPEGCompression:

          {

            /*

              If JPEG compression is not supported, then use RLE compression

              and report a warning to user.

            */

            compression=RLECompression;

            ThrowException(&image->exception,MissingDelegateError,JPEGLibraryIsNotAvailable,image->filename);

            break;

          }

#endif

#if !defined(HasZLIB)

        case ZipCompression:

          {

            /*

              If ZIP compression is not supported, then use RLE compression

              and report a warning to user.

            */

            compression=RLECompression;

            ThrowException(&image->exception,MissingDelegateError,ZipLibraryIsNotAvailable,image->filename);

            break;

          }

#endif

        default:

          break;

        }

      (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                            "%s compression.",

                            CompressionTypeToString(compression));

      /*

        Scale image to size of Portable Document page.

      */

      text_size=0;

      attribute=GetImageAttribute(image,"label");

      if (attribute != (const ImageAttribute *) NULL)

        text_size=(unsigned int)

          (MultilineCensus(attribute->value)*image_info->pointsize+12);

      SetGeometry(image,&geometry);

      geometry.y=(long) text_size;

      FormatString(page_geometry,"%lux%lu",image->columns,image->rows);

      if (image_info->page != (char *) NULL)

        {

          (void) strlcpy(page_geometry,image_info->page,MaxTextExtent);

          (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                                "Page: %s (from ImageInfo) ", page_geometry);

        }

      else

        {

          if ((image->page.width != 0) && (image->page.height != 0))

            {

              (void) FormatString(page_geometry,"%lux%lu%+ld%+ld",image->page.width,

                                  image->page.height,image->page.x,image->page.y);

              (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                                    "Page: %s (from Image)", page_geometry);

            }

          else

            {

              if (LocaleCompare(image_info->magick,"PDF") == 0)

                {

                  (void) strlcpy(page_geometry,PSPageGeometry,sizeof(page_geometry));

                  (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                                        "Page: %s (defaulted)", page_geometry);

                }

              else

                {

                  (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                                        "Page: %s (from Image columns/rows)",

                                        page_geometry);

                }

            }

        }

      (void) GetMagickGeometry(page_geometry,&geometry.x,&geometry.y,

                               &geometry.width,&geometry.height);

      (void) GetGeometry(page_geometry,&media_info.x,&media_info.y,