//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 "DjVuImage.h"

#include "GScaler.h"

#include "DjVuDocument.h"

#include "DjVuPalette.h"

#include "GContainer.h"

#include "GSmartPointer.h"

#include "JB2Image.h"

#include "IW44Image.h"

#include "DataPool.h"

#include "ByteStream.h"

#include "GMapAreas.h"

#include "DjVuText.h"

#include "IFFByteStream.h"

#include "BSByteStream.h"

#include "debug.h"

#include <stdarg.h>

#ifdef HAVE_NAMESPACES

namespace DJVU {

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

}

#endif

#endif

//// DJVUIMAGE: CONSTRUCTION

DjVuImage::DjVuImage(void) 

: rotate_count(-1),relayout_sent(false)

{

}

void

DjVuImage::connect(const GP<DjVuFile> & xfile)

{

   file=xfile;

   DjVuPort::get_portcaster()->add_route(file, this);

}

//// DJVUIMAGE: DATA COLLECTORS

GP<DjVuInfo>

DjVuImage::get_info(const GP<DjVuFile> & file) const

{

   if (file->info)

   {

     if(rotate_count<0)

     {

       const_cast<DjVuImage *>(this)->init_rotate(*(file->info));

     }

     return file->info;

   }

   GPList<DjVuFile> list=file->get_included_files();

   for(GPosition pos=list;pos;++pos)

   {

      GP<DjVuInfo> info=get_info(list[pos]);

      if (info) 

      {

        if(rotate_count<0)

        {

          const_cast<DjVuImage *>(this)->init_rotate(*(file->info));

        }

        return info;

      }

   }

   return 0;

}

GP<IW44Image>

DjVuImage::get_bg44(const GP<DjVuFile> & file) const

{

   if (file->bg44)

     return file->bg44;

   GPList<DjVuFile> list=file->get_included_files();

   for(GPosition pos=list;pos;++pos)

   {

      GP<IW44Image> bg44=get_bg44(list[pos]);

      if (bg44)

        return bg44;

   }

   return 0;

}

GP<GPixmap>

DjVuImage::get_bgpm(const GP<DjVuFile> & file) const

{

   if (file->bgpm)

     return file->bgpm;

   GPList<DjVuFile> list=file->get_included_files();

   for(GPosition pos=list;pos;++pos)

   {

      GP<GPixmap> bgpm=get_bgpm(list[pos]);

      if (bgpm) return bgpm;

   }

   return 0;

}

GP<JB2Image>

DjVuImage::get_fgjb(const GP<DjVuFile> & file) const

{

   if (file->fgjb)

     return file->fgjb;

   GPList<DjVuFile> list=file->get_included_files();

   for(GPosition pos=list;pos;++pos)

   {

      GP<JB2Image> fgjb=get_fgjb(list[pos]);

      if (fgjb)

        return fgjb;

   }

   return 0;

}

GP<GPixmap>

DjVuImage::get_fgpm(const GP<DjVuFile> & file) const

{

   if (file->fgpm)

     return file->fgpm;

   GPList<DjVuFile> list=file->get_included_files();

   for(GPosition pos=list;pos;++pos)

   {

      GP<GPixmap> fgpm=get_fgpm(list[pos]);

      if (fgpm)

        return fgpm;

   }

   return 0;

}

GP<DjVuPalette>

DjVuImage::get_fgbc(const GP<DjVuFile> & file) const

{

   if (file->fgbc)

     return file->fgbc;

   GPList<DjVuFile> list=file->get_included_files();

   for(GPosition pos=list;pos;++pos)

   {

      GP<DjVuPalette> fgbc=get_fgbc(list[pos]);

      if (fgbc) return fgbc;

   }

   return 0;

}

GP<DjVuInfo>   

DjVuImage::get_info() const

{

   if (file)

   {

     return get_info(file);

   }else

   {

     return 0;

   }

}

GP<ByteStream>

DjVuImage::get_anno() const

{

   GP<ByteStream> out = ByteStream::create();

   ByteStream &mbs = *out;

   if (file) 

   {

     file->merge_anno(mbs);

   }

   mbs.seek(0);

   if(!mbs.size())

   {

     out=0;

   }

   return out;

}

GP<ByteStream>

DjVuImage::get_text() const

{

   GP<ByteStream> out = ByteStream::create();

   ByteStream &mbs = *out;

   if (file) 

   {

     file->get_text(mbs);

   }

   mbs.seek(0);

   if(!mbs.size())

   {

     out=0;

   }

   return out;

}

