//C-  -*- C++ -*-

//C- -------------------------------------------------------------------

//C- DjVuLibre-3.5

//C- Copyright (c) 2002  Leon Bottou and Yann Le Cun.

//C- Copyright (c) 2001  AT&T

//C-

//C- This software is subject to, and may be distributed under, the

//C- GNU General Public License, either Version 2 of the license,

//C- or (at your option) any later version. The license should have

//C- accompanied the software or you may obtain a copy of the license

//C- from the Free Software Foundation at http://www.fsf.org .

//C-

//C- This program is distributed in the hope that it will be useful,

//C- but WITHOUT ANY WARRANTY; without even the implied warranty of

//C- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

//C- GNU General Public License for more details.

//C- 

//C- DjVuLibre-3.5 is derived from the DjVu(r) Reference Library from

//C- Lizardtech Software.  Lizardtech Software has authorized us to

//C- replace the original DjVu(r) Reference Library notice by the following

//C- text (see doc/lizard2002.djvu and doc/lizardtech2007.djvu):

//C-

//C-  ------------------------------------------------------------------

//C- | DjVu (r) Reference Library (v. 3.5)

//C- | Copyright (c) 1999-2001 LizardTech, Inc. All Rights Reserved.

//C- | The DjVu Reference Library is protected by U.S. Pat. No.

//C- | 6,058,214 and patents pending.

//C- |

//C- | This software is subject to, and may be distributed under, the

//C- | GNU General Public License, either Version 2 of the license,

//C- | or (at your option) any later version. The license should have

//C- | accompanied the software or you may obtain a copy of the license

//C- | from the Free Software Foundation at http://www.fsf.org .

//C- |

//C- | The computer code originally released by LizardTech under this

//C- | license and unmodified by other parties is deemed "the LIZARDTECH

//C- | ORIGINAL CODE."  Subject to any third party intellectual property

//C- | claims, LizardTech grants recipient a worldwide, royalty-free, 

//C- | non-exclusive license to make, use, sell, or otherwise dispose of 

//C- | the LIZARDTECH ORIGINAL CODE or of programs derived from the 

//C- | LIZARDTECH ORIGINAL CODE in compliance with the terms of the GNU 

//C- | General Public License.   This grant only confers the right to 

//C- | infringe patent claims underlying the LIZARDTECH ORIGINAL CODE to 

//C- | the extent such infringement is reasonably necessary to enable 

//C- | recipient to make, have made, practice, sell, or otherwise dispose 

//C- | of the LIZARDTECH ORIGINAL CODE (or portions thereof) and not to 

//C- | any greater extent that may be necessary to utilize further 

//C- | modifications or combinations.

//C- |

//C- | The LIZARDTECH ORIGINAL CODE is provided "AS IS" WITHOUT WARRANTY

//C- | OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED

//C- | TO ANY WARRANTY OF NON-INFRINGEMENT, OR ANY IMPLIED WARRANTY OF

//C- | MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.

//C- +------------------------------------------------------------------

#ifdef HAVE_CONFIG_H

# include "config.h"

#endif

#if NEED_GNUG_PRAGMAS

# pragma implementation

#endif

#include "DjVuToPS.h"

#include "IFFByteStream.h"

#include "BSByteStream.h"

#include "DjVuImage.h"

#include "DjVuText.h"

#include "DataPool.h"

#include "IW44Image.h"

#include "JB2Image.h"

#include "GBitmap.h"

#include "GPixmap.h"

#include "debug.h"

#include <stdarg.h>

#include <stddef.h>

#include <stdlib.h>

#include <stdio.h>

#include <time.h>

#include <math.h>

#ifdef UNIX

#include <pwd.h>

#include <grp.h>

#include <unistd.h>

#endif

#ifdef HAVE_NAMESPACES

namespace DJVU {

# ifdef NOT_DEFINED // Just to fool emacs c++ mode

}

#endif

#endif

static const size_t ps_string_size=15000;

// ***************************************************************************

// ****************************** Options ************************************

// ***************************************************************************

DjVuToPS::Options::

Options(void)

: format(PS), 

  level(2), 

  orientation(AUTO), 

  mode(COLOR), 

  zoom(0),

  color(true), 

  calibrate(true), 

  text(false),

  gamma((double)2.2), 

  copies(1), 

  frame(false),

  cropmarks(false),

  bookletmode(OFF),

  bookletmax(0),

  bookletalign(0),

  bookletfold(18),

  bookletxfold(200)

