diff options
Diffstat (limited to 'kviewshell/plugins/djvu/libdjvu/IW44Image.h')
| -rw-r--r-- | kviewshell/plugins/djvu/libdjvu/IW44Image.h | 761 |
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 <[email protected]> + +// 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 ↦ // 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 + |