GP<ByteStream>

DjVuImage::get_meta() const

{

   GP<ByteStream> out = ByteStream::create();

   ByteStream &mbs = *out;

   if (file) 

   {

     file->get_meta(mbs);

   }

   mbs.seek(0);

   if(!mbs.size())

   {

     out=0;

   }

   return out;

}

GP<IW44Image>   

DjVuImage::get_bg44() const

{

   if (file)

     return get_bg44(file);

   else

     return 0;

}

GP<GPixmap>   

DjVuImage::get_bgpm() const

{

   if (file)

     return get_bgpm(file);

   else

     return 0;

}

GP<JB2Image>   

DjVuImage::get_fgjb() const

{

   if (file)

     return get_fgjb(file);

   else

     return 0;

}

GP<GPixmap>    

DjVuImage::get_fgpm() const

{

   if (file)

     return get_fgpm(file);

   else

     return 0;

}

GP<DjVuPalette>    

DjVuImage::get_fgbc() const

{

   if (file)

     return get_fgbc(file);

   else

     return 0;

}

int

DjVuImage::get_width() const

{

   GP<DjVuInfo> info=get_info();

   return info?((rotate_count&1)?(info->height):(info->width)):0;

}

int

DjVuImage::get_height() const

{

   GP<DjVuInfo> info=get_info();

   return info?((rotate_count&1)?(info->width):(info->height)):0;

}

int

DjVuImage::get_real_width() const

{

   GP<DjVuInfo> info=get_info();

   return info ? info->width : 0;

}

int

DjVuImage::get_real_height() const

{

   GP<DjVuInfo> info=get_info();

   return info ? info->height : 0;

}

int

DjVuImage::get_version() const

{

   GP<DjVuInfo> info=get_info();

   return info ? info->version : DJVUVERSION;

}

int

DjVuImage::get_dpi() const

{

   GP<DjVuInfo> info=get_info();

   return info ? info->dpi : 300;

}

int

DjVuImage::get_rounded_dpi() const

