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

#include "IFFByteStream.h"

#include "GOS.h"

#include "MMRDecoder.h"

#ifdef NEED_JPEG_DECODER

#include "JPEGDecoder.h"

#endif

#include "DjVuAnno.h"

#include "DjVuText.h"

#include "DataPool.h"

#include "JB2Image.h"

#include "IW44Image.h"

#include "DjVuNavDir.h"

#ifndef NEED_DECODER_ONLY

#include "BSByteStream.h"

#endif // NEED_DECODER_ONLY

#include "debug.h"

#ifdef HAVE_NAMESPACES

namespace DJVU {

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

}

#endif

#endif

#define STRINGIFY(x) STRINGIFY_(x)

#define STRINGIFY_(x) #x

#define REPORT_EOF(x) \

  {G_TRY{G_THROW( ByteStream::EndOfFile );}G_CATCH(ex){report_error(ex,(x));}G_ENDCATCH;}

static GP<GPixmap> (*djvu_decode_codec)(ByteStream &bs)=0;

class ProgressByteStream : public ByteStream

{

public:

  ProgressByteStream(const GP<ByteStream> & xstr) : str(xstr),

    last_call_pos(0) {}

  virtual ~ProgressByteStream() {}

  virtual size_t read(void *buffer, size_t size)

  {

    int rc=0;

	   // G_TRY {} CATCH; block here is merely to avoid egcs internal error

    G_TRY {

      int cur_pos=str->tell();

      if (progress_cb && (last_call_pos/256!=cur_pos/256))

      {

        progress_cb(cur_pos, progress_cl_data);

        last_call_pos=cur_pos;

      }

      rc=str->read(buffer, size);

    } G_CATCH_ALL {

      G_RETHROW;

    } G_ENDCATCH;

    return rc;

  }

  virtual size_t write(const void *buffer, size_t size)

  {

    return str->write(buffer, size);

  }

  virtual int seek(long offset, int whence = SEEK_SET, bool nothrow=false)

  {

    return str->seek(offset, whence);

  }

  virtual long tell(void ) const { return str->tell(); }

  void		set_progress_cb(void (* xprogress_cb)(int, void *),

  void * xprogress_cl_data)

  {

    progress_cb=xprogress_cb;

    progress_cl_data=xprogress_cl_data;

  }

private:

  GP<ByteStream> str;

  void		* progress_cl_data;

  void		(* progress_cb)(int pos, void *);

  int		last_call_pos;

  // Cancel C++ default stuff

  ProgressByteStream & operator=(const ProgressByteStream &);

};

DjVuFile::DjVuFile()

: file_size(0), recover_errors(ABORT), verbose_eof(false), chunks_number(-1),

initialized(false)

{

}

void

DjVuFile::check() const

{

  if (!initialized)

    G_THROW( ERR_MSG("DjVuFile.not_init") );

}

GP<DjVuFile>

DjVuFile::create(

  const GP<ByteStream> & str, const ErrorRecoveryAction recover_errors,

  const bool verbose_eof )

{

  DjVuFile *file=new DjVuFile();

  GP<DjVuFile> retval=file;

  file->set_recover_errors(recover_errors);

  file->set_verbose_eof(verbose_eof);

  file->init(str);

  return retval;

}

void 

DjVuFile::init(const GP<ByteStream> & str)

{

  DEBUG_MSG("DjVuFile::DjVuFile(): ByteStream constructor\n");

  DEBUG_MAKE_INDENT(3);

  if (initialized)

    G_THROW( ERR_MSG("DjVuFile.2nd_init") );

  if (!get_count())

    G_THROW( ERR_MSG("DjVuFile.not_secured") );

  file_size=0;

  decode_thread=0;

  // Read the data from the stream

  data_pool=DataPool::create(str);

  // Construct some dummy URL

  GUTF8String buffer;

  buffer.format("djvufile:/%p.djvu", this);

  DEBUG_MSG("DjVuFile::DjVuFile(): url is "<<(const char *)buffer<<"\n");

  url=GURL::UTF8(buffer);

  // Set it here because trigger will call other DjVuFile's functions

  initialized=true;

  // Add (basically - call) the trigger

  data_pool->add_trigger(-1, static_trigger_cb, this);

}

GP<DjVuFile>

