//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

// From: Leon Bottou, 1/31/2002

// Lizardtech has split the corresponding cpp file into a decoder and an encoder.

// Only superficial changes.  The meat is mine.

#include "JB2Image.h"

#include "GThreads.h"

#include "GRect.h"

#include "GBitmap.h"

#include <string.h>

#ifdef HAVE_NAMESPACES

namespace DJVU {

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

}

#endif

#endif

////////////////////////////////////////

//// CLASS JB2Codec::Decode:  DECLARATION

////////////////////////////////////////

// This class is accessed via the decode

// functions of class JB2Image

//**** Class JB2Codec

// This class implements the JB2 decoder.

// Contains all contextual information for decoding a JB2Image.

class JB2Dict::JB2Codec::Decode : public JB2Dict::JB2Codec

{

public:

  Decode(void);

  void init(const GP<ByteStream> &gbs;;

// virtual

  void code(const GP<JB2Image> &jim);

  void code(JB2Image *jim) {const GP<JB2Image> gjim(jim);code(gjim);}

  void code(const GP<JB2Dict> &jim);

  void code(JB2Dict *jim) {const GP<JB2Dict> gjim(jim);code(gjim);}

  void set_dict_callback(JB2DecoderCallback *cb, void *arg);

protected:

  int CodeNum(const int lo, const int hi, NumContext &ctx;;

// virtual

  bool CodeBit(const bool bit, BitContext &ctx;;

  void code_comment(GUTF8String &comment);

  void code_record_type(int &rectype);

  int code_match_index(int &index, JB2Dict &jim);

  void code_inherited_shape_count(JB2Dict &jim);

  void code_image_size(JB2Dict &jim);

  void code_image_size(JB2Image &jim);

  void code_absolute_location(JB2Blit *jblt,  int rows, int columns);

  void code_absolute_mark_size(GBitmap &bm, int border=0);

  void code_relative_mark_size(GBitmap &bm, int cw, int ch, int border=0);

  void code_bitmap_directly(GBitmap &bm,const int dw, int dy,

    unsigned char *up2, unsigned char *up1, unsigned char *up0 );

  void code_bitmap_by_cross_coding (GBitmap &bm, GBitmap &cbm,

    const int xd2c, const int dw, int dy, int cy,

    unsigned char *up1, unsigned char *up0, unsigned char *xup1, 

    unsigned char *xup0, unsigned char *xdn1 );

  int get_diff(const int x_diff,NumContext &rel_loc);

private:

  GP<ZPCodec> gzp;

  JB2DecoderCallback *cbfunc;

  void *cbarg;

};

////////////////////////////////////////

//// CLASS JB2DICT: IMPLEMENTATION

////////////////////////////////////////

JB2Dict::JB2Dict()

  : inherited_shapes(0)

{

}

void

JB2Dict::init()

{

  inherited_shapes = 0;

  inherited_dict = 0;

  shapes.empty();

}

JB2Shape &

JB2Dict::get_shape(const int shapeno)

{

  JB2Shape *retval;

  if(shapeno >= inherited_shapes)

  {

    retval=&shapes[shapeno - inherited_shapes];

  }else if(inherited_dict)

  {

    retval=&(inherited_dict->get_shape(shapeno));

  }else

  {

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

  }

  return *retval;

}

const JB2Shape &

JB2Dict::get_shape(const int shapeno) const

{

  const JB2Shape *retval;

  if(shapeno >= inherited_shapes)

  {

    retval=&shapes[shapeno - inherited_shapes];

  }else if(inherited_dict)

  {

    retval=&(inherited_dict->get_shape(shapeno));

  }else

  {

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

  }

  return *retval;

}

void 

JB2Dict::set_inherited_dict(const GP<JB2Dict> &dict)

{

  if (shapes.size() > 0)

    G_THROW( ERR_MSG("JB2Image.cant_set") );

  if (inherited_dict)

    G_THROW( ERR_MSG("JB2Image.cant_change") );

  inherited_dict = dict; 

  inherited_shapes = dict->get_shape_count();

  // Make sure that inherited bitmaps are marked as shared

  for (int i=0; i

    {

      JB2Shape &jshp = dict->get_shape(i);

      if (jshp.bits) jshp.bits->share();

    }

}

void

JB2Dict::compress()

{

  for (int i=shapes.lbound(); i<=shapes.hbound(); i++)

    shapes[i].bits->compress();

}

unsigned int

JB2Dict::get_memory_usage() const

{

  unsigned int usage = sizeof(JB2Dict);

  usage += sizeof(JB2Shape) * shapes.size();

  for (int i=shapes.lbound(); i<=shapes.hbound(); i++)

    if (shapes[i].bits)

      usage += shapes[i].bits->get_memory_usage();

  return usage;

}

int  

JB2Dict::add_shape(const JB2Shape &shape)

{

  if (shape.parent >= get_shape_count())

    G_THROW( ERR_MSG("JB2Image.bad_parent_shape") );

  int index = shapes.size();

  shapes.touch(index);

  shapes[index] = shape;

  return index + inherited_shapes;

}

void 

JB2Dict::decode(const GP<ByteStream> &gbs, JB2DecoderCallback *cb, void *arg)

{

  init();

  JB2Codec::Decode codec;

  codec.init(gbs);

  codec.set_dict_callback(cb,arg);

  codec.code(this);

}

////////////////////////////////////////

//// CLASS JB2IMAGE: IMPLEMENTATION

////////////////////////////////////////

JB2Image::JB2Image(void)

  : width(0), height(0), reproduce_old_bug(false)

{

}

void

JB2Image::init(void)

{

  width = height = 0;

  blits.empty();

  JB2Dict::init();

}

unsigned int

JB2Image::get_memory_usage() const

{

  unsigned int usage = JB2Dict::get_memory_usage();

  usage += sizeof(JB2Image) - sizeof(JB2Dict);

  usage += sizeof(JB2Blit) * blits.size();

  return usage;

}

void 

JB2Image::set_dimension(int awidth, int aheight)

{

  width = awidth;

  height = aheight;

}

int  

JB2Image::add_blit(const JB2Blit &blit)

{

  if (blit.shapeno >= (unsigned int)get_shape_count())

    G_THROW( ERR_MSG("JB2Image.bad_shape") );

  int index = blits.size();

  blits.touch(index);

  blits[index] = blit;

  return index;

}

GP<GBitmap>

JB2Image::get_bitmap(int subsample, int align) const

{

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

    G_THROW( ERR_MSG("JB2Image.cant_create") );

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

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

  int border = ((swidth + align - 1) & ~(align - 1)) - swidth;

  GP<GBitmap> bm = GBitmap::create(sheight, swidth, border);

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

  for (int blitno = 0; blitno < get_blit_count(); blitno++)

    {

      const JB2Blit *pblit = get_blit(blitno);

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

      if (pshape.bits)

        bm->blit(pshape.bits, pblit->left, pblit->bottom, subsample);

    }

  return bm;

}

GP<GBitmap>

JB2Image::get_bitmap(const GRect &rect, int subsample, int align, int dispy) const

{

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

    G_THROW( ERR_MSG("JB2Image.cant_create") );

  int rxmin = rect.xmin * subsample;

  int rymin = rect.ymin * subsample;

  int swidth = rect.width();

  int sheight = rect.height();

  int border = ((swidth + align - 1) & ~(align - 1)) - swidth;

  GP<GBitmap> bm = GBitmap::create(sheight, swidth, border);

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

  for (int blitno = 0; blitno < get_blit_count(); blitno++)

    {

      const JB2Blit *pblit = get_blit(blitno);

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

      if (pshape.bits)

        bm->blit(pshape.bits, pblit->left-rxmin, pblit->bottom-rymin+dispy, subsample);

    }

  return bm;

}

void 

JB2Image::decode(const GP<ByteStream> &gbs, JB2DecoderCallback *cb, void *arg)

{

  init();

  JB2Codec::Decode codec;

  codec.init(gbs);

  codec.set_dict_callback(cb,arg);

  codec.code(this);

}

////////////////////////////////////////

//// CLASS JB2CODEC : IMPLEMENTATION

////////////////////////////////////////

#define START_OF_DATA                   (0)

#define NEW_MARK                        (1)

#define NEW_MARK_LIBRARY_ONLY           (2)

#define NEW_MARK_IMAGE_ONLY             (3)

#define MATCHED_REFINE                  (4)

#define MATCHED_REFINE_LIBRARY_ONLY     (5)

#define MATCHED_REFINE_IMAGE_ONLY       (6)

#define MATCHED_COPY                    (7)

#define NON_MARK_DATA                   (8)

#define REQUIRED_DICT_OR_RESET          (9)

#define PRESERVED_COMMENT               (10)

#define END_OF_DATA                     (11)

// STATIC DATA MEMBERS

static const int BIGPOSITIVE = 262142;

static const int BIGNEGATIVE = -262143;

static const int CELLCHUNK = 20000;

static const int CELLEXTRA =   500;

// CONSTRUCTOR

JB2Dict::JB2Codec::Decode::Decode(void)

: JB2Dict::JB2Codec(0), cbfunc(0), cbarg(0) {}

void

JB2Dict::JB2Codec::Decode::init(const GP<ByteStream> &gbs)

{

  gzp=ZPCodec::create(gbs,false,true);

}

JB2Dict::JB2Codec::JB2Codec(const bool xencoding)

  : encoding(xencoding),

    cur_ncell(0),

    gbitcells(bitcells,CELLCHUNK+CELLEXTRA),

    gleftcell(leftcell,CELLCHUNK+CELLEXTRA),

    grightcell(rightcell,CELLCHUNK+CELLEXTRA),

    refinementp(false),

    gotstartrecordp(0),

    dist_comment_byte(0),

    dist_comment_length(0),

    dist_record_type(0),

    dist_match_index(0),

    dist_refinement_flag(0),

    abs_loc_x(0),

    abs_loc_y(0),

    abs_size_x(0),

    abs_size_y(0),

    image_size_dist(0),

    inherited_shape_count_dist(0),

    offset_type_dist(0),

    rel_loc_x_current(0),

    rel_loc_x_last(0),

    rel_loc_y_current(0),

    rel_loc_y_last(0),

    rel_size_x(0),

    rel_size_y(0)

{

  memset(bitdist, 0, sizeof(bitdist));

  memset(cbitdist, 0, sizeof(cbitdist));

  // Initialize numcoder

  bitcells[0] = 0; // dummy cell

  leftcell[0] = rightcell[0] = 0;

  cur_ncell = 1;

}

JB2Dict::JB2Codec::~JB2Codec() {}

void 

JB2Dict::JB2Codec::reset_numcoder()

{

  dist_comment_byte = 0;

  dist_comment_length = 0;

  dist_record_type = 0;

  dist_match_index = 0;

  abs_loc_x = 0;

  abs_loc_y = 0;

  abs_size_x = 0;

  abs_size_y = 0;

  image_size_dist = 0;

  inherited_shape_count_dist = 0;

  rel_loc_x_current = 0;

  rel_loc_x_last = 0;

  rel_loc_y_current = 0;

  rel_loc_y_last = 0;

  rel_size_x = 0;

  rel_size_y = 0;

  gbitcells.clear();

  gleftcell.clear();

  grightcell.clear();

  cur_ncell = 1;

}

void 

JB2Dict::JB2Codec::Decode::set_dict_callback(JB2DecoderCallback *cb, void *arg)

{

  cbfunc = cb;

  cbarg = arg;

}

// CODE NUMBERS

inline bool

JB2Dict::JB2Codec::Decode::CodeBit(const bool, BitContext &ctx)

{

  return gzp->decoder(ctx)?true:false;

}

int

JB2Dict::JB2Codec::Decode::CodeNum(int low, int high, NumContext &ctx)

{

  return JB2Codec::CodeNum(low,high,&ctx,0);

}

int

JB2Dict::JB2Codec::CodeNum(int low, int high, NumContext *pctx, int v)

{

  bool negative=false;

  int cutoff;

  // Check

  if (!pctx || ((int)*pctx >= cur_ncell))

    G_THROW( ERR_MSG("JB2Image.bad_numcontext") );

  // Start all phases

  cutoff = 0;

  for(int phase=1,range=0xffffffff;range != 1;)

    {

      if (! *pctx)

        {

          const int max_ncell=gbitcells;

          if (cur_ncell >= max_ncell)

            {

              const int nmax_ncell = max_ncell+CELLCHUNK;

              gbitcells.resize(nmax_ncell);

              gleftcell.resize(nmax_ncell);

              grightcell.resize(nmax_ncell);

            }

          *pctx = cur_ncell ++;

          bitcells[*pctx] = 0;

          leftcell[*pctx] = rightcell[*pctx] = 0;

        }

      // encode

      const bool decision = encoding

        ? ((low < cutoff && high >= cutoff)

          ? CodeBit((v>=cutoff),bitcells[*pctx])

          : (v >= cutoff))

        : ((low>=cutoff)||((high>=cutoff)&&CodeBit(false,bitcells[*pctx])));

      // context for new bit

      pctx = decision?(&rightcell[*pctx]):(&leftcell[*pctx]);

      // phase dependent part

      switch (phase) 

        {

	case 1:

          negative = !decision;

          if (negative) 

            {

              if (encoding)

                v = - v - 1;

              const int temp = - low - 1; 

              low = - high - 1; 

              high = temp;

	    }

          phase = 2; cutoff =  1;

          break;

	case 2:

          if (!decision) 

            {

              phase = 3;

              range = (cutoff + 1) / 2;

              if (range == 1)

                cutoff = 0;

              else

                cutoff -= range / 2;

	    }

          else 

            { 

              cutoff += cutoff + 1; 

            }

          break;

	case 3:

          range /= 2;

          if (range != 1) 

            {

              if (!decision)

                cutoff -= range / 2;

              else               

                cutoff += range / 2;

	    }

          else if (!decision) 

            {

                cutoff --;

	    }

          break;

	}

    }

    return (negative)?(- cutoff - 1):cutoff;

}

// CODE COMMENTS

void 

JB2Dict::JB2Codec::Decode::code_comment(GUTF8String &comment)

{

      int size=CodeNum(0, BIGPOSITIVE, dist_comment_length);

      comment.empty();

      char *combuf = comment.getbuf(size);

      for (int i=0; i

        {

          combuf[i]=CodeNum(0, 255, dist_comment_byte);

        }

      comment.getbuf();

}

// LIBRARY

void

JB2Dict::JB2Codec::init_library(JB2Dict &jim)

{

  int nshape = jim.get_inherited_shape_count();

  shape2lib.resize(0,nshape-1);

  lib2shape.resize(0,nshape-1);

  libinfo.resize(0,nshape-1);

  for (int i=0; i

    {

      shape2lib[i] = i;

      lib2shape[i] = i;

      jim.get_bounding_box(i, libinfo[i]);

    }

}

int 

JB2Dict::JB2Codec::add_library(const int shapeno, JB2Shape &jshp)

{

  const int libno = lib2shape.hbound() + 1;

  lib2shape.touch(libno);

  lib2shape[libno] = shapeno;

  shape2lib.touch(shapeno);

  shape2lib[shapeno] = libno;

  libinfo.touch(libno);

  libinfo[libno].compute_bounding_box(*(jshp.bits));

  return libno;

}

// CODE SIMPLE VALUES

inline void 

JB2Dict::JB2Codec::Decode::code_record_type(int &rectype)

{

  rectype=CodeNum( START_OF_DATA, END_OF_DATA, dist_record_type);

}

int 

JB2Dict::JB2Codec::Decode::code_match_index(int &index, JB2Dict &)

{

    int match=CodeNum(0, lib2shape.hbound(), dist_match_index);

    index = lib2shape[match];

    return match;

}

// HANDLE SHORT LIST

int 

JB2Dict::JB2Codec::update_short_list(const int v)

{

  if (++ short_list_pos == 3)

    short_list_pos = 0;

  int * const s = short_list;

  s[short_list_pos] = v;

  return (s[0] >= s[1])

    ?((s[0] > s[2])?((s[1] >= s[2])?s[1]:s[2]):s[0])

    :((s[0] < s[2])?((s[1] >= s[2])?s[2]:s[1]):s[0]);

}

// CODE PAIRS

void

JB2Dict::JB2Codec::Decode::code_inherited_shape_count(JB2Dict &jim)

{

  int size=CodeNum(0, BIGPOSITIVE, inherited_shape_count_dist);

    {

      GP<JB2Dict> dict = jim.get_inherited_dict();

      if (!dict && size>0)

        {

          // Call callback function to obtain dictionary

          if (cbfunc)

            dict = (*cbfunc)(cbarg);

          if (dict)

            jim.set_inherited_dict(dict);

        }

      if (!dict && size>0)

        G_THROW( ERR_MSG("JB2Image.need_dict") );

      if (dict && size!=dict->get_shape_count())

        G_THROW( ERR_MSG("JB2Image.bad_dict") );

    }

}

void 

JB2Dict::JB2Codec::Decode::code_image_size(JB2Dict &jim)

{

  int w=CodeNum(0, BIGPOSITIVE, image_size_dist);

  int h=CodeNum(0, BIGPOSITIVE, image_size_dist);

  if (w || h)

    G_THROW( ERR_MSG("JB2Image.bad_dict2") );

  JB2Codec::code_image_size(jim);

}

void 

JB2Dict::JB2Codec::code_image_size(JB2Dict &)

{

  last_left = 1;

  last_row_left = 0;

  last_row_bottom = 0;

  last_right = 0;

  fill_short_list(last_row_bottom);

  gotstartrecordp = 1;

}

void 

JB2Dict::JB2Codec::Decode::code_image_size(JB2Image &jim)

{

  image_columns=CodeNum(0, BIGPOSITIVE, image_size_dist);

  image_rows=CodeNum(0, BIGPOSITIVE, image_size_dist);

  if (!image_columns || !image_rows)

    G_THROW( ERR_MSG("JB2Image.zero_dim") );

  jim.set_dimension(image_columns, image_rows);

  JB2Codec::code_image_size(jim);

}

void 

JB2Dict::JB2Codec::code_image_size(JB2Image &)

{

  last_left = 1 + image_columns;

  last_row_left = 0;

  last_row_bottom = image_rows;

  last_right = 0;

  fill_short_list(last_row_bottom);

  gotstartrecordp = 1;

}

inline int

JB2Dict::JB2Codec::Decode::get_diff(int,NumContext &rel_loc)

{

   return CodeNum(BIGNEGATIVE, BIGPOSITIVE, rel_loc);

}

void 

JB2Dict::JB2Codec::code_relative_location(JB2Blit *jblt, int rows, int columns)

{

  // Check start record

  if (!gotstartrecordp)

    G_THROW( ERR_MSG("JB2Image.no_start") );

  // Find location

  int bottom=0, left=0, top=0, right=0;

  int x_diff, y_diff;

  if (encoding)

    {

      left = jblt->left + 1;

      bottom = jblt->bottom + 1;

      right = left + columns - 1;

      top = bottom + rows - 1;

    }

  // Code offset type

  int new_row=CodeBit((left

  if (new_row)

    {

      // Begin a new row

      x_diff=get_diff(left-last_row_left,rel_loc_x_last);

      y_diff=get_diff(top-last_row_bottom,rel_loc_y_last);

      if (!encoding)

        {

          left = last_row_left + x_diff;

          top = last_row_bottom + y_diff;

          right = left + columns - 1;

          bottom = top - rows + 1;

        }

      last_left = last_row_left = left;

      last_right = right;

      last_bottom = last_row_bottom = bottom;

      fill_short_list(bottom);

    }

  else

    {

      // Same row

      x_diff=get_diff(left-last_right,rel_loc_x_current);

      y_diff=get_diff(bottom-last_bottom,rel_loc_y_current);

      if (!encoding)

        {

          left = last_right + x_diff;

          bottom = last_bottom + y_diff;

          right = left + columns - 1;

          top = bottom + rows - 1;

        }

      last_left = left;

      last_right = right;

      last_bottom = update_short_list(bottom);

    }

  // Store in blit record

  if (!encoding)

    {

      jblt->bottom = bottom - 1;

      jblt->left = left - 1;

    }

}

void 

JB2Dict::JB2Codec::Decode::code_absolute_location(JB2Blit *jblt, int rows, int columns)

{

  // Check start record

  if (!gotstartrecordp)

    G_THROW( ERR_MSG("JB2Image.no_start") );

  int left=CodeNum(1, image_columns, abs_loc_x);

  int top=CodeNum(1, image_rows, abs_loc_y);

  jblt->bottom = top - rows + 1 - 1;

  jblt->left = left - 1;

}

void 

JB2Dict::JB2Codec::Decode::code_absolute_mark_size(GBitmap &bm, int border)

{

  int xsize=CodeNum(0, BIGPOSITIVE, abs_size_x);

  int ysize=CodeNum(0, BIGPOSITIVE, abs_size_y);

  if ((xsize!=(unsigned short)xsize) || (ysize!=(unsigned short)ysize))

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

  bm.init(ysize, xsize, border);

}

void 

JB2Dict::JB2Codec::Decode::code_relative_mark_size(GBitmap &bm, int cw, int ch, int border)

{

  int xdiff=CodeNum(BIGNEGATIVE, BIGPOSITIVE, rel_size_x);

  int ydiff=CodeNum(BIGNEGATIVE, BIGPOSITIVE, rel_size_y);

  int xsize = cw + xdiff;

  int ysize = ch + ydiff;

  if ((xsize!=(unsigned short)xsize) || (ysize!=(unsigned short)ysize))

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

  bm.init(ysize, xsize, border);

}

// CODE BITMAP DIRECTLY

void 

JB2Dict::JB2Codec::code_bitmap_directly (GBitmap &bm)

{

  // Make sure bitmap will not be disturbed

  GMonitorLock lock(bm.monitor());

  // ensure borders are adequate

  bm.minborder(3);

  // initialize row pointers

  int dy = bm.rows() - 1;

  code_bitmap_directly(bm,bm.columns(),dy,bm[dy+2],bm[dy+1],bm[dy]);

}

void 

JB2Dict::JB2Codec::Decode::code_bitmap_directly(

  GBitmap &bm,const int dw, int dy,

  unsigned char *up2, unsigned char *up1, unsigned char *up0 )

{

      ZPCodec &zp=*gzp;

      // iterate on rows (decoding)      

      while (dy >= 0)

        {

          int context=get_direct_context(up2, up1, up0, 0);

          for(int dx=0;dx < dw;)

            {

              int n = zp.decoder(bitdist[context]);

              up0[dx++] = n;

              context=shift_direct_context(context, n, up2, up1, up0, dx);

            }

          // next row

          dy -= 1;

          up2 = up1;

          up1 = up0;

          up0 = bm[dy];

        }

#ifndef NDEBUG

      bm.check_border();

#endif

}

// CODE BITMAP BY CROSS CODING

void 

JB2Dict::JB2Codec::code_bitmap_by_cross_coding (GBitmap &bm, GP<GBitmap> &cbm, const int libno)

{

  // Make sure bitmaps will not be disturbed

  GP<GBitmap> copycbm=GBitmap::create();

  if (cbm->monitor())

    {

      // Perform a copy when the bitmap is explicitely shared

      GMonitorLock lock2(cbm->monitor());

      copycbm->init(*cbm);

      cbm = copycbm;

    }

  GMonitorLock lock1(bm.monitor());

  // Center bitmaps

  const int cw = cbm->columns();

  const int dw = bm.columns();

  const int dh = bm.rows();

  const LibRect &l = libinfo[libno];

  const int xd2c = (dw/2 - dw + 1) - ((l.right - l.left + 1)/2 - l.right);

  const int yd2c = (dh/2 - dh + 1) - ((l.top - l.bottom + 1)/2 - l.top);

  // Ensure borders are adequate

  bm.minborder(2);

  cbm->minborder(2-xd2c);

  cbm->minborder(2+dw+xd2c-cw);

  // Initialize row pointers

  const int dy = dh - 1;

  const int cy = dy + yd2c;

#ifndef NDEBUG

  bm.check_border();

  cbm->check_border();