Logo Search packages:      
Sourcecode: djvulibre version File versions

DjVuToPS.cpp

//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- +------------------------------------------------------------------
// 
// $Id: DjVuToPS.cpp,v 1.27 2008/08/05 20:50:35 bpearlmutter Exp $
// $Name: debian_version_3_5_21-1 $

#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 <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::
00126 set_format(Format xformat)
{
  if (xformat != EPS && xformat != PS)
    G_THROW(ERR_MSG("DjVuToPS.bad_format"));
  format=xformat;
}

void
DjVuToPS::Options::
00135 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::
00145 set_orientation(Orientation xorientation)
{
  if (xorientation!=PORTRAIT && 
      xorientation!=LANDSCAPE &&
      xorientation!=AUTO )
    G_THROW(ERR_MSG("DjVuToPS.bad_orient"));
  orientation=xorientation;
}

void
DjVuToPS::Options::
00156 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::
00165 set_zoom(int xzoom)
{
  if (xzoom!=0 && !(xzoom>=5 && xzoom<=999))
    G_THROW(ERR_MSG("DjVuToPS.bad_zoom"));
  zoom=xzoom;
}

void
DjVuToPS::Options::
00174 set_color(bool xcolor)
{
  color=xcolor;
}

void 
DjVuToPS::Options::
00181 set_sRGB(bool xcalibrate)
{
  calibrate=xcalibrate;
}

void
DjVuToPS::Options::
00188 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::
00197 set_copies(int xcopies)
{
  if (xcopies<=0)
    G_THROW(ERR_MSG("DjVuToPS.bad_number"));
  copies=xcopies;
}

void
DjVuToPS::Options::
00206 set_frame(bool xframe)
{
  frame=xframe;
}

void
DjVuToPS::Options::
00213 set_cropmarks(bool xmarks)
{
  cropmarks=xmarks;
}

void
DjVuToPS::Options::
00220 set_text(bool xtext)
{
  text=xtext;
}

void 
DjVuToPS::Options::
00227 set_bookletmode(BookletMode m)
{
  bookletmode = m;
}

void 
DjVuToPS::Options::
00234 set_bookletmax(int m)
{
  bookletmax = 0;
  if (m > 0)
    bookletmax = (m+3)/4;
  bookletmax *= 4;
}

void 
DjVuToPS::Options::
00244 set_bookletalign(int m)
{
  bookletalign = m;
}

void 
DjVuToPS::Options::
00251 set_bookletfold(int fold, int xfold)
{
  if (fold >= 0)
    bookletfold = fold;
  if (xfold >= 0)
    bookletxfold = xfold;
}


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

static char bin2hex[256][2];

00266 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<src_end;ptr+=4)
    {
      unsigned int num=0;
      if (ptr+3<src_end)
        {
          num |= ptr[0] << 24; 
          num |= ptr[1] << 16; 
          num |= ptr[2] << 8; 
          num |= ptr[3];
        }
      else
        {
          num |= ptr[0] << 24; 
          if (ptr+1<src_end) 
            num |= ptr[1] << 16; 
          if (ptr+2<src_end) 
            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<src_end)
        *dst++ = a3+33;
      if (ptr+2<src_end)
        *dst++ = a4+33;
      if (ptr+3<src_end)
        *dst++ = a5+33;
      symbols += 5;
      if (symbols > 70 && ptr+4<src_end)
        { 
          *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<src_end;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<src_end-1;ptr1++)
            if (ptr1[0]==ptr1[1] || ptr1-ptr>=128) break;
          int pixels=ptr1-ptr;
          *dst++=pixels-1;
          for(int cnt=0;cnt<pixels;cnt++)
            *dst++=*ptr++;
          ptr--;
        } 
      else
        {
          // Get the number of repeating bytes
          const unsigned char * ptr1;
          for(ptr1=ptr+1;ptr1<src_end-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)
        return 0;
      pm = bg44->get_pixmap(1,rect);
      return pm;
    }
  // 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;
      pm->init(*bgpm, rect);
      return pm;
    }
  // FAILURE
  return 0;
}

void 
DjVuToPS::
make_gamma_ramp(GP<DjVuImage> dimg)
{
  double targetgamma = options.get_gamma();
  double whitepoint = (options.get_sRGB() ? 255 : 280);
  for (int i=0; i<256; i++)
    ramp[i] = i;
  if (! dimg->get_info()) 
    return;
  if (targetgamma < 0.1)
    return;
  double filegamma = dimg->get_info()->gamma;
  double correction = filegamma / targetgamma;
  if (correction<0.1 || correction>10)
    return;
  {
    for (int i=0; i<256; i++)
    {
      double x = (double)(i)/255.0;
      if (correction != 1.0) 
        x = pow(x, correction);        
      int j = (int) floor(whitepoint * x + 0.5);
      ramp[i] = (j>255) ? 255 : (j<0) ? 0 : j;
    }
  }
}

void
DjVuToPS::
print_fg_2layer(ByteStream &str, 
                GP<DjVuImage> dimg,
                const GRect &prn_rect, 
                unsigned char *blit_list)
{
  // Pure-jb2 or color-jb2 case.
  GPixel p;
  int currentx=0;
  int currenty=0;
  GP<DjVuPalette> pal = dimg->get_fgbc();
  GP<JB2Image> jb2 = dimg->get_fgjb();
  if (! jb2) return;
  int num_blits = jb2->get_blit_count();
  int current_blit;
  for(current_blit=0; current_blit<num_blits; current_blit++)
    {
      if (blit_list[current_blit])
        {
          JB2Blit *blit = jb2->get_blit(current_blit);
          if ((pal) && !(options.get_mode()==Options::BW))
            {
              pal->index_to_color(pal->colordata[current_blit], p);
              if (options.get_color())
                {
                  write(str,"/%d %d %d %f %f %f c\n",
                        blit->shapeno, 
                        blit->left-currentx, blit->bottom-currenty,
                        ramp[p.r]/255.0, ramp[p.g]/255.0, ramp[p.b]/255.0);
                } 
              else
                {
                  write(str,"/%d %d %d %f c\n",
                        blit->shapeno, 
                        blit->left-currentx, blit->bottom-currenty,
                        ramp[GRAY(p.r, p.g, p.b)]/255.0);
                }
            }
          else
            {
              write(str,"/%d %d %d s\n", 
                    blit->shapeno, 
                    blit->left-currentx, blit->bottom-currenty);
            }
          currentx = blit->left;
          currenty = blit->bottom;
        }
    }
}

