DjVuFile.h

//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: DjVuFile.h,v 1.12 2007/05/19 03:07:33 leonb Exp $// $Name: debian_version_3_5_20-7 $#ifndef _DJVUFILE_H#define _DJVUFILE_H#ifdef HAVE_CONFIG_H#include "config.h"#endif#if NEED_GNUG_PRAGMAS# pragma interface#endif#include "DjVuInfo.h"#include "DjVuPalette.h"#include "DjVuPort.h"#ifdef HAVE_NAMESPACESnamespace DJVU {
# ifdef NOT_DEFINED // Just to fool emacs c++ mode}
#endif#endifclass DjVuTXT;
class ByteStream;
class DataPool;
class JB2Image;
class JB2Dict;
class IW44Image;
class IFFByteStream;
class GPixmap;
class DjVuNavDir;
/** @name DjVuFile.h Files #"DjVuFile.h"# and #"DjVuFile.cpp"# contain implementation of the \Ref{DjVuFile} class, which takes the leading role in decoding of \Ref{DjVuImage}s. In the previous releases of the library the work of decoding has been entirely done in \Ref{DjVuImage}. Now, due to the introduction of multipage documents, the decoding procedure became significantly more complex and has been moved out from \Ref{DjVuImage} into \Ref{DjVuFile}. There is not much point though in creating just \Ref{DjVuFile} alone. The maximum power of the decoder is achieved when you create the \Ref{DjVuDocument} and work with {\bf it} when decoding the image. @memo Classes representing DjVu files. @author Andrei Erofeev <eaf@geocities.com> @version #$Id: DjVuFile.h,v 1.12 2007/05/19 03:07:33 leonb Exp $#*///@{/** #DjVuFile# plays the central role in decoding \Ref{DjVuImage}s. First of all, it represents a DjVu file whether it's part of a multipage all-in-one-file DjVu document, or part of a multipage DjVu document where every page is in a separate file, or the whole single page document. #DjVuFile# can read its contents from a file and store it back when necessary. Second, #DjVuFile# does the greatest part of decoding work. In the past this was the responsibility of \Ref{DjVuImage}. Now, with the introduction of the multipage DjVu formats, the decoding routines have been extracted from the \Ref{DjVuImage} and put into this separate class #DjVuFile#. As \Ref{DjVuImage} before, #DjVuFile# now contains public class variables corresponding to every component, that can ever be decoded from a DjVu file (such as #INFO# chunk, #BG44# chunk, #SJBZ# chunk, etc.). As before, the decoding is initiated by a single function (\Ref{start_decode}() in this case, and \Ref{DjVuImage::decode}() before). The difference is that #DjVuFile# now handles threads creation itself. When you call the \Ref{start_decode}() function, it creates the decoding thread, which starts decoding, and which can create additional threads: one per each file included into this one. {\bf Inclusion} is also a new feature specifically designed for a multipage document. Indeed, inside a given document there can be a lot of things shared between its pages. Examples can be the document annotation (\Ref{DjVuAnno}) and other things like shared shapes and dictionary (to be implemented). To avoid putting these chunks into every page, we have invented new chunk called #INCL# which purpose is to make the decoder open the specified file and decode it. {\bf Source of data.} The #DjVuFile# can be initialized in two ways: \begin{itemize} \item With #URL# and \Ref{DjVuPort}. In this case #DjVuFile# will request its data thru the communication mechanism provided by \Ref{DjVuPort} in the constructor. If this file references (includes) any other file, data for them will also be requested in the same way. \item With \Ref{ByteStream}. In this case the #DjVuFile# will read its data directly from the passed stream. This constructor has been added to simplify creation of #DjVuFile#s, which do no include anything else. In this case the \Ref{ByteStream} is enough for the #DjVuFile# to initialize. \end{itemize} {\bf Progress information.} #DjVuFile# does not do decoding silently. Instead, it sends a whole set of notifications through the mechanism provided by \Ref{DjVuPort} and \Ref{DjVuPortcaster}. It tells the user of the class about the progress of the decoding, about possible errors, chunk being decoded, etc. The data is requested using this mechanism too. {\bf Creating.} Depending on where you have data of the DjVu file, the #DjVuFile# can be initialized in two ways: \begin{itemize} \item By providing #URL# and pointer to \Ref{DjVuPort}. In this case #DjVuFile# will request data using communication mechanism provided by \Ref{DjVuPort}. This is useful when the data is on the web or when this file includes other files. \item By providing a \Ref{ByteStream} with the data for the file. Use it only when the file doesn't include other files. \end{itemize} There is also a bunch of functions provided for composing the desired \Ref{DjVuDocument} and modifying #DjVuFile# structure. The examples are \Ref{delete_chunks}(), \Ref{insert_chunk}(), \Ref{include_file}() and \Ref{unlink_file}(). {\bf Caching.} In the case of plugin it's important to do the caching of decoded images or files. #DjVuFile# appears to be the best candidate for caching, and that's why it supports this procedure. Whenever a #DjVuFile# is successfully decoded, it's added to the cache by \Ref{DjVuDocument}. Next time somebody needs it, it will be extracted from the cache directly by \Ref{DjVuDocument} and won't be decoded again. {\bf URLs.} Historically the biggest strain is put on making the decoder available for Netscape and IE plugins where the original files reside somewhere in the net. That is why #DjVuFile# uses {\bf URLs} to identify itself and other files. If you're working with files on the hard disk, you have to use the local URLs instead of file names. A good way to do two way conversion is the \Ref{GOS} class. Sometimes it happens that a given file does not reside anywhere but the memory. No problem in this case either. There is a special port \Ref{DjVuMemoryPort}, which can associate any URL with the corresponding data in the memory. All you need to do is to invent your own URL prefix for this case. "#memory:#" will do. The usage of absolute URLs has many advantages among which is the capability to cache files with their URL being the cache key. Please note, that the #DjVuFile# class has been designed to work closely with \Ref{DjVuDocument}. So please review the documentation on this class too. */00203class DJVUAPI DjVuFile : publicDjVuPort
{
public:
enum { DECODING=1, DECODE_OK=2, DECODE_FAILED=4, DECODE_STOPPED=8,
DATA_PRESENT=16, ALL_DATA_PRESENT=32, INCL_FILES_CREATED=64,
MODIFIED=128, DONT_START_DECODE=256, STOPPED=512,
BLOCKED_STOPPED=1024, CAN_COMPRESS=2048, NEEDS_COMPRESSION=4096 };
enum { STARTED=1, FINISHED=2 };
/** @name Decoded file contents */ //@{ /// Pointer to the DjVu file information component.00215GP<DjVuInfo> info; /// Pointer to the background component of DjVu image (IW44 encoded).00217GP<IW44Image> bg44; /// Pointer to the background component of DjVu image (Raw).00219GP<GPixmap> bgpm; /// Pointer to the mask of foreground component of DjVu image (JB2 encoded).00221GP<JB2Image> fgjb; /// Pointer to the optional shape dictionary for the mask (JB2 encoded).00223GP<JB2Dict> fgjd; /// Pointer to a colors layer for the foreground component of DjVu image.00225GP<GPixmap> fgpm; /// Pointer to a colors vector for the foreground component of DjVu image.00227GP<DjVuPalette> fgbc; /// Pointer to collected annotation chunks.00229GP<ByteStream> anno; /// Pointer to collected hiddentext chunks.00231GP<ByteStream> text; /// Pointer to meta data chunks.00233GP<ByteStream> meta; /// Pointer to the *old* navigation directory contained in this file00235GP<DjVuNavDir> dir; /// Description of the file formed during decoding00237GUTF8String description; /// MIME type string describing the DjVu data.00239GUTF8String mimetype; /// Size of the file.00241int file_size; //@}protected: /** Default constructor. Must follow with an init() */DjVuFile(void);
public:
virtual ~DjVuFile(void);
/** Initializes a #DjVuFile# object. This is a simplified initializer, which is not supposed to be used for decoding or creating #DjVuFile#s, which include other files. If the file is stored on the hard drive, you may also use the other constructor and pass it the file's URL and #ZERO# #port#. The #DjVuFile# will read the data itself. If you want to receive error messages and notifications, you may connect the #DjVuFile# to your own \Ref{DjVuPort} after it has been constructed. @param str The stream containing data for the file. */void init(constGP<ByteStream> & str);
/** Creator, does the init(ByteStream &str) */staticGP<DjVuFile> create( constGP<ByteStream> & str,
constErrorRecoveryAction recover_action=ABORT,
constbool verbose_eof=true);
/** Initializes a #DjVuFile# object. As you can notice, the data is not directly passed to this function. The #DjVuFile# will ask for it through the \Ref{DjVuPort} mechanism before the constructor finishes. If the data is stored locally on the hard disk then the pointer to \Ref{DjVuPort} may be set to #ZERO#, which will make #DjVuFile# read all data from the hard disk and report all errors to #stderr#. {\bf Note}. If the file includes (by means of #INCL# chunks) other files then you should be ready to \begin{enumerate} \item Reply to requests \Ref{DjVuPort::id_to_url}() issued to translate IDs (used in #INCL# chunks) to absolute URLs. Usually, when the file is created by \Ref{DjVuDocument} this job is done by it. If you construct such a file manually, be prepared to do the ID to URL translation \item Provide data for all included files. \end{enumerate} @param url The URL assigned to this file. It will be used when the #DjVuFile# asks for data. @param port All communication between #DjVuFile#s and \Ref{DjVuDocument}s is done through the \Ref{DjVuPort} mechanism. If the {\em url} is not local or the data does not reside on the hard disk, the {\em port} parameter must not be #ZERO#. If the {\em port} is #ZERO# then #DjVuFile# will create an internal instance of \Ref{DjVuSimplePort} for accessing local files and reporting errors. It can later be disabled by means of \Ref{disable_standard_port}() function. */void init(constGURL & url, GP<DjVuPort> port=0);
/** Creator, does the init(const GURL &url, GP<DjVuPort> port=0) */staticGP<DjVuFile> create(
constGURL & url, GP<DjVuPort> port=0,
constErrorRecoveryAction recover_action=ABORT,
constbool verbose_eof=true);
/** Disables the built-in port for accessing local files, which may have been created in the case when the #port# argument to the \Ref{DjVuFile::DjVuFile}() constructor is #ZERO# */void disable_standard_port(void);
/** Looks for #decoded# navigation directory (\Ref{DjVuNavDir}) in this or included files. Returns #ZERO# if nothing could be found. {\bf Note.} This function does {\bf not} attempt to decode #NDIR# chunks. It is looking for predecoded components. #NDIR# can be decoded either during regular decoding (initiated by \Ref{start_decode}() function) or by \Ref{decode_ndir}() function, which processes this and included files recursively in search of #NDIR# chunks and decodes them. */GP<DjVuNavDir> find_ndir(void);
/** @name #DjVuFile# flags query functions */ //@{ /** Returns the #DjVuFile# flags. The value returned is the result of ORing one or more of the following constants: \begin{itemize} \item #DECODING# The decoding is in progress \item #DECODE_OK# The decoding has finished successfully \item #DECODE_FAILED# The decoding has failed \item #DECODE_STOPPED# The decoding has been stopped by \Ref{stop_decode}() function \item #DATA_PRESENT# All data for this file has been received. It's especially important in the case of Netscape or IE plugins when the data is being received while the decoding is done. \item #ALL_DATA_PRESENT# Not only data for this file, but also for all included file has been received. \item #INCL_FILES_CREATED# All #INCL# and #INCF# chunks have been processed and the corresponding #DjVuFile#s created. This is important to know to be sure that the list returned by \Ref{get_included_files}() is OK. \end{itemize} */long get_flags(void) const; /// Returns #TRUE# if the file is being decoded.bool is_decoding(void) const; /// Returns #TRUE# if decoding of the file has finished successfully.bool is_decode_ok(void) const; /// Returns #TRUE# if decoding of the file has failed.bool is_decode_failed(void) const; /** Returns #TRUE# if decoding of the file has been stopped by \Ref{stop_decode}() function. */bool is_decode_stopped(void) const; /// Returns #TRUE# if this file has received all data.bool is_data_present(void) const; /** Returns #TRUE# if this file {\bf and} all included files have received all data. */bool is_all_data_present(void) const; /** Returns #TRUE# if all included files have been created. Only when this function returns 1, the \Ref{get_included_files}() returns the correct information. */bool are_incl_files_created(void) const;
bool is_modified(void) const;
bool needs_compression(void) const;
bool can_compress(void) const;
void set_modified(bool m);
void set_needs_compression(bool m);
void set_can_compress(bool m); //@} /// Returns the URL assigned to this fileGURL get_url(void) const;
/** @name Decode control routines */ //@{ /** Starts decode. If threads are enabled, the decoding will be done in another thread. Be sure to use \Ref{wait_for_finish}() or listen for notifications sent through the \Ref{DjVuPortcaster} to remain in sync. */void start_decode(void); /** Start the decode iff not already decoded. If sync is true, wait wait for decode to complete. Returns true of start_decode is called. */bool resume_decode(constbool sync=false); /** Stops decode. If #sync# is 1 then the function will not return until the decoding thread actually dies. Otherwise it will just signal the thread to stop and will return immediately. Decoding of all included files will be stopped too. */void stop_decode(bool sync); /** Recursively stops all data-related operations. Depending on the value of #only_blocked# flag this works as follows: \begin{itemize} \item If #only_blocked# is #TRUE#, the function will make sure, that any further access to the file's data will result in a #STOP# exception if the desired data is not available (and the thread would normally block). \item If #only_blocked# is #FALSE#, then {\bf any} further access to the file's data will result in immediate #STOP# exception. \end{itemize} The action of this function is recursive, meaning that any #DjVuFile# included into this one will also be stopped. Use this function when you don't need the #DjVuFile# anymore. The results cannot be undone, and the whole idea is to make all threads working with this file exit with the #STOP# exception. */void stop(bool only_blocked); /** Wait for the decoding to finish. This will wait for the termination of included files too. */void wait_for_finish(void); /** Looks for #NDIR# chunk (navigation directory), and decodes its contents. If the #NDIR# chunk has not been found in {\em this} file, but this file includes others, the procedure will continue recursively. This function is useful to obtain the document navigation directory before any page has been decoded. After it returns the directory can be obtained by calling \Ref{find_ndir}() function. {\bf Warning.} Contrary to \Ref{start_decode}(), this function does not return before it completely decodes the directory. Make sure, that this file and all included files have enough data. */GP<DjVuNavDir> decode_ndir(void); /// Clears all decoded components.void reset(void); /** Processes #INCL# chunks and creates included files. Normally you won't need to call this function because included files are created automatically when the file is being decoded. But if due to some reason you'd like to obtain the list of included files without decoding this file, this is an ideal function to call. {\bf Warning.} This function does not return before it reads the whole file, which may block your application under some circumstances if not all data is available. */void process_incl_chunks(void); //@}// Function needed by the cacheunsignedint get_memory_usage(void) const;
/** Returns the list of included DjVuFiles. {\bf Warning.} Included files are normally created during decoding. Before that they do not exist. If you call this function at that time and set #only_created# to #FALSE# then it will have to read all the data from this file in order to find #INCL# chunks, which may block your application, if not all data is available. @param only_created If #TRUE#, the file will not try to process #INCL# chunks and load referenced files. It will return just those files, which have already been created during the decoding procedure. */GPList<DjVuFile> get_included_files(bool only_created=true);
/** Includes a #DjVuFile# with the specified #id# into this one. This function will also insert an #INCL# chunk at position #chunk_num#. The function will request data for the included file and will create it before returning. */void insert_file(constGUTF8String &id, int chunk_num=1); /// Will get rid of included file with the given #id#void unlink_file(constGUTF8String &id); /** Will find an #INCL# chunk containing #name# in input #data# and will remove it */staticGP<DataPool> unlink_file(constGP<DataPool> & data, constGUTF8String &name);
/// Returns the number of chunks in the IFF file dataint get_chunks_number(void); /// Returns the name of chunk number #chunk_num#GUTF8String get_chunk_name(int chunk_num); /// Returns 1 if this file contains chunk with name #chunk_name#bool contains_chunk(constGUTF8String &chunk_name);
/** Processes the included files hierarchy and returns merged annotations. This function may be used even when the #DjVuFile# has not been decoded yet. If all data has been received for this #DjVuFile# and all included #DjVuFile#s, it will will gather annotations from them and will return the result. If no annotations have been found, #ZERO# will be returned. If either this #DjVuFile# or any of the included files do not have all the data, the function will use the results of decoding, which may have been started with the \Ref{start_decode}() function. Otherwise #ZERO# will be returned as well. If #max_level_ptr# pointer is not zero, the function will use it to store the maximum level number from which annotations have been obtained. #ZERO# level corresponds to the top-level page file. {\bf Summary:} This function will return complete annotations only when the \Ref{is_all_data_present}() returns #TRUE#. */GP<ByteStream> get_merged_anno(int * max_level_ptr=0);
/** Returns the annotation chunks (#"ANTa"# and #"ANTz"#). This function may be used even when the #DjVuFile# has not been decoded yet. If all data has been received for this #DjVuFile#, it will gather hidden text and return the result. If no hidden text has been found, #ZERO# will be returned. {\bf Summary:} This function will return complete annotations only when the \Ref{is_all_data_present}() returns #TRUE#. */GP<ByteStream> get_anno(void);
/** Returns the text chunks (#"TXTa"# and #"TXTz"#). This function may be used even when the #DjVuFile# has not been decoded yet. If all data has been received for this #DjVuFile#, it will gather hidden text and return the result. If no hidden text has been found, #ZERO# will be returned. {\bf Summary:} This function will return complete hidden text layers only when the \Ref{is_all_data_present}() returns #TRUE#. */GP<ByteStream> get_text(void);
/** Returns the meta chunks (#"METa"# and #"METz"#). This function may be used even when the #DjVuFile# has not been decoded yet. If all data has been received for this #DjVuFile#, it will gather metadata and return the result. If no hidden text has been found, #ZERO# will be returned. {\bf Summary:} This function will return complete meta data only when the \Ref{is_all_data_present}() returns #TRUE#. */GP<ByteStream> get_meta(void);
/** Goes down the hierarchy of #DjVuFile#s and merges their annotations. (shouldn't this one be private?). @param max_level_ptr If this pointer is not ZERO, the function will use it to store the maximum level at which annotations were found. Top-level page files have ZERO #level#. @param ignore_list The function will not process included #DjVuFile#s with URLs matching those mentioned in this #ignore_list#. */GP<ByteStream> get_merged_anno(constGList<GURL> & ignore_list,
int * max_level_ptr);
/** Clears this file of all annotations. */void remove_anno(void);
/** Clears the hidden text. */void remove_text(void);
/// Clears the meta data.void remove_meta(void);
/** Returns #TRUE# if the file contains annotation chunks. Known annotation chunks at the time of writing this help are: {\bf ANTa}, {\bf ANTz}, {\bf FORM:ANNO}. */bool contains_anno(void);
/** Returns #TRUE# if the file contains hiddentext chunks. Known hiddentext chunks at the time of writing this help are: {\bf TXTa}, and {\bf TXTz}. */bool contains_text(void);
/** Returns #TRUE# if the file contains metadata chunks. Known metadata chunks at the time of writing this help are: {\bf METa}, and {\bf METz}. */bool contains_meta(void);
/** Changes the value of the hiddentext. */void change_info(GP<DjVuInfo> info, constbool do_reset=false);
/** Changes the value of the hiddentext. */void change_text(GP<DjVuTXT> txt, constbool do_reset=false);
/** Changes the value of the metadata. */void change_meta(constGUTF8String &meta, constbool do_reset=false);
/** @name Encoding routines */ //@{ /** The main function that encodes data back into binary stream. The data returned will reflect possible changes made into the chunk structure, annotation chunks and navigation directory chunk #NDIR#. {\bf Note:} The file stream will not have the magic #0x41,0x54,0x26,0x54# at the beginning. @param included_too Process included files too. */GP<ByteStream> get_djvu_bytestream(constbool included_too, constbool no_ndir=true);
/** Same as \Ref{get_djvu_bytestream}(), returning a DataPool. @param included_too Process included files too. */GP<DataPool> get_djvu_data(constbool included_too, constbool no_ndir=true ); //@}// Internal. Used by DjVuDocumentGP<DataPool> get_init_data_pool(void) const { return data_pool; };
// Internal. Used by DjVuDocument. May block for data.void move(constGURL & dir_url);
/** Internal. Used by DjVuDocument. The #name# should {\bf not} be encoded with \Ref{GOS::encode_reserved}(). */void set_name(constGUTF8String &name);
// Internal. Used by DjVuDocumentGSafeFlags & get_safe_flags(void);
// Internal. Used by DjVuImagevoid merge_anno(ByteStream &out);
// Internal. Used by DjVuImagevoid get_text(ByteStream &out);
// Internal. Used by DjVuImagevoid get_meta(ByteStream &out);
// Internal. Used by DjVuDocEditorvoid rebuild_data_pool(void);
// Functions inherited from DjVuPortvirtualboolinherits(constGUTF8String &class_name) const;
virtualvoidnotify_chunk_done(constDjVuPort * source, constGUTF8String &name);
virtualvoidnotify_file_flags_changed(constDjVuFile * source,
long set_mask, long clr_mask);
virtualvoid set_recover_errors(const ErrorRecoveryAction=ABORT);
virtualvoid set_verbose_eof(constbool verbose_eof=true);
virtualvoid report_error(constGException &ex,constbool=true);
staticvoid set_decode_codec(GP<GPixmap> (*codec)(ByteStream &bs));
protected:
GURL url;
GP<DataPool> data_pool;
GPList<DjVuFile> inc_files_list;
GCriticalSection inc_files_lock;
GCriticalSection anno_lock;
GCriticalSection text_lock;
GCriticalSection meta_lock;
ErrorRecoveryAction recover_errors;
bool verbose_eof;
int chunks_number;
private:
bool initialized;
GSafeFlags flags;
GThread * decode_thread;
GP<DataPool> decode_data_pool;
GP<DjVuFile> decode_life_saver;
GP<DjVuPort> simple_port;
GMonitor chunk_mon, finish_mon;
// Functions called when the decoding thread startsstaticvoid static_decode_func(void *);
void decode_func(void);
void decode(constGP<ByteStream> &str);
GUTF8String decode_chunk(constGUTF8String &chkid,
constGP<ByteStream> &str, bool djvi, bool djvu, bool iw44);
int get_dpi(int w, int h);
// Functions dealing with the shape directory (fgjd)staticGP<JB2Dict> static_get_fgjd(void *);
GP<JB2Dict> get_fgjd(int block=0);
// Functions used to wait for smthvoid wait_for_chunk(void);
bool wait_for_finish(boolself);
// INCL chunk processorGP<DjVuFile> process_incl_chunk(ByteStream & str, int file_num=-1);
// Trigger: called when DataPool has all datastaticvoid static_trigger_cb(void *);
void trigger_cb(void);
// Progress callback: called from time to timestaticvoid progress_cb(int pos, void *);
staticvoid get_merged_anno(constGP<DjVuFile> & file,
constGP<ByteStream> &str_out, constGList<GURL> & ignore_list,
int level, int & max_level, GMap<GURL, void *> & map);
staticvoid get_anno(constGP<DjVuFile> & file,
constGP<ByteStream> &str_out);
staticvoid get_text(constGP<DjVuFile> & file,
constGP<ByteStream> &str_out);
staticvoid get_meta(constGP<DjVuFile> & file,
constGP<ByteStream> &str_out);
void check() const;
GP<DjVuNavDir>find_ndir(GMap<GURL, void *> & map);
GP<DjVuNavDir>decode_ndir(GMap<GURL, void *> & map);
void add_djvu_data(IFFByteStream & str,
GMap<GURL, void *> & map,
constbool included_too, constbool no_ndir=true);
void move(GMap<GURL, void *> & map, constGURL & dir_url);
private: // dummy stuffstaticvoid decode(ByteStream *);
staticGUTF8String decode_chunk(constGUTF8String &, ByteStream *,bool,bool,bool);
staticvoid get_merged_anno(constGP<DjVuFile> &,ByteStream *,
constGList<GURL> &, int, int &, GMap<GURL, void *> &);
staticvoid get_text(constGP<DjVuFile> &,ByteStream *);
staticvoid get_meta(constGP<DjVuFile> &,ByteStream *);
};
inlinelong00698DjVuFile::get_flags(void) const{
return flags;
}
inlineGSafeFlags &
DjVuFile::get_safe_flags(void)
{
return flags;
}
inlinebool00710DjVuFile::is_decoding(void) const{
return (flags & DECODING)!=0;
}
inlinebool00716DjVuFile::is_decode_ok(void) const{
return (flags & DECODE_OK)!=0;
}
inlinebool00722DjVuFile::is_decode_failed(void) const{
return (flags & DECODE_FAILED)!=0;
}
inlinebool00728DjVuFile::is_decode_stopped(void) const{
return (flags & DECODE_STOPPED)!=0;
}
inlinebool00734DjVuFile::is_data_present(void) const{
return (flags & DATA_PRESENT)!=0;
}
inlinebool00740DjVuFile::is_all_data_present(void) const{
return (flags & ALL_DATA_PRESENT)!=0;
}
inlinebool00746DjVuFile::are_incl_files_created(void) const{
return (flags & INCL_FILES_CREATED)!=0;
}
inlinebool
DjVuFile::is_modified(void) const{
return (flags & MODIFIED)!=0;
}
inlinevoid
DjVuFile::set_modified(bool m)
{
flags=m ? (flags | MODIFIED) : (flags & ~MODIFIED);
}
inlinebool
DjVuFile::needs_compression(void) const{
return (flags & NEEDS_COMPRESSION)!=0;
}
inlinevoid
DjVuFile::set_needs_compression(bool m)
{
if (m) flags=flags | NEEDS_COMPRESSION;
else flags=flags & ~NEEDS_COMPRESSION;
}
inlinebool
DjVuFile::can_compress(void) const{
return (flags & CAN_COMPRESS)!=0;
}
inlinevoid
DjVuFile::set_can_compress(bool m)
{
if (m)
flags=flags | CAN_COMPRESS;
else
flags=flags & ~CAN_COMPRESS;
}
inlinevoid00792DjVuFile::disable_standard_port(void)
{
simple_port=0;
}
inlinebool00798DjVuFile::inherits(constGUTF8String &class_name) const{
return
(GUTF8String("DjVuFile") == class_name) ||
DjVuPort::inherits(class_name);
// !strcmp("DjVuFile", class_name) ||// DjVuPort::inherits(class_name);
}
inlinevoid00808DjVuFile::wait_for_finish(void)
{
while(wait_for_finish(1))
EMPTY_LOOP;
}
inlineGURL00815DjVuFile::get_url(void) const{
return url;
}
inlinevoid
DjVuFile::set_verbose_eof
(constbool verbose)
{
verbose_eof=verbose;
}
inlinevoid
DjVuFile::set_recover_errors
(constErrorRecoveryAction action)
{
recover_errors=action;
}
//@}#ifdef HAVE_NAMESPACES}
# ifndef NOT_USING_DJVU_NAMESPACEusing namespace DJVU;
# endif#endif#endif