source: trunk/libdjvu/DjVuImage.cpp @ 209

Last change on this file since 209 was 206, checked in by Eugene Romanenko, 14 years ago

DJVU plugin: djvulibre updated to version 3.5.19

File size: 38.9 KB
Line 
1//C-  -*- C++ -*-
2//C- -------------------------------------------------------------------
3//C- DjVuLibre-3.5
4//C- Copyright (c) 2002  Leon Bottou and Yann Le Cun.
5//C- Copyright (c) 2001  AT&T
6//C-
7//C- This software is subject to, and may be distributed under, the
8//C- GNU General Public License, either Version 2 of the license,
9//C- or (at your option) any later version. The license should have
10//C- accompanied the software or you may obtain a copy of the license
11//C- from the Free Software Foundation at http://www.fsf.org .
12//C-
13//C- This program is distributed in the hope that it will be useful,
14//C- but WITHOUT ANY WARRANTY; without even the implied warranty of
15//C- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16//C- GNU General Public License for more details.
17//C-
18//C- DjVuLibre-3.5 is derived from the DjVu(r) Reference Library from
19//C- Lizardtech Software.  Lizardtech Software has authorized us to
20//C- replace the original DjVu(r) Reference Library notice by the following
21//C- text (see doc/lizard2002.djvu and doc/lizardtech2007.djvu):
22//C-
23//C-  ------------------------------------------------------------------
24//C- | DjVu (r) Reference Library (v. 3.5)
25//C- | Copyright (c) 1999-2001 LizardTech, Inc. All Rights Reserved.
26//C- | The DjVu Reference Library is protected by U.S. Pat. No.
27//C- | 6,058,214 and patents pending.
28//C- |
29//C- | This software is subject to, and may be distributed under, the
30//C- | GNU General Public License, either Version 2 of the license,
31//C- | or (at your option) any later version. The license should have
32//C- | accompanied the software or you may obtain a copy of the license
33//C- | from the Free Software Foundation at http://www.fsf.org .
34//C- |
35//C- | The computer code originally released by LizardTech under this
36//C- | license and unmodified by other parties is deemed "the LIZARDTECH
37//C- | ORIGINAL CODE."  Subject to any third party intellectual property
38//C- | claims, LizardTech grants recipient a worldwide, royalty-free,
39//C- | non-exclusive license to make, use, sell, or otherwise dispose of
40//C- | the LIZARDTECH ORIGINAL CODE or of programs derived from the
41//C- | LIZARDTECH ORIGINAL CODE in compliance with the terms of the GNU
42//C- | General Public License.   This grant only confers the right to
43//C- | infringe patent claims underlying the LIZARDTECH ORIGINAL CODE to
44//C- | the extent such infringement is reasonably necessary to enable
45//C- | recipient to make, have made, practice, sell, or otherwise dispose
46//C- | of the LIZARDTECH ORIGINAL CODE (or portions thereof) and not to
47//C- | any greater extent that may be necessary to utilize further
48//C- | modifications or combinations.
49//C- |
50//C- | The LIZARDTECH ORIGINAL CODE is provided "AS IS" WITHOUT WARRANTY
51//C- | OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
52//C- | TO ANY WARRANTY OF NON-INFRINGEMENT, OR ANY IMPLIED WARRANTY OF
53//C- | MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
54//C- +------------------------------------------------------------------
55//
56// $Id: DjVuImage.cpp,v 1.14 2007/03/25 20:48:30 leonb Exp $
57// $Name: release_3_5_19 $
58
59#ifdef HAVE_CONFIG_H
60# include "config.h"
61#endif
62#if NEED_GNUG_PRAGMAS
63# pragma implementation
64#endif
65
66#include "DjVuImage.h"
67#include "GScaler.h"
68#include "DjVuDocument.h"
69#include "DjVuPalette.h"
70#include "GContainer.h"
71#include "GSmartPointer.h"
72#include "JB2Image.h"
73#include "IW44Image.h"
74#include "DataPool.h"
75#include "ByteStream.h"
76#include "GMapAreas.h"
77#include "DjVuText.h"
78#include "IFFByteStream.h"
79#include "BSByteStream.h"
80#include "debug.h"
81#include <stdarg.h>
82
83
84#ifdef HAVE_NAMESPACES
85namespace DJVU {
86# ifdef NOT_DEFINED // Just to fool emacs c++ mode
87}
88#endif
89#endif
90
91
92
93//// DJVUIMAGE: CONSTRUCTION
94
95DjVuImage::DjVuImage(void) 
96: rotate_count(-1),relayout_sent(false)
97{
98}
99
100void
101DjVuImage::connect(const GP<DjVuFile> & xfile)
102{
103   file=xfile;
104   DjVuPort::get_portcaster()->add_route(file, this);
105}
106
107
108
109
110//// DJVUIMAGE: DATA COLLECTORS
111
112GP<DjVuInfo>
113DjVuImage::get_info(const GP<DjVuFile> & file) const
114{
115   if (file->info)
116   {
117     if(rotate_count<0)
118     {
119       const_cast<DjVuImage *>(this)->init_rotate(*(file->info));
120     }
121     return file->info;
122   }
123   GPList<DjVuFile> list=file->get_included_files();
124   for(GPosition pos=list;pos;++pos)
125   {
126      GP<DjVuInfo> info=get_info(list[pos]);
127      if (info) 
128      {
129        if(rotate_count<0)
130        {
131          const_cast<DjVuImage *>(this)->init_rotate(*(file->info));
132        }
133        return info;
134      }
135   }
136   return 0;
137}
138
139GP<IW44Image>
140DjVuImage::get_bg44(const GP<DjVuFile> & file) const
141{
142   if (file->bg44)
143     return file->bg44;
144   GPList<DjVuFile> list=file->get_included_files();
145   for(GPosition pos=list;pos;++pos)
146   {
147      GP<IW44Image> bg44=get_bg44(list[pos]);
148      if (bg44)
149        return bg44;
150   }
151   return 0;
152}
153
154GP<GPixmap>
155DjVuImage::get_bgpm(const GP<DjVuFile> & file) const
156{
157   if (file->bgpm)
158     return file->bgpm;
159   GPList<DjVuFile> list=file->get_included_files();
160   for(GPosition pos=list;pos;++pos)
161   {
162      GP<GPixmap> bgpm=get_bgpm(list[pos]);
163      if (bgpm) return bgpm;
164   }
165   return 0;
166}
167
168GP<JB2Image>
169DjVuImage::get_fgjb(const GP<DjVuFile> & file) const
170{
171   if (file->fgjb)
172     return file->fgjb;
173   GPList<DjVuFile> list=file->get_included_files();
174   for(GPosition pos=list;pos;++pos)
175   {
176      GP<JB2Image> fgjb=get_fgjb(list[pos]);
177      if (fgjb)
178        return fgjb;
179   }
180   return 0;
181}
182
183GP<GPixmap>
184DjVuImage::get_fgpm(const GP<DjVuFile> & file) const
185{
186   if (file->fgpm)
187     return file->fgpm;
188   GPList<DjVuFile> list=file->get_included_files();
189   for(GPosition pos=list;pos;++pos)
190   {
191      GP<GPixmap> fgpm=get_fgpm(list[pos]);
192      if (fgpm)
193        return fgpm;
194   }
195   return 0;
196}
197
198GP<DjVuPalette>
199DjVuImage::get_fgbc(const GP<DjVuFile> & file) const
200{
201   if (file->fgbc)
202     return file->fgbc;
203   GPList<DjVuFile> list=file->get_included_files();
204   for(GPosition pos=list;pos;++pos)
205   {
206      GP<DjVuPalette> fgbc=get_fgbc(list[pos]);
207      if (fgbc) return fgbc;
208   }
209   return 0;
210}
211
212GP<DjVuInfo>   
213DjVuImage::get_info() const
214{
215   if (file)
216   {
217     return get_info(file);
218   }else
219   {
220     return 0;
221   }
222}
223
224GP<ByteStream>
225DjVuImage::get_anno() const
226{
227   GP<ByteStream> out = ByteStream::create();
228   ByteStream &mbs = *out;
229   if (file) 
230   {
231     file->merge_anno(mbs);
232   }
233   mbs.seek(0);
234   if(!mbs.size())
235   {
236     out=0;
237   }
238   return out;
239}
240
241GP<ByteStream>
242DjVuImage::get_text() const
243{
244   GP<ByteStream> out = ByteStream::create();
245   ByteStream &mbs = *out;
246   if (file) 
247   {
248     file->get_text(mbs);
249   }
250   mbs.seek(0);
251   if(!mbs.size())
252   {
253     out=0;
254   }
255   return out;
256}
257
258GP<ByteStream>
259DjVuImage::get_meta() const
260{
261   GP<ByteStream> out = ByteStream::create();
262   ByteStream &mbs = *out;
263   if (file) 
264   {
265     file->get_meta(mbs);
266   }
267   mbs.seek(0);
268   if(!mbs.size())
269   {
270     out=0;
271   }
272   return out;
273}
274
275GP<IW44Image>   
276DjVuImage::get_bg44() const
277{
278   if (file)
279     return get_bg44(file);
280   else
281     return 0;
282}
283
284GP<GPixmap>   
285DjVuImage::get_bgpm() const
286{
287   if (file)
288     return get_bgpm(file);
289   else
290     return 0;
291}
292
293GP<JB2Image>   
294DjVuImage::get_fgjb() const
295{
296   if (file)
297     return get_fgjb(file);
298   else
299     return 0;
300}
301
302GP<GPixmap>   
303DjVuImage::get_fgpm() const
304{
305   if (file)
306     return get_fgpm(file);
307   else
308     return 0;
309}
310
311GP<DjVuPalette>   
312DjVuImage::get_fgbc() const
313{
314   if (file)
315     return get_fgbc(file);
316   else
317     return 0;
318}
319
320int
321DjVuImage::get_width() const
322{
323   GP<DjVuInfo> info=get_info();
324   return info?((rotate_count&1)?(info->height):(info->width)):0;
325}
326
327int
328DjVuImage::get_height() const
329{
330   GP<DjVuInfo> info=get_info();
331   return info?((rotate_count&1)?(info->width):(info->height)):0;
332}
333
334int
335DjVuImage::get_real_width() const
336{
337   GP<DjVuInfo> info=get_info();
338   return info ? info->width : 0;
339}
340
341int
342DjVuImage::get_real_height() const
343{
344   GP<DjVuInfo> info=get_info();
345   return info ? info->height : 0;
346}
347
348int
349DjVuImage::get_version() const
350{
351   GP<DjVuInfo> info=get_info();
352   return info ? info->version : DJVUVERSION;
353}
354
355int
356DjVuImage::get_dpi() const
357{
358   GP<DjVuInfo> info=get_info();
359   return info ? info->dpi : 300;
360}
361
362int
363DjVuImage::get_rounded_dpi() const
364{
365   return (get_dpi()+5)/10*10;
366#if 0   
367      /* This code used to round the reported dpi to 25, 50, 75, 100, 150,
368         300, and 600. Now we just round the dpi to 10ths and return it */
369   int dpi=get_dpi();
370   if (dpi>700) return dpi;
371 
372   const int std_dpi[]={ 25, 50, 75, 100, 150, 300, 600 };
373   const int std_dpis=sizeof(std_dpi)/sizeof(std_dpi[0]);
374   int min_dist=abs(dpi-std_dpi[0]);
375   int min_idx=0;
376   for(int i=1;i<std_dpis;i++)
377      if (abs(std_dpi[i]-dpi)<min_dist)
378      {
379         min_dist=abs(std_dpi[i]-dpi);
380         min_idx=i;
381      };
382   return std_dpi[min_idx];
383#endif
384}
385
386double
387DjVuImage::get_gamma() const
388{
389   GP<DjVuInfo> info=get_info();
390   return info ? info->gamma : 2.2;
391}
392
393GUTF8String
394DjVuImage::get_mimetype() const
395{
396   return file ? file->mimetype : GUTF8String();
397}
398
399
400//// DJVUIMAGE: UTILITIES
401
402GUTF8String
403DjVuImage::get_short_description() const
404{
405  GUTF8String msg = "Empty";
406  int width = get_width();
407  int height = get_height();
408  if (width && height)
409    if (file && file->file_size>100)
410      //msg.format("%dx%d in %0.1f Kb", width, height, file->file_size/1024.0);
411      msg.format( ERR_MSG("DjVuImage.short1") "\t%d\t%d\t%0.1f", width, height, file->file_size/1024.0 );
412    else
413      //msg.format("%dx%d", width, height);
414      msg.format( ERR_MSG("DjVuImage.short2") "\t%d\t%d", width, height );
415  return msg;
416}
417
418GUTF8String
419DjVuImage::get_long_description() const
420{
421  return file?(file->description):GUTF8String();
422}
423
424
425void
426DjVuImage::notify_chunk_done(const DjVuPort *, const GUTF8String & name)
427{
428   if (!relayout_sent &&
429     ( !name.cmp("INFO", 4) ||
430       !name.cmp("PMxx", 2) ||
431       !name.cmp("BMxx", 2)  ) )
432   {
433      DjVuPort::get_portcaster()->notify_relayout(this);
434      relayout_sent=true;
435   } 
436   else if (!name.cmp("Sxxx", 1) ||
437            !name.cmp("BGxx", 2) ||
438            !name.cmp("FGxx", 2) ||
439            !name.cmp("BMxx", 2) ||
440            !name.cmp("PMxx", 2)  )
441     DjVuPort::get_portcaster()->notify_redisplay(this);
442}
443
444
445
446
447
448
449//// DJVUIMAGE: OLD-STYLE DECODING
450
451DjVuInterface::~DjVuInterface() 
452{
453}
454
455class DjVuImageNotifier : public DjVuPort
456{
457  friend class DjVuImage;
458  DjVuInterface  *notifier;
459  GP<DataPool>    stream_pool;
460  GURL            stream_url;
461public:
462  DjVuImageNotifier(DjVuInterface *notifier);
463  GP<DataPool> request_data(const DjVuPort *src, const GURL & url);
464  void notify_chunk_done(const DjVuPort *, const GUTF8String &name);
465  void notify_redisplay(const class DjVuImage * source);
466  void notify_relayout(const class DjVuImage * source);
467};
468
469DjVuImageNotifier::DjVuImageNotifier(DjVuInterface *notifier)
470  : notifier(notifier)
471{
472}
473
474GP<DataPool> 
475DjVuImageNotifier::request_data(const DjVuPort *src, const GURL & url)
476{
477  if (url!=stream_url)
478    G_THROW( ERR_MSG("DjVuImage.not_decode") );
479  return stream_pool;
480}
481
482void 
483DjVuImageNotifier::notify_redisplay(const class DjVuImage * source)
484{
485  if (notifier)
486    notifier->notify_redisplay();
487}
488
489void 
490DjVuImageNotifier::notify_relayout(const class DjVuImage * source)
491{
492  if (notifier)
493    notifier->notify_relayout();
494}
495
496void 
497DjVuImageNotifier::notify_chunk_done(const DjVuPort *, const GUTF8String &name)
498{
499  if (notifier)
500    notifier->notify_chunk(name, "" );
501}
502
503void
504DjVuImage::decode(ByteStream & str, DjVuInterface *notifier)
505{
506  DEBUG_MSG("DjVuImage::decode(): decoding old way...\n");
507  DEBUG_MAKE_INDENT(3);
508  if (file) 
509    G_THROW( ERR_MSG("DjVuImage.bad_call") );
510  GP<DjVuImageNotifier> pport = new DjVuImageNotifier(notifier);
511  pport->stream_url=GURL::UTF8("internal://fake/fake.djvu");
512  pport->stream_pool=DataPool::create();
513  // Get all the data first
514  int length;
515  char buffer[1024];
516  while((length=str.read(buffer, 1024)))
517    pport->stream_pool->add_data(buffer, length);
518  pport->stream_pool->set_eof();
519  GP<DjVuDocument> doc = DjVuDocument::create_wait(pport->stream_url, (DjVuImageNotifier*)pport);
520  GP<DjVuImage> dimg=doc->get_page(-1, true, (DjVuImageNotifier*)pport);
521  file=dimg->get_djvu_file();
522  if (file->is_decode_stopped())
523    G_THROW( DataPool::Stop );
524  if (file->is_decode_failed())
525    G_THROW( ByteStream::EndOfFile ); // guess
526  if (!file->is_decode_ok())
527    G_THROW( ERR_MSG("DjVuImage.mult_error") );
528  DEBUG_MSG("decode DONE\n");
529}
530
531
532//// DJVUIMAGE: CHECKING
533
534static int
535compute_red(int w, int h, int rw, int rh)
536{
537  for (int red=1; red<16; red++)
538    if (((w+red-1)/red==rw) && ((h+red-1)/red==rh))
539      return red;
540  return 16;
541}
542
543
544int 
545DjVuImage::is_legal_bilevel() const
546{
547  // Components
548  GP<DjVuInfo> info = get_info();
549  GP<JB2Image> fgjb = get_fgjb();
550  GP<IW44Image> bg44 = get_bg44();
551  GP<GPixmap>  bgpm = get_bgpm();
552  GP<GPixmap>  fgpm = get_fgpm();
553  // Check info
554  if (! info)
555    return 0;
556  int width = info->width;
557  int height = info->height;
558  if (! (width>0 && height>0))
559    return 0;
560  // Check fgjb
561  if (!fgjb)
562    return 0;
563  if (fgjb->get_width()!=width || fgjb->get_height()!=height)
564    return 0;
565  // Check that color information is not present.
566  if (bg44 || bgpm || fgpm)
567    return 0;
568  // Ok.
569  return 1;
570}
571
572int 
573DjVuImage::is_legal_photo() const
574{
575  // Components
576  GP<DjVuInfo> info = get_info();
577  GP<JB2Image> fgjb = get_fgjb(); 
578  GP<IW44Image> bg44 = get_bg44();
579  GP<GPixmap>  bgpm = get_bgpm();
580  GP<GPixmap>  fgpm = get_fgpm();
581  // Check info
582  if (! info)
583    return 0;
584  int width = info->width;
585  int height = info->height;
586  if (! (width>0 && height>0))
587    return 0;
588  // Check that extra information is not present.
589  if (fgjb || fgpm)
590    return 0;
591  // Check bg44
592  if (bg44 && bg44->get_width()==width && bg44->get_height()==height)
593    return 1;
594  // Check bgpm
595  if (bgpm && (int)bgpm->columns()==width && (int)bgpm->rows()==height)
596    return 1;
597  // Ok.
598  return 0;
599}
600
601int 
602DjVuImage::is_legal_compound() const
603{
604  // Components
605  GP<DjVuInfo>     info = get_info();
606  GP<JB2Image>     fgjb = get_fgjb();
607  GP<IW44Image>     bg44 = get_bg44();
608  GP<GPixmap>      bgpm = get_bgpm();
609  GP<GPixmap>      fgpm = get_fgpm();
610  GP<DjVuPalette>  fgbc = get_fgbc();
611  // Check size
612  if (! info)
613    return 0;
614  int width = info->width;
615  int height = info->height;
616  if (! (width>0 && height>0))
617    return 0;
618  // Check fgjb
619  if (!fgjb)
620    return 0;
621  if (fgjb->get_width()!=width || fgjb->get_height()!=height)
622    return 0;
623  // Check background
624  int bgred = 0;
625  if (bg44)
626    bgred = compute_red(width, height, bg44->get_width(), bg44->get_height());
627  else if (bgpm)
628    bgred = compute_red(width, height, bgpm->columns(), bgpm->rows());
629  if (bgred<1 || bgred>12)
630    return 0;
631  // Check foreground colors
632  int fgred = 0;
633  if (fgbc)
634    fgred = 1;
635  else if (fgpm)
636    fgred = compute_red(width, height, fgpm->columns(), fgpm->rows());
637  if (fgred<1 || fgred>12)
638    return 0;
639  // Check that all components are present
640  if (fgjb && bgred && fgred)
641    return 1;
642  // Unrecognized
643  return 0;
644}
645
646
647//// DJVUIMAGE: LOW LEVEL RENDERING
648
649GP<GBitmap>
650DjVuImage::get_bitmap(const GRect &rect, 
651                      int subsample, int align) const
652{
653  // Access image size
654  int width = get_real_width();
655  int height = get_real_height();
656  GP<JB2Image> fgjb = get_fgjb();
657  if ( width && height && fgjb && 
658       (fgjb->get_width() == width) && 
659       (fgjb->get_height() == height) ) 
660    {
661      return fgjb->get_bitmap(rect, subsample, align);
662    }
663  return 0;
664}
665
666GP<GPixmap>
667DjVuImage::get_bg_pixmap(const GRect &rect, 
668                         int subsample, double gamma) const
669{
670  GP<GPixmap> pm = 0;
671  // Access image size
672 
673  GP<DjVuInfo> info = get_info();
674  int width = get_real_width();
675  int height = get_real_height();
676
677
678  if (width<=0 || height<=0 || !info) return 0;
679  // Compute gamma_correction
680  double gamma_correction = 1.0;
681  if (gamma > 0)
682    gamma_correction = gamma / info->gamma;
683  if (gamma_correction < 0.1)
684    gamma_correction = 0.1;
685  else if (gamma_correction > 10)
686    gamma_correction = 10;
687 
688  // CASE1: Incremental BG IW44Image
689  GP<IW44Image> bg44 = get_bg44();
690  if (bg44)
691    {
692      int w = bg44->get_width();
693      int h = bg44->get_height();
694      // Avoid silly cases
695      if (w==0 || h==0 || width==0 || height==0)
696        return 0;
697      // Determine how much bg44 is reduced
698      int red = compute_red(width,height,w,h);
699      if (red<1 || red>12)
700        return 0;
701      // Handle pure downsampling cases
702      if (subsample == red)
703        pm = bg44->get_pixmap(1,rect);
704      else if (subsample == 2*red)
705        pm = bg44->get_pixmap(2,rect);   
706      else if (subsample == 4*red)
707        pm = bg44->get_pixmap(4,rect); 
708      else if (subsample == 8*red)
709        pm = bg44->get_pixmap(8,rect); 
710      // Handle fractional downsampling case
711      else if (red*4 == subsample*3)
712        {
713          GRect nrect = rect;
714          GRect xrect = rect;
715          xrect.xmin = (xrect.xmin/3)*4;
716          xrect.ymin = (xrect.ymin/3)*4;
717          xrect.xmax = ((xrect.xmax+2)/3)*4;
718          xrect.ymax = ((xrect.ymax+2)/3)*4;
719          nrect.translate(-xrect.xmin*3/4, -xrect.ymin*3/4);
720          if (xrect.xmax > w) 
721            xrect.xmax = w;
722          if (xrect.ymax > h) 
723            xrect.ymax = h;
724          GP<GPixmap> ipm = bg44->get_pixmap(1,xrect);
725          pm = GPixmap::create();
726          pm->downsample43(ipm, &nrect);
727        }
728      // Handle all other cases with pixmapscaler
729      else
730        {
731          // find suitable power of two
732          int po2 = 16;
733          while (po2>1 && subsample<po2*red)
734            po2 >>= 1;
735          // setup pixmap scaler
736          int inw = (w+po2-1)/po2;
737          int inh = (h+po2-1)/po2;
738          int outw = (width+subsample-1)/subsample;
739          int outh = (height+subsample-1)/subsample;
740          GP<GPixmapScaler> gps=GPixmapScaler::create(inw, inh, outw, outh);
741          GPixmapScaler &ps=*gps;
742          ps.set_horz_ratio(red*po2, subsample);
743          ps.set_vert_ratio(red*po2, subsample);
744          // run pixmap scaler
745          GRect xrect;
746          ps.get_input_rect(rect,xrect);
747          GP<GPixmap> ipm = bg44->get_pixmap(po2,xrect);
748          pm = GPixmap::create();
749          ps.scale(xrect, *ipm, rect, *pm);
750        }
751      // Apply gamma correction
752      if (pm && gamma_correction!=1.0)
753        pm->color_correct(gamma_correction);
754      return pm;
755    }
756
757  // CASE 2: Raw background pixmap
758  GP<GPixmap>  bgpm = get_bgpm();
759  if (bgpm)
760    {
761      int w = bgpm->columns();
762      int h = bgpm->rows();
763      // Avoid silly cases
764      if (w==0 || h==0 || width==0 || height==0)
765        return 0;
766      // Determine how much bgpm is reduced
767      int red = compute_red(width,height,w,h);
768      if (red<1 || red>12)
769        return 0;
770      // Handle pure downsampling cases
771      int ratio = subsample/red;
772      if (subsample==ratio*red && ratio>=1)
773        {
774          pm = GPixmap::create();
775          if (ratio == 1)
776            pm->init(*bgpm, rect);
777          else if (ratio > 1)
778            pm->downsample(bgpm, ratio, &rect);
779        }
780      // Handle all other cases with pixmapscaler
781      else
782        {
783          // setup pixmap scaler
784          int outw = (width+subsample-1)/subsample;
785          int outh = (height+subsample-1)/subsample;
786          GP<GPixmapScaler> gps=GPixmapScaler::create(w, h, outw, outh);
787          GPixmapScaler &ps=*gps;
788          ps.set_horz_ratio(red, subsample);
789          ps.set_vert_ratio(red, subsample);
790          // run pixmap scaler
791          pm = GPixmap::create();
792          GRect xrect(0,0,w,h);
793          ps.scale(xrect, *bgpm, rect, *pm);
794        }
795      // Apply gamma correction
796      if (pm && gamma_correction!=1.0)
797        pm->color_correct(gamma_correction);
798      return pm;
799    }
800
801  // FAILURE
802  return 0;
803}
804
805
806
807int 
808DjVuImage::stencil(GPixmap *pm, const GRect &rect,
809                   int subsample, double gamma) const
810{
811  // Warping and blending.
812  if (!pm)
813    return 0;
814  // Access components
815 
816  GP<DjVuInfo> info = get_info();
817  int width = get_real_width();
818  int height = get_real_height();
819
820
821  if (width<=0 || height<=0 || !info) return 0;
822  GP<JB2Image> fgjb = get_fgjb();
823  GP<GPixmap> fgpm = get_fgpm();
824  GP<DjVuPalette> fgbc = get_fgbc();
825 
826  // Compute gamma_correction
827  double gamma_correction = 1.0;
828  if (gamma > 0)
829    gamma_correction = gamma / info->gamma;
830  if (gamma_correction < 0.1)
831    gamma_correction = 0.1;
832  else if (gamma_correction > 10)
833    gamma_correction = 10;
834
835  // Compute alpha map and relevant JB2Image components
836  GList<int> components;
837  GP<GBitmap> bm;
838  if (fgjb)
839    {
840      JB2Image *jimg = fgjb;
841      if (! (width && height && 
842             jimg->get_width() == width && 
843             jimg->get_height() == height ) )
844        return 0;
845      // Decode bitmap
846      bm = GBitmap::create(rect.height(), rect.width());
847      bm->set_grays(1+subsample*subsample);
848      int rxmin = rect.xmin * subsample;
849      int rymin = rect.ymin * subsample;
850      for (int blitno = 0; blitno < jimg->get_blit_count(); blitno++)
851        {
852          const JB2Blit *pblit = jimg->get_blit(blitno);
853          const JB2Shape  &pshape = jimg->get_shape(pblit->shapeno);
854          if (pshape.bits &&
855              pblit->left <= rect.xmax * subsample &&
856              pblit->bottom <= rect.ymax * subsample &&
857              pblit->left + (int)pshape.bits->columns() >= rect.xmin * subsample &&
858              pblit->bottom + (int)pshape.bits->rows() >= rect.ymin * subsample )
859            {
860              // Record component list
861              if (fgbc) components.append(blitno);
862              // Blit
863              bm->blit(pshape.bits, 
864                       pblit->left - rxmin, pblit->bottom - rymin, 
865                       subsample);
866            }
867        }
868    }
869
870
871  // TWO LAYER MODEL
872  if (bm && fgbc)
873    {
874      // Perform attenuation from scratch
875      pm->attenuate(bm, 0, 0);
876      // Check that fgbc has the correct size
877      JB2Image *jimg = fgjb;
878      DjVuPalette *fg = fgbc;
879      if (jimg->get_blit_count() != fg->colordata.size())
880        return 0;
881      // Copy and color correct palette
882      int palettesize = fg->size();
883      GTArray<GPixel> colors(0,palettesize-1);
884      for (int i=0; i<palettesize; i++)
885        fg->index_to_color(i, colors[i]);
886      GPixmap::color_correct(gamma_correction, colors, palettesize);
887      // Blit all components (one color at a time)
888      while (components.size() > 0)
889        {
890          GPosition nullpos;
891          GPosition pos = components;
892          int lastx = 0;
893          int colorindex = fg->colordata[components[pos]];
894          if (colorindex >= palettesize)
895            G_THROW( ERR_MSG("DjVuImage.corrupted") );
896          // Gather relevant components and relevant rectangle
897          GList<int> compset;
898          GRect comprect;
899          while (pos)
900            {
901              int blitno = components[pos];
902              const JB2Blit *pblit = jimg->get_blit(blitno);
903              if (pblit->left < lastx) break; 
904              lastx = pblit->left;
905              if (fg->colordata[blitno] == colorindex)
906                {
907                  const JB2Shape  &pshape = jimg->get_shape(pblit->shapeno);
908                  GRect rect(pblit->left, pblit->bottom, 
909                             pshape.bits->columns(), pshape.bits->rows());
910                  comprect.recthull(comprect, rect);
911                  compset.insert_before(nullpos, components, pos);
912                  continue;
913                }
914              ++pos;
915            }
916          // Round alpha map rectangle
917          comprect.xmin = comprect.xmin / subsample;
918          comprect.ymin = comprect.ymin / subsample;
919          comprect.xmax = (comprect.xmax+subsample-1) / subsample;
920          comprect.ymax = (comprect.ymax+subsample-1) / subsample;
921          comprect.intersect(comprect, rect);
922          // Compute alpha map for that color
923          bm = 0;
924          bm = GBitmap::create(comprect.height(), comprect.width());
925          bm->set_grays(1+subsample*subsample);
926          int rxmin = comprect.xmin * subsample;
927          int rymin = comprect.ymin * subsample;
928          for (pos=compset; pos; ++pos)
929            {
930              int blitno = compset[pos];
931              const JB2Blit *pblit = jimg->get_blit(blitno);
932              const JB2Shape  &pshape = jimg->get_shape(pblit->shapeno);
933              bm->blit(pshape.bits, 
934                       pblit->left - rxmin, pblit->bottom - rymin, 
935                       subsample);
936            }
937          // Blend color into background pixmap
938          pm->blit(bm, comprect.xmin-rect.xmin, comprect.ymin-rect.ymin, &colors[colorindex]);
939        }
940      return 1;
941    }
942
943
944  // THREE LAYER MODEL
945  if (bm && fgpm)
946    {
947      // This follows fig. 4 in Adelson "Layered representations for image
948      // coding" (1991) http://www-bcs.mit.edu/people/adelson/papers.html.
949      // The properly warped background is already in PM.  The properly warped
950      // alpha map is already in BM.  We just have to warp the foreground and
951      // perform alpha blending.
952#ifdef SIMPLE_THREE_LAYER_RENDERING
953      int w = fgpm->columns();
954      int h = fgpm->rows();
955      // Determine foreground reduction
956      int red = compute_red(width,height, w, h);
957      if (red<1 || red>12)
958        return 0;
959      // Warp foreground pixmap
960      GPixmapScaler ps(w,h,width/subsample+1,height/subsample+1);
961      ps.set_horz_ratio(red,subsample);
962      ps.set_vert_ratio(red,subsample);
963      GP<GPixmap> nfg = new GPixmap;
964      GRect provided(0,0,w,h);
965      ps.scale(provided, *fgpm, rect, *nfg);
966      // Attenuate background and blit
967      nfg->color_correct(gamma_correction);
968      pm->blend(bm, 0, 0, nfg); // blend == attenuate + blit
969      return 1;
970#else
971      // Things are now a little bit more complex because the convenient
972      // function GPixmap::stencil() simultaneously upsamples the foreground
973      // by an integer factor and performs the alpha blending.  We have
974      // to determine how and when this facility can be used.
975      int w = fgpm->columns();
976      int h = fgpm->rows();
977      // Determine foreground reduction
978      int red = compute_red(width,height,w,h);
979      if (red<1 || red>12)
980        return 0;
981      // Try supersampling foreground pixmap by an integer factor
982      int supersample = ( red>subsample ? red/subsample : 1);
983      int wantedred = supersample*subsample;
984      // Try simple foreground upsampling
985      if (red == wantedred)
986        {
987          // Simple foreground upsampling is enough.
988          pm->stencil(bm, fgpm, supersample, &rect, gamma_correction);
989          return 1;
990        }
991      else 
992        {
993          // Must pre-warp foreground pixmap
994          GP<GPixmap> nfg;
995          int desw = (w*red+wantedred-1)/wantedred;
996          int desh = (h*red+wantedred-1)/wantedred;
997          // Cache rescaled fgpm for speed
998          static const DjVuImage *tagimage  = 0;
999          static const GPixmap *tagfgpm   = 0;
1000          static GP<GPixmap> cachednfg = 0;
1001          // Check whether cached fgpm applies.
1002          if ( cachednfg && this==tagimage && fgpm==tagfgpm
1003               && desw==(int)cachednfg->columns()
1004               && desh==(int)cachednfg->rows() )
1005            {
1006              nfg = cachednfg;
1007            }
1008          else
1009            {
1010              GP<GPixmapScaler> gps=GPixmapScaler::create(w,h,desw,desh);
1011              GPixmapScaler &ps=*gps;
1012              ps.set_horz_ratio(red, wantedred);
1013              ps.set_vert_ratio(red, wantedred);
1014              nfg = GPixmap::create();
1015              GRect provided(0,0,w,h);
1016              GRect desired(0,0,desw,desh);
1017              ps.scale(provided, *fgpm, desired, *nfg);
1018            }
1019          // Use combined warp+blend function
1020          pm->stencil(bm, nfg, supersample, &rect, gamma_correction);
1021          // Cache
1022          tagimage = this;
1023          tagfgpm = fgpm;
1024          cachednfg = nfg;
1025          return 1;
1026        }
1027#endif
1028    }
1029 
1030  // FAILURE
1031  return 0;
1032}
1033
1034
1035GP<GPixmap>
1036DjVuImage::get_fg_pixmap(const GRect &rect, 
1037                         int subsample, double gamma) const
1038{
1039  // Obtain white background pixmap
1040  GP<GPixmap> pm;
1041  // Access components
1042  const int width = get_real_width();
1043  const int height = get_real_height();
1044  if (width && height)
1045  {
1046    pm = GPixmap::create(rect.height(),rect.width(), &GPixel::WHITE);
1047    if (!stencil(pm, rect, subsample, gamma))
1048      pm=0;
1049  }
1050  return pm;
1051}
1052
1053
1054GP<GPixmap>
1055DjVuImage::get_pixmap(const GRect &rect, int subsample, double gamma) const
1056{
1057  // Get background
1058  GP<GPixmap> pm = get_bg_pixmap(rect, subsample, gamma);
1059  // Superpose foreground
1060  if (! stencil(pm, rect, subsample, gamma))
1061    // Avoid ugly progressive display (hack)
1062    if (get_fgjb()) return 0;
1063  // Return
1064  return pm;
1065}
1066
1067
1068//// DJVUIMAGE: RENDERING (ARBITRARY SCALE)
1069
1070typedef GP<GBitmap>(DjVuImage::*BImager)(const GRect &, int, int) const;
1071typedef GP<GPixmap>(DjVuImage::*PImager)(const GRect &, int, double) const;
1072
1073static GP<GBitmap>
1074do_bitmap(const DjVuImage &dimg, BImager get,
1075          const GRect &inrect, const GRect &inall, int align )
1076{
1077    GRect rect=inrect;
1078    GRect all=inall;
1079    if( dimg.get_rotate() )
1080      {
1081        GRectMapper mapper;
1082        mapper.rotate(-dimg.get_rotate());
1083        mapper.map(rect);
1084        mapper.map(all);
1085    }
1086   
1087  // Sanity
1088  if (! ( all.contains(rect.xmin, rect.ymin) &&
1089          all.contains(rect.xmax-1, rect.ymax-1) ))
1090    G_THROW( ERR_MSG("DjVuImage.bad_rect") );
1091  // Check for integral reduction
1092  int red;
1093  int w = dimg.get_real_width();
1094  int h = dimg.get_real_height();
1095
1096  int rw = all.width();
1097  int rh = all.height();
1098  GRect zrect = rect; 
1099  zrect.translate(-all.xmin, -all.ymin);
1100  for (red=1; red<=15; red++)
1101    if (rw*red>w-red && rw*red<w+red && rh*red>h-red && rh*red<h+red)
1102    {
1103        GP<GBitmap> bm=(dimg.*get)(zrect, red, align);
1104        if(bm)
1105            return bm->rotate(dimg.get_rotate());
1106        else
1107                return NULL;
1108    }
1109  // Find best reduction
1110  for (red=15; red>1; red--)
1111    if ( (rw*red < w && rh*red < h) ||
1112         (rw*red*3 < w || rh*red*3 < h) )
1113      break;
1114  // Setup bitmap scaler
1115  if (w<=0 || h<=0) return 0;
1116  GP<GBitmapScaler> gbs=GBitmapScaler::create();
1117  GBitmapScaler &bs=*gbs;
1118  bs.set_input_size( (w+red-1)/red, (h+red-1)/red );
1119  bs.set_output_size( rw, rh );
1120  bs.set_horz_ratio( rw*red, w );
1121  bs.set_vert_ratio( rh*red, h );
1122  // Scale
1123  GRect srect;
1124  bs.get_input_rect(zrect, srect);
1125  GP<GBitmap> sbm = (dimg.*get)(srect, red, 1);
1126  if (!sbm) return 0;
1127  int border = ((zrect.width() + align - 1) & ~(align - 1)) - zrect.width();
1128  GP<GBitmap> bm = GBitmap::create(zrect.height(), zrect.width(), border);
1129  bs.scale(srect, *sbm, zrect, *bm);
1130  if( bm )
1131      return bm->rotate(dimg.get_rotate());
1132  else
1133      return NULL;
1134}
1135
1136static GP<GPixmap>
1137do_pixmap(const DjVuImage &dimg, PImager get,
1138          const GRect &inrect, const GRect &inall, double gamma )
1139{
1140  GRect rect=inrect;
1141  GRect all=inall;
1142  if( dimg.get_rotate()%4 )
1143    {
1144      GRectMapper mapper;
1145      mapper.rotate(-dimg.get_rotate());
1146      mapper.map(rect);
1147      mapper.map(all);
1148    }
1149 
1150  // Sanity
1151  if (! ( all.contains(rect.xmin, rect.ymin) &&
1152          all.contains(rect.xmax-1, rect.ymax-1) ))
1153    G_THROW( ERR_MSG("DjVuImage.bad_rect2") );
1154  // Check for integral reduction
1155  int red, w=0, h=0, rw=0, rh=0;
1156  w = dimg.get_real_width();
1157  h = dimg.get_real_height();
1158
1159  rw = all.width();
1160  rh = all.height();
1161  GRect zrect = rect; 
1162  zrect.translate(-all.xmin, -all.ymin);
1163  for (red=1; red<=15; red++)
1164    if (rw*red>w-red && rw*red<w+red && rh*red>h-red && rh*red<h+red)
1165    {
1166        GP<GPixmap> pm = (dimg.*get)(zrect, red, gamma);
1167        if( pm ) 
1168            return pm->rotate(dimg.get_rotate());
1169        else
1170            return NULL;
1171    }
1172  // These reductions usually go faster (improve!)
1173  static int fastred[] = { 12,6,4,3,2,1 };
1174  // Find best reduction
1175  for (int i=0; (red=fastred[i])>1; i++)
1176    if ( (rw*red < w && rh*red < h) ||
1177         (rw*red*3 < w || rh*red*3 < h) )
1178      break;
1179  // Setup pixmap scaler
1180  if (w<=0 || h<=0) return 0;
1181  GP<GPixmapScaler> gps=GPixmapScaler::create();
1182  GPixmapScaler &ps=*gps;
1183  ps.set_input_size( (w+red-1)/red, (h+red-1)/red );
1184  ps.set_output_size( rw, rh );
1185  ps.set_horz_ratio( rw*red, w );
1186  ps.set_vert_ratio( rh*red, h );
1187  // Scale
1188  GRect srect;
1189  ps.get_input_rect(zrect, srect);
1190  GP<GPixmap> spm = (dimg.*get)(srect, red, gamma);
1191  if (!spm) return 0;
1192  GP<GPixmap> pm = GPixmap::create();
1193  ps.scale(srect, *spm, zrect, *pm);
1194  if(pm)
1195      return pm->rotate(dimg.get_rotate());
1196  else
1197      return NULL;
1198}
1199
1200GP<GPixmap> 
1201DjVuImage::get_pixmap(const GRect &rect, const GRect &all, double gamma) const
1202{
1203  return do_pixmap(*this, & DjVuImage::get_pixmap, rect, all, gamma);
1204}
1205
1206GP<GBitmap> 
1207DjVuImage::get_bitmap(const GRect &rect, const GRect &all, int align) const
1208{
1209  return do_bitmap(*this, & DjVuImage::get_bitmap, rect, all, align);
1210}
1211
1212GP<GPixmap> 
1213DjVuImage::get_bg_pixmap(const GRect &rect, const GRect &all, double gamma) const
1214{
1215  return do_pixmap(*this, & DjVuImage::get_bg_pixmap, rect, all, gamma);
1216}
1217
1218GP<GPixmap> 
1219DjVuImage::get_fg_pixmap(const GRect &rect, const GRect &all, double gamma) const
1220{
1221  return do_pixmap(*this, & DjVuImage::get_fg_pixmap, rect, all, gamma);
1222}
1223
1224int 
1225DjVuImage::get_rotate() const
1226{
1227  return (rotate_count<0) ? 0 : rotate_count;
1228}
1229
1230void
1231DjVuImage::init_rotate(const DjVuInfo &info)
1232{ 
1233  rotate_count = info.orientation;
1234}
1235
1236void DjVuImage::set_rotate(int count) 
1237{ 
1238  rotate_count = count % 4;
1239}
1240
1241GP<DjVuAnno> 
1242DjVuImage::get_decoded_anno()
1243{
1244    GP<DjVuInfo> djvuinfo = get_info();
1245    GP<DjVuAnno> djvuanno = DjVuAnno::create();
1246    GP<ByteStream> bs=get_anno();
1247    if( bs )
1248    {
1249      int rotate_count=get_rotate(); 
1250      /// Brain damaged adjustment of annotation
1251      /// coordinates that reflect the orientation
1252      /// flag in the info chunk....
1253      if (djvuinfo)
1254        rotate_count = rotate_count - djvuinfo->orientation;
1255      ///decode
1256      djvuanno->decode(bs);
1257      ///map hyperlinks correctly for rotation           
1258      if( rotate_count & 3 )
1259        {   
1260          GRect input, output;
1261          input = GRect(0,0,get_width(),get_height());
1262          if (rotate_count & 1)
1263            output = GRect(0,0,get_height(),get_width());
1264          else
1265            output = GRect(0,0,get_width(),get_height());
1266          GRectMapper mapper;
1267          mapper.clear();
1268          mapper.set_input(input);
1269          mapper.set_output(output);               
1270          mapper.rotate(-rotate_count);
1271          GPList<GMapArea> &list=djvuanno->ant->map_areas;
1272          for(GPosition pos=list;pos;++pos)
1273            list[pos]->unmap(mapper);
1274        }
1275      return djvuanno;
1276    }
1277    else
1278      return NULL;
1279}
1280
1281
1282void
1283DjVuImage::map(GRect &rect) const
1284{
1285    GRect input, output;
1286    const int rotate_count=get_rotate(); 
1287    if(rotate_count>0)
1288    { 
1289        input = GRect(0,0,get_width(), get_height());
1290        output = GRect(0,0, get_real_width(), get_real_height());
1291
1292        GRectMapper mapper;
1293        mapper.clear();
1294        mapper.set_input(input);
1295        mapper.set_output(output);               
1296        mapper.rotate(-rotate_count);
1297        mapper.map(rect);
1298    }
1299}
1300
1301void
1302DjVuImage::unmap(GRect &rect) const
1303{
1304    GRect input, output;
1305    const int rotate_count=get_rotate(); 
1306    if(rotate_count>0)
1307    { 
1308        input = GRect(0,0,get_width(), get_height());
1309        output = GRect(0,0, get_real_width(), get_real_height());
1310
1311        GRectMapper mapper;
1312        mapper.clear();
1313        mapper.set_input(input);
1314        mapper.set_output(output);               
1315        mapper.rotate(-rotate_count);
1316        mapper.unmap(rect);
1317    }
1318}
1319
1320void
1321DjVuImage::map(int &x, int &y) const
1322{
1323    GRect input, output;
1324    const int rotate_count=get_rotate(); 
1325    if(rotate_count>0)
1326    { 
1327        input = GRect(0,0,get_width(), get_height());
1328        output = GRect(0,0, get_real_width(), get_real_height());
1329
1330        GRectMapper mapper;
1331        mapper.clear();
1332        mapper.set_input(input);
1333        mapper.set_output(output);               
1334        mapper.rotate(-rotate_count);
1335        mapper.map(x, y);
1336    }
1337}
1338
1339void
1340DjVuImage::unmap(int &x, int &y) const
1341{
1342    GRect input, output;
1343    const int rotate_count=get_rotate(); 
1344    if(rotate_count>0)
1345    { 
1346        input = GRect(0,0,get_width(), get_height());
1347        output = GRect(0,0, get_real_width(), get_real_height());
1348
1349        GRectMapper mapper;
1350        mapper.clear();
1351        mapper.set_input(input);
1352        mapper.set_output(output);               
1353        mapper.rotate(-rotate_count);
1354        mapper.unmap(x, y);
1355    }
1356}
1357
1358bool
1359DjVuImage::wait_for_complete_decode(void)
1360{
1361  if (file) 
1362  {
1363    file->resume_decode(true);
1364    return file->is_decode_ok();
1365  }
1366  return 0;
1367}
1368
1369// Write out a DjVuXML object tag and map tag.
1370void
1371DjVuImage::writeXML(ByteStream &str_out,const GURL &doc_url,const int flags) const
1372{
1373  const int height=get_height();
1374 
1375  static const char *Object="<OBJECT data=\"";
1376  const GURL url(get_djvu_file()->get_url());
1377  const GUTF8String pagename(url.fname());
1378  GUTF8String page_param;
1379  if(doc_url.is_valid() && !doc_url.is_empty() && (doc_url != url))
1380  {
1381    str_out.writestring(Object+doc_url.get_string());
1382    page_param="<PARAM name=\"PAGE\" value=\""+pagename+"\" />\n";
1383  }else
1384  {
1385    str_out.writestring(Object+doc_url.get_string());
1386  }
1387  str_out.writestring("\" type=\""+get_mimetype()+"\" height=\""
1388    +GUTF8String(height)+"\" width=\""+GUTF8String(get_width())
1389    +"\" usemap=\""+pagename.toEscaped()+"\" >\n");
1390  if(!(flags & NOINFO))
1391  {
1392    const GP<DjVuInfo> info(get_info());
1393    if(info)
1394    {
1395      info->writeParam(str_out);
1396    }
1397  }
1398  str_out.writestring(page_param);
1399  const GP<DjVuAnno> anno(DjVuAnno::create());
1400  if(!(flags & NOINFO)||!(flags&NOMAP))
1401  {
1402    const GP<ByteStream> anno_str(get_anno());
1403    if(anno_str)
1404    {
1405      anno->decode(anno_str);
1406    }
1407    if(!(flags & NOINFO))
1408    {
1409      anno->writeParam(str_out);
1410    }
1411  }
1412  if(!(flags & NOTEXT))
1413  {
1414    const GP<DjVuText> text(DjVuText::create());
1415    {
1416      const GP<ByteStream> text_str(get_text());
1417      if(text_str)
1418      {
1419        text->decode(text_str);
1420      }
1421      text->writeText(str_out,height);
1422    }
1423  }
1424  if(!(flags & NOMETA))
1425  {
1426    const GP<ByteStream> meta_str(get_meta());
1427    if(meta_str)
1428    {
1429      GP<IFFByteStream> giff=IFFByteStream::create(meta_str);
1430      IFFByteStream &iff=*giff;
1431      GUTF8String chkid;
1432      while( iff.get_chunk(chkid))
1433      {
1434        GP<ByteStream> gbs(iff.get_bytestream());
1435        if(chkid == "METa")
1436        {
1437           str_out.copy(*gbs);
1438          //str_out.writestring(gbs->getAsUTF8());
1439        }else if(chkid == "METz")
1440        {
1441          gbs=BSByteStream::create(gbs);
1442          str_out.copy(*gbs);
1443          //str_out.writestring(gbs->getAsUTF8());
1444        }
1445        iff.close_chunk();
1446      }
1447    }
1448  }
1449  str_out.writestring(GUTF8String("</OBJECT>\n"));
1450  if(!(flags & NOMAP))
1451  {
1452    anno->writeMap(str_out,pagename,height);
1453  }
1454}
1455
1456// Write out a DjVuXML object tag and map tag.
1457void
1458DjVuImage::writeXML(ByteStream &str_out) const
1459{
1460  writeXML(str_out,GURL());
1461}
1462
1463// Write out a DjVuXML object tag and map tag.
1464GUTF8String
1465DjVuImage::get_XML(const GURL &doc_url,const int flags) const
1466{
1467  GP<ByteStream> gbs(ByteStream::create());
1468  ByteStream &bs=*gbs;
1469  writeXML(bs,doc_url);
1470  bs.seek(0L);
1471  return bs.getAsUTF8();
1472}
1473
1474// Write out a DjVuXML object tag and map tag.
1475GUTF8String
1476DjVuImage::get_XML(void) const
1477{
1478  return get_XML(GURL());
1479}
1480
1481
1482#ifdef HAVE_NAMESPACES
1483}
1484# ifndef NOT_USING_DJVU_NAMESPACE
1485using namespace DJVU;
1486# endif
1487#endif
Note: See TracBrowser for help on using the repository browser.