void
DjVuToPS::
print_fg_3layer(ByteStream &str, 
                GP<DjVuImage> dimg,
                const GRect &cprn_rect, 
                unsigned char *blit_list )
{
  GRect prn_rect;
  GP<GPixmap> brush = dimg->get_fgpm();
  if (! brush) return;
  int br = brush->rows();
  int bc = brush->columns();
  int red = compute_red(dimg->get_width(),dimg->get_height(),bc,br);
  prn_rect.ymin = (cprn_rect.ymin)/red;
  prn_rect.xmin = (cprn_rect.xmin)/red;
  prn_rect.ymax = (cprn_rect.ymax+red-1)/red;
  prn_rect.xmax = (cprn_rect.xmax+red-1)/red;
  int color_nb = ((options.get_color()) ? 3 : 1);
  GP<JB2Image> jb2 = dimg->get_fgjb();
  if (! jb2) return;
  int pw = bc;
  int ph = 2;

  write(str,
        "/P {\n" 
        "  11 dict dup begin 4 1 roll\n"
        "    /PatternType 1 def\n"
        "    /PaintType 1 def\n"
        "    /TilingType 1 def\n"
        "    /H exch def\n"
        "    /W exch def\n"
        "    /Red %d def\n"
        "    /PatternString exch def\n"
        "    /XStep W Red mul def\n"
        "    /YStep H Red mul def\n"
        "    /BBox [0 0 XStep YStep] def\n"
        "    /PaintProc { begin\n"
        "       Red dup scale\n"
        "       << /ImageType 1 /Width W /Height H\n"
        "          /BitsPerComponent 8 /Interpolate false\n"
        "          /Decode [%s] /ImageMatrix [1 0 0 1 0 0]\n"
        "          /DataSource PatternString >> image\n"
        "       end } bind def\n"
        "     0 0 XStep YStep rectclip\n"
        "     end matrix makepattern\n"
        "  /Pattern setcolorspace setpattern\n"
        "  0 0 moveto\n"
        "} def\n", red, (color_nb == 1) ? "0 1" : "0 1 0 1 0 1" );

  unsigned char *s;
  GPBuffer<unsigned char> gs(s,pw*ph*color_nb);
  unsigned char *s_ascii_encoded;
  GPBuffer<unsigned char> gs_ascii_encoded(s_ascii_encoded,pw*ph*2*color_nb);
    {
      for (int y=prn_rect.ymin; y<prn_rect.ymax; y+=ph)
        for (int x=prn_rect.xmin; x<prn_rect.xmax; x+=pw)
          {
            int w = ((x+pw > prn_rect.xmax) ? prn_rect.xmax-x : pw);
            int h = ((y+ph > prn_rect.ymax) ? prn_rect.ymax-y : ph);
            int currentx = x * red;
            int currenty = y * red;
            // Find first intersecting blit
            int current_blit;
            int num_blits = jb2->get_blit_count();
            GRect rect1(currentx,currenty, w*red, h*red);
            for(current_blit=0; current_blit<num_blits; current_blit++)
              if (blit_list[current_blit])
                {
                  JB2Blit *blit = jb2->get_blit(current_blit);
                  GRect rect2(blit->left, blit->bottom,
                              jb2->get_shape(blit->shapeno).bits->columns(),
                              jb2->get_shape(blit->shapeno).bits->rows());
                  if (rect2.intersect(rect1,rect2)) 
                    break;
                }
            if (current_blit >= num_blits)
              continue;
            // Setup pattern
            write(str,"gsave %d %d translate\n", currentx, currenty);
            write(str,"<~");
            unsigned char *q = s;
            for(int current_row = y; current_row<y+h; current_row++)
              { 
                GPixel *row_pix = (*brush)[current_row];
                for(int current_col = x; current_col<x+w; current_col++)
                  { 
                    GPixel &p = row_pix[current_col];
                    if (color_nb>1)
                      {
                        *q++ = ramp[p.r];
                        *q++ = ramp[p.g];
                        *q++ = ramp[p.b];
                      }
                    else
                      {
                        *q++ = ramp[GRAY(p.r,p.g,p.b)];
                      }
                  }
              }
            unsigned char *stop_ascii = 
              ASCII85_encode(s_ascii_encoded,s,s+w*h*color_nb);
            *stop_ascii++='\0';
            write(str,"%s",s_ascii_encoded);
            write(str,"~> %d %d P\n", w, h);
            // Keep performing blits
            for(; current_blit<num_blits; current_blit++)
              if (blit_list[current_blit])
                {
                  JB2Blit *blit = jb2->get_blit(current_blit);
                  GRect rect2(blit->left, blit->bottom,
                              jb2->get_shape(blit->shapeno).bits->columns(),
                              jb2->get_shape(blit->shapeno).bits->rows()); 
                  if (rect2.intersect(rect1,rect2)) 
                    {   
                      write(str,"/%d %d %d s\n",
                            blit->shapeno, 
                            blit->left-currentx, blit->bottom-currenty);
                      currentx = blit->left;
                      currenty = blit->bottom;
                    }
                }
            write(str,"grestore\n");
          }
      // Cleanup
    }
}

void
DjVuToPS::
print_fg(ByteStream &str, 
         GP<DjVuImage> dimg,
         const GRect &prn_rect )
{
  GP<JB2Image> jb2=dimg->get_fgjb();
  if (! jb2) return;
  int num_blits = jb2->get_blit_count();
  int num_shapes = jb2->get_shape_count();
  unsigned char *dict_shapes = 0;
  unsigned char *blit_list = 0;
  GPBuffer<unsigned char> gdict_shapes(dict_shapes,num_shapes);
  GPBuffer<unsigned char> gblit_list(blit_list,num_blits);
  for(int i=0; i<num_shapes; i++)
  {
    dict_shapes[i]=0;
  }
  for(int current_blit=0; current_blit<num_blits; current_blit++)
  {
    JB2Blit *blit = jb2->get_blit(current_blit);
    JB2Shape *shape = & jb2->get_shape(blit->shapeno);
    blit_list[current_blit] = 0;
    if (! shape->bits) 
      continue;
    GRect rect2(blit->left, blit->bottom, 
      shape->bits->columns(), shape->bits->rows());
    if (rect2.intersect(rect2, prn_rect))
    {
      dict_shapes[blit->shapeno] = 1;
      blit_list[current_blit] = 1;
    }
  }
  write(str,
    "%% --- now doing the foreground\n"
    "gsave DjVuColorSpace setcolorspace\n" );
      // Define font
  write(str,
    "/$DjVuLocalFont 7 dict def\n"
    "$DjVuLocalFont begin\n"
    "/FontType 3 def \n"
    "/FontMatrix [1 0 0 1 0 0] def\n"
    "/FontBBox [0 0 1 .5] def\n"
    "/CharStrings %d dict def\n"
    "/Encoding 2 array def\n"
    "0 1 1 {Encoding exch /.notdef put} for \n"
    "CharStrings begin\n"
    "/.notdef {} def\n",
    num_shapes+1);
  for(int current_shape=0; current_shape<num_shapes; current_shape++)
  {
    if (dict_shapes[current_shape])
    {
      JB2Shape *shape = & jb2->get_shape(current_shape);
      GP<GBitmap> bitmap = shape->bits;
      int rows = bitmap->rows();
      int columns = bitmap->columns();
      int nbytes = (columns+7)/8*rows+1;
      int nrows = rows;
      int nstrings=0;
      if (nbytes>(int)ps_string_size)   //max string length
      {
        nrows=ps_string_size/((columns+7)/8);
        nbytes=(columns+7)/8*nrows+1;
      }
      unsigned char *s_start;
      GPBuffer<unsigned char> gs_start(s_start,nbytes);
      unsigned char *s_ascii;
      GPBuffer<unsigned char> gs_ascii(s_ascii,nbytes*2);
      write(str,"/%d {",current_shape);

      unsigned char *s = s_start;
      for(int current_row=0; current_row<rows; current_row++)
      {  
        unsigned char * row_bits = (*bitmap)[current_row];
        unsigned char acc = 0;
        unsigned char mask = 0;
        for(int current_col=0; current_col<columns; current_col++)
        {
          if (mask == 0)
            mask = 0x80;
          if (row_bits[current_col])
            acc |= mask;
          mask >>= 1;
          if (mask == 0)
          {
            *s=acc;
            s++;
            acc = mask = 0;
          }
        }
        if (mask != 0)
        {
          *s=acc;
          s++;
        }
        if (!((current_row+1)%nrows))
        {
          unsigned char *stop_ascii = ASCII85_encode(s_ascii,s_start,s); 
          *stop_ascii++='\0';
          write(str,"<~%s~> ",s_ascii);
          s=s_start;
          nstrings++;
        }
      }
      if (s!=s_start)
      {
        unsigned char *stop_ascii = ASCII85_encode(s_ascii,s_start,s);
        *stop_ascii++='\0';
        write(str,"<~%s~> ",s_ascii);
          nstrings++;
      }
      if (nstrings==1)
        write(str," %d %d g} def\n", columns, rows);                  
      else
        write(str," %d %d %d gn} def\n", columns, rows,nstrings);
    }
  }
  write(str, 
    "end\n"
    "/BuildGlyph {\n"
    "  exch /CharStrings get exch\n"
    "  2 copy known not\n"
    "  {pop /.notdef} if\n"
    "  get exec \n"
    "} bind def\n"
    "end\n"
    "/LocalDjVuFont $DjVuLocalFont definefont pop\n"
    "/LocalDjVuFont findfont setfont\n" );
  write(str,
    "-%d -%d translate\n"
    "0 0 moveto\n",
    prn_rect.xmin, prn_rect.ymin);
  // Print the foreground layer
  if (dimg->get_fgpm() && !(options.get_mode()==Options::BW)) 
    print_fg_3layer(str, dimg, prn_rect, blit_list);
  else
    print_fg_2layer(str, dimg, prn_rect, blit_list);        
  write(str, "/LocalDjVuFont undefinefont grestore\n");
}