{}

void

DjVuToPS::Options::

set_format(Format xformat)

{

  if (xformat != EPS && xformat != PS)

    G_THROW(ERR_MSG("DjVuToPS.bad_format"));

  format=xformat;

}

void

DjVuToPS::Options::

set_level(int xlevel)

{

  if (xlevel<1 || xlevel>3)

    G_THROW(ERR_MSG("DjVuToPS.bad_level")

           + GUTF8String("\t") + GUTF8String(xlevel));

  level=xlevel;

}

void

DjVuToPS::Options::

set_orientation(Orientation xorientation)

{

  if (xorientation!=PORTRAIT && 

      xorientation!=LANDSCAPE &&

      xorientation!=AUTO )

    G_THROW(ERR_MSG("DjVuToPS.bad_orient"));

  orientation=xorientation;

}

void

DjVuToPS::Options::

set_mode(Mode xmode)

{

  if (xmode!=COLOR && xmode!=FORE && xmode!=BACK && xmode!=BW)

    G_THROW(ERR_MSG("DjVuToPS.bad_mode"));

  mode=xmode;

}

void

DjVuToPS::Options::

set_zoom(int xzoom)

{

  if (xzoom!=0 && !(xzoom>=5 && xzoom<=999))

    G_THROW(ERR_MSG("DjVuToPS.bad_zoom"));

  zoom=xzoom;

}

void

DjVuToPS::Options::

set_color(bool xcolor)

{

  color=xcolor;

}

void 

DjVuToPS::Options::

set_sRGB(bool xcalibrate)

{

  calibrate=xcalibrate;

}

void

DjVuToPS::Options::

set_gamma(double xgamma)

{

  if  (xgamma<(double)(0.3-0.0001) || xgamma>(double)(5.0+0.0001))

    G_THROW(ERR_MSG("DjVuToPS.bad_gamma"));

  gamma=xgamma;

}

void

DjVuToPS::Options::

set_copies(int xcopies)

{

  if (xcopies<=0)

    G_THROW(ERR_MSG("DjVuToPS.bad_number"));

  copies=xcopies;

}

void

DjVuToPS::Options::

set_frame(bool xframe)

{

  frame=xframe;

}

void

DjVuToPS::Options::

set_cropmarks(bool xmarks)

{

  cropmarks=xmarks;

}

void

DjVuToPS::Options::

set_text(bool xtext)

{

  text=xtext;

}

void 

DjVuToPS::Options::

set_bookletmode(BookletMode m)

{

  bookletmode = m;

}

void 

DjVuToPS::Options::

set_bookletmax(int m)

{

  bookletmax = 0;

  if (m > 0)

    bookletmax = (m+3)/4;

  bookletmax *= 4;

}

void 

DjVuToPS::Options::

set_bookletalign(int m)

{

  bookletalign = m;

}

void 

DjVuToPS::Options::

set_bookletfold(int fold, int xfold)

{

  if (fold >= 0)

    bookletfold = fold;

  if (xfold >= 0)

    bookletxfold = xfold;

}

// ***************************************************************************

// ******************************* DjVuToPS **********************************

// ***************************************************************************

static char bin2hex[256][2];

DjVuToPS::DjVuToPS(void)

{

  DEBUG_MSG("DjVuToPS::DjVuToPS(): initializing...\n");

  DEBUG_MAKE_INDENT(3);

  DEBUG_MSG("Initializing dig2hex[]\n");

  // Creating tables for bin=>text translation

  static const char * dig2hex="0123456789ABCDEF";

  int i;

  for(i=0;i<256;i++)

    {

      bin2hex[i][0]=dig2hex[i/16];

      bin2hex[i][1]=dig2hex[i%16];

    }

  refresh_cb=0;

  refresh_cl_data=0;

  prn_progress_cb=0;

  prn_progress_cl_data=0;

  dec_progress_cb=0;

  dec_progress_cl_data=0;

  info_cb=0;

  info_cl_data=0;

}

#ifdef __GNUC__

static void

write(ByteStream &str, const char *format, ...)

__attribute__((format (printf, 2, 3)));