DjVuFile::create(

  const GURL & xurl, GP<DjVuPort> port, 

  const ErrorRecoveryAction recover_errors, const bool verbose_eof ) 

{

  DjVuFile *file=new DjVuFile();

  GP<DjVuFile> retval=file;

  file->set_recover_errors(recover_errors);

  file->set_verbose_eof(verbose_eof);

  file->init(xurl,port);

  return retval;

}

void

DjVuFile::init(const GURL & xurl, GP<DjVuPort> port) 

{

  DEBUG_MSG("DjVuFile::init(): url='" << xurl << "'\n");

  DEBUG_MAKE_INDENT(3);

  if (initialized)

    G_THROW( ERR_MSG("DjVuFile.2nd_init") );

  if (!get_count())

    G_THROW( ERR_MSG("DjVuFile.not_secured") );

  if (xurl.is_empty())

    G_THROW( ERR_MSG("DjVuFile.empty_URL") );

  url = xurl;

  DEBUG_MSG("DjVuFile::DjVuFile(): url is "<<(const char *)url<<"\n");

  file_size=0;

  decode_thread=0;

  DjVuPortcaster * pcaster=get_portcaster();

  // We need it 'cause we're waiting for our own termination in stop_decode()

  pcaster->add_route(this, this);

  if (!port)

    port = simple_port = new DjVuSimplePort();

  pcaster->add_route(this, port);

  // Set it here because trigger will call other DjVuFile's functions

  initialized=true;

  if (!(data_pool=DataPool::create(pcaster->request_data(this, url))))

    G_THROW( ERR_MSG("DjVuFile.no_data") "\t"+url.get_string());

  data_pool->add_trigger(-1, static_trigger_cb, this);

}

DjVuFile::~DjVuFile(void)

{

  DEBUG_MSG("DjVuFile::~DjVuFile(): destroying...\n");

  DEBUG_MAKE_INDENT(3);

  // No more messages. They may result in adding this file to a cache

  // which will be very-very bad as we're being destroyed

  get_portcaster()->del_port(this);

  // Unregister the trigger (we don't want it to be called and attempt

  // to access the destroyed object)

  if (data_pool)

    data_pool->del_trigger(static_trigger_cb, this);

  // We don't have to wait for decoding to finish here. It's already

  // finished (we know it because there is a "life saver" in the

  // thread function)  -- but we need to delete it

  delete decode_thread; decode_thread=0;

}

void

DjVuFile::reset(void)

{

   flags.enter();

   info = 0; 

   anno = 0; 

   text = 0; 

   meta = 0; 

   bg44 = 0; 

   fgbc = 0;

   fgjb = 0; 

   fgjd = 0;

   fgpm = 0;

   dir  = 0; 

   description = ""; 

   mimetype = "";

   flags=(flags&(ALL_DATA_PRESENT|DECODE_STOPPED|DECODE_FAILED));

   flags.leave();

}

unsigned int

DjVuFile::get_memory_usage(void) const

{

   unsigned int size=sizeof(*this);

   if (info) size+=info->get_memory_usage();

   if (bg44) size+=bg44->get_memory_usage();

   if (fgjb) size+=fgjb->get_memory_usage();

   if (fgpm) size+=fgpm->get_memory_usage();

   if (fgbc) size+=fgbc->size()*sizeof(int);

   if (anno) size+=anno->size();

   if (meta) size+=meta->size();

   if (dir) size+=dir->get_memory_usage();

   return size;

}

GPList<DjVuFile>

DjVuFile::get_included_files(bool only_created)

{

  check();

  if (!only_created && !are_incl_files_created())

    process_incl_chunks();

  GCriticalSectionLock lock(&inc_files_lock);

  GPList<DjVuFile> list=inc_files_list;	// Get a copy when locked

  return list;

}

void

DjVuFile::wait_for_chunk(void)

// Will return after a chunk has been decoded

{

  check();

  DEBUG_MSG("DjVuFile::wait_for_chunk() called\n");

  DEBUG_MAKE_INDENT(3);

  chunk_mon.enter();

  chunk_mon.wait();

  chunk_mon.leave();

}

bool

DjVuFile::wait_for_finish(bool self)

// if self==TRUE, will block until decoding of this file is over

// if self==FALSE, will block until decoding of a child (direct