void 
DjVuToPS::
print_bg(ByteStream &str, 
         GP<DjVuImage> dimg,
         const GRect &cprn_rect)
{
  GP<GPixmap> pm;
  GRect prn_rect;
  double print_done = 0;
  int red = 0;
  write(str, "%% --- now doing the background\n");
  if (! (red = get_bg_red(dimg)))
    return;
  write(str, 
        "gsave -%d -%d translate\n"
        "/bgred %d def bgred bgred scale\n",
        cprn_rect.xmin % red, 
        cprn_rect.ymin % red, 
        red);
  prn_rect.ymin = (cprn_rect.ymin)/red;
  prn_rect.ymax = (cprn_rect.ymax+red-1)/red;
  prn_rect.xmin = (cprn_rect.xmin)/red;
  prn_rect.xmax = (cprn_rect.xmax+red-1)/red;
  // Display image
  int band_bytes = 125000;
  int band_height = band_bytes/prn_rect.width();
  int buffer_size = band_height*prn_rect.width();
  int ps_chunk_height = 30960/prn_rect.width()+1;
  buffer_size = buffer_size*23/10;
  bool do_color = options.get_color();
  if ((!dimg->is_legal_photo() &&
       !dimg->is_legal_compound())
      || options.get_mode()==Options::BW)
    do_color = false;
  if (do_color) 
    buffer_size *= 3;
  if (do_color)
    write(str, 
          "/bufferR %d string def\n"
          "/bufferG %d string def\n"
          "/bufferB %d string def\n"
          "DjVuColorSpace setcolorspace\n"
          "<< /ImageType 1\n"
          "   /Width %d\n"
          "   /Height %d\n"
          "   /BitsPerComponent 8\n"
          "   /Decode [0 1 0 1 0 1]\n"
          "   /ImageMatrix [1 0 0 1 0 0]\n"
          "   /MultipleDataSources true\n"
          "   /DataSource [ { ReadR } { ReadG } { ReadB } ]\n"
          "   /Interpolate false >> image\n",
          ps_chunk_height*prn_rect.width(),
          ps_chunk_height*prn_rect.width(),
          ps_chunk_height*prn_rect.width(),
          prn_rect.width(), prn_rect.height());
  else
    write(str, 
          "DjVuColorSpace setcolorspace\n"
          "<< /ImageType 1\n"
          "   /Width %d\n"
          "   /Height %d\n"
          "   /BitsPerComponent 8\n"
          "   /Decode [0 1]\n"
          "   /ImageMatrix [1 0 0 1 0 0]\n"
          "   /DataSource currentfile /ASCII85Decode\n"
          "      filter /RunLengthDecode filter\n"
          "   /Interpolate false >> image\n",
          prn_rect.width(), prn_rect.height());
  
  unsigned char *buffer;
  GPBuffer<unsigned char> gbuffer(buffer,buffer_size);
  unsigned char *rle_in;
  GPBuffer<unsigned char> grle_in(rle_in,ps_chunk_height*prn_rect.width());
  unsigned char *rle_out;
  GPBuffer<unsigned char> grle_out(rle_out,2*ps_chunk_height*prn_rect.width());
  {
    // Start storing image in bands
    unsigned char * rle_out_end = rle_out;
    GRect grectBand = prn_rect;
    grectBand.ymax = grectBand.ymin;
    while(grectBand.ymax < prn_rect.ymax)
      {
        GP<GPixmap> pm = 0;
        // Compute next band
        grectBand.ymin=grectBand.ymax;
        grectBand.ymax=grectBand.ymin+band_bytes/grectBand.width();
        if (grectBand.ymax>prn_rect.ymax)
          grectBand.ymax=prn_rect.ymax;
        pm = get_bg_pixmap(dimg, grectBand);
        unsigned char *buf_ptr = buffer;
        if (pm)
          {
            if (do_color)
              {
                int y=0;
                while(y<grectBand.height())
                  {
                    int row, y1;
                    unsigned char *ptr, *ptr1;
                    // Doing R component of current chunk
                    for (row=0,ptr=rle_in,y1=y; 
                         row<ps_chunk_height && y1<grectBand.height(); 
                         row++,y1++)
                      {
                        GPixel *pix = (*pm)[y1];
                        for (int x=grectBand.width(); x>0; x--,pix++)
                          *ptr++ = ramp[pix->r];
                      }
                    ptr1 = RLE_encode(rle_out, rle_in, ptr); 
                    *ptr1++ = 0x80;
                    buf_ptr = ASCII85_encode(buf_ptr, rle_out, ptr1);
                    *buf_ptr++ = '~'; *buf_ptr++ = '>'; *buf_ptr++ = '\n';
                    // Doing G component of current chunk
                    for (row=0,ptr=rle_in,y1=y; 
                         row<ps_chunk_height && y1<grectBand.height(); 
                         row++,y1++)
                      {
                        GPixel *pix = (*pm)[y1];
                        for (int x=grectBand.width(); x>0; x--,pix++)
                          *ptr++ = ramp[pix->g];
                      }
                    ptr1 = RLE_encode(rle_out, rle_in, ptr); 
                    *ptr1++ = 0x80;
                    buf_ptr = ASCII85_encode(buf_ptr, rle_out, ptr1);
                    *buf_ptr++ = '~'; 
                    *buf_ptr++ = '>'; 
                    *buf_ptr++ = '\n';
                    // Doing B component of current chunk
                    for (row=0, ptr=rle_in, y1=y;
                         row<ps_chunk_height && y1<grectBand.height(); 
                         row++,y1++)
                      {
                        GPixel *pix = (*pm)[y1];
                        for (int x=grectBand.width(); x>0; x--,pix++)
                          *ptr++ = ramp[pix->b];
                      }
                    ptr1 = RLE_encode(rle_out, rle_in, ptr);
                    *ptr1++ = 0x80;
                    buf_ptr = ASCII85_encode(buf_ptr, rle_out, ptr1);
                    *buf_ptr++ = '~'; 
                    *buf_ptr++ = '>'; 
                    *buf_ptr++ = '\n';
                    y=y1;
                    if (refresh_cb) 
                      refresh_cb(refresh_cl_data);
                  } //while (y>=0)
              } 
            else
              {
                // Don't use color
                int y=0;
                while(y<grectBand.height())
                  {
                    unsigned char *ptr = rle_in;
                    for(int row=0; 
                        row<ps_chunk_height && y<grectBand.height(); 
                        row++,y++)
                      {
                        GPixel *pix = (*pm)[y];
                        for (int x=grectBand.width(); x>0; x--,pix++)
                          *ptr++ = ramp[GRAY(pix->r,pix->g,pix->b)];
                      }
                    rle_out_end = RLE_encode(rle_out_end, rle_in, ptr);
                    unsigned char *encode_to 
                      = rle_out+(rle_out_end-rle_out)/4*4;
                    int bytes_left = rle_out_end-encode_to;
                    buf_ptr = ASCII85_encode(buf_ptr, rle_out, encode_to);
                    *buf_ptr++ = '\n';
                    memcpy(rle_out, encode_to, bytes_left);
                    rle_out_end = rle_out+bytes_left;
                    if (refresh_cb) 
                      refresh_cb(refresh_cl_data);
                  }
              }
          } // if (pm)
        str.writall(buffer, buf_ptr-buffer);
        if (prn_progress_cb)
          {
            double done=(double)(grectBand.ymax 
                                 - prn_rect.ymin)/prn_rect.height();
            if ((int) (20*print_done)!=(int) (20*done))
              {
                print_done=done;
                prn_progress_cb(done, prn_progress_cl_data);
              }
          }
      } // while(grectBand.yax<grect.ymax)
    if (! do_color)
      {
        unsigned char * buf_ptr = buffer;
        *rle_out_end++ = 0x80;
        buf_ptr = ASCII85_encode(buf_ptr, rle_out, rle_out_end);
        *buf_ptr++='~'; 
        *buf_ptr++='>'; 
        *buf_ptr++='\n';
        str.writall(buffer, buf_ptr-buffer);
      }
  } 
  //restore the scaling
  write(str, "grestore\n");
}