{

   return (get_dpi()+5)/10*10;

#if 0   

      /* This code used to round the reported dpi to 25, 50, 75, 100, 150,

	 300, and 600. Now we just round the dpi to 10ths and return it */

   int dpi=get_dpi();

   if (dpi>700) return dpi;

   const int std_dpi[]={ 25, 50, 75, 100, 150, 300, 600 };

   const int std_dpis=sizeof(std_dpi)/sizeof(std_dpi[0]);

   int min_dist=abs(dpi-std_dpi[0]);

   int min_idx=0;

   for(int i=1;i

      if (abs(std_dpi[i]-dpi)

      {

         min_dist=abs(std_dpi[i]-dpi);

         min_idx=i;

      };

   return std_dpi[min_idx];

#endif

}

double

DjVuImage::get_gamma() const

{

   GP<DjVuInfo> info=get_info();

   return info ? info->gamma : 2.2;

}

GUTF8String

DjVuImage::get_mimetype() const

{

   return file ? file->mimetype : GUTF8String();

}

//// DJVUIMAGE: UTILITIES

GUTF8String

DjVuImage::get_short_description() const

{

  GUTF8String msg = "Empty";

  int width = get_width();

  int height = get_height();

  if (width && height)

    {

      if (file && file->file_size>100)

	//msg.format("%dx%d in %0.1f Kb", width, height, file->file_size/1024.0);

	msg.format( ERR_MSG("DjVuImage.short1") "\t%d\t%d\t%0.1f",

		    width, height, file->file_size/1024.0 );

      else

	//msg.format("%dx%d", width, height);

	msg.format( ERR_MSG("DjVuImage.short2") "\t%d\t%d", width, height );

    }

  return msg;

}

GUTF8String

DjVuImage::get_long_description() const

{

  return file?(file->description):GUTF8String();

}

void

DjVuImage::notify_chunk_done(const DjVuPort *, const GUTF8String & name)

{

   if (!relayout_sent &&

     ( !name.cmp("INFO", 4) ||

       !name.cmp("PMxx", 2) ||

       !name.cmp("BMxx", 2)  ) )

   {

      DjVuPort::get_portcaster()->notify_relayout(this);

      relayout_sent=true;

   } 

   else if (!name.cmp("Sxxx", 1) ||

            !name.cmp("BGxx", 2) ||

            !name.cmp("FGxx", 2) ||

            !name.cmp("BMxx", 2) ||

            !name.cmp("PMxx", 2)  )

     DjVuPort::get_portcaster()->notify_redisplay(this);

}

//// DJVUIMAGE: OLD-STYLE DECODING

DjVuInterface::~DjVuInterface() 

{

}

class DjVuImageNotifier : public DjVuPort

{

  friend class DjVuImage;

  DjVuInterface  *notifier;

  GP<DataPool>	  stream_pool;

  GURL		  stream_url;

public:

  DjVuImageNotifier(DjVuInterface *notifier);

  GP<DataPool> request_data(const DjVuPort *src, const GURL & url);

  void notify_chunk_done(const DjVuPort *, const GUTF8String &name);

  void notify_redisplay(const class DjVuImage * source);

  void notify_relayout(const class DjVuImage * source);

};

DjVuImageNotifier::DjVuImageNotifier(DjVuInterface *notifier)

  : notifier(notifier)

{

}

GP<DataPool> 

DjVuImageNotifier::request_data(const DjVuPort *src, const GURL & url)

{

  if (url!=stream_url)

    G_THROW( ERR_MSG("DjVuImage.not_decode") );

  return stream_pool;

}

void 

DjVuImageNotifier::notify_redisplay(const class DjVuImage * source)

{

  if (notifier)

    notifier->notify_redisplay();

}

void 

DjVuImageNotifier::notify_relayout(const class DjVuImage * source)

{

  if (notifier)

    notifier->notify_relayout();

}

void 

DjVuImageNotifier::notify_chunk_done(const DjVuPort *, const GUTF8String &name)

{

  if (notifier)

    notifier->notify_chunk(name, "" );

}

void

DjVuImage::decode(ByteStream & str, DjVuInterface *notifier)

{

  DEBUG_MSG("DjVuImage::decode(): decoding old way...\n");

  DEBUG_MAKE_INDENT(3);

  if (file) 

    G_THROW( ERR_MSG("DjVuImage.bad_call") );

  GP<DjVuImageNotifier> pport = new DjVuImageNotifier(notifier);

  pport->stream_url=GURL::UTF8("internal://fake/fake.djvu");

  pport->stream_pool=DataPool::create();

  // Get all the data first

  int length;

  char buffer[1024];

  while((length=str.read(buffer, 1024)))

    pport->stream_pool->add_data(buffer, length);

  pport->stream_pool->set_eof();

  GP<DjVuDocument> doc = DjVuDocument::create_wait(pport->stream_url, (DjVuImageNotifier*)pport);

  GP<DjVuImage> dimg=doc->get_page(-1, true, (DjVuImageNotifier*)pport);

  file=dimg->get_djvu_file();

  if (file->is_decode_stopped())

    G_THROW( DataPool::Stop );

  if (file->is_decode_failed())

    G_THROW( ByteStream::EndOfFile ); // guess

  if (!file->is_decode_ok())

    G_THROW( ERR_MSG("DjVuImage.mult_error") );

  DEBUG_MSG("decode DONE\n");

}

//// DJVUIMAGE: CHECKING

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;

}

int 

DjVuImage::is_legal_bilevel() const

{

  // Components

  GP<DjVuInfo> info = get_info();

  GP<JB2Image> fgjb = get_fgjb();

  GP<IW44Image> bg44 = get_bg44();

  GP<GPixmap>  bgpm = get_bgpm();

  GP<GPixmap>  fgpm = get_fgpm();

  // Check info

  if (! info)

    return 0;

  int width = info->width;

  int height = info->height;

  if (! (width>0 && height>0))

    return 0;

  // Check fgjb

  if (!fgjb)

    return 0;

  if (fgjb->get_width()!=width || fgjb->get_height()!=height)

    return 0;

  // Check that color information is not present.

  if (bg44 || bgpm || fgpm)

    return 0;

  // Ok.

  return 1;

}

int 

DjVuImage::is_legal_photo() const

{

  // Components

  GP<DjVuInfo> info = get_info();

  GP<JB2Image> fgjb = get_fgjb(); 

  GP<IW44Image> bg44 = get_bg44();

  GP<GPixmap>  bgpm = get_bgpm();

  GP<GPixmap>  fgpm = get_fgpm();

  // Check info

  if (! info)

    return 0;

  int width = info->width;

  int height = info->height;

  if (! (width>0 && height>0))

    return 0;

  // Check that extra information is not present.

  if (fgjb || fgpm)

    return 0;

  // Check bg44

  if (bg44 && bg44->get_width()==width && bg44->get_height()==height)

    return 1;

  // Check bgpm

  if (bgpm && (int)bgpm->columns()==width && (int)bgpm->rows()==height)

    return 1;

  // Ok.

  return 0;

}

int 

DjVuImage::is_legal_compound() const

{

  // Components

  GP<DjVuInfo>     info = get_info();

  GP<JB2Image>     fgjb = get_fgjb();

  GP<IW44Image>     bg44 = get_bg44();

  GP<GPixmap>      bgpm = get_bgpm();

  GP<GPixmap>      fgpm = get_fgpm();

  GP<DjVuPalette>  fgbc = get_fgbc();

  // Check size

  if (! info)

    return 0;

  int width = info->width;

  int height = info->height;

  if (! (width>0 && height>0))

    return 0;

  // Check fgjb

  if (!fgjb)

    return 0;

  if (fgjb->get_width()!=width || fgjb->get_height()!=height)

    return 0;

  // Check background

  int bgred = 0;

  if (bg44)

    bgred = compute_red(width, height, bg44->get_width(), bg44->get_height());

  else if (bgpm)

    bgred = compute_red(width, height, bgpm->columns(), bgpm->rows());

  if (bgred<1 || bgred>12)

    return 0;

  // Check foreground colors

  int fgred = 0;

  if (fgbc)

    fgred = 1;

  else if (fgpm)

    fgred = compute_red(width, height, fgpm->columns(), fgpm->rows());

  if (fgred<1 || fgred>12)

    return 0;

  // Check that all components are present

  if (fgjb && bgred && fgred)

    return 1;

  // Unrecognized

  return 0;

}

//// DJVUIMAGE: LOW LEVEL RENDERING

GP<GBitmap>

DjVuImage::get_bitmap(const GRect &rect, 

                      int subsample, int align) const

{

  // Access image size

  int width = get_real_width();

  int height = get_real_height();

  GP<JB2Image> fgjb = get_fgjb();

  if ( width && height && fgjb && 

       (fgjb->get_width() == width) && 

       (fgjb->get_height() == height) ) 

    {

      return fgjb->get_bitmap(rect, subsample, align);

    }

  return 0;

}

GP<GPixmap>

DjVuImage::get_bg_pixmap(const GRect &rect, 

                         int subsample, double gamma, GPixel white) const

{

  GP<GPixmap> pm = 0;

  // Access image size

  GP<DjVuInfo> info = get_info();

  int width = get_real_width();

  int height = get_real_height();

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

  // Compute gamma_correction

  double gamma_correction = 1.0;

  if (gamma > 0)

    gamma_correction = gamma / info->gamma;

  if (gamma_correction < 0.1)

    gamma_correction = 0.1;

  else if (gamma_correction > 10)

    gamma_correction = 10;

  // CASE1: Incremental BG IW44Image

  GP<IW44Image> bg44 = 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;

      // Determine how much bg44 is reduced

      int red = compute_red(width,height,w,h);

      if (red<1 || red>12)

        return 0;

      // Handle pure downsampling cases

      if (subsample == red)

        pm = bg44->get_pixmap(1,rect);

      else if (subsample == 2*red)

        pm = bg44->get_pixmap(2,rect);    

      else if (subsample == 4*red)

        pm = bg44->get_pixmap(4,rect); 

      else if (subsample == 8*red)

        pm = bg44->get_pixmap(8,rect); 

      // Handle fractional downsampling case

      else if (red*4 == subsample*3)

        {

          GRect nrect = rect;

          GRect xrect = rect;

          xrect.xmin = (xrect.xmin/3)*4;

          xrect.ymin = (xrect.ymin/3)*4;

          xrect.xmax = ((xrect.xmax+2)/3)*4;

          xrect.ymax = ((xrect.ymax+2)/3)*4;

          nrect.translate(-xrect.xmin*3/4, -xrect.ymin*3/4);

          if (xrect.xmax > w) 

            xrect.xmax = w;

          if (xrect.ymax > h) 

            xrect.ymax = h;

          GP<GPixmap> ipm = bg44->get_pixmap(1,xrect);

          pm = GPixmap::create();

          pm->downsample43(ipm, &nrect);

        }

      // Handle all other cases with pixmapscaler

      else

        {

          // find suitable power of two

          int po2 = 16;

          while (po2>1 && subsample

            po2 >>= 1;

          // setup pixmap scaler

          int inw = (w+po2-1)/po2;

          int inh = (h+po2-1)/po2;

          int outw = (width+subsample-1)/subsample;

          int outh = (height+subsample-1)/subsample;

          GP<GPixmapScaler> gps=GPixmapScaler::create(inw, inh, outw, outh);

          GPixmapScaler &ps=*gps;

          ps.set_horz_ratio(red*po2, subsample);

          ps.set_vert_ratio(red*po2, subsample);

          // run pixmap scaler

          GRect xrect;

          ps.get_input_rect(rect,xrect);

          GP<GPixmap> ipm = bg44->get_pixmap(po2,xrect);

          pm = GPixmap::create();

          ps.scale(xrect, *ipm, rect, *pm);

        }

      // Apply gamma correction

      if (pm)

        if (gamma_correction!=1.0 || white != GPixel::WHITE)

          pm->color_correct(gamma_correction, white);

      return pm;

    }

  // CASE 2: Raw background pixmap

  GP<GPixmap>  bgpm = 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;

      // Determine how much bgpm is reduced

      int red = compute_red(width,height,w,h);

      if (red<1 || red>12)

        return 0;

      // Handle pure downsampling cases

      int ratio = subsample/red;

      if (subsample==ratio*red && ratio>=1)

        {

          pm = GPixmap::create();

          if (ratio == 1)

            pm->init(*bgpm, rect);

          else if (ratio > 1)

            pm->downsample(bgpm, ratio, &rect);

        }

      // Handle all other cases with pixmapscaler

      else

        {

          // setup pixmap scaler

          int outw = (width+subsample-1)/subsample;

          int outh = (height+subsample-1)/subsample;

          GP<GPixmapScaler> gps=GPixmapScaler::create(w, h, outw, outh);

          GPixmapScaler &ps=*gps;

          ps.set_horz_ratio(red, subsample);

          ps.set_vert_ratio(red, subsample);

          // run pixmap scaler

          pm = GPixmap::create();

          GRect xrect(0,0,w,h);

          ps.scale(xrect, *bgpm, rect, *pm);

        }

      // Apply gamma correction

      if (pm)

        if (gamma_correction!=1.0 || white != GPixel::WHITE)

          pm->color_correct(gamma_correction, white);

      return pm;

    }

  // FAILURE

  return 0;

}