// or indirect) is over.

// Will return FALSE if there is nothing to wait for. TRUE otherwise

{

  DEBUG_MSG("DjVuFile::wait_for_finish():  self=" << self <<"\n");

  DEBUG_MAKE_INDENT(3);

  check();

  if (self)

  {

    // It's best to check for self termination using flags. The reason

    // is that finish_mon is updated in a DjVuPort function, which

    // will not be called if the object is being destroyed

    GMonitorLock lock(&flags);

    if (is_decoding())

    {

      while(is_decoding()) flags.wait();

      DEBUG_MSG("got it\n");

      return 1;

    }

  } else

  {

    // By locking the monitor, we guarantee that situation doesn't change

    // between the moments when we check for pending finish events

    // and when we actually run wait(). If we don't lock, the last child

    // may terminate in between, and we'll wait forever.

    //

    // Locking is required by GMonitor interface too, btw.

    GMonitorLock lock(&finish_mon);

    GP<DjVuFile> file;

    {

      GCriticalSectionLock lock(&inc_files_lock);

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

      {

        GP<DjVuFile> & f=inc_files_list[pos];

        if (f->is_decoding())

        {

          file=f; break;

        }

      }

    }

    if (file)

    {

      finish_mon.wait();

      DEBUG_MSG("got it\n");

      return 1;

    }

  }

  DEBUG_MSG("nothing to wait for\n");

  return 0;

}

void

DjVuFile::notify_chunk_done(const DjVuPort *, const GUTF8String &)

{

  check();

  chunk_mon.enter();

  chunk_mon.broadcast();

  chunk_mon.leave();

}

void

DjVuFile::notify_file_flags_changed(const DjVuFile * src,

                                    long set_mask, long clr_mask)

{

  check();

  if (set_mask & (DECODE_OK | DECODE_FAILED | DECODE_STOPPED))

  {

    // Signal threads waiting for file termination

    finish_mon.enter();

    finish_mon.broadcast();

    finish_mon.leave();

    // In case a thread is still waiting for a chunk

    chunk_mon.enter();

    chunk_mon.broadcast();

    chunk_mon.leave();

  }

  if ((set_mask & ALL_DATA_PRESENT) && src!=this &&

    are_incl_files_created() && is_data_present())

  {

    if (src!=this && are_incl_files_created() && is_data_present())

    {

      // Check if all children have data

      bool all=true;

      {

        GCriticalSectionLock lock(&inc_files_lock);

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

          if (!inc_files_list[pos]->is_all_data_present())

          {

            all=false;

            break;

          }

      }

      if (all)

      {

        DEBUG_MSG("Just got ALL data for '" << url << "'\n");

        flags|=ALL_DATA_PRESENT;

        get_portcaster()->notify_file_flags_changed(this, ALL_DATA_PRESENT, 0);

      }

    }

  }

}

void

DjVuFile::static_decode_func(void * cl_data)

{

  DjVuFile * th=(DjVuFile *) cl_data;

  /* Please do not undo this life saver. If you do then try to resolve the

  following conflict first:

  1. Decoding starts and there is only one external reference

  to the DjVuFile.

  2. Decoding proceeds and calls DjVuPortcaster::notify_error(),

  which creates inside a temporary GP<DjVuFile>.

  3. While notify_error() is running, the only external reference

  is lost, but the DjVuFile is still alive (remember the

  temporary GP<>?)

  4. The notify_error() returns, the temporary GP<> gets destroyed

  and the DjVuFile is attempting to destroy right in the middle

  of the decoding thread. This is either a dead block (waiting

  for the termination of the decoding from the ~DjVuFile() called

  from the decoding thread) or coredump. */

  GP<DjVuFile> life_saver=th;

  th->decode_life_saver=0;

  G_TRY {

    th->decode_func();

  } G_CATCH_ALL {

  } G_ENDCATCH;

}

void

DjVuFile::decode_func(void)