void
DjVuToPS::
print_image_lev1(ByteStream &str, 
                 GP<DjVuImage> dimg,
                 const GRect &prn_rect)
{         
  double print_done=0;
  GRect all(0,0, dimg->get_width(),dimg->get_height());
  GP<GPixmap> pm;
  GP<GBitmap> bm;
  GRect test(0,0,1,1);
  if (options.get_mode() == Options::FORE)
    pm = dimg->get_fg_pixmap(test, all);
  else if (options.get_mode() == Options::BACK)
    pm = dimg->get_bg_pixmap(test, all);
  else if (options.get_mode() != Options::BW)
    pm = dimg->get_pixmap(test, all);
  if (! pm)
    bm = dimg->get_bitmap(test,all);
  if (! pm && ! bm)
    return;
  write(str,
        "%% --- now doing a level 1 image\n"
        "gsave\n");
  // Display image
  int band_bytes=125000;
  int band_height = band_bytes/prn_rect.width();
  int buffer_size = band_height*prn_rect.width();
  buffer_size = buffer_size*21/10;
  bool do_color = false;
  bool do_color_or_gray = false;
  if (pm && (options.get_mode() != Options::BW))
    do_color_or_gray = true;
  if (do_color_or_gray && options.get_color())
    do_color = true;
  if (do_color) 
    buffer_size *= 3;
  if (do_color)
    write(str, "/buffer24 %d string def\n", 3*prn_rect.width());
  if (do_color_or_gray)
    write(str, "/buffer8 %d string def\n", prn_rect.width());
  else
    write(str, "/buffer8 %d string def\n", (prn_rect.width()+7)/8);
  if (do_color)
    {
      write(str,
            "%d %d 8 [ 1 0 0 1 0 0 ]\n"
            "{ ColorProc } false 3 ColorImage\n",
            prn_rect.width(), prn_rect.height());
    } 
  else if (do_color_or_gray)
    {
      write(str,
            "%d %d 8 [ 1 0 0 1 0 0 ]\n"
            "{ currentfile buffer8 readhexstring pop } image\n",
            prn_rect.width(), prn_rect.height());
    } 
  else
    {
      write(str,
            "%d %d 1 [ 1 0 0 1 0 0 ]\n"
            "{ currentfile buffer8 readhexstring pop } image\n",
            prn_rect.width(), prn_rect.height());
    }
  unsigned char * buffer;
  GPBuffer<unsigned char> gbuffer(buffer,buffer_size);
    {
      // Start storing image in bands
      GRect grectBand = prn_rect;
      grectBand.ymax = grectBand.ymin;
      while(grectBand.ymax < prn_rect.ymax)
        {
          // Compute next band
          grectBand.ymin = grectBand.ymax;
          grectBand.ymax = grectBand.ymin+band_bytes/grectBand.width();
          if (grectBand.ymax > prn_rect.ymax)
            grectBand.ymax = prn_rect.ymax;
          GRect all(0,0, dimg->get_width(),dimg->get_height());
          pm = 0;
          bm = 0;
          if (do_color_or_gray)
            {
              if (options.get_mode() == Options::FORE)
                pm = dimg->get_fg_pixmap(grectBand, all);
              else if (options.get_mode() == Options::BACK)
                pm = dimg->get_bg_pixmap(grectBand, all);
              else
                pm = dimg->get_pixmap(grectBand, all);
            }
          else 
            {
              bm = dimg->get_bitmap(grectBand, all);
            }
          // Store next band
          unsigned char *buf_ptr = buffer;
          int symbols=0;
          for (int y=0; y<grectBand.height(); y++)
            {
              if (pm && do_color_or_gray)
                {
                  GPixel *pix = (*pm)[y];
                  for (int x=grectBand.width(); x>0; x--, pix++)
                    {
                      if (do_color)
                        {
                          char *data;
                          data = bin2hex[ramp[pix->r]];
                          *buf_ptr++ = data[0];
                          *buf_ptr++ = data[1];
                          data = bin2hex[ramp[pix->g]];
                          *buf_ptr++ = data[0];
                          *buf_ptr++ = data[1];
                          data = bin2hex[ramp[pix->b]];
                          *buf_ptr++ = data[0];
                          *buf_ptr++ = data[1];
                          symbols += 6;
                        }
                      else
                        {
                          char *data;
                          data = bin2hex[ramp[GRAY(pix->r,pix->g,pix->b)]];
                          *buf_ptr++ = data[0];
                          *buf_ptr++ = data[1];
                          symbols += 2;
                        }
                      if (symbols>70) 
                        { 
                          *buf_ptr++ = '\n'; 
                          symbols=0; 
                        }
                    }
                }
              else if (bm)
                {
                  unsigned char *pix = (*bm)[y];
                  unsigned char acc = 0;
                  unsigned char mask = 0;
                  char *data;
                  for (int x=grectBand.width(); x>0; x--, pix++)
                    {
                      if (mask == 0)
                        mask = 0x80;
                      if (! *pix)
                        acc |= mask;
                      mask >>= 1;
                      if (mask == 0)
                        {
                          data = bin2hex[acc];
                          acc = 0;
                          *buf_ptr++ = data[0];
                          *buf_ptr++ = data[1];
                          symbols += 2;
                          if (symbols>70) 
                            { 
                              *buf_ptr++ = '\n'; 
                              symbols = 0; 
                            }
                        }
                    }
                  if (mask != 0) 
                    {
                      data = bin2hex[acc];
                      *buf_ptr++ = data[0];
                      *buf_ptr++ = data[1];
                      symbols += 2;
                    }
                }
              if (refresh_cb) 
                refresh_cb(refresh_cl_data);
            }
          str.writall(buffer, buf_ptr-buffer);
          if (prn_progress_cb)
            {
              double done=(double) (grectBand.ymax 
                                    - prn_rect.ymin)/prn_rect.height();
              if ((int) (20*print_done)!=(int) (20*done))
                {
                  print_done=done;
                  prn_progress_cb(done, prn_progress_cl_data);
                }
            }
        }
      write(str, "\n");
    } 
  write(str, "grestore\n");
}