#endif

static void

write(ByteStream &str, const char *format, ...)

{

  /* Will output the formated string to the specified \Ref{ByteStream}

     like #fprintf# would do it for a #FILE#. */

  va_list args;

  va_start(args, format);

  GUTF8String tmp;

  tmp.vformat(format, args);

  str.writall((const char *) tmp, tmp.length());

}

// ************************* DOCUMENT LEVEL *********************************

void

DjVuToPS::

store_doc_prolog(ByteStream &str, int pages, int dpi, GRect *grect)

{

  /* Will store the {\em document prolog}, which is basically a

     block of document-level comments in PS DSC 3.0 format.

     @param str Stream where PostScript data should be written

     @param pages Total number of pages

     @param dpi (EPS mode only) 

     @param grect (EPS mode only) */

  DEBUG_MSG("storing the document prolog\n");

  DEBUG_MAKE_INDENT(3);

  if (options.get_format()==Options::EPS)

    write(str,

          "%%!PS-Adobe-3.0 EPSF 3.0\n"

          "%%%%BoundingBox: 0 0 %d %d\n",

          (grect->width()*100+dpi-1)/dpi, 

          (grect->height()*100+dpi-1)/dpi );

  else

    write(str, "%%!PS-Adobe-3.0\n");

  write(str,

        "%%%%Title: DjVu PostScript document\n"

        "%%%%Copyright: Copyright (c) 1998-1999 AT&T\n"

        "%%%%Creator: DjVu (code by Andrei Erofeev)\n"

        "%%%%DocumentData: Clean7Bit\n");

  // Date

  time_t tm=time(0);

  write(str, "%%%%CreationDate: %s", ctime(&tm));

  // For

#ifdef UNIX

  passwd *pswd = getpwuid(getuid());

  if (pswd)

    {

      char *s = strchr(pswd->pw_gecos, ',');

      if (s) 

        *s = 0;

      s = 0;

      if (pswd->pw_gecos && strlen(pswd->pw_gecos))

        s = pswd->pw_gecos;

      else if (pswd->pw_name && strlen(pswd->pw_name))

        s = pswd->pw_name;

      if (s)

        write(str, "%%%%For: %s\n", s);

    }

#endif

  // Language

  write(str, "%%%%LanguageLevel: %d\n", options.get_level());

  if (options.get_level()<2 && options.get_color())

    write(str, "%%%%Extensions: CMYK\n");

  // Pages

  write(str, "%%%%Pages: %d\n",pages );

  write(str, "%%%%PageOrder: Ascend\n");

  // Orientation

  if (options.get_orientation() != Options::AUTO)

    write(str, "%%%%Orientation: %s\n", 

          options.get_orientation()==Options::PORTRAIT ?

          "Portrait" : "Landscape" );

  // Requirements

  if (options.get_format() == Options::PS)

    {

      write(str, "%%%%Requirements:");

      if (options.get_color())

        write(str, " color");

      if (options.get_copies()>1)

        write(str, " numcopies(%d)", options.get_copies());

      if (options.get_level()>=2)

        {

          if (options.get_copies()>1)

            write(str, " collate");

          if (options.get_bookletmode() == Options::RECTOVERSO)

            write(str, " duplex(tumble)");

        }

      write(str, "\n");

    }

  // End

  write(str,

        "%%%%EndComments\n"

        "%%%%EndProlog\n"

        "\n");

}

void

DjVuToPS::

store_doc_setup(ByteStream &str)

