TDE
/
tdegraphics
mirror of https://mirror.git.trinitydesktop.org/gitea/TDE/tdegraphics
0
0
Fork 0
Code Issues Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '03d51915bf'
${ noResults }
tdegraphics/kviewshell/plugins/djvu/libdjvu/DjVuImage.cpp

1487 lines
39 KiB
Raw Blame History

//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: DjVuImage.cpp,v 1.10 2005/04/27 16:34:13 leonb Exp $
// $Name: release_3_5_15 $
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#if NEED_GNUG_PRAGMAS
# pragma implementation
#endif
#include "DjVuImage.h"
#include "GScaler.h"
#include "DjVuDocument.h"
#include "DjVuPalette.h"
#include "GContainer.h"
#include "GSmartPointer.h"
#include "JB2Image.h"
#include "IW44Image.h"
#include "DataPool.h"
#include "ByteStream.h"
#include "GMapAreas.h"
#include "DjVuText.h"
#include "IFFByteStream.h"
#include "BSByteStream.h"
#include "debug.h"
#include <stdarg.h>
#ifdef HAVE_NAMESPACES
namespace DJVU {
# ifdef NOT_DEFINED // Just to fool emacs c++ mode
}
#endif
#endif
//// DJVUIMAGE: CONSTRUCTION
DjVuImage::DjVuImage(void)
: rotate_count(-1),retqlayout_sent(false)
{
}
void
DjVuImage::connect(const GP<DjVuFile> & xfile)
{
file=xfile;
DjVuPort::get_portcaster()->add_route(file, this);
}
//// DJVUIMAGE: DATA COLLECTORS
GP<DjVuInfo>
DjVuImage::get_info(const GP<DjVuFile> & file) const
{
if (file->info)
{
if(rotate_count<0)
{
const_cast<DjVuImage *>(this)->init_rotate(*(file->info));
}
return file->info;
}
GPList<DjVuFile> list=file->get_included_files();
for(GPosition pos=list;pos;++pos)
{
GP<DjVuInfo> info=get_info(list[pos]);
if (info)
{
if(rotate_count<0)
{
const_cast<DjVuImage *>(this)->init_rotate(*(file->info));
}
return info;
}
}
return 0;
}
GP<IW44Image>
DjVuImage::get_bg44(const GP<DjVuFile> & file) const
{
if (file->bg44)
return file->bg44;
GPList<DjVuFile> list=file->get_included_files();
for(GPosition pos=list;pos;++pos)
{
GP<IW44Image> bg44=get_bg44(list[pos]);
if (bg44)
return bg44;
}
return 0;
}
GP<GPixmap>
DjVuImage::get_bgpm(const GP<DjVuFile> & file) const
{
if (file->bgpm)
return file->bgpm;
GPList<DjVuFile> list=file->get_included_files();
for(GPosition pos=list;pos;++pos)
{
GP<GPixmap> bgpm=get_bgpm(list[pos]);
if (bgpm) return bgpm;
}
return 0;
}
GP<JB2Image>
DjVuImage::get_fgjb(const GP<DjVuFile> & file) const
{
if (file->fgjb)
return file->fgjb;
GPList<DjVuFile> list=file->get_included_files();
for(GPosition pos=list;pos;++pos)
{
GP<JB2Image> fgjb=get_fgjb(list[pos]);
if (fgjb)
return fgjb;
}
return 0;
}
GP<GPixmap>
DjVuImage::get_fgpm(const GP<DjVuFile> & file) const
{
if (file->fgpm)
return file->fgpm;
GPList<DjVuFile> list=file->get_included_files();
for(GPosition pos=list;pos;++pos)
{
GP<GPixmap> fgpm=get_fgpm(list[pos]);
if (fgpm)
return fgpm;
}
return 0;
}
GP<DjVuPalette>
DjVuImage::get_fgbc(const GP<DjVuFile> & file) const
{
if (file->fgbc)
return file->fgbc;
GPList<DjVuFile> list=file->get_included_files();
for(GPosition pos=list;pos;++pos)
{
GP<DjVuPalette> fgbc=get_fgbc(list[pos]);
if (fgbc) return fgbc;
}
return 0;
}
GP<DjVuInfo>
DjVuImage::get_info() const
{
if (file)
{
return get_info(file);
}else
{
return 0;
}
}
GP<ByteStream>
DjVuImage::get_anno() const
{
GP<ByteStream> out = ByteStream::create();
ByteStream &mbs = *out;
if (file)
{
file->merge_anno(mbs);
}
mbs.seek(0);
if(!mbs.size())
{
out=0;
}
return out;
}
GP<ByteStream>
DjVuImage::get_text() const
{
GP<ByteStream> out = ByteStream::create();
ByteStream &mbs = *out;
if (file)
{
file->get_text(mbs);
}
mbs.seek(0);
if(!mbs.size())
{
out=0;
}
return out;
}
GP<ByteStream>
DjVuImage::get_meta() const
{
GP<ByteStream> out = ByteStream::create();
ByteStream &mbs = *out;
if (file)
{
file->get_meta(mbs);
}
mbs.seek(0);
if(!mbs.size())
{
out=0;
}
return out;
}
GP<IW44Image>
DjVuImage::get_bg44() const
{
if (file)
return get_bg44(file);
else
return 0;
}
GP<GPixmap>
DjVuImage::get_bgpm() const
{
if (file)
return get_bgpm(file);
else
return 0;
}
GP<JB2Image>
DjVuImage::get_fgjb() const
{
if (file)
return get_fgjb(file);
else
return 0;
}
GP<GPixmap>
DjVuImage::get_fgpm() const
{
if (file)
return get_fgpm(file);
else
return 0;
}
GP<DjVuPalette>
DjVuImage::get_fgbc() const
{
if (file)
return get_fgbc(file);
else
return 0;
}
int
DjVuImage::get_width() const
{
GP<DjVuInfo> info=get_info();
return info?((rotate_count&1)?(info->height):(info->width)):0;
}
int
DjVuImage::get_height() const
{
GP<DjVuInfo> info=get_info();
return info?((rotate_count&1)?(info->width):(info->height)):0;
}
int
DjVuImage::get_real_width() const
{
GP<DjVuInfo> info=get_info();
return info ? info->width : 0;
}
int
DjVuImage::get_real_height() const
{
GP<DjVuInfo> info=get_info();
return info ? info->height : 0;
}
int
DjVuImage::get_version() const
{
GP<DjVuInfo> info=get_info();
return info ? info->version : DJVUVERSION;
}
int
DjVuImage::get_dpi() const
{
GP<DjVuInfo> info=get_info();
return info ? info->dpi : 300;
}
int
DjVuImage::get_rounded_dpi() const
{
return (get_dpi()+5)/10*10;
#if 0
/* This code used to round the reported dpi to 25, 50, 75, 100, 150,
300, and 600. Now we just round the dpi to 10ths and return it */
int dpi=get_dpi();
if (dpi>700) return dpi;
const int std_dpi[]={ 25, 50, 75, 100, 150, 300, 600 };
const int std_dpis=sizeof(std_dpi)/sizeof(std_dpi[0]);
int min_dist=abs(dpi-std_dpi[0]);
int min_idx=0;
for(int i=1;i<std_dpis;i++)
if (abs(std_dpi[i]-dpi)<min_dist)
{
min_dist=abs(std_dpi[i]-dpi);
min_idx=i;
};
return std_dpi[min_idx];
#endif
}
double
DjVuImage::get_gamma() const
{
GP<DjVuInfo> info=get_info();
return info ? info->gamma : 2.2;
}
GUTF8String
DjVuImage::get_mimetype() const
{
return file ? file->mimetype : GUTF8String();
}
//// DJVUIMAGE: UTILITIES
GUTF8String
DjVuImage::get_short_description() const
{
GUTF8String msg = "Empty";
int width = get_width();
int height = get_height();
if (width && height)
if (file && file->file_size>100)
//msg.format("%dx%d in %0.1f Kb", width, height, file->file_size/1024.0);
msg.format( ERR_MSG("DjVuImage.short1") "\t%d\t%d\t%0.1f", width, height, file->file_size/1024.0 );
else
//msg.format("%dx%d", width, height);
msg.format( ERR_MSG("DjVuImage.short2") "\t%d\t%d", width, height );
return msg;
}
GUTF8String
DjVuImage::get_long_description() const
{
return file?(file->description):GUTF8String();
}
void
DjVuImage::notify_chunk_done(const DjVuPort *, const GUTF8String & name)
{
if (!retqlayout_sent &&
( !name.cmp("INFO", 4) ||
!name.cmp("PMxx", 2) ||
!name.cmp("BMxx", 2) ) )
{
DjVuPort::get_portcaster()->notify_retqlayout(this);
retqlayout_sent=true;
}
else if (!name.cmp("Sxxx", 1) ||
!name.cmp("BGxx", 2) ||
!name.cmp("FGxx", 2) ||
!name.cmp("BMxx", 2) ||
!name.cmp("PMxx", 2) )
DjVuPort::get_portcaster()->notify_redisplay(this);
}
//// DJVUIMAGE: OLD-STYLE DECODING
DjVuInterface::~DjVuInterface()
{
}
class DjVuImageNotifier : public DjVuPort
{
friend class DjVuImage;
DjVuInterface *notifier;
GP<DataPool> stream_pool;
GURL stream_url;
public:
DjVuImageNotifier(DjVuInterface *notifier);
GP<DataPool> request_data(const DjVuPort *src, const GURL & url);
void notify_chunk_done(const DjVuPort *, const GUTF8String &name);
void notify_redisplay(const class DjVuImage * source);
void notify_retqlayout(const class DjVuImage * source);
};
DjVuImageNotifier::DjVuImageNotifier(DjVuInterface *notifier)
: notifier(notifier)
{
}
GP<DataPool>
DjVuImageNotifier::request_data(const DjVuPort *src, const GURL & url)
{
if (url!=stream_url)
G_THROW( ERR_MSG("DjVuImage.not_decode") );
return stream_pool;
}
void
DjVuImageNotifier::notify_redisplay(const class DjVuImage * source)
{
if (notifier)
notifier->notify_redisplay();
}
void
DjVuImageNotifier::notify_retqlayout(const class DjVuImage * source)
{
if (notifier)
notifier->notify_retqlayout();
}
void
DjVuImageNotifier::notify_chunk_done(const DjVuPort *, const GUTF8String &name)
{
if (notifier)
notifier->notify_chunk(name, "" );
}
void
DjVuImage::decode(ByteStream & str, DjVuInterface *notifier)
{
DEBUG_MSG("DjVuImage::decode(): decoding old way...\n");
DEBUG_MAKE_INDENT(3);
if (file)
G_THROW( ERR_MSG("DjVuImage.bad_call") );
GP<DjVuImageNotifier> pport = new DjVuImageNotifier(notifier);
pport->stream_url=GURL::UTF8("internal://fake/fake.djvu");
pport->stream_pool=DataPool::create();
// Get all the data first
int length;
char buffer[1024];
while((length=str.read(buffer, 1024)))
pport->stream_pool->add_data(buffer, length);
pport->stream_pool->set_eof();
GP<DjVuDocument> doc = DjVuDocument::create_wait(pport->stream_url, (DjVuImageNotifier*)pport);
GP<DjVuImage> dimg=doc->get_page(-1, true, (DjVuImageNotifier*)pport);
file=dimg->get_djvu_file();
if (file->is_decode_stopped())
G_THROW( DataPool::Stop );
if (file->is_decode_failed())
G_THROW( ByteStream::EndOfFile ); // guess
if (!file->is_decode_ok())
G_THROW( ERR_MSG("DjVuImage.mult_error") );
DEBUG_MSG("decode DONE\n");
}
//// DJVUIMAGE: CHECKING
static int
compute_red(int w, int h, int rw, int rh)
{
for (int red=1; red<16; red++)
if (((w+red-1)/red==rw) && ((h+red-1)/red==rh))
return red;
return 16;
}
int
DjVuImage::is_legal_bilevel() const
{
// Components
GP<DjVuInfo> info = get_info();
GP<JB2Image> fgjb = get_fgjb();
GP<IW44Image> bg44 = get_bg44();
GP<GPixmap> bgpm = get_bgpm();
GP<GPixmap> fgpm = get_fgpm();
// Check info
if (! info)
return 0;
int width = info->width;
int height = info->height;
if (! (width>0 && height>0))
return 0;
// Check fgjb
if (!fgjb)
return 0;
if (fgjb->get_width()!=width || fgjb->get_height()!=height)
return 0;
// Check that color information is not present.
if (bg44 || bgpm || fgpm)
return 0;
// Ok.
return 1;
}
int
DjVuImage::is_legal_photo() const
{
// Components
GP<DjVuInfo> info = get_info();
GP<JB2Image> fgjb = get_fgjb();
GP<IW44Image> bg44 = get_bg44();
GP<GPixmap> bgpm = get_bgpm();
GP<GPixmap> fgpm = get_fgpm();
// Check info
if (! info)
return 0;
int width = info->width;
int height = info->height;
if (! (width>0 && height>0))
return 0;
// Check that extra information is not present.
if (fgjb || fgpm)
return 0;
// Check bg44
if (bg44 && bg44->get_width()==width && bg44->get_height()==height)
return 1;
// Check bgpm
if (bgpm && (int)bgpm->columns()==width && (int)bgpm->rows()==height)
return 1;
// Ok.
return 0;
}
int
DjVuImage::is_legal_compound() const
{
// Components
GP<DjVuInfo> info = get_info();
GP<JB2Image> fgjb = get_fgjb();
GP<IW44Image> bg44 = get_bg44();
GP<GPixmap> bgpm = get_bgpm();
GP<GPixmap> fgpm = get_fgpm();
GP<DjVuPalette> fgbc = get_fgbc();
// Check size
if (! info)
return 0;
int width = info->width;
int height = info->height;
if (! (width>0 && height>0))
return 0;
// Check fgjb
if (!fgjb)
return 0;
if (fgjb->get_width()!=width || fgjb->get_height()!=height)
return 0;
// Check background
int bgred = 0;
if (bg44)
bgred = compute_red(width, height, bg44->get_width(), bg44->get_height());
else if (bgpm)
bgred = compute_red(width, height, bgpm->columns(), bgpm->rows());
if (bgred<1 || bgred>12)
return 0;
// Check foreground colors
int fgred = 0;
if (fgbc)
fgred = 1;
else if (fgpm)
fgred = compute_red(width, height, fgpm->columns(), fgpm->rows());
if (fgred<1 || fgred>12)
return 0;
// Check that all components are present
if (fgjb && bgred && fgred)
return 1;
// Unrecognized
return 0;
}
//// DJVUIMAGE: LOW LEVEL RENDERING
GP<GBitmap>
DjVuImage::get_bitmap(const GRect &rect,
int subsample, int align) const
{
// Access image size
int width = get_real_width();
int height = get_real_height();
GP<JB2Image> fgjb = get_fgjb();
if ( width && height && fgjb &&
(fgjb->get_width() == width) &&
(fgjb->get_height() == height) )
{
return fgjb->get_bitmap(rect, subsample, align);
}
return 0;
}
GP<GPixmap>
DjVuImage::get_bg_pixmap(const GRect &rect,
int subsample, double gamma) const
{
GP<GPixmap> pm = 0;
// Access image size
GP<DjVuInfo> info = get_info();
int width = get_real_width();
int height = get_real_height();
if (width<=0 || height<=0 || !info) return 0;
// Compute gamma_correction
double gamma_correction = 1.0;
if (gamma > 0)
gamma_correction = gamma / info->gamma;
if (gamma_correction < 0.1)
gamma_correction = 0.1;
else if (gamma_correction > 10)
gamma_correction = 10;
// CASE1: Incremental BG IW44Image
GP<IW44Image> bg44 = get_bg44();
if (bg44)
{
int w = bg44->get_width();
int h = bg44->get_height();
// Avoid silly cases
if (w==0 || h==0 || width==0 || height==0)
return 0;
// Determine how much bg44 is reduced
int red = compute_red(width,height,w,h);
if (red<1 || red>12)
return 0;
// Handle pure downsampling cases
if (subsample == red)
pm = bg44->get_pixmap(1,rect);
else if (subsample == 2*red)
pm = bg44->get_pixmap(2,rect);
else if (subsample == 4*red)
pm = bg44->get_pixmap(4,rect);
else if (subsample == 8*red)
pm = bg44->get_pixmap(8,rect);
// Handle fractional downsampling case
else if (red*4 == subsample*3)
{
GRect nrect = rect;
GRect xrect = rect;
xrect.xmin = (xrect.xmin/3)*4;
xrect.ymin = (xrect.ymin/3)*4;
xrect.xmax = ((xrect.xmax+2)/3)*4;
xrect.ymax = ((xrect.ymax+2)/3)*4;
nrect.translate(-xrect.xmin*3/4, -xrect.ymin*3/4);
if (xrect.xmax > w)
xrect.xmax = w;
if (xrect.ymax > h)
xrect.ymax = h;
GP<GPixmap> ipm = bg44->get_pixmap(1,xrect);
pm = GPixmap::create();
pm->downsample43(ipm, &nrect);
}
// Handle all other cases with pixmapscaler
else
{
// find suitable power of two
int po2 = 16;
while (po2>1 && subsample<po2*red)
po2 >>= 1;
// setup pixmap scaler
int inw = (w+po2-1)/po2;
int inh = (h+po2-1)/po2;
int outw = (width+subsample-1)/subsample;
int outh = (height+subsample-1)/subsample;
GP<GPixmapScaler> gps=GPixmapScaler::create(inw, inh, outw, outh);
GPixmapScaler &ps=*gps;
ps.set_horz_ratio(red*po2, subsample);
ps.set_vert_ratio(red*po2, subsample);
// run pixmap scaler
GRect xrect;
ps.get_input_rect(rect,xrect);
GP<GPixmap> ipm = bg44->get_pixmap(po2,xrect);
pm = GPixmap::create();
ps.scale(xrect, *ipm, rect, *pm);
}
// Apply gamma correction
if (pm && gamma_correction!=1.0)
pm->color_correct(gamma_correction);
return pm;
}
// CASE 2: Raw background pixmap
GP<GPixmap> bgpm = get_bgpm();
if (bgpm)
{
int w = bgpm->columns();
int h = bgpm->rows();
// Avoid silly cases
if (w==0 || h==0 || width==0 || height==0)
return 0;
// Determine how much bgpm is reduced
int red = compute_red(width,height,w,h);
if (red<1 || red>12)
return 0;
// Handle pure downsampling cases
int ratio = subsample/red;
if (subsample==ratio*red && ratio>=1)
{
pm = GPixmap::create();
if (ratio == 1)
pm->init(*bgpm, rect);
else if (ratio > 1)
pm->downsample(bgpm, ratio, &rect);
}
// Handle all other cases with pixmapscaler
else
{
// setup pixmap scaler
int outw = (width+subsample-1)/subsample;
int outh = (height+subsample-1)/subsample;
GP<GPixmapScaler> gps=GPixmapScaler::create(w, h, outw, outh);
GPixmapScaler &ps=*gps;
ps.set_horz_ratio(red, subsample);
ps.set_vert_ratio(red, subsample);
// run pixmap scaler
pm = GPixmap::create();
GRect xrect(0,0,w,h);
ps.scale(xrect, *bgpm, rect, *pm);
}
// Apply gamma correction
if (pm && gamma_correction!=1.0)
pm->color_correct(gamma_correction);
return pm;
}
// FAILURE
return 0;
}
int
DjVuImage::stencil(GPixmap *pm, const GRect &rect,
int subsample, double gamma) const
{
// Warping and blending.
if (!pm)
return 0;
// Access components
GP<DjVuInfo> info = get_info();
int width = get_real_width();
int height = get_real_height();
if (width<=0 || height<=0 || !info) return 0;
GP<JB2Image> fgjb = get_fgjb();
GP<GPixmap> fgpm = get_fgpm();
GP<DjVuPalette> fgbc = get_fgbc();
// Compute gamma_correction
double gamma_correction = 1.0;
if (gamma > 0)
gamma_correction = gamma / info->gamma;
if (gamma_correction < 0.1)
gamma_correction = 0.1;
else if (gamma_correction > 10)
gamma_correction = 10;
// Compute alpha map and relevant JB2Image components
GList<int> components;
GP<GBitmap> bm;
if (fgjb)
{
JB2Image *jimg = fgjb;
if (! (width && height &&
jimg->get_width() == width &&
jimg->get_height() == height ) )
return 0;
// Decode bitmap
bm = GBitmap::create(rect.height(), rect.width());
bm->set_grays(1+subsample*subsample);
int rxmin = rect.xmin * subsample;
int rymin = rect.ymin * subsample;
for (int blitno = 0; blitno < jimg->get_blit_count(); blitno++)
{
const JB2Blit *pblit = jimg->get_blit(blitno);
const JB2Shape &ptqshape = jimg->get_tqshape(pblit->tqshapeno);
if (ptqshape.bits &&
pblit->left <= rect.xmax * subsample &&
pblit->bottom <= rect.ymax * subsample &&
pblit->left + (int)ptqshape.bits->columns() >= rect.xmin * subsample &&
pblit->bottom + (int)ptqshape.bits->rows() >= rect.ymin * subsample )
{
// Record component list
if (fgbc) components.append(blitno);
// Blit
bm->blit(ptqshape.bits,
pblit->left - rxmin, pblit->bottom - rymin,
subsample);
}
}
}
// TWO LAYER MODEL
if (bm && fgbc)
{
// Perform attenuation from scratch
pm->attenuate(bm, 0, 0);
// Check that fgbc has the correct size
JB2Image *jimg = fgjb;
DjVuPalette *fg = fgbc;
if (jimg->get_blit_count() != fg->colordata.size())
return 0;
// Copy and color correct palette
int palettesize = fg->size();
GTArray<GPixel> colors(0,palettesize-1);
for (int i=0; i<palettesize; i++)
fg->index_to_color(i, colors[i]);
GPixmap::color_correct(gamma_correction, colors, palettesize);
// Blit all components (one color at a time)
while (components.size() > 0)
{
GPosition nullpos;
GPosition pos = components;
int lastx = 0;
int colorindex = fg->colordata[components[pos]];
if (colorindex >= palettesize)
G_THROW( ERR_MSG("DjVuImage.corrupted") );
// Gather relevant components and relevant rectangle
GList<int> compset;
GRect comprect;
while (pos)
{
int blitno = components[pos];
const JB2Blit *pblit = jimg->get_blit(blitno);
if (pblit->left < lastx) break;
lastx = pblit->left;
if (fg->colordata[blitno] == colorindex)
{
const JB2Shape &ptqshape = jimg->get_tqshape(pblit->tqshapeno);
GRect rect(pblit->left, pblit->bottom,
ptqshape.bits->columns(), ptqshape.bits->rows());
comprect.recthull(comprect, rect);
compset.insert_before(nullpos, components, pos);
continue;
}
++pos;
}
// Round alpha map rectangle
comprect.xmin = comprect.xmin / subsample;
comprect.ymin = comprect.ymin / subsample;
comprect.xmax = (comprect.xmax+subsample-1) / subsample;
comprect.ymax = (comprect.ymax+subsample-1) / subsample;
comprect.intersect(comprect, rect);
// Compute alpha map for that color
bm = 0;
bm = GBitmap::create(comprect.height(), comprect.width());
bm->set_grays(1+subsample*subsample);
int rxmin = comprect.xmin * subsample;
int rymin = comprect.ymin * subsample;
for (pos=compset; pos; ++pos)
{
int blitno = compset[pos];
const JB2Blit *pblit = jimg->get_blit(blitno);
const JB2Shape &ptqshape = jimg->get_tqshape(pblit->tqshapeno);
bm->blit(ptqshape.bits,
pblit->left - rxmin, pblit->bottom - rymin,
subsample);
}
// Blend color into background pixmap
pm->blit(bm, comprect.xmin-rect.xmin, comprect.ymin-rect.ymin, &colors[colorindex]);
}
return 1;
}
// THREE LAYER MODEL
if (bm && fgpm)
{
// This follows fig. 4 in Adelson "Layered representations for image
// coding" (1991) http://www-bcs.mit.edu/people/adelson/papers.html.
// The properly warped background is already in PM. The properly warped
// alpha map is already in BM. We just have to warp the foreground and
// perform alpha blending.
#ifdef SIMPLE_THREE_LAYER_RENDERING
int w = fgpm->columns();
int h = fgpm->rows();
// Determine foreground reduction
int red = compute_red(width,height, w, h);
if (red<1 || red>12)
return 0;
// Warp foreground pixmap
GPixmapScaler ps(w,h,width/subsample+1,height/subsample+1);
ps.set_horz_ratio(red,subsample);
ps.set_vert_ratio(red,subsample);
GP<GPixmap> nfg = new GPixmap;
GRect provided(0,0,w,h);
ps.scale(provided, *fgpm, rect, *nfg);
// Attenuate background and blit
nfg->color_correct(gamma_correction);
pm->blend(bm, 0, 0, nfg); // blend == attenuate + blit
return 1;
#else
// Things are now a little bit more complex because the convenient
// function GPixmap::stencil() simultaneously upsamples the foreground
// by an integer factor and performs the alpha blending. We have
// to determine how and when this facility can be used.
int w = fgpm->columns();
int h = fgpm->rows();
// Determine foreground reduction
int red = compute_red(width,height,w,h);
if (red<1 || red>12)
return 0;
// Try supersampling foreground pixmap by an integer factor
int supersample = ( red>subsample ? red/subsample : 1);
int wantedred = supersample*subsample;
// Try simple foreground upsampling
if (red == wantedred)
{
// Simple foreground upsampling is enough.
pm->stencil(bm, fgpm, supersample, &rect, gamma_correction);
return 1;
}
else
{
// Must pre-warp foreground pixmap
GP<GPixmap> nfg;
int desw = (w*red+wantedred-1)/wantedred;
int desh = (h*red+wantedred-1)/wantedred;
// Cache rescaled fgpm for speed
static const DjVuImage *tagimage = 0;
static const GPixmap *tagfgpm = 0;
static GP<GPixmap> cachednfg = 0;
// Check whether cached fgpm applies.
if ( cachednfg && this==tagimage && fgpm==tagfgpm
&& desw==(int)cachednfg->columns()
&& desh==(int)cachednfg->rows() )
{
nfg = cachednfg;
}
else
{
GP<GPixmapScaler> gps=GPixmapScaler::create(w,h,desw,desh);
GPixmapScaler &ps=*gps;
ps.set_horz_ratio(red, wantedred);
ps.set_vert_ratio(red, wantedred);
nfg = GPixmap::create();
GRect provided(0,0,w,h);
GRect desired(0,0,desw,desh);
ps.scale(provided, *fgpm, desired, *nfg);
}
// Use combined warp+blend function
pm->stencil(bm, nfg, supersample, &rect, gamma_correction);
// Cache
tagimage = this;
tagfgpm = fgpm;
cachednfg = nfg;
return 1;
}
#endif
}
// FAILURE
return 0;
}
GP<GPixmap>
DjVuImage::get_fg_pixmap(const GRect &rect,
int subsample, double gamma) const
{
// Obtain white background pixmap
GP<GPixmap> pm;
// Access components
const int width = get_real_width();
const int height = get_real_height();
if (width && height)
{
pm = GPixmap::create(rect.height(),rect.width(), &GPixel::WHITE);
if (!stencil(pm, rect, subsample, gamma))
pm=0;
}
return pm;
}
GP<GPixmap>
DjVuImage::get_pixmap(const GRect &rect, int subsample, double gamma) const
{
// Get background
GP<GPixmap> pm = get_bg_pixmap(rect, subsample, gamma);
// Superpose foreground
if (! stencil(pm, rect, subsample, gamma))
// Avoid ugly progressive display (hack)
if (get_fgjb()) return 0;
// Return
return pm;
}
//// DJVUIMAGE: RENDERING (ARBITRARY SCALE)
typedef GP<GBitmap>(DjVuImage::*BImager)(const GRect &, int, int) const;
typedef GP<GPixmap>(DjVuImage::*PImager)(const GRect &, int, double) const;
static GP<GBitmap>
do_bitmap(const DjVuImage &dimg, BImager get,
const GRect &inrect, const GRect &inall, int align )
{
GRect rect=inrect;
GRect all=inall;
///* rotate code
if( dimg.get_rotate()%4 )
{
GRectMapper mapper;
mapper.rotate((4-dimg.get_rotate())%4);
mapper.map(rect);
mapper.map(all);
}
///* rotate code ends
// Sanity
if (! ( all.tqcontains(rect.xmin, rect.ymin) &&
all.tqcontains(rect.xmax-1, rect.ymax-1) ))
G_THROW( ERR_MSG("DjVuImage.bad_rect") );
// Check for integral reduction
int red;
int w = dimg.get_real_width();
int h = dimg.get_real_height();
int rw = all.width();
int rh = all.height();
GRect zrect = rect;
zrect.translate(-all.xmin, -all.ymin);
for (red=1; red<=15; red++)
if (rw*red>w-red && rw*red<w+red && rh*red>h-red && rh*red<h+red)
{
GP<GBitmap> bm=(dimg.*get)(zrect, red, align);
if(bm)
return bm->rotate((4-dimg.get_rotate())%4);
else
return NULL;
}
// Find best reduction
for (red=15; red>1; red--)
if ( (rw*red < w && rh*red < h) ||
(rw*red*3 < w || rh*red*3 < h) )
break;
// Setup bitmap scaler
if (! (w && h)) return 0;
GP<GBitmapScaler> gbs=GBitmapScaler::create();
GBitmapScaler &bs=*gbs;
bs.set_input_size( (w+red-1)/red, (h+red-1)/red );
bs.set_output_size( rw, rh );
bs.set_horz_ratio( rw*red, w );
bs.set_vert_ratio( rh*red, h );
// Scale
GRect srect;
bs.get_input_rect(zrect, srect);
GP<GBitmap> sbm = (dimg.*get)(srect, red, 1);
if (!sbm) return 0;
int border = ((zrect.width() + align - 1) & ~(align - 1)) - zrect.width();
GP<GBitmap> bm = GBitmap::create(zrect.height(), zrect.width(), border);
bs.scale(srect, *sbm, zrect, *bm);
if( bm )
return bm->rotate((4-dimg.get_rotate())%4);
else
return NULL;
}
static GP<GPixmap>
do_pixmap(const DjVuImage &dimg, PImager get,
const GRect &inrect, const GRect &inall, double gamma )
{
GRect rect=inrect;
GRect all=inall;
///* rotate code
if( dimg.get_rotate()%4 )
{
GRectMapper mapper;
mapper.rotate((4-dimg.get_rotate())%4);
mapper.map(rect);
mapper.map(all);
}
///* rotate code ends
// Sanity
if (! ( all.tqcontains(rect.xmin, rect.ymin) &&
all.tqcontains(rect.xmax-1, rect.ymax-1) ))
G_THROW( ERR_MSG("DjVuImage.bad_rect2") );
// Check for integral reduction
int red, w=0, h=0, rw=0, rh=0;
w = dimg.get_real_width();
h = dimg.get_real_height();
rw = all.width();
rh = all.height();
GRect zrect = rect;
zrect.translate(-all.xmin, -all.ymin);
for (red=1; red<=15; red++)
if (rw*red>w-red && rw*red<w+red && rh*red>h-red && rh*red<h+red)
{
GP<GPixmap> pm = (dimg.*get)(zrect, red, gamma);
if( pm )
return pm->rotate((4-dimg.get_rotate())%4);
else
return NULL;
}
// These reductions usually go faster (improve!)
static int fastred[] = { 12,6,4,3,2,1 };
// Find best reduction
for (int i=0; (red=fastred[i])>1; i++)
if ( (rw*red < w && rh*red < h) ||
(rw*red*3 < w || rh*red*3 < h) )
break;
// Setup pixmap scaler
if (w<0 || h<0) return 0;
GP<GPixmapScaler> gps=GPixmapScaler::create();
GPixmapScaler &ps=*gps;
ps.set_input_size( (w+red-1)/red, (h+red-1)/red );
ps.set_output_size( rw, rh );
ps.set_horz_ratio( rw*red, w );
ps.set_vert_ratio( rh*red, h );
// Scale
GRect srect;
ps.get_input_rect(zrect, srect);
GP<GPixmap> spm = (dimg.*get)(srect, red, gamma);
if (!spm) return 0;
GP<GPixmap> pm = GPixmap::create();
ps.scale(srect, *spm, zrect, *pm);
if(pm)
return pm->rotate((4-dimg.get_rotate())%4);
else
return NULL;
}
GP<GPixmap>
DjVuImage::get_pixmap(const GRect &rect, const GRect &all, double gamma) const
{
return do_pixmap(*this, & DjVuImage::get_pixmap, rect, all, gamma);
}
GP<GBitmap>
DjVuImage::get_bitmap(const GRect &rect, const GRect &all, int align) const
{
return do_bitmap(*this, & DjVuImage::get_bitmap, rect, all, align);
}
GP<GPixmap>
DjVuImage::get_bg_pixmap(const GRect &rect, const GRect &all, double gamma) const
{
return do_pixmap(*this, & DjVuImage::get_bg_pixmap, rect, all, gamma);
}
GP<GPixmap>
DjVuImage::get_fg_pixmap(const GRect &rect, const GRect &all, double gamma) const
{
return do_pixmap(*this, & DjVuImage::get_fg_pixmap, rect, all, gamma);
}
int
DjVuImage::get_rotate() const
{
return (rotate_count<0)?0:rotate_count;
}
void
DjVuImage::init_rotate(const DjVuInfo &info)
{
rotate_count=((360-GRect::findangle(info.orientation))/90)%4;
}
void DjVuImage::set_rotate(int count)
{
rotate_count=((count%4)+4)%4;
}
GP<DjVuAnno>
DjVuImage::get_decoded_anno()
{
GP<DjVuAnno> djvuanno = DjVuAnno::create();
GP<ByteStream> bs=get_anno();
if( bs )
{
djvuanno->decode(bs);
const int rotate_count=get_rotate();
if( rotate_count % 4 )
{
///map hyperlinks correctly for rotation
GRect input, output;
input = GRect(0,0,get_width(), get_height());
output = GRect(0,0, get_real_width(), get_real_height());
GRectMapper mapper;
mapper.clear();
mapper.set_input(input);
mapper.set_output(output);
mapper.rotate((4-rotate_count)%4);
GPList<GMapArea> &list=djvuanno->ant->map_areas;
for(GPosition pos=list;pos;++pos)
{
list[pos]->unmap(mapper);
}
}
return djvuanno;
}
else
return NULL;
}
void
DjVuImage::map(GRect &rect) const
{
GRect input, output;
const int rotate_count=get_rotate();
if(rotate_count%4)
{
input = GRect(0,0,get_width(), get_height());
output = GRect(0,0, get_real_width(), get_real_height());
GRectMapper mapper;
mapper.clear();
mapper.set_input(input);
mapper.set_output(output);
mapper.rotate((4-rotate_count)%4);
mapper.map(rect);
}
}
void
DjVuImage::unmap(GRect &rect) const
{
GRect input, output;
const int rotate_count=get_rotate();
if(rotate_count%4)
{
input = GRect(0,0,get_width(), get_height());
output = GRect(0,0, get_real_width(), get_real_height());
GRectMapper mapper;
mapper.clear();
mapper.set_input(input);
mapper.set_output(output);
mapper.rotate((4-rotate_count)%4);
mapper.unmap(rect);
}
}
void
DjVuImage::map(int &x, int &y) const
{
GRect input, output;
const int rotate_count=get_rotate();
if(rotate_count%4)
{
input = GRect(0,0,get_width(), get_height());
output = GRect(0,0, get_real_width(), get_real_height());
GRectMapper mapper;
mapper.clear();
mapper.set_input(input);
mapper.set_output(output);
mapper.rotate((4-rotate_count)%4);
mapper.map(x, y);
}
}
void
DjVuImage::unmap(int &x, int &y) const
{
GRect input, output;
const int rotate_count=get_rotate();
if(rotate_count%4)
{
input = GRect(0,0,get_width(), get_height());
output = GRect(0,0, get_real_width(), get_real_height());
GRectMapper mapper;
mapper.clear();
mapper.set_input(input);
mapper.set_output(output);
mapper.rotate((4-rotate_count)%4);
mapper.unmap(x, y);
}
}
bool
DjVuImage::wait_for_complete_decode(void)
{
if (file)
{
file->resume_decode(true);
return file->is_decode_ok();
}
return 0;
}
// Write out a DjVuXML object tag and map tag.
void
DjVuImage::writeXML(ByteStream &str_out,const GURL &doc_url,const int flags) const
{
const int height=get_height();
static const char *Object="<OBJECT data=\"";
const GURL url(get_djvu_file()->get_url());
const GUTF8String pagename(url.fname());
GUTF8String page_param;
if(doc_url.is_valid() && !doc_url.is_empty() && (doc_url != url))
{
str_out.writestring(Object+doc_url.get_string());
page_param="<PARAM name=\"PAGE\" value=\""+pagename+"\" />\n";
}else
{
str_out.writestring(Object+doc_url.get_string());
}
str_out.writestring("\" type=\""+get_mimetype()+"\" height=\""
+GUTF8String(height)+"\" width=\""+GUTF8String(get_width())
+"\" usemap=\""+pagename.toEscaped()+"\" >\n");
if(!(flags & NOINFO))
{
const GP<DjVuInfo> info(get_info());
if(info)
{
info->writeParam(str_out);
}
}
str_out.writestring(page_param);
const GP<DjVuAnno> anno(DjVuAnno::create());
if(!(flags & NOINFO)||!(flags&NOMAP))
{
const GP<ByteStream> anno_str(get_anno());
if(anno_str)
{
anno->decode(anno_str);
}
if(!(flags & NOINFO))
{
anno->writeParam(str_out);
}
}
if(!(flags & NOTEXT))
{
const GP<DjVuText> text(DjVuText::create());
{
const GP<ByteStream> text_str(get_text());
if(text_str)
{
text->decode(text_str);
}
text->writeText(str_out,height);
}
}
if(!(flags & NOMETA))
{
const GP<ByteStream> meta_str(get_meta());
if(meta_str)
{
GP<IFFByteStream> giff=IFFByteStream::create(meta_str);
IFFByteStream &iff=*giff;
GUTF8String chkid;
while( iff.get_chunk(chkid))
{
GP<ByteStream> gbs(iff.get_bytestream());
if(chkid == "METa")
{
str_out.copy(*gbs);
//str_out.writestring(gbs->getAsUTF8());
}else if(chkid == "METz")
{
gbs=BSByteStream::create(gbs);
str_out.copy(*gbs);
//str_out.writestring(gbs->getAsUTF8());
}
iff.close_chunk();
}
}
}
str_out.writestring(GUTF8String("</OBJECT>\n"));
if(!(flags & NOMAP))
{
anno->writeMap(str_out,pagename,height);
}
}
// Write out a DjVuXML object tag and map tag.
void
DjVuImage::writeXML(ByteStream &str_out) const
{
writeXML(str_out,GURL());
}
// Write out a DjVuXML object tag and map tag.
GUTF8String
DjVuImage::get_XML(const GURL &doc_url,const int flags) const
{
GP<ByteStream> gbs(ByteStream::create());
ByteStream &bs=*gbs;
writeXML(bs,doc_url);
bs.seek(0L);
return bs.getAsUTF8();
}
// Write out a DjVuXML object tag and map tag.
GUTF8String
DjVuImage::get_XML(void) const
{
return get_XML(GURL());
}
#ifdef HAVE_NAMESPACES
}
# ifndef NOT_USING_DJVU_NAMESPACE
using namespace DJVU;
# endif
#endif
View Git Blame Copy Permalink