{

  check();

  DEBUG_MSG("DjVuFile::decode_func() called, url='" << url << "'\n");

  DEBUG_MAKE_INDENT(3);

  DjVuPortcaster * pcaster=get_portcaster();

  G_TRY {

    const GP<ByteStream> decode_stream(decode_data_pool->get_stream());

    ProgressByteStream *pstr=new ProgressByteStream(decode_stream);

    const GP<ByteStream> gpstr(pstr);

    pstr->set_progress_cb(progress_cb, this);

    decode(gpstr);

    // Wait for all child files to finish

    while(wait_for_finish(0))

    	continue;

    DEBUG_MSG("waiting for children termination\n");

    // Check for termination status

    GCriticalSectionLock lock(&inc_files_lock);

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

    {

      GP<DjVuFile> & f=inc_files_list[pos];

      if (f->is_decode_failed())

	G_THROW( ERR_MSG("DjVuFile.decode_fail") );

      if (f->is_decode_stopped())

	G_THROW( DataPool::Stop );

      if (!f->is_decode_ok())

	{

	  DEBUG_MSG("this_url='" << url << "'\n");

	  DEBUG_MSG("incl_url='" << f->get_url() << "'\n");

	  DEBUG_MSG("decoding=" << f->is_decoding() << "\n");

	  DEBUG_MSG("status='" << f->get_flags() << "\n");

	  G_THROW( ERR_MSG("DjVuFile.not_finished") );

	}

    }

  } G_CATCH(exc) {

    G_TRY {

      if (!exc.cmp_cause(DataPool::Stop))

	{

	  flags.enter();

	  flags = (flags & ~DECODING) | DECODE_STOPPED;

	  flags.leave();

	  pcaster->notify_status(this, GUTF8String(ERR_MSG("DjVuFile.stopped"))

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

	  pcaster->notify_file_flags_changed(this, DECODE_STOPPED, DECODING);

	} else

	{

	  flags.enter();

	  flags = (flags & ~DECODING) | DECODE_FAILED;

	  flags.leave();

	  pcaster->notify_status(this, GUTF8String(ERR_MSG("DjVuFile.failed"))

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

	  pcaster->notify_error(this, exc.get_cause());

	  pcaster->notify_file_flags_changed(this, DECODE_FAILED, DECODING);

	}

    } G_CATCH_ALL

	{

	  DEBUG_MSG("******* Oops. Almost missed an exception\n");

	} G_ENDCATCH;

  } G_ENDCATCH;

  decode_data_pool->clear_stream();

  G_TRY {

    if (flags.test_and_modify(DECODING, 0, DECODE_OK | INCL_FILES_CREATED, DECODING))

      pcaster->notify_file_flags_changed(this, DECODE_OK | INCL_FILES_CREATED, 

                                         DECODING);

  } G_CATCH_ALL {} G_ENDCATCH;

  DEBUG_MSG("decoding thread for url='" << url << "' ended\n");

}

GP<DjVuFile>

DjVuFile::process_incl_chunk(ByteStream & str, int file_num)

{

  check();

  DEBUG_MSG("DjVuFile::process_incl_chunk(): processing INCL chunk...\n");

  DEBUG_MAKE_INDENT(3);

  DjVuPortcaster * pcaster=get_portcaster();

  GUTF8String incl_str;

  char buffer[1024];

  int length;

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

    incl_str+=GUTF8String(buffer, length);

  // Eat '\n' in the beginning and at the end

  while(incl_str.length() && incl_str[0]=='\n')

  {

    incl_str=incl_str.substr(1,(unsigned int)(-1));

  }

  while(incl_str.length()>0 && incl_str[(int)incl_str.length()-1]=='\n')

  {

    incl_str.setat(incl_str.length()-1, 0);

  }

  if (incl_str.length()>0)

  {

    if (strchr(incl_str, '/'))

      G_THROW( ERR_MSG("DjVuFile.malformed") );

    DEBUG_MSG("incl_str='" << incl_str << "'\n");

    GURL incl_url=pcaster->id_to_url(this, incl_str);

    if (incl_url.is_empty())	// Fallback. Should never be used.

      incl_url=GURL::UTF8(incl_str,url.base());

    // Now see if there is already a file with this *name* created

    {

      GCriticalSectionLock lock(&inc_files_lock);

      GPosition pos;

      for(pos=inc_files_list;pos;++pos)

      {

        if (inc_files_list[pos]->url.fname()==incl_url.fname())

           break;

      }

      if (pos)

        return inc_files_list[pos];

    }

    // No. We have to request a new file

    GP<DjVuFile> file;

    G_TRY

    {

      file=pcaster->id_to_file(this, incl_str);

    }

    G_CATCH(ex)

    {

      unlink_file(incl_str);

      // In order to keep compatibility with the previous

      // release of the DjVu plugin, we will not interrupt

      // decoding here. We will just report the error.

      // NOTE, that it's now the responsibility of the

      // decoder to resolve all chunk dependencies, and

      // abort decoding if necessary.

      get_portcaster()->notify_error(this,ex.get_cause());

      return 0;

    }

    G_ENDCATCH;

    if (!file)

    {

      G_THROW( ERR_MSG("DjVuFile.no_create") "\t"+incl_str);

    }

    if (recover_errors!=ABORT)

      file->set_recover_errors(recover_errors);

    if (verbose_eof)

      file->set_verbose_eof(verbose_eof);

    pcaster->add_route(file, this);

    // We may have been stopped. Make sure the child will be stopped too.

    if (flags & STOPPED)

      file->stop(false);

    if (flags & BLOCKED_STOPPED)

      file->stop(true);

    // Lock the list again and check if the file has already been

    // added by someone else

    {

      GCriticalSectionLock lock(&inc_files_lock);

      GPosition pos;

      for(pos=inc_files_list;pos;++pos)

      {

        if (inc_files_list[pos]->url.fname()==incl_url.fname())

          break;

      }

      if (pos)

      {

        file=inc_files_list[pos];

      } else if (file_num<0 || !(pos=inc_files_list.nth(file_num)))

      {

        inc_files_list.append(file);

      } else 

      {

        inc_files_list.insert_before(pos, file);

      }

    }

    return file;

  }

  return 0;

}

void

DjVuFile::report_error(const GException &ex,bool throw_errors)

{

  data_pool->clear_stream();

  if((!verbose_eof)|| (ex.cmp_cause(ByteStream::EndOfFile)))

    {

      if(throw_errors)

        G_RETHROW(ex);

      else

        get_portcaster()->notify_error(this,ex.get_cause());

    }

  else

    {

      GURL url=get_url();

      GUTF8String url_str=url.get_string();

      GUTF8String msg = GUTF8String( ERR_MSG("DjVuFile.EOF") "\t") + url;

      if(throw_errors)

        G_RETHROW(GException(msg,ex.get_file(),ex.get_line(),ex.get_function()));

      else

        get_portcaster()->notify_error(this,msg);

    }

}

void

DjVuFile::process_incl_chunks(void)

// This function may block for data

// NOTE: It may be called again when INCL_FILES_CREATED is set.

// It happens in insert_file() when it has modified the data

// and wants to create the actual file

{

  DEBUG_MSG("DjVuFile::process_incl_chunks(void)\n");

  DEBUG_MAKE_INDENT(3);

  check();

  int incl_cnt=0;

  const GP<ByteStream> str(data_pool->get_stream());

  GUTF8String chkid;

  const GP<IFFByteStream> giff(IFFByteStream::create(str));

  IFFByteStream &iff=*giff;

  if (iff.get_chunk(chkid))

  {

    int chunks=0;

    int last_chunk=0;

    G_TRY

    {

      int chunks_left=(recover_errors>SKIP_PAGES)?chunks_number:(-1);

      int chksize;

      for(;(chunks_left--)&&(chksize=iff.get_chunk(chkid));last_chunk=chunks)

      {

        chunks++;

        if (chkid=="INCL")

        {

          G_TRY

          {

            process_incl_chunk(*iff.get_bytestream(), incl_cnt++);

          }

          G_CATCH(ex);

          {

            report_error(ex,(recover_errors <= SKIP_PAGES));

          }

          G_ENDCATCH;

        }else if(chkid=="FAKE")

        {

          set_needs_compression(true);

          set_can_compress(true);

        }else if(chkid=="BGjp")

        {

          set_can_compress(true);

        }else if(chkid=="Smmr")

        {

          set_can_compress(true);

        }

        iff.seek_close_chunk();

      }

      if (chunks_number < 0) chunks_number=last_chunk;

    }

    G_CATCH(ex)

    {	

      if (chunks_number < 0)

        chunks_number=(recover_errors>SKIP_CHUNKS)?chunks:last_chunk;

      report_error(ex,(recover_errors <= SKIP_PAGES));

    }

    G_ENDCATCH;

  }

  flags|=INCL_FILES_CREATED;

  data_pool->clear_stream();

}

GP<JB2Dict>

DjVuFile::static_get_fgjd(void *arg)

{

  DjVuFile *file = (DjVuFile*)arg;

  return file->get_fgjd(1);

}

GP<JB2Dict>

DjVuFile::get_fgjd(int block)

{

  check();

  // Simplest case

  if (fgjd)

    return fgjd;

  // Check wether included files

  chunk_mon.enter();

  G_TRY {

    for(;;)

    {

      int active = 0;

      GPList<DjVuFile> incs = get_included_files();

      for (GPosition pos=incs.firstpos(); pos; ++pos)

      {

        GP<DjVuFile> file = incs[pos];

        if (file->is_decoding())

          active = 1;

        GP<JB2Dict> fgjd = file->get_fgjd();

        if (fgjd)

        {

          chunk_mon.leave();

          return fgjd;

        }

      }

      // Exit if non-blocking mode

      if (! block)

        break;

      // Exit if there is no decoding activity

      if (! active)

        break;

      // Wait until a new chunk gets decoded

      wait_for_chunk();

    }

  } G_CATCH_ALL {

    chunk_mon.leave();

    G_RETHROW;

  } G_ENDCATCH;

  chunk_mon.leave();

  if (is_decode_stopped()) G_THROW( DataPool::Stop );

  return 0;

}

int

DjVuFile::get_dpi(int w, int h)

{

  int dpi=0, red=1;

  if (info)

  {

    for(red=1; red<=12; red++)

      if ((info->width+red-1)/red==w)

        if ((info->height+red-1)/red==h)

          break;

    if (red>12)

      G_THROW( ERR_MSG("DjVuFile.corrupt_BG44") );

    dpi=info->dpi;

  }

  return (dpi ? dpi : 300)/red;

}

static inline bool

is_info(const GUTF8String &chkid)

{

  return (chkid=="INFO");

}

static inline bool

is_annotation(const GUTF8String &chkid)

{

  return (chkid=="ANTa" ||

    chkid=="ANTz" ||

    chkid=="FORM:ANNO" ); 

}

static inline bool

is_text(const GUTF8String &chkid)

{

  return (chkid=="TXTa" || chkid=="TXTz");

}

static inline bool

is_meta(const GUTF8String &chkid)

{

  return (chkid=="METa" || chkid=="METz");

}

GUTF8String

DjVuFile::decode_chunk( const GUTF8String &id, const GP<ByteStream> &gbs,

  bool djvi, bool djvu, bool iw44)

{

  DEBUG_MSG("DjVuFile::decode_chunk()\n");

  ByteStream &bs=*gbs;

  check();

  // If this object is referenced by only one GP<> pointer, this

  // pointer should be the "life_saver" created by the decoding thread.

  // If it is the only GP<> pointer, then nobody is interested in the

  // results of the decoding and we can abort now with #DataPool::Stop#

  if (get_count()==1)

    G_THROW( DataPool::Stop );

  GUTF8String desc = ERR_MSG("DjVuFile.unrecog_chunk");

  GUTF8String chkid = id;

  DEBUG_MSG("DjVuFile::decode_chunk() : decoding " << id << "\n");

  // INFO  (information chunk for djvu page)

  if (is_info(chkid) && (djvu || djvi))

  {

    if (info)

      G_THROW( ERR_MSG("DjVuFile.corrupt_dupl") );

    if (djvi)

      G_THROW( ERR_MSG("DjVuFile.corrupt_INFO") );

    // DjVuInfo::decode no longer throws version exceptions

    GP<DjVuInfo> xinfo=DjVuInfo::create();

    xinfo->decode(bs);

    info = xinfo;

    desc.format( ERR_MSG("DjVuFile.page_info") );

    // Consistency checks (previously in DjVuInfo::decode)

    if (info->width<0 || info->height<0)

      G_THROW( ERR_MSG("DjVuFile.corrupt_zero") );

    if (info->version >= DJVUVERSION_TOO_NEW)

      G_THROW( ERR_MSG("DjVuFile.new_version") "\t" 

               STRINGIFY(DJVUVERSION_TOO_NEW) );

  }

  // INCL (inclusion chunk)