void
DjVuToPS::
print_image_lev2(ByteStream &str, 
                 GP<DjVuImage> dimg,
                 const GRect &prn_rect)
{         
  double print_done=0;
  GRect all(0,0, dimg->get_width(),dimg->get_height());
  GP<GPixmap> pm;
  GRect test(0,0,1,1);
  if (options.get_mode() == Options::FORE)
    pm = dimg->get_fg_pixmap(test, all);
  else if (options.get_mode() == Options::BACK)
    pm = dimg->get_bg_pixmap(test, all);
  else if (options.get_mode() != Options::BW)
    pm = dimg->get_pixmap(test, all);
  if (! pm)
    return;
  write(str,
        "%% --- now doing a level 2 image\n"
        "gsave\n");
  // Display image
  int band_bytes=125000;
  int band_height = band_bytes/prn_rect.width();
  int buffer_size = band_height*prn_rect.width();
  int ps_chunk_height = 30960/prn_rect.width()+1;
  buffer_size = buffer_size*21/10 + 32;
  bool do_color = options.get_color();
  if (do_color)
    {
      buffer_size *= 3;
      write(str, 
            "/bufferR %d string def\n"
            "/bufferG %d string def\n"
            "/bufferB %d string def\n"
            "DjVuColorSpace setcolorspace\n"
            "<< /ImageType 1\n"
            "   /Width %d\n"
            "   /Height %d\n"
            "   /BitsPerComponent 8\n"
            "   /Decode [0 1 0 1 0 1]\n"
            "   /ImageMatrix [1 0 0 1 0 0]\n"
            "   /MultipleDataSources true\n"
            "   /DataSource [ { ReadR } { ReadG } { ReadB } ]\n"
            "   /Interpolate false >> image\n",
            ps_chunk_height*prn_rect.width(),
            ps_chunk_height*prn_rect.width(),
            ps_chunk_height*prn_rect.width(),
            prn_rect.width(), prn_rect.height());
    } 
  else
    {
      write(str, 
            "DjVuColorSpace setcolorspace\n"
            "<< /ImageType 1\n"
            "   /Width %d\n"
            "   /Height %d\n"
            "   /BitsPerComponent 8\n"
            "   /Decode [0 1]\n"
            "   /ImageMatrix [1 0 0 1 0 0]\n"
            "   /DataSource currentfile /ASCII85Decode\n"
            "       filter /RunLengthDecode filter\n"
            "   /Interpolate false >> image\n",
            prn_rect.width(), prn_rect.height());
    } 
  unsigned char *buffer;
  GPBuffer<unsigned char> gbuffer(buffer,buffer_size);
  unsigned char *rle_in;
  GPBuffer<unsigned char> grle_in(rle_in,ps_chunk_height*prn_rect.width());
  unsigned char *rle_out;
  GPBuffer<unsigned char> grle_out(rle_out,2*ps_chunk_height*prn_rect.width());
    {
      // Start storing image in bands
      unsigned char * rle_out_end = rle_out;
      GRect grectBand = prn_rect;
      grectBand.ymax = grectBand.ymin;
      while(grectBand.ymax < prn_rect.ymax)
        {
          // Compute next band
          grectBand.ymin = grectBand.ymax;
          grectBand.ymax = grectBand.ymin+band_bytes/grectBand.width();
          if (grectBand.ymax > prn_rect.ymax)
            grectBand.ymax = prn_rect.ymax;
          GRect all(0,0, dimg->get_width(),dimg->get_height());
          pm = 0;
          if (options.get_mode() == Options::FORE)
            pm = dimg->get_fg_pixmap(grectBand, all);
          else if (options.get_mode() == Options::BACK)
            pm = dimg->get_bg_pixmap(grectBand, all);
          else
            pm = dimg->get_pixmap(grectBand, all);
          // Store next band
          unsigned char *buf_ptr = buffer;
          if (do_color && pm)
            {
              int y=0;
              while(y<grectBand.height())
                {
                  int row, y1;
                  unsigned char *ptr, *ptr1;
                  // Doing R component of current chunk
                  for (row=0,ptr=rle_in,y1=y; 
                       row<ps_chunk_height && y1<grectBand.height(); 
                       row++,y1++)
                    {
                      GPixel *pix = (*pm)[y1];
                      for (int x=grectBand.width(); x>0; x--,pix++)
                        *ptr++ = ramp[pix->r];
                    }
                  ptr1 = RLE_encode(rle_out, rle_in, ptr); 
                  *ptr1++ = 0x80;
                  buf_ptr = ASCII85_encode(buf_ptr, rle_out, ptr1);
                  *buf_ptr++ = '~'; *buf_ptr++ = '>'; *buf_ptr++ = '\n';
                  // Doing G component of current chunk
                  for (row=0,ptr=rle_in,y1=y; 
                       row<ps_chunk_height && y1<grectBand.height(); 
                       row++,y1++)
                    {
                      GPixel *pix = (*pm)[y1];
                      for (int x=grectBand.width(); x>0; x--,pix++)
                        *ptr++ = ramp[pix->g];
                    }
                  ptr1 = RLE_encode(rle_out, rle_in, ptr); 
                  *ptr1++ = 0x80;
                  buf_ptr = ASCII85_encode(buf_ptr, rle_out, ptr1);
                  *buf_ptr++ = '~'; 
                  *buf_ptr++ = '>'; 
                  *buf_ptr++ = '\n';
                  // Doing B component of current chunk
                  for (row=0, ptr=rle_in, y1=y;
                       row<ps_chunk_height && y1<grectBand.height(); 
                       row++,y1++)
                    {
                      GPixel *pix = (*pm)[y1];
                      for (int x=grectBand.width(); x>0; x--,pix++)
                        *ptr++ = ramp[pix->b];
                    }
                  ptr1 = RLE_encode(rle_out, rle_in, ptr);
                  *ptr1++ = 0x80;
                  buf_ptr = ASCII85_encode(buf_ptr, rle_out, ptr1);
                  *buf_ptr++ = '~'; 
                  *buf_ptr++ = '>'; 
                  *buf_ptr++ = '\n';
                  y=y1;
                  if (refresh_cb) 
                    refresh_cb(refresh_cl_data);
                } //while (y>=0)
            } 
          else if (pm)
            {
              // Don't use color
              int y=0;
              while(y<grectBand.height())
                {
                  unsigned char *ptr = rle_in;
                  for(int row=0;
                      row<ps_chunk_height && y<grectBand.height(); 
                      row++,y++)
                    {
                      GPixel *pix = (*pm)[y];
                      for (int x=grectBand.width(); x>0; x--,pix++)
                        *ptr++ = ramp[GRAY(pix->r,pix->g,pix->b)];
                    }
                  rle_out_end = RLE_encode(rle_out_end, rle_in, ptr);
                  unsigned char *encode_to = rle_out 
                    + (rle_out_end-rle_out)/4*4;
                  int bytes_left = rle_out_end-encode_to;
                  buf_ptr = ASCII85_encode(buf_ptr, rle_out, encode_to);
                  *buf_ptr++ = '\n';
                  memcpy(rle_out, encode_to, bytes_left);
                  rle_out_end = rle_out+bytes_left;
                  if (refresh_cb) 
                    refresh_cb(refresh_cl_data);
                }
              if (grectBand.ymax >= prn_rect.ymax)
                {
                  *rle_out_end++ = 0x80; // Add EOF marker
                  buf_ptr = ASCII85_encode(buf_ptr, rle_out, rle_out_end);
                  *buf_ptr++ = '~'; 
                  *buf_ptr++ = '>'; 
                  *buf_ptr++ = '\n';
                }
            }
          str.writall(buffer, buf_ptr-buffer);
          if (prn_progress_cb)
            {
              double done=(double) (grectBand.ymax
                                    - prn_rect.ymin)/prn_rect.height();
              if ((int) (20*print_done)!=(int) (20*done))
                {
                  print_done=done;
                  prn_progress_cb(done, prn_progress_cl_data);
                }
            }
        }
      write(str, "\n");
    } 
  write(str, "grestore\n");
}