{

  /* Will store the {\em document setup}, which is a set of

     PostScript commands and functions used to inspect and prepare

     the PostScript interpreter environment before displaying images. */

  write(str, 

        "%%%%BeginSetup\n"

        "/doc-origstate save def\n");

  if (options.get_level()>=2)

    {

      if (options.get_format() == Options::PS)

        {

          if (options.get_copies()>1)

            write(str, 

                  "[{\n"

                  "%%%%BeginFeature: NumCopies %d\n"

                  "<< /NumCopies %d >> setpagedevice\n"

                  "%%%%EndFeature\n"

                  "} stopped cleartomark\n"

                  "[{\n"

                  "%%%%BeginFeature: Collate\n"

                  "<< /Collate true >> setpagedevice\n"

                  "%%%%EndFeature\n"

                  "} stopped cleartomark\n",

                  options.get_copies(),

                  options.get_copies() );

          if (options.get_bookletmode()==Options::RECTOVERSO)

            write(str, 

                  "[{\n"

                  "%%%%BeginFeature: Duplex DuplexTumble\n"

                  "<< /Duplex true /Tumble true >> setpagedevice\n"

                  "%%%%EndFeature\n"

                  "} stopped cleartomark\n");

        }

      if (options.get_color())

        write(str, 

              "%% -- procs for reading color image\n"

              "/readR () def\n"

              "/readG () def\n"

              "/readB () def\n"

              "/ReadData {\n"

              "   currentfile /ASCII85Decode filter dup\n"

              "   /RunLengthDecode filter\n"

              "   bufferR readstring pop /readR exch def\n"

              "   dup status { flushfile } { pop } ifelse\n"

              "   currentfile /ASCII85Decode filter dup\n"

              "   /RunLengthDecode filter\n"

              "   bufferG readstring pop /readG exch def\n"

              "   dup status { flushfile } { pop } ifelse\n"

              "   currentfile /ASCII85Decode filter dup\n"

              "   /RunLengthDecode filter\n"

              "   bufferB readstring pop /readB exch def\n"

              "   dup status { flushfile } { pop } ifelse\n"

              "} bind def\n"

              "/ReadR {\n"

              "   readR length 0 eq { ReadData } if\n"

              "   readR /readR () def\n"

              "} bind def\n"

              "/ReadG {\n"

              "   readG length 0 eq { ReadData } if\n"

              "   readG /readG () def\n"

              "} bind def\n"

              "/ReadB {\n"

              "   readB length 0 eq { ReadData } if\n"

              "   readB /readB () def\n"

              "} bind def\n");

      write(str,

            "%% -- procs for foreground layer\n"

            "/g {gsave 0 0 0 0 5 index 5 index setcachedevice\n"

            "    true [1 0 0 1 0 0] 5 4 roll imagemask grestore\n"

            "} bind def\n"

            "/gn {gsave 0 0 0 0 6 index 6 index setcachedevice\n"

            "  true [1 0 0 1 0 0] 3 2 roll 5 1 roll \n"

            "  { 1 sub 0 index 2 add 1 index  1 add roll\n"

            "  } imagemask grestore pop \n"

            "} bind def\n"

            "/c {setcolor rmoveto glyphshow} bind def\n"

            "/s {rmoveto glyphshow} bind def\n"

            "/S {rmoveto gsave show grestore} bind def\n" 

            "/F {(Helvetica) findfont exch scalefont setfont} bind def\n"

            "%% -- emulations\n"

            "systemdict /rectstroke known not {\n"

            "  /rectstroke  %% stack : x y width height \n"

            "  { newpath 4 2 roll moveto 1 index 0 rlineto\n"

            "    0 exch rlineto neg 0 rlineto closepath stroke\n"

            "  } bind def } if\n"

            "systemdict /rectclip known not {\n"

            "  /rectclip  %% stack : x y width height \n"

            "  { newpath 4 2 roll moveto 1 index 0 rlineto\n"

            "    0 exch rlineto neg 0 rlineto closepath clip\n"

            "  } bind def } if\n"

            "%% -- color space\n" );

      if (options.get_sRGB())

        write(str,

              "/DjVuColorSpace [ %s\n"

              "<< /DecodeLMN [ { dup 0.03928 le {\n"

              "       12.92321 div\n"

              "     } {\n"

              "       0.055 add 1.055 div 2.4 exp\n"

              "     } ifelse } bind dup dup ]\n"

              "   /MatrixLMN [\n"

              "      0.412457 0.212673 0.019334\n"

              "      0.357576 0.715152 0.119192\n"

              "      0.180437 0.072175 0.950301 ]\n"

              "   /WhitePoint [ 0.9505 1 1.0890 ] %% D65 \n"

              "   /BlackPoint[0 0 0] >> ] def\n",

              (options.get_color()) ? "/CIEBasedABC" : "/CIEBasedA" );

      else if (options.get_color())

        write(str,"/DjVuColorSpace /DeviceRGB def\n");

      else

        write(str,"/DjVuColorSpace /DeviceGray def\n");

    } 

  else 

    {

      // level<2

      if (options.get_format() == Options::PS)

        if (options.get_copies() > 1)

          write(str,"/#copies %d def\n", options.get_copies());

      if (options.get_color())

        write(str, 

              "%% -- buffers for reading image\n"

              "/buffer8 () def\n"

              "/buffer24 () def\n"

              "%% -- colorimage emulation\n"

              "systemdict /colorimage known {\n"

              "   /ColorProc {\n"

              "      currentfile buffer24 readhexstring pop\n"

              "   } bind def\n"

              "   /ColorImage {\n"

              "      colorimage\n"

              "   } bind def\n"

              "} {\n"

              "   /ColorProc {\n"

              "      currentfile buffer24 readhexstring pop\n"

              "      /data exch def /datalen data length def\n"

              "      /cnt 0 def\n"

              "      0 1 datalen 3 idiv 1 sub {\n"

              "         buffer8 exch\n"

              "                data cnt get 20 mul /cnt cnt 1 add def\n"

              "                data cnt get 32 mul /cnt cnt 1 add def\n"

              "                data cnt get 12 mul /cnt cnt 1 add def\n"

              "                add add 64 idiv put\n"

              "      } for\n"

              "      buffer8 0 datalen 3 idiv getinterval\n"

              "   } bind def\n"

              "   /ColorImage {\n"

              "      pop pop image\n"

              "   } bind def\n"

              "} ifelse\n");

    } // level<2

  write(str, "%%%%EndSetup\n\n");

}

