//C- -*- C++ -*-
//C- -------------------------------------------------------------------
//C- DjVuLibre-3.5
//C- Copyright (c) 2002 Leon Bottou and Yann Le Cun.
//C- Copyright (c) 2001 AT&T
//C-
//C- This software is subject to, and may be distributed under, the
//C- GNU General Public License, either Version 2 of the license,
//C- or (at your option) any later version. The license should have
//C- accompanied the software or you may obtain a copy of the license
//C- from the Free Software Foundation at http://www.fsf.org .
//C-
//C- This program is distributed in the hope that it will be useful,
//C- but WITHOUT ANY WARRANTY; without even the implied warranty of
//C- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
//C- GNU General Public License for more details.
//C-
//C- DjVuLibre-3.5 is derived from the DjVu(r) Reference Library from
//C- Lizardtech Software. Lizardtech Software has authorized us to
//C- replace the original DjVu(r) Reference Library notice by the following
//C- text (see doc/lizard2002.djvu and doc/lizardtech2007.djvu):
//C-
//C- ------------------------------------------------------------------
//C- | DjVu (r) Reference Library (v. 3.5)
//C- | Copyright (c) 1999-2001 LizardTech, Inc. All Rights Reserved.
//C- | The DjVu Reference Library is protected by U.S. Pat. No.
//C- | 6,058,214 and patents pending.
//C- |
//C- | This software is subject to, and may be distributed under, the
//C- | GNU General Public License, either Version 2 of the license,
//C- | or (at your option) any later version. The license should have
//C- | accompanied the software or you may obtain a copy of the license
//C- | from the Free Software Foundation at http://www.fsf.org .
//C- |
//C- | The computer code originally released by LizardTech under this
//C- | license and unmodified by other parties is deemed "the LIZARDTECH
//C- | ORIGINAL CODE." Subject to any third party intellectual property
//C- | claims, LizardTech grants recipient a worldwide, royalty-free,
//C- | non-exclusive license to make, use, sell, or otherwise dispose of
//C- | the LIZARDTECH ORIGINAL CODE or of programs derived from the
//C- | LIZARDTECH ORIGINAL CODE in compliance with the terms of the GNU
//C- | General Public License. This grant only confers the right to
//C- | infringe patent claims underlying the LIZARDTECH ORIGINAL CODE to
//C- | the extent such infringement is reasonably necessary to enable
//C- | recipient to make, have made, practice, sell, or otherwise dispose
//C- | of the LIZARDTECH ORIGINAL CODE (or portions thereof) and not to
//C- | any greater extent that may be necessary to utilize further
//C- | modifications or combinations.
//C- |
//C- | The LIZARDTECH ORIGINAL CODE is provided "AS IS" WITHOUT WARRANTY
//C- | OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
//C- | TO ANY WARRANTY OF NON-INFRINGEMENT, OR ANY IMPLIED WARRANTY OF
//C- | MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
//C- +------------------------------------------------------------------
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#if NEED_GNUG_PRAGMAS
# pragma implementation
#endif
// - Author: Leon Bottou, 08/1998
// From: Leon Bottou, 1/31/2002
// Lizardtech has split this file into a decoder and an encoder.
// Only superficial changes. The meat is mine.
#define IW44IMAGE_IMPLIMENTATION /* */
#include "IW44Image.h"
#include "ZPCodec.h"
#include "GBitmap.h"
#include "GPixmap.h"
#include "IFFByteStream.h"
#include "GRect.h"
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include "MMX.h"
#undef IWTRANSFORM_TIMER
#ifdef IWTRANSFORM_TIMER
#include "GOS.h"
#endif
#include <assert.h>
#include <string.h>
#include <math.h>
#ifndef NEED_DECODER_ONLY
#ifdef HAVE_NAMESPACES
namespace DJVU {
# ifdef NOT_DEFINED // Just to fool emacs c++ mode
}
#endif
#endif
#define IWALLOCSIZE 4080
#define IWCODEC_MAJOR 1
#define IWCODEC_MINOR 2
#define DECIBEL_PRUNE 5.0
//////////////////////////////////////////////////////
// WAVELET DECOMPOSITION CONSTANTS
//////////////////////////////////////////////////////
// Parameters for IW44 wavelet.
// - iw_norm: norm of all wavelets (for db estimation)
// - iw_shift: scale applied before decomposition
static const float iw_norm[16] = {
2.627989e+03F,
1.832893e+02F, 1.832959e+02F, 5.114690e+01F,
4.583344e+01F, 4.583462e+01F, 1.279225e+01F,
1.149671e+01F, 1.149712e+01F, 3.218888e+00F,
2.999281e+00F, 2.999476e+00F, 8.733161e-01F,
1.074451e+00F, 1.074511e+00F, 4.289318e-01F
};
static const int iw_shift = 6;
static const int iw_round = (1<<(iw_shift-1));
static const struct { int start; int size; }
bandbuckets[] =
{
// Code first bucket and number of buckets in each band
{ 0, 1 }, // -- band zero contains all lores info
{ 1, 1 }, { 2, 1 }, { 3, 1 },
{ 4, 4 }, { 8, 4 }, { 12,4 },
{ 16,16 }, { 32,16 }, { 48,16 },
};
/** 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::Encode : public IWBitmap
{
public:
/// Destructor
virtual ~Encode(void);
/** 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. */
Encode(void);
/** 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}). */
void init(const GBitmap &bm, const GP<GBitmap> mask=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#) composed of #nchunks# chunks
(identifier #BM44#). 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);
/** 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);
protected:
Codec::Encode *ycodec_enc;
};
/** 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::Encode : public IWPixmap
{
public:
enum CRCBMode {
CRCBnone=IW44Image::CRCBnone,
CRCBhalf=IW44Image::CRCBhalf,
CRCBnormal=IW44Image::CRCBnormal,
CRCBfull=IW44Image::CRCBfull };
/// Destructor
virtual ~Encode(void);
/** 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. */
Encode(void);
/** 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}). */
void init(const GPixmap &bm, const GP<GBitmap> mask=0, CRCBMode crcbmode=CRCBnormal);
// 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 color image into a DjVu IW44 file. This function creates a
composite chunk (identifier #FORM:PM44#) composed of #nchunks# chunks
(identifier #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);
/** 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);
protected:
Codec::Encode *ycodec_enc, *cbcodec_enc, *crcodec_enc;
};
class IW44Image::Map::Encode : public IW44Image::Map // DJVU_CLASS
{
public:
Encode(const int w, const int h) : Map(w,h) {}
// creation (from image)
void create(const signed char *img8, int imgrowsize,
const signed char *msk8=0, int mskrowsize=0);
// slash resolution
void slashres(int res);
};
class IW44Image::Codec::Encode : public IW44Image::Codec
{
public:
Encode(IW44Image::Map &map);
// Coding
virtual int code_slice(ZPCodec &zp);
float estimate_decibel(float frac);
// Data
void encode_buckets(ZPCodec &zp, int bit, int band,
IW44Image::Block &blk, IW44Image::Block &eblk, int fbucket, int nbucket);
int encode_prepare(int band, int fbucket, int nbucket, IW44Image::Block &blk, IW44Image::Block &eblk);
IW44Image::Map emap;
};
IW44Image::Codec::Encode::Encode(IW44Image::Map &map)
: Codec(map), emap(map.iw,map.ih) {}
//////////////////////////////////////////////////////
/** IW44Image::Transform::Encode
*/
class IW44Image::Transform::Encode : IW44Image::Transform
{
public:
// WAVELET TRANSFORM
/** Forward transform. */
static void forward(short *p, int w, int h, int rowsize, int begin, int end);
// COLOR TRANSFORM
/** Extracts Y */
static void RGB_to_Y(const GPixel *p, int w, int h, int rowsize,
signed char *out, int outrowsize);
/** Extracts Cb */
static void RGB_to_Cb(const GPixel *p, int w, int h, int rowsize,
signed char *out, int outrowsize);
/** Extracts Cr */
static void RGB_to_Cr(const GPixel *p, int w, int h, int rowsize,
signed char *out, int outrowsize);
};
//////////////////////////////////////////////////////
// MMX IMPLEMENTATION HELPERS
//////////////////////////////////////////////////////
// Note:
// MMX implementation for vertical transforms only.
// Speedup is basically related to faster memory transfer
// The IW44 transform is not CPU bound, it is memory bound.
#ifdef MMX
static const short w9[] = {9,9,9,9};
static const short w1[] = {1,1,1,1};
static const int d8[] = {8,8};
static const int d16[] = {16,16};
static inline void
mmx_fv_1 ( short* &q, short* e, int s, int s3 )
{
while (q<e && (((size_t)q)&0x7))
{
int a = (int)q[-s] + (int)q[s];
int b = (int)q[-s3] + (int)q[s3];
*q -= (((a<<3)+a-b+8)>>4);
q++;
}
while (q+3<e)
{
MMXar( movq, q-s,mm0); // MM0=[ b3, b2, b1, b0 ]
MMXar( movq, q+s,mm2); // MM2=[ c3, c2, c1, c0 ]
MMXrr( movq, mm0,mm1);
MMXrr( punpcklwd, mm2,mm0); // MM0=[ c1, b1, c0, b0 ]
MMXrr( punpckhwd, mm2,mm1); // MM1=[ c3, b3, c2, b2 ]
MMXar( pmaddwd, w9,mm0); // MM0=[ (c1+b1)*9, (c0+b0)*9 ]
MMXar( pmaddwd, w9,mm1); // MM1=[ (c3+b3)*9, (c2+b2)*9 ]
MMXar( movq, q-s3,mm2);
MMXar( movq, q+s3,mm4);
MMXrr( movq, mm2,mm3);
MMXrr( punpcklwd, mm4,mm2); // MM2=[ d1, a1, d0, a0 ]
MMXrr( punpckhwd, mm4,mm3); // MM3=[ d3, a3, d2, a2 ]
MMXar( pmaddwd, w1,mm2); // MM2=[ (a1+d1)*1, (a0+d0)*1 ]
MMXar( pmaddwd, w1,mm3); // MM3=[ (a3+d3)*1, (a2+d2)*1 ]
MMXar( paddd, d8,mm0);
MMXar( paddd, d8,mm1);
MMXrr( psubd, mm2,mm0); // MM0=[ (c1+b1)*9-a1-d1+8, ...
MMXrr( psubd, mm3,mm1); // MM1=[ (c3+b3)*9-a3-d3+8, ...
MMXir( psrad, 4,mm0);
MMXar( movq, q,mm7); // MM7=[ p3,p2,p1,p0 ]
MMXir( psrad, 4,mm1);
MMXrr( packssdw, mm1,mm0); // MM0=[ x3,x2,x1,x0 ]
MMXrr( psubw, mm0,mm7); // MM7=[ p3-x3, p2-x2, ... ]
MMXra( movq, mm7,q);
#if defined(_MSC_VER) && defined(_DEBUG)
MMXemms;
#endif
q += 4;
}
}
static inline void
mmx_fv_2 ( short* &q, short* e, int s, int s3 )
{
while (q<e && (((size_t)q)&0x7))
{
int a = (int)q[-s] + (int)q[s];
int b = (int)q[-s3] + (int)q[s3];
*q += (((a<<3)+a-b+16)>>5);
q ++;
}
while (q+3<e)
{
MMXar( movq, q-s,mm0); // MM0=[ b3, b2, b1, b0 ]
MMXar( movq, q+s,mm2); // MM2=[ c3, c2, c1, c0 ]
MMXrr( movq, mm0,mm1);
MMXrr( punpcklwd, mm2,mm0); // MM0=[ c1, b1, c0, b0 ]
MMXrr( punpckhwd, mm2,mm1); // MM1=[ c3, b3, c2, b2 ]
MMXar( pmaddwd, w9,mm0); // MM0=[ (c1+b1)*9, (c0+b0)*9 ]
MMXar( pmaddwd, w9,mm1); // MM1=[ (c3+b3)*9, (c2+b2)*9 ]
MMXar( movq, q-s3,mm2);
MMXar( movq, q+s3,mm4);
MMXrr( movq, mm2,mm3);
MMXrr( punpcklwd, mm4,mm2); // MM2=[ d1, a1, d0, a0 ]
MMXrr( punpckhwd, mm4,mm3); // MM3=[ d3, a3, d2, a2 ]
MMXar( pmaddwd, w1,mm2); // MM2=[ (a1+d1)*1, (a0+d0)*1 ]
MMXar( pmaddwd, w1,mm3); // MM3=[ (a3+d3)*1, (a2+d2)*1 ]
MMXar( paddd, d16,mm0);
MMXar( paddd, d16,mm1);
MMXrr( psubd, mm2,mm0); // MM0=[ (c1+b1)*9-a1-d1+8, ...
MMXrr( psubd, mm3,mm1); // MM1=[ (c3+b3)*9-a3-d3+8, ...
MMXir( psrad, 5,mm0);
MMXar( movq, q,mm7); // MM7=[ p3,p2,p1,p0 ]
MMXir( psrad, 5,mm1);
MMXrr( packssdw, mm1,mm0); // MM0=[ x3,x2,x1,x0 ]
MMXrr( paddw, mm0,mm7); // MM7=[ p3+x3, p2+x2, ... ]
MMXra( movq, mm7,q);
#if defined(_MSC_VER) && defined(_DEBUG)
MMXemms;
#endif
q += 4;
}
}
#endif /* MMX */
//////////////////////////////////////////////////////
// NEW FILTERS
//////////////////////////////////////////////////////
static void
filter_fv(short *p, int w, int h, int rowsize, int scale)
{
int y = 0;
int s = scale*rowsize;
int s3 = s+s+s;
h = ((h-1)/scale)+1;
y += 1;
p += s;
while (y-3 < h)
{
// 1-Delta
{
short *q = p;
short *e = q+w;
if (y>=3 && y+3<h)
{
// Generic case
#ifdef MMX
if (scale==1 && MMXControl::mmxflag>0)
mmx_fv_1(q, e, s, s3);
#endif
while (q<e)
{
int a = (int)q[-s] + (int)q[s];
int b = (int)q[-s3] + (int)q[s3];
*q -= (((a<<3)+a-b+8)>>4);
q += scale;
}
}
else if (y<h)
{
// Special cases
short *q1 = (y+1<h ? q+s : q-s);
while (q<e)
{
int a = (int)q[-s] + (int)(*q1);
*q -= ((a+1)>>1);
q += scale;
q1 += scale;
}
}
}
// 2-Update
{
short *q = p-s3;
short *e = q+w;
if (y>=6 && y<h)
{
// Generic case
#ifdef MMX
if (scale==1 && MMXControl::mmxflag>0)
mmx_fv_2(q, e, s, s3);
#endif
while (q<e)
{
int a = (int)q[-s] + (int)q[s];
int b = (int)q[-s3] + (int)q[s3];
*q += (((a<<3)+a-b+16)>>5);
q += scale;
}
}
else if (y>=3)
{
// Special cases
short *q1 = (y-2<h ? q+s : 0);
short *q3 = (y<h ? q+s3 : 0);
if (y>=6)
{
while (q<e)
{
int a = (int)q[-s] + (q1 ? (int)(*q1) : 0);
int b = (int)q[-s3] + (q3 ? (int)(*q3) : 0);
*q += (((a<<3)+a-b+16)>>5);
q += scale;
if (q1) q1 += scale;
if (q3) q3 += scale;
}
}
else if (y>=4)
{
while (q<e)
{
int a = (int)q[-s] + (q1 ? (int)(*q1) : 0);
int b = (q3 ? (int)(*q3) : 0);
*q += (((a<<3)+a-b+16)>>5);
q += scale;
if (q1) q1 += scale;
if (q3) q3 += scale;
}
}
else
{
while (q<e)
{
int a = (q1 ? (int)(*q1) : 0);
int b = (q3 ? (int)(*q3) : 0);
*q += (((a<<3)+a-b+16)>>5);
q += scale;
if (q1) q1 += scale;
if (q3) q3 += scale;
}
}
}
}
y += 2;
p += s+s;
}
}
static void
filter_fh(short *p, int w, int h, int rowsize, int scale)
{
int y = 0;
int s = scale;
int s3 = s+s+s;
rowsize *= scale;
while (y<h)
{
short *q = p+s;
short *e = p+w;
int a0=0, a1=0, a2=0, a3=0;
int b0=0, b1=0, b2=0, b3=0;
if (q < e)
{
// Special case: x=1
a1 = a2 = a3 = q[-s];
if (q+s<e)
a2 = q[s];
if (q+s3<e)
a3 = q[s3];
b3 = q[0] - ((a1+a2+1)>>1);
q[0] = b3;
q += s+s;
}
while (q+s3 < e)
{
// Generic case
a0=a1;
a1=a2;
a2=a3;
a3=q[s3];
b0=b1;
b1=b2;
b2=b3;
b3 = q[0] - ((((a1+a2)<<3)+(a1+a2)-a0-a3+8) >> 4);
q[0] = b3;
q[-s3] = q[-s3] + ((((b1+b2)<<3)+(b1+b2)-b0-b3+16) >> 5);
q += s+s;
}
while (q < e)
{
// Special case: w-3 <= x < w
a1=a2;
a2=a3;
b0=b1;
b1=b2;
b2=b3;
b3 = q[0] - ((a1+a2+1)>>1);
q[0] = b3;
q[-s3] = q[-s3] + ((((b1+b2)<<3)+(b1+b2)-b0-b3+16) >> 5);
q += s+s;
}
while (q-s3 < e)
{
// Special case w <= x < w+3
b0=b1;
b1=b2;
b2=b3;
b3=0;
if (q-s3 >= p)
q[-s3] = q[-s3] + ((((b1+b2)<<3)+(b1+b2)-b0-b3+16) >> 5);
q += s+s;
}
y += scale;
p += rowsize;
}
}
//////////////////////////////////////////////////////
// WAVELET TRANSFORM
//////////////////////////////////////////////////////
//----------------------------------------------------
// Function for applying bidimensional IW44 between
// scale intervals begin(inclusive) and end(exclusive)
void
IW44Image::Transform::Encode::forward(short *p, int w, int h, int rowsize, int begin, int end)
{
// PREPARATION
filter_begin(w,h);
// LOOP ON SCALES
for (int scale=begin; scale<end; scale<<=1)
{
#ifdef IWTRANSFORM_TIMER
int tv,th;
th = tv = GOS::ticks();
#endif
filter_fh(p, w, h, rowsize, scale);
#ifdef IWTRANSFORM_TIMER
th = GOS::ticks();
tv = th - tv;
#endif
filter_fv(p, w, h, rowsize, scale);
#ifdef IWTRANSFORM_TIMER
th = GOS::ticks()-th;
DjVuPrintErrorUTF8("forw%d\tv=%dms h=%dms\n", scale,th,tv);
#endif
}
// TERMINATE
filter_end();
}
//////////////////////////////////////////////////////
// COLOR TRANSFORM
//////////////////////////////////////////////////////
static const float
rgb_to_ycc[3][3] =
{ { 0.304348F, 0.608696F, 0.086956F },
{ 0.463768F, -0.405797F, -0.057971F },
{-0.173913F, -0.347826F, 0.521739F } };
/* Extracts Y */
void
IW44Image::Transform::Encode::RGB_to_Y(const GPixel *p, int w, int h, int rowsize,
signed char *out, int outrowsize)
{
int rmul[256], gmul[256], bmul[256];
for (int k=0; k<256; k++)
{
rmul[k] = (int)(k*0x10000*rgb_to_ycc[0][0]);
gmul[k] = (int)(k*0x10000*rgb_to_ycc[0][1]);
bmul[k] = (int)(k*0x10000*rgb_to_ycc[0][2]);
}
for (int i=0; i<h; i++, p+=rowsize, out+=outrowsize)
{
const GPixel *p2 = p;
signed char *out2 = out;
for (int j=0; j<w; j++,p2++,out2++)
{
int y = rmul[p2->r] + gmul[p2->g] + bmul[p2->b] + 32768;
*out2 = (y>>16) - 128;
}
}
}
#ifdef min
#undef min
#endif
static inline int min(const int x,const int y) {return (x<y)?x:y;}
#ifdef max
#undef max
#endif
static inline int max(const int x,const int y) {return (x>y)?x:y;}
/* Extracts Cb */
void
IW44Image::Transform::Encode::RGB_to_Cb(const GPixel *p, int w, int h, int rowsize,
signed char *out, int outrowsize)
{
int rmul[256], gmul[256], bmul[256];
for (int k=0; k<256; k++)
{
rmul[k] = (int)(k*0x10000*rgb_to_ycc[2][0]);
gmul[k] = (int)(k*0x10000*rgb_to_ycc[2][1]);
bmul[k] = (int)(k*0x10000*rgb_to_ycc[2][2]);
}
for (int i=0; i<h; i++, p+=rowsize, out+=outrowsize)
{
const GPixel *p2 = p;
signed char *out2 = out;
for (int j=0; j<w; j++,p2++,out2++)
{
int c = rmul[p2->r] + gmul[p2->g] + bmul[p2->b] + 32768;
*out2 = max(-128, min(127, c>>16));
}
}
}
/* Extracts Cr */
void
IW44Image::Transform::Encode::RGB_to_Cr(const GPixel *p, int w, int h, int rowsize,
signed char *out, int outrowsize)
{
int rmul[256], gmul[256], bmul[256];
for (int k=0; k<256; k++)
{
rmul[k] = (int)((k*0x10000)*rgb_to_ycc[1][0]);
gmul[k] = (int)((k*0x10000)*rgb_to_ycc[1][1]);
bmul[k] = (int)((k*0x10000)*rgb_to_ycc[1][2]);
}
for (int i=0; i<h; i++, p+=rowsize, out+=outrowsize)
{
const GPixel *p2 = p;
signed char *out2 = out;
for (int j=0; j<w; j++,p2++,out2++)
{
int c = rmul[p2->r] + gmul[p2->g] + bmul[p2->b] + 32768;
*out2 = max(-128, min(127, c>>16));
}
}
}
//////////////////////////////////////////////////////
// MASKING DECOMPOSITION
//////////////////////////////////////////////////////
//----------------------------------------------------
// Function for applying bidimensional IW44 between
// scale intervals begin(inclusive) and end(exclusive)
// with a MASK bitmap
static void
interpolate_mask(short *data16, int w, int h, int rowsize,
const signed char *mask8, int mskrowsize)
{
int i,j;
// count masked bits
short *count;
GPBuffer<short> gcount(count,w*h);
short *cp = count;
for (i=0; i<h; i++, cp+=w, mask8+=mskrowsize)
for (j=0; j<w; j++)
cp[j] = (mask8[j] ? 0 : 0x1000);
// copy image
short *sdata;
GPBuffer<short> gsdata(sdata,w*h);
short *p = sdata;
short *q = data16;
for (i=0; i<h; i++, p+=w, q+=rowsize)
for (j=0; j<w; j++)
p[j] = q[j];
// iterate over resolutions
int split = 1;
int scale = 2;
int again = 1;
while (again && scale<w && scale<h)
{
again = 0;
p = data16;
q = sdata;
cp = count;
// iterate over block
for (i=0; i<h; i+=scale, cp+=w*scale, q+=w*scale, p+=rowsize*scale)
for (j=0; j<w; j+=scale)
{
int ii, jj;
int gotz = 0;
int gray = 0;
int npix = 0;
short *cpp = cp;
short *qq = q;
// look around when square goes beyond border
int istart = i;
if (istart+split>h)
{
istart -= scale;
cpp -= w*scale;
qq -= w*scale;
}
int jstart = j;
if (jstart+split>w)
jstart -= scale;
// compute gray level
for (ii=istart; ii<i+scale && ii<h; ii+=split, cpp+=w*split, qq+=w*split)
for (jj=jstart; jj<j+scale && jj<w; jj+=split)
{
if (cpp[jj]>0)
{
npix += cpp[jj];
gray += cpp[jj] * qq[jj];
}
else if (ii>=i && jj>=j)
{
gotz = 1;
}
}
// process result
if (npix == 0)
{
// continue to next resolution
again = 1;
cp[j] = 0;
}
else
{
gray = gray / npix;
// check whether initial image require fix
if (gotz)
{
cpp = cp;
qq = p;
for (ii=i; ii<i+scale && ii<h; ii+=1, cpp+=w, qq+=rowsize)
for (jj=j; jj<j+scale && jj<w; jj+=1)
if (cpp[jj] == 0)
{
qq[jj] = gray;
cpp[jj] = 1;
}
}
// store average for next iteration
cp[j] = npix>>2;
q[j] = gray;
}
}
// double resolution
split = scale;
scale = scale+scale;
}
}
static void
forward_mask(short *data16, int w, int h, int rowsize, int begin, int end,
const signed char *mask8, int mskrowsize )
{
int i,j;
signed char *m;
short *p;
short *d;
// Allocate buffers
short *sdata;
GPBuffer<short> gsdata(sdata,w*h);
signed char *smask;
GPBuffer<signed char> gsmask(smask,w*h);
// Copy mask
m = smask;
for (i=0; i<h; i+=1, m+=w, mask8+=mskrowsize)
memcpy((void*)m, (void*)mask8, w);
// Loop over scale
for (int scale=begin; scale<end; scale<<=1)
{
// Copy data into sdata buffer
p = data16;
d = sdata;
for (i=0; i<h; i+=scale)
{
for (j=0; j<w; j+=scale)
d[j] = p[j];
p += rowsize * scale;
d += w * scale;
}
// Decompose
IW44Image::Transform::Encode::forward(sdata, w, h, w, scale, scale+scale);
// Cancel masked coefficients
d = sdata;
m = smask;
for (i=0; i<h; i+=scale+scale)
{
for (j=scale; j<w; j+=scale+scale)
if (m[j])
d[j] = 0;
d += w * scale;
m += w * scale;
if (i+scale < h)
{
for (j=0; j<w; j+=scale)
if (m[j])
d[j] = 0;
d += w * scale;
m += w * scale;
}
}
// Reconstruct
IW44Image::Transform::Decode::backward(sdata, w, h, w, scale+scale, scale);
// Correct visible pixels
p = data16;
d = sdata;
m = smask;
for (i=0; i<h; i+=scale)
{
for (j=0; j<w; j+=scale)
if (! m[j])
d[j] = p[j];
p += rowsize*scale;
m += w*scale;
d += w*scale;
}
// Decompose again (no need to iterate actually!)
IW44Image::Transform::Encode::forward(sdata, w, h, w, scale, scale+scale);
// Copy coefficients from sdata buffer
p = data16;
d = sdata;
for (i=0; i<h; i+=scale)
{
for (j=0; j<w; j+=scale)
p[j] = d[j];
p += rowsize * scale;
d += w * scale;
}
// Compute new mask for next scale
m = smask;
signed char *m0 = m;
signed char *m1 = m;
for (i=0; i<h; i+=scale+scale)
{
m0 = m1;
if (i+scale < h)
m1 = m + w*scale;
for (j=0; j<w; j+=scale+scale)
if (m[j] && m0[j] && m1[j] && (j<=0 || m[j-scale]) && (j+scale>=w || m[j+scale]))
m[j] = 1;
else
m[j] = 0;
m = m1 + w*scale;
}
}
// Free buffers
}
void
IW44Image::Map::Encode::create(const signed char *img8, int imgrowsize,
const signed char *msk8, int mskrowsize )
{
int i, j;
// Progress
DJVU_PROGRESS_TASK(transf,"create iw44 map",3);
// Allocate decomposition buffer
short *data16;
GPBuffer<short> gdata16(data16,bw*bh);
// Copy pixels
short *p = data16;
const signed char *row = img8;
for (i=0; i<ih; i++)
{
for (j=0; j<iw; j++)
*p++ = (int)(row[j]) << iw_shift;
row += imgrowsize;
for (j=iw; j<bw; j++)
*p++ = 0;
}
for (i=ih; i<bh; i++)
for (j=0; j<bw; j++)
*p++ = 0;
// Handle bitmask
if (msk8)
{
// Interpolate pixels below mask
DJVU_PROGRESS_RUN(transf, 1);
interpolate_mask(data16, iw, ih, bw, msk8, mskrowsize);
// Multiscale iterative masked decomposition
DJVU_PROGRESS_RUN(transf, 3);
forward_mask(data16, iw, ih, bw, 1, 32, msk8, mskrowsize);
}
else
{
// Perform traditional decomposition
DJVU_PROGRESS_RUN(transf, 3);
IW44Image::Transform::Encode::forward(data16, iw, ih, bw, 1, 32);
}
// Copy coefficient into blocks
p = data16;
IW44Image::Block *block = blocks;
for (i=0; i<bh; i+=32)
{
for (j=0; j<bw; j+=32)
{
short liftblock[1024];
// transfer coefficients at (p+j) into aligned block
short *pp = p + j;
short *pl = liftblock;
for (int ii=0; ii<32; ii++, pp+=bw)
for (int jj=0; jj<32; jj++)
*pl++ = pp[jj];
// transfer into IW44Image::Block (apply zigzag and scaling)
block->read_liftblock(liftblock, this);
block++;
}
// next row of blocks
p += 32*bw;
}
}
void
IW44Image::Map::Encode::slashres(int res)
{
int minbucket = 1;
if (res < 2)
return;
else if (res < 4)
minbucket=16;
else if (res < 8)
minbucket=4;
for (int blockno=0; blockno<nb; blockno++)
for (int buckno=minbucket; buckno<64; buckno++)
blocks[blockno].zero(buckno);
}
// encode_prepare
// -- compute the states prior to encoding the buckets
int
IW44Image::Codec::Encode::encode_prepare(int band, int fbucket, int nbucket, IW44Image::Block &blk, IW44Image::Block &eblk)
{
int bbstate = 0;
// compute state of all coefficients in all buckets
if (band)
{
// Band other than zero
int thres = quant_hi[band];
char *cstate = coeffstate;
for (int buckno=0; buckno<nbucket; buckno++, cstate+=16)
{
const short *pcoeff = blk.data(fbucket+buckno);
const short *epcoeff = eblk.data(fbucket+buckno);
int bstatetmp = 0;
if (! pcoeff)
{
bstatetmp = UNK;
// cstate[i] is not used and does not need initialization
}
else if (! epcoeff)
{
for (int i=0; i<16; i++)
{
int cstatetmp = UNK;
if ((int)(pcoeff[i])>=thres || (int)(pcoeff[i])<=-thres)
cstatetmp = NEW|UNK;
cstate[i] = cstatetmp;
bstatetmp |= cstatetmp;
}
}
else
{
for (int i=0; i<16; i++)
{
int cstatetmp = UNK;
if (epcoeff[i])
cstatetmp = ACTIVE;
else if ((int)(pcoeff[i])>=thres || (int)(pcoeff[i])<=-thres)
cstatetmp = NEW|UNK;
cstate[i] = cstatetmp;
bstatetmp |= cstatetmp;
}
}
bucketstate[buckno] = bstatetmp;
bbstate |= bstatetmp;
}
}
else
{
// Band zero ( fbucket==0 implies band==zero and nbucket==1 )
const short *pcoeff = blk.data(0, &map);
const short *epcoeff = eblk.data(0, &emap);
char *cstate = coeffstate;
for (int i=0; i<16; i++)
{
int thres = quant_lo[i];
int cstatetmp = cstate[i];
if (cstatetmp != ZERO)
{
cstatetmp = UNK;
if (epcoeff[i])
cstatetmp = ACTIVE;
else if ((int)(pcoeff[i])>=thres || (int)(pcoeff[i])<=-thres)
cstatetmp = NEW|UNK;
}
cstate[i] = cstatetmp;
bbstate |= cstatetmp;
}
bucketstate[0] = bbstate;
}
return bbstate;
}
// encode_buckets
// -- code a sequence of buckets in a given block
void
IW44Image::Codec::Encode::encode_buckets(ZPCodec &zp, int bit, int band,
IW44Image::Block &blk, IW44Image::Block &eblk,
int fbucket, int nbucket)
{
// compute state of all coefficients in all buckets
int bbstate = encode_prepare(band, fbucket, nbucket, blk, eblk);
// code root bit
if ((nbucket<16) || (bbstate&ACTIVE))
{
bbstate |= NEW;
}
else if (bbstate & UNK)
{
zp.encoder( (bbstate&NEW) ? 1 : 0 , ctxRoot);
#ifdef TRACE
DjVuPrintMessage("bbstate[bit=%d,band=%d] = %d\n", bit, band, bbstate);
#endif
}
// code bucket bits
if (bbstate & NEW)
for (int buckno=0; buckno<nbucket; buckno++)
{
// Code bucket bit
if (bucketstate[buckno] & UNK)
{
// Context
int ctx = 0;
#ifndef NOCTX_BUCKET_UPPER
if (band>0)
{
int k = (fbucket+buckno)<<2;
const short *b = eblk.data(k>>4);
if (b)
{
k = k & 0xf;
if (b[k])
ctx += 1;
if (b[k+1])
ctx += 1;
if (b[k+2])
ctx += 1;
if (ctx<3 && b[k+3])
ctx += 1;
}
}
#endif
#ifndef NOCTX_BUCKET_ACTIVE
if (bbstate & ACTIVE)
ctx |= 4;
#endif
// Code
zp.encoder( (bucketstate[buckno]&NEW) ? 1 : 0, ctxBucket[band][ctx] );
#ifdef TRACE
DjVuPrintMessage(" bucketstate[bit=%d,band=%d,buck=%d] = %d\n",
bit, band, buckno, bucketstate[buckno] & ~ZERO);
#endif
}
}
// code new active coefficient (with their sign)
if (bbstate & NEW)
{
int thres = quant_hi[band];
char *cstate = coeffstate;
for (int buckno=0; buckno<nbucket; buckno++, cstate+=16)
if (bucketstate[buckno] & NEW)
{
int i;
#ifndef NOCTX_EXPECT
int gotcha = 0;
const int maxgotcha = 7;
for (i=0; i<16; i++)
if (cstate[i] & UNK)
gotcha += 1;
#endif
const short *pcoeff = blk.data(fbucket+buckno);
short *epcoeff = eblk.data(fbucket+buckno, &emap);
// iterate within bucket
for (i=0; i<16; i++)
{
if (cstate[i] & UNK)
{
// Prepare context
int ctx = 0;
#ifndef NOCTX_EXPECT
if (gotcha>=maxgotcha)
ctx = maxgotcha;
else
ctx = gotcha;
#endif
#ifndef NOCTX_ACTIVE
if (bucketstate[buckno] & ACTIVE)
ctx |= 8;
#endif
// Code
zp.encoder( (cstate[i]&NEW) ? 1 : 0, ctxStart[ctx] );
if (cstate[i] & NEW)
{
// Code sign
zp.IWencoder( (pcoeff[i]<0) ? 1 : 0 );
// Set encoder state
if (band==0)
thres = quant_lo[i];
epcoeff[i] = thres + (thres>>1);
}
#ifndef NOCTX_EXPECT
if (cstate[i] & NEW)
gotcha = 0;
else if (gotcha > 0)
gotcha -= 1;
#endif
#ifdef TRACE
DjVuPrintMessage(" coeffstate[bit=%d,band=%d,buck=%d,c=%d] = %d\n",
bit, band, buckno, i, cstate[i]);
#endif
}
}
}
}
// code mantissa bits
if (bbstate & ACTIVE)
{
int thres = quant_hi[band];
char *cstate = coeffstate;
for (int buckno=0; buckno<nbucket; buckno++, cstate+=16)
if (bucketstate[buckno] & ACTIVE)
{
const short *pcoeff = blk.data(fbucket+buckno);
short *epcoeff = eblk.data(fbucket+buckno, &emap);
for (int i=0; i<16; i++)
if (cstate[i] & ACTIVE)
{
// get coefficient
int coeff = pcoeff[i];
int ecoeff = epcoeff[i];
if (coeff < 0)
coeff = -coeff;
// get band zero thresholds
if (band == 0)
thres = quant_lo[i];
// compute mantissa bit
int pix = 0;
if (coeff >= ecoeff)
pix = 1;
// encode second or lesser mantissa bit
if (ecoeff <= 3*thres)
zp.encoder(pix, ctxMant);
else
zp.IWencoder(!!pix);
// adjust epcoeff
epcoeff[i] = ecoeff - (pix ? 0 : thres) + (thres>>1);
}
}
}
}
// IW44Image::Codec::estimate_decibel
// -- estimate encoding error (after code_slice) in decibels.
float
IW44Image::Codec::Encode::estimate_decibel(float frac)
{
int i,j;
const float *q;
// Fill norm arrays
float norm_lo[16];
float norm_hi[10];
// -- lo coefficients
q = iw_norm;
for (i=j=0; i<4; j++)
norm_lo[i++] = *q++;
for (j=0; j<4; j++)
norm_lo[i++] = *q;
q += 1;
for (j=0; j<4; j++)
norm_lo[i++] = *q;
q += 1;
for (j=0; j<4; j++)
norm_lo[i++] = *q;
q += 1;
// -- hi coefficients
norm_hi[0] = 0;
for (j=1; j<10; j++)
norm_hi[j] = *q++;
// Initialize mse array
float *xmse;
GPBuffer<float> gxmse(xmse,map.nb);
// Compute mse in each block
for (int blockno=0; blockno<map.nb; blockno++)
{
float mse = 0;
// Iterate over bands
for (int bandno=0; bandno<10; bandno++)
{
int fbucket = bandbuckets[bandno].start;
int nbucket = bandbuckets[bandno].size;
IW44Image::Block &blk = map.blocks[blockno];
IW44Image::Block &eblk = emap.blocks[blockno];
float norm = norm_hi[bandno];
for (int buckno=0; buckno<nbucket; buckno++)
{
const short *pcoeff = blk.data(fbucket+buckno);
const short *epcoeff = eblk.data(fbucket+buckno);
if (pcoeff)
{
if (epcoeff)
{
for (i=0; i<16; i++)
{
if (bandno == 0)
norm = norm_lo[i];
float delta = (float)(pcoeff[i]<0 ? -pcoeff[i] : pcoeff[i]);
delta = delta - epcoeff[i];
mse = mse + norm * delta * delta;
}
}
else
{
for (i=0; i<16; i++)
{
if (bandno == 0)
norm = norm_lo[i];
float delta = (float)(pcoeff[i]);
mse = mse + norm * delta * delta;
}
}
}
}
}
xmse[blockno] = mse / 1024;
}
// Compute partition point
int n = 0;
int m = map.nb - 1;
int p = (int)floor(m*(1.0-frac)+0.5);
p = (p>m ? m : (p<0 ? 0 : p));
float pivot = 0;
// Partition array
while (n < p)
{
int l = n;
int h = m;
if (xmse[l] > xmse[h]) { float tmp=xmse[l]; xmse[l]=xmse[h]; xmse[h]=tmp; }
pivot = xmse[(l+h)/2];
if (pivot < xmse[l]) { float tmp=pivot; pivot=xmse[l]; xmse[l]=tmp; }
if (pivot > xmse[h]) { float tmp=pivot; pivot=xmse[h]; xmse[h]=tmp; }
while (l < h)
{
if (xmse[l] > xmse[h]) { float tmp=xmse[l]; xmse[l]=xmse[h]; xmse[h]=tmp; }
while (xmse[l]<pivot || (xmse[l]==pivot && l<h)) l++;
while (xmse[h]>pivot) h--;
}
if (p>=l)
n = l;
else
m = l-1;
}
// Compute average mse
float mse = 0;
for (i=p; i<map.nb; i++)
mse = mse + xmse[i];
mse = mse / (map.nb - p);
// Return
float factor = 255 << iw_shift;
float decibel = (float)(10.0 * log ( factor * factor / mse ) / 2.302585125);
return decibel;
}
//////////////////////////////////////////////////////
// IW44IMAGE ENCODING ROUTINES
//////////////////////////////////////////////////////
void
IW44Image::PrimaryHeader::encode(GP<ByteStream> gbs)
{
gbs->write8(serial);
gbs->write8(slices);
}
void
IW44Image::SecondaryHeader::encode(GP<ByteStream> gbs)
{
gbs->write8(major);
gbs->write8(minor);
}
void
IW44Image::TertiaryHeader::encode(GP<ByteStream> gbs)
{
gbs->write8(xhi);
gbs->write8(xlo);
gbs->write8(yhi);
gbs->write8(ylo);
gbs->write8(crcbdelay);
}
GP<IW44Image>
IW44Image::create_encode(const ImageType itype)
{
switch(itype)
{
case COLOR:
return new IWPixmap::Encode();
case GRAY:
return new IWBitmap::Encode();
default:
return 0;
}
}
GP<IW44Image>
IW44Image::create_encode(const GBitmap &bm, const GP<GBitmap> mask)
{
IWBitmap::Encode *bit=new IWBitmap::Encode();
GP<IW44Image> retval=bit;
bit->init(bm, mask);
return retval;
}
IWBitmap::Encode::Encode(void)
: IWBitmap(), ycodec_enc(0)
{}
IWBitmap::Encode::~Encode()
{
close_codec();
}
void
IWBitmap::Encode::init(const GBitmap &bm, const GP<GBitmap> gmask)
{
// Free
close_codec();
delete ymap;
ymap = 0;
// Init
int i, j;
int w = bm.columns();
int h = bm.rows();
int g = bm.get_grays()-1;
signed char *buffer;
GPBuffer<signed char> gbuffer(buffer,w*h);
// Prepare gray level conversion table
signed char bconv[256];
for (i=0; i<256; i++)
bconv[i] = max(0,min(255,i*255/g)) - 128;
// Perform decomposition
// Prepare mask information
const signed char *msk8 = 0;
int mskrowsize = 0;
GBitmap *mask=gmask;
if (gmask)
{
msk8 = (const signed char*)((*mask)[0]);
mskrowsize = mask->rowsize();
}
// Prepare a buffer of signed bytes
for (i=0; i<h; i++)
{
signed char *bufrow = buffer + i*w;
const unsigned char *bmrow = bm[i];
for (j=0; j<w; j++)
bufrow[j] = bconv[bmrow[j]];
}
// Create map
Map::Encode *eymap=new Map::Encode(w,h);
ymap = eymap;
eymap->create(buffer, w, msk8, mskrowsize);
}
void
IWBitmap::Encode::close_codec(void)
{
delete ycodec_enc;
ycodec_enc = 0;
IWBitmap::close_codec();
}
int
IWBitmap::Encode::encode_chunk(GP<ByteStream> gbs, const IWEncoderParms &parm)
{
// Check
if (parm.slices==0 && parm.bytes==0 && parm.decibels==0)
G_THROW( ERR_MSG("IW44Image.need_stop") );
if (! ymap)
G_THROW( ERR_MSG("IW44Image.empty_object") );
// Open codec
if (!ycodec_enc)
{
cslice = cserial = cbytes = 0;
ycodec_enc = new Codec::Encode(*ymap);
}
// Adjust cbytes
cbytes += sizeof(struct IW44Image::PrimaryHeader);
if (cserial == 0)
cbytes += sizeof(struct IW44Image::SecondaryHeader) + sizeof(struct IW44Image::TertiaryHeader);
// Prepare zcoded slices
int flag = 1;
int nslices = 0;
GP<ByteStream> gmbs=ByteStream::create();
ByteStream &mbs=*gmbs;
DJVU_PROGRESS_TASK(chunk,"encode chunk",parm.slices-cslice);
{
float estdb = -1.0;
GP<ZPCodec> gzp=ZPCodec::create(gmbs, true, true);
ZPCodec &zp=*gzp;
while (flag)
{
if (parm.decibels>0 && estdb>=parm.decibels)
break;
if (parm.bytes>0 && mbs.tell()+cbytes>=parm.bytes)
break;
if (parm.slices>0 && nslices+cslice>=parm.slices)
break;
DJVU_PROGRESS_RUN(chunk, (1+nslices-cslice)|0xf);
flag = ycodec_enc->code_slice(zp);
if (flag && parm.decibels>0.0)
if (ycodec_enc->curband==0 || estdb>=parm.decibels-DECIBEL_PRUNE)
estdb = ycodec_enc->estimate_decibel(db_frac);
nslices++;
}
}
// Write primary header
struct IW44Image::PrimaryHeader primary;
primary.serial = cserial;
primary.slices = nslices;
primary.encode(gbs);
// Write auxilliary headers
if (cserial == 0)
{
struct IW44Image::SecondaryHeader secondary;
secondary.major = IWCODEC_MAJOR + 0x80;
secondary.minor = IWCODEC_MINOR;
secondary.encode(gbs);
struct IW44Image::TertiaryHeader tertiary;
tertiary.xhi = (ymap->iw >> 8) & 0xff;
tertiary.xlo = (ymap->iw >> 0) & 0xff;
tertiary.yhi = (ymap->ih >> 8) & 0xff;
tertiary.ylo = (ymap->ih >> 0) & 0xff;
tertiary.crcbdelay = 0;
tertiary.encode(gbs);
}
// Write slices
mbs.seek(0);
gbs->copy(mbs);
// Return
cbytes += mbs.tell();
cslice += nslices;
cserial += 1;
return flag;
}
void
IWBitmap::Encode::encode_iff(IFFByteStream &iff, int nchunks, const IWEncoderParms *parms)
{
if (ycodec_enc)
G_THROW( ERR_MSG("IW44Image.left_open1") );
int flag = 1;
iff.put_chunk("FORM:BM44", 1);
DJVU_PROGRESS_TASK(iff,"encode iff chunk",nchunks);
for (int i=0; flag && i<nchunks; i++)
{
DJVU_PROGRESS_RUN(iff,i+1);
iff.put_chunk("BM44");
flag = encode_chunk(iff.get_bytestream(),parms[i]);
iff.close_chunk();
}
iff.close_chunk();
close_codec();
}
GP<IW44Image>
IW44Image::create_encode(
const GPixmap &pm, const GP<GBitmap> gmask, CRCBMode crcbmode)
{
IWPixmap::Encode *pix=new IWPixmap::Encode();
GP<IW44Image> retval=pix;
pix->init(pm, gmask,(IWPixmap::Encode::CRCBMode)crcbmode);
return retval;
}
IWPixmap::Encode::Encode(void)
: IWPixmap(), ycodec_enc(0), cbcodec_enc(0), crcodec_enc(0)
{}
IWPixmap::Encode::~Encode()
{
close_codec();
}
void
IWPixmap::Encode::init(const GPixmap &pm, const GP<GBitmap> gmask, CRCBMode crcbmode)
{
/* Free */
close_codec();
delete ymap;
delete cbmap;
delete crmap;
ymap = cbmap = crmap = 0;
/* Create */
int w = pm.columns();
int h = pm.rows();
signed char *buffer;
GPBuffer<signed char> gbuffer(buffer,w*h);
// Create maps
Map::Encode *eymap = new Map::Encode(w,h);
ymap = eymap;
// Handle CRCB mode
switch (crcbmode)
{
case CRCBnone: crcb_half=1; crcb_delay=-1; break;
case CRCBhalf: crcb_half=1; crcb_delay=10; break;
case CRCBnormal: crcb_half=0; crcb_delay=10; break;
case CRCBfull: crcb_half=0; crcb_delay= 0; break;
}
// Prepare mask information
const signed char *msk8 = 0;
int mskrowsize = 0;
GBitmap *mask=gmask;
if (mask)
{
msk8 = (signed char const *)((*mask)[0]);
mskrowsize = mask->rowsize();
}
// Fill buffer with luminance information
DJVU_PROGRESS_TASK(create,"initialize pixmap",3);
DJVU_PROGRESS_RUN(create,(crcb_delay>=0 ? 1 : 3));
Transform::Encode::RGB_to_Y(pm[0], w, h, pm.rowsize(), buffer, w);
if (crcb_delay < 0)
{
// Stupid inversion for gray images
signed char *e = buffer + w*h;
for (signed char *b=buffer; b<e; b++)
*b = 255 - *b;
}
// Create YMAP
eymap->create(buffer, w, msk8, mskrowsize);
// Create chrominance maps
if (crcb_delay >= 0)
{
Map::Encode *ecbmap = new Map::Encode(w,h);
cbmap = ecbmap;
Map::Encode *ecrmap = new Map::Encode(w,h);
crmap = ecrmap;
// Process CB information
DJVU_PROGRESS_RUN(create,2);
Transform::Encode::RGB_to_Cb(pm[0], w, h, pm.rowsize(), buffer, w);
ecbmap->create(buffer, w, msk8, mskrowsize);
// Process CR information
DJVU_PROGRESS_RUN(create,3);
Transform::Encode::RGB_to_Cr(pm[0], w, h, pm.rowsize(), buffer, w);
ecrmap->create(buffer, w, msk8, mskrowsize);
// Perform chrominance reduction (CRCBhalf)
if (crcb_half)
{
ecbmap->slashres(2);
ecrmap->slashres(2);
}
}
}
void
IWPixmap::Encode::encode_iff(IFFByteStream &iff, int nchunks, const IWEncoderParms *parms)
{
if (ycodec_enc)
G_THROW( ERR_MSG("IW44Image.left_open3") );
int flag = 1;
iff.put_chunk("FORM:PM44", 1);
DJVU_PROGRESS_TASK(iff,"encode pixmap chunk", nchunks);
for (int i=0; flag && i<nchunks; i++)
{
DJVU_PROGRESS_RUN(iff,i+1);
iff.put_chunk("PM44");
flag = encode_chunk(iff.get_bytestream(), parms[i]);
iff.close_chunk();
}
iff.close_chunk();
close_codec();
}
void
IWPixmap::Encode::close_codec(void)
{
delete ycodec_enc;
delete cbcodec_enc;
delete crcodec_enc;
ycodec_enc = crcodec_enc = cbcodec_enc = 0;
IWPixmap::close_codec();
}
int
IWPixmap::Encode::encode_chunk(GP<ByteStream> gbs, const IWEncoderParms &parm)
{
// Check
if (parm.slices==0 && parm.bytes==0 && parm.decibels==0)
G_THROW( ERR_MSG("IW44Image.need_stop2") );
if (!ymap)
G_THROW( ERR_MSG("IW44Image.empty_object2") );
// Open
if (!ycodec_enc)
{
cslice = cserial = cbytes = 0;
ycodec_enc = new Codec::Encode(*ymap);
if (crmap && cbmap)
{
cbcodec_enc = new Codec::Encode(*cbmap);
crcodec_enc = new Codec::Encode(*crmap);
}
}
// Adjust cbytes
cbytes += sizeof(struct IW44Image::PrimaryHeader);
if (cserial == 0)
cbytes += sizeof(struct IW44Image::SecondaryHeader) + sizeof(struct IW44Image::TertiaryHeader);
// Prepare zcodec slices
int flag = 1;
int nslices = 0;
GP<ByteStream> gmbs=ByteStream::create();
ByteStream &mbs=*gmbs;
DJVU_PROGRESS_TASK(chunk, "encode pixmap chunk", parm.slices-cslice);
{
float estdb = -1.0;
GP<ZPCodec> gzp=ZPCodec::create(gmbs, true, true);
ZPCodec &zp=*gzp;
while (flag)
{
if (parm.decibels>0 && estdb>=parm.decibels)
break;
if (parm.bytes>0 && mbs.tell()+cbytes>=parm.bytes)
break;
if (parm.slices>0 && nslices+cslice>=parm.slices)
break;
DJVU_PROGRESS_RUN(chunk,(1+nslices-cslice)|0xf);
flag = ycodec_enc->code_slice(zp);
if (flag && parm.decibels>0)
if (ycodec_enc->curband==0 || estdb>=parm.decibels-DECIBEL_PRUNE)
estdb = ycodec_enc->estimate_decibel(db_frac);
if (crcodec_enc && cbcodec_enc && cslice+nslices>=crcb_delay)
{
flag |= cbcodec_enc->code_slice(zp);
flag |= crcodec_enc->code_slice(zp);
}
nslices++;
}
}
// Write primary header
struct IW44Image::PrimaryHeader primary;
primary.serial = cserial;
primary.slices = nslices;
primary.encode(gbs);
// Write secondary header
if (cserial == 0)
{
struct IW44Image::SecondaryHeader secondary;
secondary.major = IWCODEC_MAJOR;
secondary.minor = IWCODEC_MINOR;
if (! (crmap && cbmap))
secondary.major |= 0x80;
secondary.encode(gbs);
struct IW44Image::TertiaryHeader tertiary;
tertiary.xhi = (ymap->iw >> 8) & 0xff;
tertiary.xlo = (ymap->iw >> 0) & 0xff;
tertiary.yhi = (ymap->ih >> 8) & 0xff;
tertiary.ylo = (ymap->ih >> 0) & 0xff;
tertiary.crcbdelay = (crcb_half ? 0x00 : 0x80);
tertiary.crcbdelay |= (crcb_delay>=0 ? crcb_delay : 0x00);
tertiary.encode(gbs);
}
// Write slices
mbs.seek(0);
gbs->copy(mbs);
// Return
cbytes += mbs.tell();
cslice += nslices;
cserial += 1;
return flag;
}
// code_slice
// -- read/write a slice of datafile
int
IW44Image::Codec::Encode::code_slice(ZPCodec &zp)
{
// Check that code_slice can still run
if (curbit < 0)
return 0;
// Perform coding
if (! is_null_slice(curbit, curband))
{
for (int blockno=0; blockno<map.nb; blockno++)
{
const int fbucket = bandbuckets[curband].start;
const int nbucket = bandbuckets[curband].size;
encode_buckets(zp, curbit, curband,
map.blocks[blockno], emap.blocks[blockno],
fbucket, nbucket);
}
}
return finish_code_slice(zp);
}
#ifdef HAVE_NAMESPACES
}
# ifndef NOT_USING_DJVU_NAMESPACE
using namespace DJVU;
# endif
#endif
#endif // NEED_DECODER_ONLY