static void 
get_anno_sub(IFFByteStream &iff, IFFByteStream &out)
{
  GUTF8String chkid;
  while (iff.get_chunk(chkid))
    {
      if (iff.composite())
        get_anno_sub(iff, out);
      else if (chkid == "ANTa" || chkid == "ANTz" ||
               chkid == "TXTa" || chkid == "TXTz"   )
        {
          out.put_chunk(chkid);
          out.copy(*iff.get_bytestream());
          out.close_chunk();
        }
      iff.close_chunk();
    }
}

static GP<ByteStream>
get_anno(GP<DjVuFile> f)
{
  if (! f->anno) 
    {
      GP<ByteStream> bs = f->get_init_data_pool()->get_stream();
      GP<ByteStream> anno = ByteStream::create();
      GP<IFFByteStream> in = IFFByteStream::create(bs);
      GP<IFFByteStream> out = IFFByteStream::create(anno);
      get_anno_sub(*in, *out);
      f->anno = anno;
    }
  f->anno->seek(0);
  return f->anno;
}

static GP<DjVuTXT>
get_text(GP<DjVuFile> file)
{ 
  GUTF8String chkid;
  GP<IFFByteStream> iff = IFFByteStream::create(get_anno(file));
  while (iff->get_chunk(chkid))
    {
      if (chkid == "TXTa") 
        {
          GP<DjVuTXT> txt = DjVuTXT::create();
          txt->decode(iff->get_bytestream());
          return txt;
        }
      else if (chkid == "TXTz") 
        {
          GP<DjVuTXT> txt = DjVuTXT::create();
          GP<ByteStream> bsiff = BSByteStream::create(iff->get_bytestream());
          txt->decode(bsiff);
          return txt;
        }
      iff->close_chunk();
    }
  return 0;
}

static void
print_ps_string(const char *data, int length, ByteStream &out)
{
  while (*data && length>0) 
    {
      int span = 0;
      while (span<length && data[span]>=0x20 && data[span]<0x7f 
             && data[span]!='(' && data[span]!=')' && data[span]!='\\' )
        span++;
      if (span > 0) 
        {
          out.write(data, span);
          data += span;
          length -= span;
        }
      else
        {
          char buffer[5];
          sprintf(buffer,"\\%03o", *(unsigned char*)data);
          out.write(buffer,4);
          data += 1;
          length -= 1;
        }
    }
}

static void
print_txt_sub(DjVuTXT &txt, DjVuTXT::Zone &zone, 
              ByteStream &out,int &lastx,int &lasty)
{
  // Get separator
  char separator = 0;
  switch(zone.ztype)
    {
    case DjVuTXT::COLUMN: 
      separator = DjVuTXT::end_of_column; break;
    case DjVuTXT::REGION: 
      separator = DjVuTXT::end_of_region; break;
    case DjVuTXT::PARAGRAPH: 
      separator = DjVuTXT::end_of_paragraph; break;
    case DjVuTXT::LINE: 
      separator = DjVuTXT::end_of_line; break;
    case DjVuTXT::WORD: 
      separator = ' '; break;
    default:
      separator = 0; break;
    }
  // Zone children
  if (zone.children.isempty()) 
    {
      const char *data = (const char*)txt.textUTF8 + zone.text_start;
      int length = zone.text_length;
      if (data[length-1] == separator)
        length -= 1;
      out.write("( ",2);
      print_ps_string(data,length,out);
      out.write(")",1);
      GUTF8String message;
      int tmpx= zone.rect.xmin-lastx;
      int tmpy= zone.rect.ymin-lasty;
      message.format(" %d %d S \n", tmpx, tmpy);
      lastx=zone.rect.xmin;
      lasty=zone.rect.ymin;
      out.write((const char*)message, message.length());
    }
  else
    {
      if (zone.ztype==DjVuTXT::LINE)
        {
          GUTF8String message;
          message.format("%d F\n",zone.rect.ymax-zone.rect.ymin);
          out.write((const char*)message,message.length());
        }
      for (GPosition pos=zone.children; pos; ++pos)
        print_txt_sub(txt, zone.children[pos], out,lastx,lasty);
    }
}

static void
print_txt(GP<DjVuTXT> txt, 
          ByteStream &out )
{
  if (txt)
    {
      int lastx=0;
      int lasty=0;
      GUTF8String message = 
        "%% -- now doing hidden text\n"
        "gsave -1 -1 0 0 clip 0 0 moveto\n";
      out.write((const char*)message,message.length());
      print_txt_sub(*txt, txt->page_zone, out,lastx,lasty);
      message = 
        "grestore \n";
      out.write((const char*)message,message.length());
    }
}

void
DjVuToPS::
print_image(ByteStream &str, 
            GP<DjVuImage> dimg,
            const GRect &prn_rect, 
            GP<DjVuTXT> txt)
{
  /* Just outputs the specified image. The function assumes, that
     all add-ons (like {\em document setup}, {\em page setup}) are
     already there. It will just output the image. Since
     output of this function will generate PostScript errors when
     used without output of auxiliary functions, it should be
     used carefully. */
  DEBUG_MSG("DjVuToPS::print_image(): Printing DjVuImage to a stream\n");
  DEBUG_MAKE_INDENT(3);
  if (!dimg)
    G_THROW(ERR_MSG("DjVuToPS.empty_image"));
  if (prn_rect.isempty())
    G_THROW(ERR_MSG("DjVuToPS.empty_rect"));
  if (prn_progress_cb)
    prn_progress_cb(0, prn_progress_cl_data);
  // Compute information for chosen display mode
  print_txt(txt, str);
  make_gamma_ramp(dimg);
  if (options.get_level() < 2)
    {
      print_image_lev1(str, dimg, prn_rect);
    }
  else if (options.get_level() < 3 && dimg->get_fgpm())
    {
      switch(options.get_mode())
        {
        case Options::COLOR:
        case Options::FORE:
          print_image_lev2(str, dimg, prn_rect);
          break;
        case Options::BW:
          print_fg(str, dimg, prn_rect);
          break;
        case Options::BACK:
          print_bg(str, dimg, prn_rect);
          break;
        }
    }
  else 
    {
      switch(options.get_mode())
        {
        case Options::COLOR:
          print_bg(str, dimg, prn_rect);
          print_fg(str, dimg, prn_rect);
          break;
        case Options::FORE:
        case Options::BW:
          print_fg(str, dimg, prn_rect);
          break;
        case Options::BACK:
          print_bg(str, dimg, prn_rect);
          break;
        }
    }
  if (prn_progress_cb)
    prn_progress_cb(1, prn_progress_cl_data);
}




// ***********************************************************************
// ******* PUBLIC FUNCTION FOR PRINTING A SINGLE PAGE ********************
// ***********************************************************************