void

DjVuToPS::

store_doc_trailer(ByteStream &str)

{

  /* Will store the {\em document trailer}, which is a clean-up code

     used to return the PostScript interpeter back to the state, in which

     it was before displaying this document. */

  write(str, 

        "%%%%Trailer\n"

        "doc-origstate restore\n"

        "%%%%EOF\n");

}

// ***********************************************************************

// ***************************** PAGE LEVEL ******************************

// ***********************************************************************

static unsigned char *

ASCII85_encode(unsigned char * dst, 

               const unsigned char * src_start,

               const unsigned char * src_end)

{

  /* Will read data between #src_start# and #src_end# pointers (excluding byte

     pointed by #src_end#), encode it using {\bf ASCII85} algorithm, and

     output the result into the destination buffer pointed by #dst#.  The

     function returns pointer to the first unused byte in the destination

     buffer. */

  int symbols=0;

  const unsigned char * ptr;

  for(ptr=src_start;ptr

    {

      unsigned int num=0;

      if (ptr+3

        {

          num |= ptr[0] << 24; 

          num |= ptr[1] << 16; 

          num |= ptr[2] << 8; 

          num |= ptr[3];

        }

      else

        {

          num |= ptr[0] << 24; 

          if (ptr+1

            num |= ptr[1] << 16; 

          if (ptr+2

            num |= ptr[2] << 8; 

        }

      int a1, a2, a3, a4, a5;

      a5=num % 85; num/=85;

      a4=num % 85; num/=85;

      a3=num % 85; num/=85;

      a2=num % 85;

      a1=num / 85;

      *dst++ = a1+33;

      *dst++ = a2+33;

      if (ptr+1

        *dst++ = a3+33;

      if (ptr+2

        *dst++ = a4+33;

      if (ptr+3

        *dst++ = a5+33;

      symbols += 5;

      if (symbols > 70 && ptr+4

        { 

          *dst++='\n'; 

          symbols=0; 

        }

    }

  return dst;

}

static unsigned char *

RLE_encode(unsigned char * dst,

           const unsigned char * src_start,

           const unsigned char * src_end)

{

  /* Will read data between #src_start# and #src_end# pointers (excluding byte

     pointed by #src_end#), RLE encode it, and output the result into the

     destination buffer pointed by #dst#.  #counter# is used to count the

     number of output bytes.  The function returns pointer to the first unused

     byte in the destination buffer. */

  const unsigned char * ptr;

  for(ptr=src_start;ptr

    {

      if (ptr==src_end-1)

        {

          *dst++=0; *dst++=*ptr;

        } 

      else if (ptr[0]!=ptr[1])

        {

          // Guess how many non repeating bytes we have

          const unsigned char * ptr1;

          for(ptr1=ptr+1;ptr1

            if (ptr1[0]==ptr1[1] || ptr1-ptr>=128) break;

          int pixels=ptr1-ptr;

          *dst++=pixels-1;

          for(int cnt=0;cnt

            *dst++=*ptr++;

          ptr--;

        } 

      else

        {

          // Get the number of repeating bytes

          const unsigned char * ptr1;

          for(ptr1=ptr+1;ptr1

            if (ptr1[0]!=ptr1[1] || ptr1-ptr+1>=128) break;

          int pixels=ptr1-ptr+1;

          *dst++=257-pixels;

          *dst++=*ptr;

          ptr=ptr1;

        }

    }

  return dst;

}

#define GRAY(r,g,b) (((r)*20+(g)*32+(b)*12)/64)

void

DjVuToPS::

store_page_setup(ByteStream &str, 

                 int dpi, 

                 const GRect &grect, 

                 int align )

{

  /* Will store PostScript code necessary to prepare page for

     the coming \Ref{DjVuImage}. This is basically a scaling

     code plus initialization of some buffers. */

  if (options.get_format() == Options::EPS)

    write(str, 

          "/page-origstate save def\n"

          "%% -- coordinate system\n"

          "/image-dpi %d def\n"

          "/image-x 0 def\n"

          "/image-y 0 def\n"

          "/image-width  %d def\n"

          "/image-height %d def\n"

          "/coeff 100 image-dpi div def\n"

          "/a11 coeff def\n"

          "/a12 0 def\n"

          "/a13 0 def\n"

          "/a21 0 def\n"

          "/a22 coeff def\n"

          "/a23 0 def\n"

          "[a11 a21 a12 a22 a13 a23] concat\n"

          "gsave 0 0 image-width image-height rectclip\n"

          "%% -- begin printing\n",

          dpi, grect.width(), grect.height() );

  else

    {

      int margin = 0;

      const char *xauto = "false";

      const char *xportrait = "false";

      const char *xfit = "false";

      if (options.get_orientation()==Options::AUTO)

        xauto = "true";

      if (options.get_orientation()==Options::PORTRAIT)

        xportrait = "true";

      if (options.get_zoom()<=0)

        xfit = "true";

      if (options.get_cropmarks())

        margin = 36;

      else if (options.get_frame())

        margin = 6;

      write(str, 

            "/page-origstate save def\n"

            "%% -- coordinate system\n"

            "/auto-orient %s def\n"

            "/portrait %s def\n"

            "/fit-page %s def\n"

            "/zoom %d def\n"

            "/image-dpi %d def\n"

            "clippath pathbbox newpath\n"

            "2 index sub exch 3 index sub\n"

            "/page-width exch def\n"

            "/page-height exch def\n"

            "/page-y exch def\n"

            "/page-x exch def\n"

            "/image-x 0 def\n"

            "/image-y 0 def\n"

            "/image-width  %d def\n"

            "/image-height %d def\n"

            "/margin %d def\n"

            "/halign %d def\n"

            "/valign 0 def\n",

            xauto, xportrait, xfit, options.get_zoom(), 

            dpi, grect.width(), grect.height(),

            margin, align );

      write(str, 

            "%% -- position page\n"

            "auto-orient {\n"

            "  image-height image-width sub\n"

            "  page-height page-width sub\n"

            "  mul 0 ge /portrait exch def\n" 

            "} if\n"

            "fit-page {\n"

            "  /page-width page-width margin sub\n"

            "     halign 0 eq { margin sub } if def\n"

            "  /page-height page-height margin sub\n"

            "     valign 0 eq { margin sub } if def\n"

            "  /page-x page-x halign 0 ge { margin add } if def\n"

            "  /page-y page-y valign 0 ge { margin add } if def\n"

            "} if\n"

            "portrait {\n"

            "  fit-page {\n"

            "    image-height page-height div\n"

            "    image-width page-width div\n"

            "    gt {\n"

            "      page-height image-height div /coeff exch def\n"

            "    } {\n"

            "      page-width image-width div /coeff exch def\n"

            "    } ifelse\n"

            "  } {\n"

            "    /coeff 72 image-dpi div zoom mul 100 div def\n"

            "  } ifelse\n"

            "  /start-x page-x page-width image-width\n"

            "    coeff mul sub 2 div halign 1 add mul add def\n"

            "  /start-y page-y page-height image-height\n"

            "    coeff mul sub 2 div valign 1 add mul add def\n"

            "  /a11 coeff def\n"

            "  /a12 0 def\n"

            "  /a13 start-x def\n"

            "  /a21 0 def\n"

            "  /a22 coeff def\n"

            "  /a23 start-y def\n"

            "} { %% landscape\n"

            "  fit-page {\n"

            "    image-height page-width div\n"

            "    image-width page-height div\n"

            "    gt {\n"

            "      page-width image-height div /coeff exch def\n"

            "    } {\n"

            "      page-height image-width div /coeff exch def\n"

            "    } ifelse\n"

            "  } {\n"

            "    /coeff 72 image-dpi div zoom mul 100 div def\n"

            "  } ifelse\n"

            "  /start-x page-x page-width add page-width image-height\n"

            "    coeff mul sub 2 div valign 1 add mul sub def\n"

            "  /start-y page-y page-height image-width\n"

            "    coeff mul sub 2 div halign 1 add mul add def\n"

            "  /a11 0 def\n"

            "  /a12 coeff neg def\n"

            "  /a13 start-x image-y coeff neg mul sub def\n"

            "  /a21 coeff def\n"

            "  /a22 0 def\n"

            "  /a23 start-y image-x coeff mul add def \n"

            "} ifelse\n"

            "[a11 a21 a12 a22 a13 a23] concat\n"

            "gsave 0 0 image-width image-height rectclip\n"

            "%% -- begin print\n");

    }

}

void

DjVuToPS::

store_page_trailer(ByteStream &str)

{

  write(str, 

        "%% -- end print\n" 

        "grestore\n");

  if (options.get_frame())

    write(str, 

          "%% Drawing frame\n"

          "gsave 0.7 setgray 0.5 coeff div setlinewidth 0 0\n"

          "image-width image-height rectstroke\n"

          "grestore\n");

  if (options.get_cropmarks() &&

      options.get_format() != Options::EPS )

    write(str,

          "%% Drawing crop marks\n"

          "/cm { gsave translate rotate 1 coeff div dup scale\n"

          "      0 setgray 0.5 setlinewidth -36 0 moveto 0 0 lineto\n"

          "      0 -36 lineto stroke grestore } bind def\n"

          "0 0 0 cm 180 image-width image-height cm\n"

          "90 image-width 0 cm 270 0 image-height cm\n");

  write(str,

        "page-origstate restore\n");

}

static int

compute_red(int w, int h, int rw, int rh)

{

  for (int red=1; red<16; red++)

    if (((w+red-1)/red==rw) && ((h+red-1)/red==rh))

      return red;

  return 16;

}

static int

get_bg_red(GP<DjVuImage> dimg) 

{

  GP<GPixmap> pm = 0;

  // Access image size

  int width = dimg->get_width();

  int height = dimg->get_height();

  if (width<=0 || height<=0) return 0;

  // CASE1: Incremental BG IW44Image

  GP<IW44Image> bg44 = dimg->get_bg44();

  if (bg44)

    {

      int w = bg44->get_width();

      int h = bg44->get_height();

      // Avoid silly cases

      if (w==0 || h==0 || width==0 || height==0)

        return 0;

      return compute_red(width,height,w,h);

    }

  // CASE 2: Raw background pixmap

  GP<GPixmap>  bgpm = dimg->get_bgpm();

  if (bgpm)

    {

      int w = bgpm->columns();

      int h = bgpm->rows();

      // Avoid silly cases

      if (w==0 || h==0 || width==0 || height==0)

        return 0;

      return compute_red(width,height,w,h);

    }

  return 0;

}

static GP<GPixmap>

get_bg_pixmap(GP<DjVuImage> dimg, const GRect &rect)

{

  GP<GPixmap> pm = 0;

  // Access image size

  int width = dimg->get_width();

  int height = dimg->get_height();

  GP<DjVuInfo> info = dimg->get_info();

  if (width<=0 || height<=0 || !info) return 0;

  // CASE1: Incremental BG IW44Image

  GP<IW44Image> bg44 = dimg->get_bg44();

  if (bg44)

    {

      int w = bg44->get_width();

      int h = bg44->get_height();

      // Avoid silly cases

      if (w==0 || h==0 || width==0 || height==0)