GP<GPixmap>

DjVuImage::get_bg_pixmap(const GRect &rect, int subsample, double gamma) const

{

  return get_bg_pixmap(rect, subsample, gamma, GPixel::WHITE);

}

int  

DjVuImage::stencil(GPixmap *pm, const GRect &rect,

		   int subsample, double gamma, GPixel white) const

{

  // Warping and blending. 

  if (!pm)

    return 0;

  // Access components

  GP<DjVuInfo> info = get_info();

  int width = get_real_width();

  int height = get_real_height();

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

  GP<JB2Image> fgjb = get_fgjb();

  GP<GPixmap> fgpm = get_fgpm();

  GP<DjVuPalette> fgbc = get_fgbc();

  // Compute gamma_correction

  double gamma_correction = 1.0;

  if (gamma > 0)

    gamma_correction = gamma / info->gamma;

  if (gamma_correction < 0.1)

    gamma_correction = 0.1;

  else if (gamma_correction > 10)

    gamma_correction = 10;

  // Compute alpha map and relevant JB2Image components

  GList<int> components;

  GP<GBitmap> bm;

  if (fgjb)

    {

      JB2Image *jimg = fgjb;

      if (! (width && height && 

             jimg->get_width() == width && 

             jimg->get_height() == height ) )

        return 0;

      // Decode bitmap

      bm = GBitmap::create(rect.height(), rect.width());

      bm->set_grays(1+subsample*subsample);

      int rxmin = rect.xmin * subsample;

      int rymin = rect.ymin * subsample;

      for (int blitno = 0; blitno < jimg->get_blit_count(); blitno++)

        {

          const JB2Blit *pblit = jimg->get_blit(blitno);

          const JB2Shape  &pshape = jimg->get_shape(pblit->shapeno);

          if (pshape.bits &&

              pblit->left <= rect.xmax * subsample &&

              pblit->bottom <= rect.ymax * subsample &&

              pblit->left+(int)pshape.bits->columns() >= rect.xmin*subsample &&

              pblit->bottom+(int)pshape.bits->rows() >= rect.ymin*subsample )

            {

              // Record component list

              if (fgbc) components.append(blitno);

              // Blit

              bm->blit(pshape.bits, 

                       pblit->left - rxmin, pblit->bottom - rymin, 

                       subsample);

            }

        }

    }

  // TWO LAYER MODEL

  if (bm && fgbc)