void
DjVuToPS::
02074 print(ByteStream &str, 
      GP<DjVuImage> dimg,
      const GRect &prn_rect_in, 
      const GRect &img_rect,
      int override_dpi)
{
  DEBUG_MSG("DjVuToPS::print(): Printing DjVu page to a stream\n");
  DEBUG_MAKE_INDENT(3);
  GRect prn_rect;
  prn_rect.intersect(prn_rect_in, img_rect);
  DEBUG_MSG("prn_rect=(" << prn_rect.xmin << ", " << prn_rect.ymin << ", " <<
            prn_rect.width() << ", " << prn_rect.height() << ")\n");
  DEBUG_MSG("img_rect=(" << img_rect.xmin << ", " << img_rect.ymin << ", " <<
            img_rect.width() << ", " << img_rect.height() << ")\n");
  if (!dimg)
    G_THROW(ERR_MSG("DjVuToPS.empty_image"));
  if (prn_rect.isempty())
    G_THROW(ERR_MSG("DjVuToPS.empty_rect"));
  if (img_rect.isempty())
    G_THROW(ERR_MSG("DjVuToPS.bad_scale"));
  GRectMapper mapper;
  mapper.set_input(img_rect);
  GRect full_rect(0, 0, dimg->get_width(), dimg->get_height());
  mapper.set_output(full_rect);
  mapper.map(prn_rect);
  int image_dpi =  dimg->get_dpi();
  if (override_dpi>0) 
    image_dpi = override_dpi;
  if (image_dpi <= 0) 
    image_dpi = 300;
  store_doc_prolog(str, 1, (int)(image_dpi), &prn_rect);
  store_doc_setup(str);
  write(str,"%%%%Page: 1 1\n");
  store_page_setup(str, (int)(image_dpi), prn_rect);
  print_image(str, dimg, prn_rect, 0);
  store_page_trailer(str);
  write(str,"showpage\n");
  store_doc_trailer(str);
}




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


void
DjVuToPS::
parse_range(GP<DjVuDocument> doc, 
             GUTF8String page_range, 
             GList<int> &pages_todo)
{
  int doc_pages = doc->get_pages_num();
  if (!page_range.length())
    page_range.format("1-%d", doc_pages);
  DEBUG_MSG("page_range='" << (const char *)page_range << "'\n");
  int spec = 0;
  int both = 1;
  int start_page = 1;
  int end_page = doc_pages;
  const char *q = (const char*)page_range;
  char *p = (char*)q;
  while (*p)
    {
      while (*p==' ')
        p += 1;
      if (! *p)
        break;
      if (*p>='0' && *p<='9') 
        {
          end_page = strtol(p, &p, 10);
          spec = 1;
        } 
      else if (*p=='$') 
        {
          spec = 1;
          end_page = doc_pages;
          p += 1;
        } 
      else if (both) 
        {
          end_page = 1;
        } 
      else 
        {
          end_page = doc_pages;
        }
      while (*p==' ')
        p += 1;
      if (both)
        {
          start_page = end_page;
          if (*p == '-') 
            {
              p += 1;
              both = 0;
              continue;
            }
        }
      both = 1;
      while (*p==' ')
        p += 1;
      if (*p && *p != ',')
        G_THROW(ERR_MSG("DjVuToPS.bad_range") 
                + GUTF8String("\t") + GUTF8String(p) );
      if (*p == ',')
        p += 1;
      if (! spec)
        G_THROW(ERR_MSG("DjVuToPS.bad_range") 
                + GUTF8String("\t") + page_range );
      spec = 0;
      if (end_page < 0)
        end_page = 0;
      if (start_page < 0)
        start_page = 0;
      if (end_page > doc_pages)
        end_page = doc_pages;
      if (start_page > doc_pages)
        start_page = doc_pages;
      if (start_page <= end_page)
        for(int page_num=start_page; page_num<=end_page; page_num++)
          pages_todo.append(page_num-1);
      else
        for(int page_num=start_page; page_num>=end_page; page_num--)
          pages_todo.append(page_num-1);
    }
}

class DjVuToPS::DecodePort : public DjVuPort
{
protected:
  DecodePort(void);
public:
  static GP<DecodePort> create(void);
  GEvent decode_event;
  bool decode_event_received;
  double decode_done;
  GURL decode_page_url;
  virtual void notify_file_flags_changed(const DjVuFile*,long,long);
  virtual void notify_decode_progress(const DjVuPort*,double);
};

DjVuToPS::DecodePort::
DecodePort(void)
  : decode_event_received(false),
    decode_done((double)0) 
{
}

GP<DjVuToPS::DecodePort> 
DjVuToPS::DecodePort::
create(void)
{
  return new DecodePort;
}

void 
DjVuToPS::DecodePort::
notify_file_flags_changed(const DjVuFile *source, 
                          long set_mask, long clr_mask)
{
  // WARNING! This function is called from another thread
  if (set_mask & (DjVuFile::DECODE_OK | 
                  DjVuFile::DECODE_FAILED | 
                  DjVuFile::DECODE_STOPPED ))
    {
      if (source->get_url() == decode_page_url)
        {
          decode_event_received=true;
          decode_event.set();
        }
    }
}

void 
DjVuToPS::DecodePort::
notify_decode_progress(const DjVuPort *source, double done)
{
  // WARNING! This function is called from another thread
  if (source->inherits("DjVuFile"))
    {
      DjVuFile * file=(DjVuFile *) source;
      if (file->get_url()==decode_page_url)
        if ((int) (decode_done*20)!=(int) (done*20))
          {
            decode_done=done;
            decode_event_received=true;
            decode_event.set();
          }
    }
}

void 
DjVuToPS::
02270 set_refresh_cb(void (*_refresh_cb)(void*), void *_refresh_cl_data)
{
  refresh_cb = _refresh_cb;
  refresh_cl_data = _refresh_cl_data;
}

void 
DjVuToPS::
02278 set_prn_progress_cb(void (*_prn_progress_cb)(double, void *),
                    void *_prn_progress_cl_data)
{
  prn_progress_cb=_prn_progress_cb;
  prn_progress_cl_data=_prn_progress_cl_data;
}

void 
DjVuToPS::
02287 set_dec_progress_cb(void (*_dec_progress_cb)(double, void *),
                    void *_dec_progress_cl_data)
{
  dec_progress_cb=_dec_progress_cb;
  dec_progress_cl_data=_dec_progress_cl_data;
}

void 
DjVuToPS::
02296 set_info_cb(void (*_info_cb)(int, int, int, Stage, void*),
            void *_info_cl_data)
{
  info_cb=_info_cb;
  info_cl_data=_info_cl_data;
}

GP<DjVuImage>
DjVuToPS::
decode_page(GP<DjVuDocument> doc, 
            int page_num, int cnt, int todo)
{
  DEBUG_MSG("processing page #" << page_num << "\n");
  if (! port)
    {
      port = DecodePort::create();
      DjVuPort::get_portcaster()->add_route((DjVuDocument*)doc, port);
    }
  port->decode_event_received = false;
  port->decode_done = 0;
  GP<DjVuFile> djvu_file;
  GP<DjVuImage> dimg;
  if (page_num >= 0 && page_num < doc->get_pages_num())
    djvu_file = doc->get_djvu_file(page_num);
  if (! djvu_file )
    return 0;
  if (djvu_file->is_decode_ok())
    return doc->get_page(page_num, false);
  // This is the best place to call info_cb(). Note, that
  // get_page() will start decoding if necessary, and will not
  // return until the decoding is over in a single threaded
  // environment. That's why we call get_djvu_file() first.
  if (info_cb)
    info_cb(page_num, cnt, todo, DECODING, info_cl_data);
  // Do NOT decode the page synchronously here!!!
  // The plugin will deadlock otherwise.
  dimg = doc->get_page(page_num, false);
  djvu_file = dimg->get_djvu_file();
  port->decode_page_url = djvu_file->get_url();
  if (djvu_file->is_decode_ok())
    return dimg;
  DEBUG_MSG("decoding\n");
  if (dec_progress_cb)
    dec_progress_cb(0, dec_progress_cl_data);
  while(! djvu_file->is_decode_ok())
    {
      while(!port->decode_event_received && 
            !djvu_file->is_decode_ok())
        {
          port->decode_event.wait(250);
          if (refresh_cb) 
            refresh_cb(refresh_cl_data);
        }
      port->decode_event_received = false;
      if (djvu_file->is_decode_failed() || 
          djvu_file->is_decode_stopped())
        G_THROW(ERR_MSG("DjVuToPS.no_image") 
                + GUTF8String("\t") 
                + GUTF8String(page_num));
      if (dec_progress_cb)
        dec_progress_cb(port->decode_done, dec_progress_cl_data);
    }
  if (dec_progress_cb)
    dec_progress_cb(1, dec_progress_cl_data);
  return dimg;
}

