summaryrefslogtreecommitdiffstats
path: root/kviewshell/plugins/djvu/libdjvu/IW44Image.h
diff options
context:
space:
mode:
authortoma <toma@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>2009-11-25 17:56:58 +0000
committertoma <toma@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>2009-11-25 17:56:58 +0000
commit47d455dd55be855e4cc691c32f687f723d9247ee (patch)
tree52e236aaa2576bdb3840ebede26619692fed6d7d /kviewshell/plugins/djvu/libdjvu/IW44Image.h
downloadtdegraphics-47d455dd55be855e4cc691c32f687f723d9247ee.tar.gz
tdegraphics-47d455dd55be855e4cc691c32f687f723d9247ee.zip
Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.
BUG:215923 git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdegraphics@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da
Diffstat (limited to 'kviewshell/plugins/djvu/libdjvu/IW44Image.h')
-rw-r--r--kviewshell/plugins/djvu/libdjvu/IW44Image.h761
1 files changed, 761 insertions, 0 deletions
diff --git a/kviewshell/plugins/djvu/libdjvu/IW44Image.h b/kviewshell/plugins/djvu/libdjvu/IW44Image.h
new file mode 100644
index 00000000..56cf00fa
--- /dev/null
+++ b/kviewshell/plugins/djvu/libdjvu/IW44Image.h
@@ -0,0 +1,761 @@
+//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, Version 2. 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
+//C- distributed by Lizardtech Software. On July 19th 2002, Lizardtech
+//C- Software authorized us to replace the original DjVu(r) Reference
+//C- Library notice by the following text (see doc/lizard2002.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, Version 2. 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: IW44Image.h,v 1.11 2003/11/07 22:08:22 leonb Exp $
+// $Name: release_3_5_15 $
+
+#ifndef IW44IMAGE_H_
+#define IW44IMAGE_H_
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+#if NEED_GNUG_PRAGMAS
+# pragma interface
+#endif
+
+
+/** @name IW44Image.h
+
+ Files #"IW44Image.h"# and #"IW44Image.cpp"# implement the DjVu IW44 wavelet
+ scheme for the compression of gray-level images (see class \Ref{IWBitmap})
+ and color images (see class \Ref{IWPixmap}). Programs \Ref{c44} and
+ \Ref{d44} demonstrate how to encode and decode IW44 files.
+
+ {\bf IW44 File Structure} --- The IW44 files are structured according to
+ the EA IFF85 specifications (see \Ref{IFFByteStream.h}). Gray level IW44
+ Images consist of a single #"FORM:BM44"# chunk composed of an arbitrary
+ number of #"BM44"# data chunks. Color IW44 Images consist of a single
+ #"FORM:PM44"# chunk composed of an arbitrary number of #"PM44"# data
+ chunks. The successive #"PM44"# or #"BM44"# data chunks contain
+ successive refinements of the encoded image. Each chunk contains a
+ certain number of ``data slices''. The first chunk also contains a small
+ image header. You can use program \Ref{djvuinfo} to display all this
+ structural information:
+ \begin{verbatim}
+ % djvuinfo lag.iw4
+ lag.iw4:
+ FORM:PM44 [62598]
+ PM44 [10807] #1 - 74 slices - v1.2 (color) - 684x510
+ PM44 [23583] #2 - 13 slices
+ PM44 [28178] #3 - 10 slices
+ \end{verbatim}
+
+ {\bf Embedded IW44 Images} --- These IW44 data chunks can also appear within
+ other contexts. Files representing a DjVu page, for instance, consist of
+ a single #"FORM:DJVU"# composite chunk. This composite chunk may contain
+ #"BG44"# chunks encoding the background layer and #"FG44"# chunks encoding
+ the foreground color layer. These #"BG44"# and #"FG44"# chunks are
+ actually regular IW44 data chunks with a different chunk identifier. This
+ information too can be displayed using program \Ref{djvuinfo}.
+ \begin{verbatim}
+ % djvuinfo graham1.djvu
+ graham1.djvu:
+ FORM:DJVU [32553]
+ INFO [5] 3156x2325, version 17
+ Sjbz [17692]
+ BG44 [2570] #1 - 74 slices - v1.2 (color) - 1052x775
+ FG44 [1035] #1 - 100 slices - v1.2 (color) - 263x194
+ BG44 [3048] #2 - 10 slices
+ BG44 [894] #3 - 4 slices
+ BG44 [7247] #4 - 9 slices
+ \end{verbatim}
+
+ {\bf Performance} --- The main design objective for the DjVu wavelets
+ consisted of allowing progressive rendering and smooth scrolling of large
+ images with limited memory requirements. Decoding functions process the
+ compressed data and update a memory efficient representation of the
+ wavelet coefficients. Imaging function then can quickly render an
+ arbitrary segment of the image using the available data. Both process can
+ be carried out in two threads of execution. This design plays an
+ important role in the DjVu system. We have investigated various
+ state-of-the-art wavelet compression schemes: although these schemes may
+ achieve slightly smaller file sizes, the decoding functions did not even
+ approach our requirements.
+
+ The IW44 wavelets satisfy these requirements today. It performs very well
+ for quality settings resulting in high compression ratios. It should not
+ be used for quasi-lossless compression because certain design choices
+ deliberately sacrifice the IW44 quasi-lossless performance in order to
+ improve the image quality at high compression ratios.
+
+ Little care however has been taken to make the IW44 encoder memory
+ efficient. This code uses two copies of the wavelet coefficient data
+ structure (one for the raw coefficients, one for the quantized
+ coefficients). A more sophisticated implementation should considerably
+ reduce the memory requirements.
+
+ {\bf Masking} --- When we create a DjVu image, we often know that certain
+ pixels of the background image are going to be covered by foreground
+ objects like text or drawings. The DjVu IW44 wavelet decomposition
+ routine can use an optional bilevel image named the mask. Every non zero
+ pixel in the mask means the value of the corresponding pixel in the
+ background image is irrelevant. The wavelet decomposition code will
+ replace these masked pixels by a color value whose coding cost is minimal
+ (see \URL{http://www.research.att.com/~leonb/DJVU/mask}).
+
+ {\bf ToDo} --- There are many improvements to be made. Besides better
+ quantization algorithms (such as trellis quantization and bitrate
+ allocation), we should allow for more wavelet transforms. These
+ improvements may be implemented in future version, if (and only if) they
+ can meet our decoding constraints. Future versions will probably split
+ file #"IW44Image.cpp"# which currently contains everything.
+
+ @memo
+ Wavelet encoded images.
+ @author
+ L\'eon Bottou <leonb@research.att.com>
+
+// 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.
+
+ @version
+ #$Id: IW44Image.h,v 1.11 2003/11/07 22:08:22 leonb Exp $# */
+//@{
+
+
+#include "GSmartPointer.h"
+#include "ZPCodec.h"
+
+
+#ifdef HAVE_NAMESPACES
+namespace DJVU {
+# ifdef NOT_DEFINED // Just to fool emacs c++ mode
+}
+#endif
+#endif
+
+class GRect;
+class IFFByteStream;
+class ByteStream;
+class GBitmap;
+class GPixmap;
+
+
+
+/** IW44 encoding parameters.
+ This data structure gathers the quality specification parameters needed
+ for encoding each chunk of an IW44 file. Chunk data is generated until
+ meeting either the slice target, the size target or the decibel target. */
+
+struct IWEncoderParms
+{
+ /** Slice target. Data generation for the current chunk stops if the total
+ number of slices (in this chunk and all the previous chunks) reaches
+ value #slice#. The default value #0# has a special meaning: data will
+ be generated regardless of the number of slices in the file. */
+ int slices;
+ /** Size target. Data generation for the current chunk stops if the total
+ data size (in this chunk and all the previous chunks), expressed in
+ bytes, reaches value #size#. The default value #0# has a special
+ meaning: data will be generated regardless of the file size. */
+ int bytes;
+ /** Decibel target. Data generation for the current chunk stops if the
+ estimated luminance error, expressed in decibels, reaches value
+ #decibel#. The default value #0# has a special meaning: data will be
+ generated regardless of the estimated luminance error. Specifying value
+ #0# in fact shortcuts the computation of the estimated luminance error
+ and sensibly speeds up the encoding process. */
+ float decibels;
+ /** Constructor. Initializes the structure with the default values. */
+ IWEncoderParms(void);
+};
+
+
+
+/** IW44 encoded gray-level and color images. This class acts as a base for
+ images represented as a collection of IW44 wavelet coefficients. The
+ coefficients are stored in a memory efficient data structure. Member
+ function \Ref{get_bitmap} renders an arbitrary segment of the image into
+ a \Ref{GBitmap}. Member functions \Ref{decode_iff} and \Ref{encode_iff}
+ read and write DjVu IW44 files (see \Ref{IW44Image.h}). Both the copy
+ constructor and the copy operator are declared as private members. It is
+ therefore not possible to make multiple copies of instances of this
+ class. */
+
+class IW44Image : public GPEnabled
+{
+public:
+ /** Chrominance processing selector. The following constants may be used as
+ argument to the following \Ref{IWPixmap} constructor to indicate how the
+ chrominance information should be processed. There are four possible values:
+ \begin{description}
+ \item[CRCBnone:] The wavelet transform will discard the chrominance
+ information and only keep the luminance. The image will show in shades of gray.
+ \item[CRCBhalf:] The wavelet transform will process the chrominance at only
+ half the image resolution. This option creates smaller files but may create
+ artifacts in highly colored images.
+ \item[CRCBnormal:] The wavelet transform will process the chrominance at full
+ resolution. This is the default.
+ \item[CRCBfull:] The wavelet transform will process the chrominance at full
+ resolution. This option also disables the chrominance encoding delay
+ (see \Ref{parm_crcbdelay}) which usually reduces the bitrate associated with the
+ chrominance information.
+ \end{description} */
+ enum CRCBMode {
+ CRCBnone,
+ CRCBhalf,
+ CRCBnormal,
+ CRCBfull };
+ class Transform;
+ class Map;
+ class Block;
+ class Codec;
+ struct Alloc;
+ struct PrimaryHeader;
+ struct SecondaryHeader;
+ struct TertiaryHeader;
+ enum ImageType {
+ GRAY=false,
+ COLOR=true };
+protected:
+ IW44Image(void);
+public:
+ /** Null constructor. Constructs an empty IW44Image object. This object does
+ not contain anything meaningful. You must call function \Ref{init},
+ \Ref{decode_iff} or \Ref{decode_chunk} to populate the wavelet
+ coefficient data structure. You may not use \Ref{encode_iff} or
+ \Ref{encode_chunk}. */
+ static GP<IW44Image> create_decode(const ImageType itype=COLOR);
+ /** Null constructor. Constructs an empty IW44Image object. This object does
+ not contain anything meaningful. You must call function \Ref{init},
+ \Ref{decode_iff} or \Ref{decode_chunk} to populate the wavelet
+ coefficient data structure. You may then use \Ref{encode_iff}
+ and \Ref{encode_chunk}. */
+ static GP<IW44Image> create_encode(const ImageType itype=COLOR);
+ // virtual destructor
+ virtual ~IW44Image();
+ /** Initializes an IWBitmap with image #bm#. This constructor
+ performs the wavelet decomposition of image #bm# and records the
+ corresponding wavelet coefficient. Argument #mask# is an optional
+ bilevel image specifying the masked pixels (see \Ref{IW44Image.h}). */
+ static GP<IW44Image> create_encode(const GBitmap &bm, const GP<GBitmap> mask=0);
+ /** Initializes an IWPixmap with color image #bm#. This constructor
+ performs the wavelet decomposition of image #bm# and records the
+ corresponding wavelet coefficient. Argument #mask# is an optional
+ bilevel image specifying the masked pixels (see \Ref{IW44Image.h}).
+ Argument #crcbmode# specifies how the chrominance information should be
+ encoded (see \Ref{CRCBMode}). */
+ static GP<IW44Image> create_encode(const GPixmap &bm, const GP<GBitmap> mask=0, CRCBMode crcbmode=CRCBnormal);
+ // ACCESS
+ /** Returns the width of the IWBitmap image. */
+ int get_width(void) const;
+ /** Returns the height of the IWBitmap image. */
+ int get_height(void) const;
+ /** Reconstructs the complete image. The reconstructed image
+ is then returned as a GBitmap object. */
+ virtual GP<GBitmap> get_bitmap(void) {return 0;}
+ /** Reconstructs a segment of the image at a given scale. The subsampling
+ ratio #subsample# must be a power of two between #1# and #32#. Argument
+ #rect# specifies which segment of the subsampled image should be
+ reconstructed. The reconstructed image is returned as a GBitmap object
+ whose size is equal to the size of the rectangle #rect#. */
+ virtual GP<GBitmap> get_bitmap(int subsample, const GRect &rect) {return 0;}
+ /** Reconstructs the complete image. The reconstructed image
+ is then returned as a GPixmap object. */
+ virtual GP<GPixmap> get_pixmap(void) {return 0;}
+ /** Reconstructs a segment of the image at a given scale. The subsampling
+ ratio #subsample# must be a power of two between #1# and #32#. Argument
+ #rect# specifies which segment of the subsampled image should be
+ reconstructed. The reconstructed image is returned as a GPixmap object
+ whose size is equal to the size of the rectangle #rect#. */
+ virtual GP<GPixmap> get_pixmap(int subsample, const GRect &rect) {return 0;}
+ /** Returns the amount of memory used by the wavelet coefficients. This
+ amount of memory is expressed in bytes. */
+ virtual unsigned int get_memory_usage(void) const = 0;
+ /** Returns the filling ratio of the internal data structure. Wavelet
+ coefficients are stored in a sparse array. This function tells what
+ percentage of bins have been effectively allocated. */
+ virtual int get_percent_memory(void) const = 0;
+ // CODER
+ /** Encodes one data chunk into ByteStream #bs#. Parameter #parms# controls
+ how much data is generated. The chunk data is written to ByteStream
+ #bs# with no IFF header. Successive calls to #encode_chunk# encode
+ successive chunks. You must call #close_codec# after encoding the last
+ chunk of a file. */
+ virtual int encode_chunk(GP<ByteStream> gbs, const IWEncoderParms &parms);
+ /** Writes a gray level image into DjVu IW44 file. This function creates a
+ composite chunk (identifier #FORM:BM44# or #FORM:PM44#) composed of
+ #nchunks# chunks (identifier #BM44# or #PM44#). Data for each chunk is
+ generated with #encode_chunk# using the corresponding parameters in
+ array #parms#. */
+ virtual void encode_iff(IFFByteStream &iff, int nchunks, const IWEncoderParms *parms);
+ // DECODER
+ /** Decodes one data chunk from ByteStream #bs#. Successive calls to
+ #decode_chunk# decode successive chunks. You must call #close_codec#
+ after decoding the last chunk of a file. Note that function
+ #get_bitmap# and #decode_chunk# may be called simultaneously from two
+ execution threads. */
+ virtual int decode_chunk(GP<ByteStream> gbs) = 0;
+ /** This function enters a composite chunk (identifier #FORM:BM44#, or
+ #FORM:PM44#), and decodes a maximum of #maxchunks# data chunks
+ (identifier #BM44#). Data for each chunk is processed using the
+ function #decode_chunk#. */
+ virtual void decode_iff(IFFByteStream &iff, int maxchunks=999) = 0;
+ // MISCELLANEOUS
+ /** Resets the encoder/decoder state. The first call to #decode_chunk# or
+ #encode_chunk# initializes the coder for encoding or decoding. Function
+ #close_codec# must be called after processing the last chunk in order to
+ reset the coder and release the associated memory. */
+ virtual void close_codec(void) = 0;
+ /** Returns the chunk serial number. This function returns the serial
+ number of the last chunk encoded with #encode_chunk# or decoded with
+ #decode_chunk#. The first chunk always has serial number #1#. Successive
+ chunks have increasing serial numbers. Value #0# is returned if this
+ function is called before calling #encode_chunk# or #decode_chunk# or
+ after calling #close_codec#. */
+ virtual int get_serial(void) = 0;
+ /** Sets the chrominance delay parameter. This function can be called
+ before encoding the first color IW44 data chunk. Parameter #parm# is an
+ encoding delay which reduces the bitrate associated with the
+ chrominance information. The default chrominance encoding delay is 10. */
+ virtual int parm_crcbdelay(const int parm) {return parm;}
+ /** Sets the #dbfrac# parameter. This function can be called before
+ encoding the first IW44 data chunk. Parameter #frac# modifies the
+ decibel estimation algorithm in such a way that the decibel target only
+ pertains to the average error of the fraction #frac# of the most
+ misrepresented 32x32 pixel blocks. Setting arguments #frac# to #1.0#
+ restores the normal behavior. */
+ virtual void parm_dbfrac(float frac) = 0;
+protected:
+ // Parameter
+ float db_frac;
+ // Data
+ Map *ymap, *cbmap, *crmap;
+ int cslice;
+ int cserial;
+ int cbytes;
+private:
+ // Disable assignment semantic
+ IW44Image(const IW44Image &ref);
+ IW44Image& operator=(const IW44Image &ref);
+};
+
+#ifdef IW44IMAGE_IMPLIMENTATION
+
+/*x IW44 encoded gray-level image. This class provided functions for managing
+ a gray level image represented as a collection of IW44 wavelet
+ coefficients. The coefficients are stored in a memory efficient data
+ structure. Member function \Ref{get_bitmap} renders an arbitrary segment
+ of the image into a \Ref{GBitmap}. Member functions \Ref{decode_iff} and
+ \Ref{encode_iff} read and write DjVu IW44 files (see \Ref{IW44Image.h}).
+ Both the copy constructor and the copy operator are declared as private
+ members. It is therefore not possible to make multiple copies of instances
+ of this class. */
+
+class IWBitmap : public IW44Image
+{
+public:
+ friend class IW44Image;
+ class Encode;
+protected:
+ /*x Null constructor. Constructs an empty IWBitmap object. This object does
+ not contain anything meaningful. You must call function \Ref{init},
+ \Ref{decode_iff} or \Ref{decode_chunk} to populate the wavelet
+ coefficient data structure. */
+ IWBitmap(void);
+public:
+ //x virtual destructor
+ virtual ~IWBitmap();
+ //x ACCESS
+ /*x Reconstructs the complete image. The reconstructed image
+ is then returned as a GBitmap object. */
+ virtual GP<GBitmap> get_bitmap(void);
+ /*x Reconstructs a segment of the image at a given scale. The subsampling
+ ratio #subsample# must be a power of two between #1# and #32#. Argument
+ #rect# specifies which segment of the subsampled image should be
+ reconstructed. The reconstructed image is returned as a GBitmap object
+ whose size is equal to the size of the rectangle #rect#. */
+ virtual GP<GBitmap> get_bitmap(int subsample, const GRect &rect);
+ /*x Returns the amount of memory used by the wavelet coefficients. This
+ amount of memory is expressed in bytes. */
+ virtual unsigned int get_memory_usage(void) const;
+ /*x Returns the filling ratio of the internal data structure. Wavelet
+ coefficients are stored in a sparse array. This function tells what
+ percentage of bins have been effectively allocated. */
+ virtual int get_percent_memory(void) const;
+ // DECODER
+ /*x Decodes one data chunk from ByteStream #bs#. Successive calls to
+ #decode_chunk# decode successive chunks. You must call #close_codec#
+ after decoding the last chunk of a file. Note that function
+ #get_bitmap# and #decode_chunk# may be called simultaneously from two
+ execution threads. */
+ virtual int decode_chunk(GP<ByteStream> gbs);
+ /*x Reads a DjVu IW44 file as a gray level image. This function enters a
+ composite chunk (identifier #FORM:BM44#), and decodes a maximum of
+ #maxchunks# data chunks (identifier #BM44#). Data for each chunk is
+ processed using the function #decode_chunk#. */
+ virtual void decode_iff(IFFByteStream &iff, int maxchunks=999);
+ // MISCELLANEOUS
+ /*x Resets the encoder/decoder state. The first call to #decode_chunk# or
+ #encode_chunk# initializes the coder for encoding or decoding. Function
+ #close_codec# must be called after processing the last chunk in order to
+ reset the coder and release the associated memory. */
+ virtual void close_codec(void);
+ /*x Returns the chunk serial number. This function returns the serial
+ number of the last chunk encoded with #encode_chunk# or decoded with
+ #decode_chunk#. The first chunk always has serial number #1#. Successive
+ chunks have increasing serial numbers. Value #0# is returned if this
+ function is called before calling #encode_chunk# or #decode_chunk# or
+ after calling #close_codec#. */
+ virtual int get_serial(void);
+ /*x Sets the #dbfrac# parameter. This function can be called before
+ encoding the first IW44 data chunk. Parameter #frac# modifies the
+ decibel estimation algorithm in such a way that the decibel target only
+ pertains to the average error of the fraction #frac# of the most
+ misrepresented 32x32 pixel blocks. Setting arguments #frac# to #1.0#
+ restores the normal behavior. */
+ virtual void parm_dbfrac(float frac);
+private:
+ Codec *ycodec;
+};
+
+
+/*x IW44 encoded color image. This class provided functions for managing a
+ color image represented as a collection of IW44 wavelet coefficients. The
+ coefficients are stored in a memory efficient data structure. Member
+ function \Ref{get_pixmap} renders an arbitrary segment of the image into a
+ \Ref{GPixmap}. Member functions \Ref{decode_iff} and \Ref{encode_iff}
+ read and write DjVu IW44 files (see \Ref{IW44Image.h}). Both the copy
+ constructor and the copy operator are declared as private members. It is
+ therefore not possible to make multiple copies of instances of this
+ class. */
+
+class IWPixmap : public IW44Image
+{
+public:
+ friend class IW44Image;
+protected:
+ class Encode;
+ /*x Null constructor. Constructs an empty IWPixmap object. This object does
+ not contain anything meaningful. You must call function \Ref{init},
+ \Ref{decode_iff} or \Ref{decode_chunk} to populate the wavelet
+ coefficient data structure. */
+ IWPixmap(void);
+public:
+ // virtual destructor
+ virtual ~IWPixmap();
+ // ACCESS
+ /*x Reconstructs the complete image. The reconstructed image
+ is then returned as a GPixmap object. */
+ virtual GP<GPixmap> get_pixmap(void);
+ /*x Reconstructs a segment of the image at a given scale. The subsampling
+ ratio #subsample# must be a power of two between #1# and #32#. Argument
+ #rect# specifies which segment of the subsampled image should be
+ reconstructed. The reconstructed image is returned as a GPixmap object
+ whose size is equal to the size of the rectangle #rect#. */
+ virtual GP<GPixmap> get_pixmap(int subsample, const GRect &rect);
+ /*x Returns the amount of memory used by the wavelet coefficients. This
+ amount of memory is expressed in bytes. */
+ virtual unsigned int get_memory_usage(void) const;
+ /*x Returns the filling ratio of the internal data structure. Wavelet
+ coefficients are stored in a sparse array. This function tells what
+ percentage of bins have been effectively allocated. */
+ virtual int get_percent_memory(void) const;
+ // DECODER
+ /*x Decodes one data chunk from ByteStream #bs#. Successive calls to
+ #decode_chunk# decode successive chunks. You must call #close_codec#
+ after decoding the last chunk of a file. Note that function
+ #get_bitmap# and #decode_chunk# may be called simultaneously from two
+ execution threads. */
+ virtual int decode_chunk(GP<ByteStream> gbs);
+ /*x Reads a DjVu IW44 file as a color image. This function enters a
+ composite chunk (identifier #FORM:PM44# or #FORM:BM44#), and decodes a
+ maximum of #maxchunks# data chunks (identifier #PM44# or #BM44#). Data
+ for each chunk is processed using the function #decode_chunk#. */
+ virtual void decode_iff(IFFByteStream &iff, int maxchunks=999);
+ // MISCELLANEOUS
+ /*x Resets the encoder/decoder state. The first call to #decode_chunk# or
+ #encode_chunk# initializes the coder for encoding or decoding. Function
+ #close_codec# must be called after processing the last chunk in order to
+ reset the coder and release the associated memory. */
+ virtual void close_codec(void);
+ /*x Returns the chunk serial number. This function returns the serial
+ number of the last chunk encoded with #encode_chunk# or decoded with
+ #decode_chunk#. The first chunk always has serial number #1#. Successive
+ chunks have increasing serial numbers. Value #0# is returned if this
+ function is called before calling #encode_chunk# or #decode_chunk# or
+ after calling #close_codec#. */
+ virtual int get_serial(void);
+ /*x Sets the chrominance delay parameter. This function can be called
+ before encoding the first IW44 data chunk. Parameter #parm# is an
+ encoding delay which reduces the bitrate associated with the
+ chrominance information. The default chrominance encoding delay is 10. */
+ virtual int parm_crcbdelay(const int parm);
+ /*x Sets the #dbfrac# parameter. This function can be called before
+ encoding the first IW44 data chunk. Parameter #frac# modifies the
+ decibel estimation algorithm in such a way that the decibel target only
+ pertains to the average error of the fraction #frac# of the most
+ misrepresented 32x32 pixel blocks. Setting arguments #frac# to #1.0#
+ restores the normal behavior. */
+ virtual void parm_dbfrac(float frac);
+protected:
+ // Parameter
+ int crcb_delay;
+ int crcb_half;
+ // Data
+private:
+ Codec *ycodec, *cbcodec, *crcodec;
+};
+
+/*x IW44Transform.
+*/
+class IW44Image::Transform
+{
+public:
+ class Decode;
+ class Encode;
+protected:
+ static void filter_begin(int w, int h);
+ static void filter_end(void);
+};
+
+struct GPixel;
+class IW44Image::Transform::Decode : public IW44Image::Transform
+{
+public:
+ // WAVELET TRANSFORM
+ /*x Forward transform. */
+ static void backward(short *p, int w, int h, int rowsize, int begin, int end);
+
+ // COLOR TRANSFORM
+ /*x Converts YCbCr to RGB. */
+ static void YCbCr_to_RGB(GPixel *p, int w, int h, int rowsize);
+};
+
+//---------------------------------------------------------------
+// *** Class IW44Image::Block [declaration]
+// Represents a block of 32x32 coefficients after zigzagging and scaling
+
+
+class IW44Image::Block // DJVU_CLASS
+{
+public:
+ // creating
+ Block(void);
+ // accessing scaled coefficients
+ short get(int n) const;
+ void set(int n, int val, IW44Image::Map *map);
+ // converting from liftblock
+ void read_liftblock(const short *coeff, IW44Image::Map *map);
+ void write_liftblock(short *coeff, int bmin=0, int bmax=64) const;
+ // sparse array access
+ const short* data(int n) const;
+ short* data(int n, IW44Image::Map *map);
+ void zero(int n);
+ // sparse representation
+private:
+ short **(pdata[4]);
+};
+
+//---------------------------------------------------------------
+// *** Class IW44Image::Map [declaration]
+// Represents all the blocks of an image
+
+class IW44Image::Map // DJVU_CLASS
+{
+public:
+ class Encode;
+
+ // construction
+ Map(int w, int h);
+ ~Map();
+ // image access
+ void image(signed char *img8, int rowsize,
+ int pixsep=1, int fast=0);
+ void image(int subsample, const GRect &rect,
+ signed char *img8, int rowsize,
+ int pixsep=1, int fast=0);
+ // array of blocks
+ IW44Image::Block *blocks;
+ // geometry
+ int iw, ih;
+ int bw, bh;
+ int nb;
+ // coefficient allocation stuff
+ short *alloc(int n);
+ short **allocp(int n);
+ IW44Image::Alloc *chain;
+ int top;
+ // statistics
+ int get_bucket_count(void) const;
+ unsigned int get_memory_usage(void) const;
+};
+
+//////////////////////////////////////////////////////
+// ENCODING/DECODING WAVELET COEFFICIENTS
+// USING HIERARCHICAL SET DIFFERENCE
+//////////////////////////////////////////////////////
+
+
+//-----------------------------------------------
+// Class IW44Image::Codec [declaration+implementation]
+// Maintains information shared while encoding or decoding
+
+class IW44Image::Codec
+{
+public:
+ class Decode;
+ class Encode;
+
+protected:
+ // Construction
+ Codec(IW44Image::Map &map);
+public:
+ virtual ~Codec();
+ // Coding
+ int finish_code_slice(ZPCodec &zp);
+ virtual int code_slice(ZPCodec &zp) = 0;
+ // Data
+ IW44Image::Map &map; // working map
+ // status
+ int curband; // current band
+ int curbit; // current bitplane
+ // quantization tables
+ int quant_hi[10]; // quantization for bands 1 to 9
+ int quant_lo[16]; // quantization for band 0.
+ // bucket state
+ char coeffstate[256];
+ char bucketstate[16];
+ enum { ZERO = 1, // this coeff never hits this bit
+ ACTIVE = 2, // this coeff is already active
+ NEW = 4, // this coeff is becoming active
+ UNK = 8 }; // this coeff may become active
+ // coding context
+ BitContext ctxStart [32];
+ BitContext ctxBucket[10][8];
+ BitContext ctxMant;
+ BitContext ctxRoot;
+ // helper
+ int is_null_slice(int bit, int band);
+ int decode_prepare(int fbucket, int nbucket, IW44Image::Block &blk);
+ void decode_buckets(ZPCodec &zp, int bit, int band,
+ IW44Image::Block &blk, int fbucket, int nbucket);
+};
+
+//////////////////////////////////////////////////////
+// DEFINITION OF CHUNK HEADERS
+//////////////////////////////////////////////////////
+
+
+struct IW44Image::PrimaryHeader {
+ unsigned char serial;
+ unsigned char slices;
+ void encode(GP<ByteStream> gbs);
+ void decode(GP<ByteStream> gbs);
+};
+
+struct IW44Image::SecondaryHeader {
+ unsigned char major;
+ unsigned char minor;
+ void encode(GP<ByteStream> gbs);
+ void decode(GP<ByteStream> gbs);
+};
+
+struct IW44Image::TertiaryHeader {
+ unsigned char xhi, xlo;
+ unsigned char yhi, ylo;
+ unsigned char crcbdelay;
+ void encode(GP<ByteStream> gbs);
+ void decode(GP<ByteStream> gbs, int major=1, int minor=2);
+};
+
+inline const short*
+IW44Image::Block::data(int n) const
+{
+ if (! pdata[n>>4])
+ return 0;
+ return pdata[n>>4][n&15];
+}
+
+inline short*
+IW44Image::Block::data(int n, IW44Image::Map *map)
+{
+ if (! pdata[n>>4])
+ pdata[n>>4] = map->allocp(16);
+ if (! pdata[n>>4][n &15])
+ pdata[n>>4][n &15] = map->alloc(16);
+ return pdata[n>>4][n&15];
+}
+
+inline short
+IW44Image::Block::get(int n) const
+{
+ int n1 = (n>>4);
+ const short *d = data(n1);
+ if (! d)
+ return 0;
+ return d[n&15];
+}
+
+inline void
+IW44Image::Block::set(int n, int val, IW44Image::Map *map)
+{
+ int n1 = (n>>4);
+ short* d = data(n1, map);
+ d[n&15] = val;
+}
+
+#endif /* IW44IMAGE_IMPLIMENTATION */
+
+//@}
+
+
+#ifdef HAVE_NAMESPACES
+}
+# ifndef NOT_USING_DJVU_NAMESPACE
+using namespace DJVU;
+# endif
+#endif
+#endif
+