void
DjVuToPS::
process_single_page(ByteStream &str, 
                    GP<DjVuDocument> doc,
                    int page_num, int cnt, int todo,
                    int magic)
{
  GP<DjVuTXT> txt;
  GP<DjVuImage> dimg;
  dimg = decode_page(doc, page_num, cnt, todo);
  if (options.get_text())
    txt = get_text(dimg->get_djvu_file());
  if (info_cb)
    info_cb(page_num, cnt, todo, PRINTING, info_cl_data);
  if (!magic)
    write(str, "%%%%Page: %d %d\n", page_num+1, cnt+1);
  if (dimg)
    {
      int dpi = dimg->get_dpi();
      dpi = ((dpi <= 0) ? 300 : dpi);
      GRect img_rect(0, 0, dimg->get_width(), dimg->get_height());
      store_page_setup(str, dpi, img_rect, magic);
      print_image(str, dimg, img_rect,txt);
      store_page_trailer(str);
    }
  if (!magic)
    write(str,"showpage\n");
}


struct pdata {
  int page1, page2;
  int smax, spos;
  int offset;
};

void 
DjVuToPS::
process_double_page(ByteStream &str, 
                    GP<DjVuDocument> doc,
                    void *v, int cnt, int todo)
{
  const pdata *inf = (const pdata*)v;
  int off = abs(inf->offset);
  write(str,
        "%%%%Page: (%d,%d) %d\n"
        "gsave\n"
        "/fold-dict 8 dict dup 3 1 roll def begin\n"
        " clippath pathbbox newpath pop pop translate\n"
        " clippath pathbbox newpath 4 2 roll pop pop\n"
        " /ph exch def\n"
        " /pw exch def\n"
        " /w ph %d sub 2 div def\n"
        " /m1 %d def\n"
        " /m2 %d def\n"
        "end\n",
        inf->page1 + 1, inf->page2 + 1, cnt,
        2 * (off + options.get_bookletfold(inf->smax-1)),
        inf->offset + options.get_bookletfold(inf->spos),
        inf->offset - options.get_bookletfold(inf->spos));
  if (options.get_cropmarks())
    write(str,
          "%% -- folding marks\n"
          "fold-dict begin\n"
          " 0 setgray 0.5 setlinewidth\n"
          " ph m1 m2 add add 2 div dup\n"
          " 0 exch moveto 36 0 rlineto stroke\n"
          " pw exch moveto -36 0 rlineto stroke\n"
          "end\n");
  write(str,
        "%% -- first page\n"
        "gsave fold-dict begin\n"
        " 0 ph 2 div w add m1 add translate 270 rotate\n"
        " 0 0 w pw rectclip end\n");
  if (inf->page1 >= 0)
    process_single_page(str, doc, inf->page1, cnt*2, todo*2, +1);
  write(str,
        "grestore\n"
        "%% -- second page\n"
        "gsave fold-dict begin\n"
        " 0 ph 2 div m2 add translate 270 rotate\n"
        " 0 0 w pw rectclip end\n");
  if (inf->page2 >= 0)
    process_single_page(str, doc, inf->page2, cnt*2+1, todo*2, -1);
  write(str,
        "grestore\n"
        "grestore\n"
        "showpage\n");
}

static void
booklet_order(GList<int>& pages, int smax)
{
  // -- make a multiple of four
  while (pages.size() & 0x3)
    pages.append(-1);
  // -- copy to array
  int i = 0;
  int n = pages.size();
  GTArray<int> p(0,n-1);
  for (GPosition pos=pages; pos; ++pos)
    p[i++] = pages[pos];
  // -- rebuild
  pages.empty();
  for (i=0; i<n; i+=smax)
    {
      int lo = i;
      int hi = i+smax-1;
      if (hi >= n)
        hi = n-1;
      while (lo < hi)
        {
          pages.append(p[hi--]);
          pages.append(p[lo++]);
          pages.append(p[lo++]);
          pages.append(p[hi--]);
        }
    }
}


// ***********************************************************************
// ******* PUBLIC FUNCTIONS FOR PRINTING MULTIPLE PAGES ******************
// ***********************************************************************



void
DjVuToPS::
02492 print(ByteStream &str, 
      GP<DjVuDocument> doc, 
      GUTF8String page_range)
{
  DEBUG_MSG("DjVuToPS::print(): Printing DjVu document\n");
  DEBUG_MAKE_INDENT(3);
  // Get page range
  GList<int> pages_todo;
  parse_range(doc, page_range, pages_todo);
  int todo = pages_todo.size();
  if (options.get_format()==Options::EPS)
    {
      /* Encapsulated Postscript mode */
      if (todo != 1)
        G_THROW(ERR_MSG("DjVuToPS.only_one_page"));
      GPosition pos = pages_todo;
      int page_num = pages_todo[pos];
      GP<DjVuImage> dimg = decode_page(doc,page_num,0,todo);
      if (! dimg)
        G_THROW(ERR_MSG("DjVuToPS.no_image") + GUTF8String("\t1"));
      GRect bbox(0, 0, dimg->get_width(), dimg->get_height());
      store_doc_prolog(str, 1, dimg->get_dpi(), &bbox);
      store_doc_setup(str);
      process_single_page(str, doc, page_num, 0, todo, 0);
    }
  else if (options.get_bookletmode()==Options::OFF)
    {
      /* Normal mode */
      int cnt = 0;
      store_doc_prolog(str, todo, 0, 0);
      store_doc_setup(str);
      for(GPosition pos = pages_todo; pos; ++pos)
        process_single_page(str,doc,pages_todo[pos],cnt++,todo,0);
      store_doc_trailer(str);
    }
  else
    {
      /* Booklet mode */
      int sheets_left = (todo+3)/4;
      int sides_todo = sheets_left;
      if (options.get_bookletmode() == Options::RECTOVERSO)
        sides_todo *= 2;
      int sheets_max = (options.get_bookletmax()+3)/4;
      if (! sheets_max)
        sheets_max = sheets_left;
      // -- reorder pages
      booklet_order(pages_todo, sheets_max*4);
      // -- print
      int sides = 0;
      int sheetpos = sheets_max;
      store_doc_prolog(str, sides_todo, 0, 0);
      store_doc_setup(str);
      for (GPosition p=pages_todo; p; ++p)
        {
          struct pdata inf;
          inf.page1 = pages_todo[p]; 
          inf.page2 = pages_todo[++p]; 
          inf.smax = sheets_max;
          inf.spos = --sheetpos;
          inf.offset = options.get_bookletalign();
          if (options.get_bookletmode() != Options::VERSO)
            process_double_page(str,doc,(void*)&inf,sides++,sides_todo);
          inf.page1 = pages_todo[++p]; 
          inf.page2 = pages_todo[++p]; 
          inf.offset = -inf.offset;
          if (options.get_bookletmode() != Options::RECTO)
            process_double_page(str,doc,(void*)&inf,sides++,sides_todo);
          sheets_left -= 1;
          if (sheetpos <= 0)
            sheetpos = ((sheets_max<sheets_left) ? sheets_max : sheets_left);
        }
      store_doc_trailer(str);
    }
}


void
DjVuToPS::
print(ByteStream &str, GP<DjVuDocument> doc)
{
  GUTF8String dummy;
  print(str,doc,dummy);
}



#ifdef HAVE_NAMESPACES
}
# ifndef NOT_USING_DJVU_NAMESPACE
using namespace DJVU;
# endif
#endif


Generated by  Doxygen 1.6.0   Back to index