1191cc0ed80e598aa09cb47e75c168781af4e702
[swftools.git] / lib / pdf / BitmapOutputDev.cc
1 /* InfoOutputDev.h
2
3    Output Device which creates a bitmap.
4
5    Swftools is free software; you can redistribute it and/or modify
6    it under the terms of the GNU General Public License as published by
7    the Free Software Foundation; either version 2 of the License, or
8    (at your option) any later version.
9
10    Swftools is distributed in the hope that it will be useful,
11    but WITHOUT ANY WARRANTY; without even the implied warranty of
12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13    GNU General Public License for more details.
14
15    You should have received a copy of the GNU General Public License
16    along with swftools; if not, write to the Free Software
17    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
18
19 #include <stdlib.h>
20 #include <stdio.h>
21 #include <memory.h>
22 #include <assert.h>
23 #include "BitmapOutputDev.h"
24 #include "GFXOutputDev.h"
25
26 #ifdef HAVE_POPPLER
27   #include "splash/SplashBitmap.h"
28   #include "splash/SplashPattern.h"
29   #include "splash/Splash.h"
30 #else
31   #include "xpdf/config.h"
32   #include "SplashBitmap.h"
33   #include "SplashPattern.h"
34   #include "Splash.h"
35 #endif
36
37 #include "../log.h"
38 #include "../png.h"
39 #include "../devices/record.h"
40 #include "../gfxtools.h"
41 #include "../types.h"
42 #include "bbox.h"
43
44 #define UNKNOWN_BOUNDING_BOX 0,0,0,0
45
46 static SplashColor splash_white = {255,255,255};
47 static SplashColor splash_black = {0,0,0};
48     
49 ClipState::ClipState()
50 {
51     this->next = 0;
52     this->clipbitmap = 0;
53     this->written = 0;
54 }
55
56 BitmapOutputDev::BitmapOutputDev(InfoOutputDev*info, PDFDoc*doc)
57 {
58     this->info = info;
59     this->doc = doc;
60     this->xref = doc->getXRef();
61     
62     /* color graphic output device, for creating bitmaps */
63     this->rgbdev = new SplashOutputDev(splashModeRGB8, 1, gFalse, splash_white, gTrue, gTrue);
64   
65     /* color mode for binary bitmaps */
66     SplashColorMode colorMode = splashModeMono1;
67
68     /* two devices for testing things against clipping: one clips, the other doesn't */
69     this->clip0dev = new SplashOutputDev(colorMode, 1, gFalse, splash_black, gTrue, gFalse);
70     this->clip1dev = new SplashOutputDev(colorMode, 1, gFalse, splash_black, gTrue, gFalse);
71     
72     /* device indicating where polygonal pixels were drawn */
73     this->boolpolydev = new SplashOutputDev(colorMode, 1, gFalse, splash_black, gTrue, gFalse);
74     /* device indicating where text pixels were drawn */
75     this->booltextdev = new SplashOutputDev(colorMode, 1, gFalse, splash_black, gTrue, gFalse);
76
77     /* device for handling texts and links */
78     this->gfxdev = new GFXOutputDev(info, this->doc);
79
80     this->rgbdev->startDoc(this->xref);
81     this->boolpolydev->startDoc(this->xref);
82     this->booltextdev->startDoc(this->xref);
83     this->clip0dev->startDoc(this->xref);
84     this->clip1dev->startDoc(this->xref);
85
86     this->gfxoutput = (gfxdevice_t*)malloc(sizeof(gfxdevice_t));
87     gfxdevice_record_init(this->gfxoutput, 0);
88
89     this->gfxdev->setDevice(this->gfxoutput);
90     
91     this->config_extrafontdata = 0;
92     this->config_optimizeplaincolorfills = 0;
93     this->bboxpath = 0;
94     //this->clipdev = 0;
95     //this->clipstates = 0;
96 }
97 BitmapOutputDev::~BitmapOutputDev()
98 {
99     if(this->gfxoutput) {
100         gfxresult_t*r = this->gfxoutput->finish(this->gfxoutput);
101         r->destroy(r);
102         free(this->gfxoutput);this->gfxoutput = 0;
103     }
104     if(this->bboxpath) {
105         delete this->bboxpath;this->bboxpath = 0;
106     }
107     if(this->rgbdev) {
108         delete this->rgbdev;this->rgbdev = 0;
109     }
110     if(this->gfxdev) {
111         delete this->gfxdev;this->gfxdev= 0;
112     }
113     if(this->boolpolydev) {
114         delete this->boolpolydev;this->boolpolydev = 0;
115     }
116     if(this->stalepolybitmap) {
117         delete this->stalepolybitmap;this->stalepolybitmap = 0;
118     }
119     if(this->staletextbitmap) {
120         delete this->staletextbitmap;this->staletextbitmap = 0;
121     }
122     if(this->booltextdev) {
123         delete this->booltextdev;this->booltextdev = 0;
124     }
125     if(this->clip0dev) {
126         delete this->clip0dev;this->clip0dev = 0;
127     }
128     if(this->clip1dev) {
129         delete this->clip1dev;this->clip1dev = 0;
130     }
131     //if(this->clipbitmap) {
132     //    delete this->clipbitmap;this->clipbitmap = 0;
133     //}
134     //if(this->clipdev) {
135     //    delete this->clipdev;this->clipdev = 0;
136     //}
137
138 }
139
140 GBool BitmapOutputDev::getVectorAntialias()
141 {
142     return this->rgbdev->getVectorAntialias();
143 }
144 void BitmapOutputDev::setVectorAntialias(GBool vaa)
145 {
146     this->rgbdev->setVectorAntialias(vaa);
147 }
148 void BitmapOutputDev::setDevice(gfxdevice_t*dev)
149 {
150     this->dev = dev;
151 }
152 void BitmapOutputDev::setMove(int x,int y)
153 {
154     this->gfxdev->setMove(x,y);
155     this->user_movex = x;
156     this->user_movey = y;
157 }
158 void BitmapOutputDev::setClip(int x1,int y1,int x2,int y2)
159 {
160     this->gfxdev->setClip(x1,y1,x2,y2);
161     this->user_clipx1 = x1;
162     this->user_clipy1 = y1;
163     this->user_clipx2 = x2;
164     this->user_clipy2 = y2;
165 }
166 void BitmapOutputDev::setParameter(const char*key, const char*value)
167 {
168     if(!strcmp(key, "extrafontdata")) {
169         this->config_extrafontdata = atoi(value);
170     }
171     this->gfxdev->setParameter(key, value);
172 }
173 void BitmapOutputDev::setPageMap(int*page2page, int num_pages)
174 {
175     this->gfxdev->setPageMap(page2page, num_pages);
176 }
177
178 void writeBitmap(SplashBitmap*bitmap, char*filename);
179 void writeAlpha(SplashBitmap*bitmap, char*filename);
180
181 static int dbg_btm_counter=1;
182
183 void BitmapOutputDev::flushBitmap()
184 {
185     int bitmap_width = rgbdev->getBitmapWidth();
186     int bitmap_height = rgbdev->getBitmapHeight();
187
188     if(sizeof(SplashColor)!=3) {
189         msg("<error> sizeof(SplashColor)!=3");
190         return;
191     }
192
193     /*static int counter=0;
194     if(!counter) {
195         writeBitmap(rgbdev->getBitmap(), "test.png");
196     } counter++;*/
197     
198     /*static int counter=0;
199     char filename[160];
200     sprintf(filename, "test%d.png", counter++);
201     writeBitmap(rgbbitmap, filename);*/
202     
203     SplashColorPtr rgb = rgbbitmap->getDataPtr();
204     Guchar*alpha = rgbbitmap->getAlphaPtr();
205     
206     Guchar*alpha2 = stalepolybitmap->getDataPtr();
207     int bitmap_width8 = (stalepolybitmap->getWidth()+7)/8;
208
209     /*char filename[80];
210     sprintf(filename, "flush%d_mask.png", dbg_btm_counter);
211     writeAlpha(stalepolybitmap, filename);
212     sprintf(filename, "flush%d_alpha.png", dbg_btm_counter);
213     writeAlpha(rgbbitmap, filename);
214     sprintf(filename, "flush%d_bitmap.png", dbg_btm_counter);
215     writeBitmap(rgbbitmap, filename);*/
216
217     ibbox_t pagebox = {-movex, -movey, -movex + this->width, -movey + this->height, 0};
218     ibbox_t bitmapbox = {0, 0, bitmap_width, bitmap_height, 0};
219     ibbox_t c = ibbox_clip(&bitmapbox, &pagebox);
220     ibbox_t* boxes = get_bitmap_bboxes((unsigned char*)(alpha+c.ymin*bitmap_width+c.xmin), c.xmax - c.xmin, c.ymax - c.ymin, bitmap_width);
221
222     ibbox_t*b;
223     for(b=boxes;b;b=b->next) {
224         int xmin = b->xmin - this->movex;
225         int ymin = b->ymin - this->movey;
226         int xmax = b->xmax - this->movex;
227         int ymax = b->ymax - this->movey;
228
229         /* clip against (-movex, -movey, -movex+width, -movey+height) */
230
231         msg("<verbose> Flushing bitmap (bbox: %d,%d,%d,%d %dx%d) (clipped against %d,%d,%d,%d)", xmin,ymin,xmax,ymax, xmax-xmin, ymax-ymin,
232                 -this->movex, -this->movey, -this->movex+this->width, -this->movey+this->height);
233
234         if(xmin < -this->movex) {
235             xmin = -this->movex;
236             if(xmax < -this->movex) continue;
237         }
238         if(ymin < -this->movey) {
239             ymin = -this->movey;
240             if(ymax < -this->movey) continue;
241         }
242         if(xmax >= -this->movex + this->width) {
243             xmax = -this->movex+this->width;
244             if(xmin >= -this->movex + this->width) continue;
245         }
246         if(ymax >= -this->movey + this->height) {
247             ymax = -this->movey+this->height;
248             if(ymin >= -this->movey + this->height) continue;
249         }
250         
251         if((xmax-xmin)<=0 || (ymax-ymin)<=0) // no bitmap, nothing to do
252             continue;
253
254         int rangex = xmax-xmin;
255         int rangey = ymax-ymin;
256         gfximage_t*img = (gfximage_t*)malloc(sizeof(gfximage_t)); 
257         img->data = (gfxcolor_t*)malloc(rangex * rangey * 4);
258         img->width = rangex;
259         img->height = rangey;
260         int x,y;
261         for(y=0;y<rangey;y++) {
262             SplashColorPtr in=&rgb[((y+ymin)*bitmap_width+xmin)*sizeof(SplashColor)];
263             gfxcolor_t*out = &img->data[y*rangex];
264             Guchar*ain = &alpha[(y+ymin)*bitmap_width+xmin];
265             Guchar*ain2 = &alpha2[(y+ymin)*bitmap_width8];
266             if(this->emptypage) {
267                 for(x=0;x<rangex;x++) {
268                     /* the first bitmap on the page doesn't need to have an alpha channel-
269                        blend against a white background*/
270                     out[x].r = (in[x*3+0]*ain[x])/255 + 255-ain[x];
271                     out[x].g = (in[x*3+1]*ain[x])/255 + 255-ain[x];
272                     out[x].b = (in[x*3+2]*ain[x])/255 + 255-ain[x];
273                     out[x].a = 255;
274                 }
275             } else {
276                 for(x=0;x<rangex;x++) {
277                     if(!(ain2[(x+xmin)/8]&(0x80>>((x+xmin)&7)))) {
278                         /* cut away pixels that we don't remember drawing (i.e., that are
279                            not in the monochrome bitmap). Prevents some "hairlines" showing
280                            up to the left and right of bitmaps. */
281                         out[x].r = 0;out[x].g = 0;out[x].b = 0;out[x].a = 0;
282                     } else {
283                         /* according to endPage()/compositeBackground() in xpdf/SplashOutputDev.cc, this
284                            data has non-premultiplied alpha, which is exactly what the output device 
285                            expects, so don't premultiply it here, either.
286                         */
287                         out[x].r = in[x*3+0];
288                         out[x].g = in[x*3+1];
289                         out[x].b = in[x*3+2];
290                         out[x].a = ain[x];
291                     }
292                 }
293             }
294         }
295
296         /* transform bitmap rectangle to "device space" */
297         xmin += movex;
298         ymin += movey;
299         xmax += movex;
300         ymax += movey;
301
302         gfxmatrix_t m;
303         m.tx = xmin;
304         m.ty = ymin;
305         m.m00 = m.m11 = 1;
306         m.m10 = m.m01 = 0;
307         m.tx -= 0.5;
308         m.ty -= 0.5;
309
310         gfxline_t* line = gfxline_makerectangle(xmin, ymin, xmax, ymax);
311         dev->fillbitmap(dev, line, img, &m, 0);
312         gfxline_free(line);
313     
314         free(img->data);img->data=0;free(img);img=0;
315     }
316     ibbox_destroy(boxes);
317
318     memset(rgbbitmap->getAlphaPtr(), 0, rgbbitmap->getWidth()*rgbbitmap->getHeight());
319     memset(rgbbitmap->getDataPtr(), 0, rgbbitmap->getRowSize()*rgbbitmap->getHeight());
320
321     this->emptypage = 0;
322 }
323
324 void BitmapOutputDev::flushText()
325 {
326     msg("<verbose> Flushing text");
327
328     static gfxfontlist_t*output_font_list = 0;
329     static gfxdevice_t*last = 0;
330     if(last != this->dev) {
331         if(output_font_list)
332             gfxfontlist_free(output_font_list, 0);
333         output_font_list = gfxfontlist_create();
334     }
335     gfxdevice_record_flush(this->gfxoutput, this->dev, &output_font_list);
336     last = this->dev;
337     
338     this->emptypage = 0;
339 }
340
341 void writeMonoBitmap(SplashBitmap*btm, char*filename)
342 {
343     int width8 = (btm->getWidth()+7)/8;
344     int width = btm->getWidth();
345     int height = btm->getHeight();
346     gfxcolor_t*b = (gfxcolor_t*)malloc(sizeof(gfxcolor_t)*width*height);
347     unsigned char*data = btm->getDataPtr();
348     int x,y;
349     for(y=0;y<height;y++) {
350         unsigned char*l = &data[width8*y];
351         gfxcolor_t*d = &b[width*y];
352         for(x=0;x<width;x++) {
353             if(l[x>>3]&(128>>(x&7))) {
354                 d[x].r = d[x].b = d[x].a = 255;
355                 d[x].g = 0;
356             } else {
357                 d[x].r = d[x].g = d[x].b = d[x].a = 0;
358             }
359         }
360     }
361     png_write(filename, (unsigned char*)b, width, height);
362     free(b);
363 }
364
365 void writeBitmap(SplashBitmap*bitmap, char*filename)
366 {
367     int y,x;
368     
369     int width = bitmap->getWidth();
370     int height = bitmap->getHeight();
371
372     gfxcolor_t*data = (gfxcolor_t*)malloc(sizeof(gfxcolor_t)*width*height);
373
374     if(bitmap->getMode()==splashModeMono1) {
375         writeMonoBitmap(bitmap, filename);
376         return;
377     }
378
379     for(y=0;y<height;y++) {
380         gfxcolor_t*line = &data[y*width];
381         for(x=0;x<width;x++) {
382             Guchar c[4] = {0,0,0,0};
383             bitmap->getPixel(x,y,c);
384             line[x].r = c[0];
385             line[x].g = c[1];
386             line[x].b = c[2];
387             line[x].a =  bitmap->getAlpha(x,y);
388         }
389     }
390     png_write(filename, (unsigned char*)data, width, height);
391     free(data);
392 }
393
394 void writeAlpha(SplashBitmap*bitmap, char*filename)
395 {
396     int y,x;
397     
398     int width = bitmap->getWidth();
399     int height = bitmap->getHeight();
400     
401     if(bitmap->getMode()==splashModeMono1) {
402         writeMonoBitmap(bitmap, filename);
403         return;
404     }
405
406     gfxcolor_t*data = (gfxcolor_t*)malloc(sizeof(gfxcolor_t)*width*height);
407
408     for(y=0;y<height;y++) {
409         gfxcolor_t*line = &data[y*width];
410         for(x=0;x<width;x++) {
411             int a = bitmap->getAlpha(x,y);
412             line[x].r = a;
413             line[x].g = 0;
414             line[x].b = a;
415             line[x].a = a;
416         }
417     }
418     png_write(filename, (unsigned char*)data, width, height);
419     free(data);
420 }
421
422 static const char*STATE_NAME[] = {"parallel", "textabovebitmap", "bitmapabovetext"};
423
424 int checkAlphaSanity(SplashBitmap*boolbtm, SplashBitmap*alphabtm)
425 {
426     assert(boolbtm->getWidth() == alphabtm->getWidth());
427     assert(boolbtm->getHeight() == alphabtm->getHeight());
428     if(boolbtm->getMode()==splashModeMono1) {
429         return 1;
430     }
431
432     int width = boolbtm->getWidth();
433     int height = boolbtm->getHeight();
434
435     int bad=0;
436     int x,y;
437     for(y=0;y<height;y++) {
438         for(x=0;x<width;x++) {
439             int a1 = alphabtm->getAlpha(x,y);
440             int a2 = boolbtm->getAlpha(x,y);
441             if(a1!=a2) {
442                 bad++;
443             }
444         }
445     }
446     double badness = bad/(double)(width*height);
447     if(badness>0.2) {
448         msg("<error> Bitmaps don't correspond: %d out of %d pixels wrong (%.2f%%)", bad, width*height, 
449                 badness*100.0);
450         return 0;
451     }
452     msg("<notice> %f", badness);
453     return 1;
454 }
455
456 static inline GBool fixBBox(int*x1, int*y1, int*x2, int*y2, int width, int height)
457 {
458     if(!(*x1|*y1|*x2|*y2)) {
459         // undefined bbox
460         *x1 = *y1 = 0;
461         *x2 = width;
462         *y2 = height;
463         return gTrue;
464     }
465     if(*x2<=*x1) return gFalse;
466     if(*x2<0) return gFalse;
467     if(*x1<0) *x1 = 0;
468     if(*x1>=width) return gFalse;
469     if(*x2>width) *x2=width;
470
471     if(*y2<=*y1) return gFalse;
472     if(*y2<0) return gFalse;
473     if(*y1<0) *y1 = 0;
474     if(*y1>=height) return gFalse;
475     if(*y2>height) *y2=height;
476     return gTrue;
477 }
478
479 static void update_bitmap(SplashBitmap*bitmap, SplashBitmap*update, int x1, int y1, int x2, int y2, char overwrite)
480 {
481     assert(bitmap->getMode()==splashModeMono1);
482     assert(update->getMode()==splashModeMono1);
483
484     int width8 = (bitmap->getWidth()+7)/8;
485     assert(width8 == bitmap->getRowSize());
486     assert(width8 == update->getRowSize());
487     int height = bitmap->getHeight();
488     assert(height == update->getHeight());
489
490     if(!fixBBox(&x1, &y1, &x2, &y2, bitmap->getWidth(), bitmap->getHeight()))
491         return;
492     
493     Guchar*b = bitmap->getDataPtr() + y1*width8 + x1/8;
494     Guchar*u = update->getDataPtr() + y1*width8 + x1/8;
495     int yspan = y2-y1;
496     int xspan = (x2+7)/8 - x1/8;
497     int size = (y2-y1)*width8;
498
499     if(overwrite) {
500         int y;
501         for(y=0;y<yspan;y++) {
502             memcpy(b, u, xspan);
503             b += width8;
504             u += width8;
505         }
506     } else {
507         if(((ptroff_t)b&7)==((ptroff_t)u&7)) {
508             int x,y;
509             for(y=0;y<yspan;y++) {
510                 Guchar*e1 = b+xspan-8;
511                 Guchar*e2 = b+xspan;
512                 while(((ptroff_t)b&7) && b<e1) {
513                     *b |= *u;
514                     b++;u++;
515                 }
516                 while(b<e1) {
517                     *(long long*)b |= *(long long*)u;
518                     b+=8;u+=8;
519                 }
520                 while(b<e2) {
521                     *b |= *u;
522                     b++;u++;
523                 }
524                 b += width8-xspan;
525                 u += width8-xspan;
526             }
527         } else {
528             int x,y;
529             for(y=0;y<yspan;y++) {
530                 for(x=0;x<xspan;x++) {
531                     b[x] |= u[x];
532                 }
533                 b += width8;
534                 u += width8;
535             }
536         }
537     }
538 }
539
540 static void clearBooleanBitmap(SplashBitmap*btm, int x1, int y1, int x2, int y2)
541 {
542     if(!fixBBox(&x1, &y1, &x2, &y2, btm->getWidth(), btm->getHeight()))
543         return;
544     
545     if(btm->getMode()==splashModeMono1) {
546         int width8 = (btm->getWidth()+7)/8;
547         assert(width8 == btm->getRowSize());
548         int width = btm->getWidth();
549         int height = btm->getHeight();
550         Guchar*data = btm->getDataPtr();
551         memset(data+y1*width8, 0, width8*(y2-y1));
552     } else {
553         int width = btm->getAlphaRowSize();
554         int height = btm->getHeight();
555         memset(btm->getAlphaPtr(), 0, width*height);
556     }
557 }
558
559 void BitmapOutputDev::dbg_newdata(char*newdata)
560 {
561     if(0) {
562         char filename1[80];
563         char filename2[80];
564         char filename3[80];
565         sprintf(filename1, "state%03dboolbitmap_after%s.png", dbg_btm_counter, newdata);
566         sprintf(filename2, "state%03dbooltext_after%s.png", dbg_btm_counter, newdata);
567         sprintf(filename3, "state%03dbitmap_after%s.png", dbg_btm_counter, newdata);
568         msg("<verbose> %s %s %s", filename1, filename2, filename3);
569         writeAlpha(stalepolybitmap, filename1);
570         writeAlpha(booltextbitmap, filename2);
571         writeBitmap(rgbdev->getBitmap(), filename3);
572     }
573     dbg_btm_counter++;
574 }
575
576 GBool BitmapOutputDev::checkNewText(int x1, int y1, int x2, int y2)
577 {
578     /* called once some new text was drawn on booltextdev, and
579        before the same thing is drawn on gfxdev */
580    
581     msg("<trace> Testing new text data against current bitmap data, state=%s, counter=%d\n", STATE_NAME[layerstate], dbg_btm_counter);
582     
583     GBool ret = false;
584     if(intersection(booltextbitmap, stalepolybitmap, x1,y1,x2,y2)) {
585         if(layerstate==STATE_PARALLEL) {
586             /* the new text is above the bitmap. So record that fact. */
587             msg("<verbose> Text is above current bitmap/polygon data");
588             layerstate=STATE_TEXT_IS_ABOVE;
589             update_bitmap(staletextbitmap, booltextbitmap, x1, y1, x2, y2, 0);
590         } else if(layerstate==STATE_BITMAP_IS_ABOVE) {
591             /* there's a bitmap above the (old) text. So we need
592                to flush out that text, and record that the *new*
593                text is now *above* the bitmap
594              */
595             msg("<verbose> Text is above current bitmap/polygon data (which is above some other text)");
596             flushText();
597             layerstate=STATE_TEXT_IS_ABOVE;
598            
599             clearBoolTextDev();
600             /* re-apply the update (which we would otherwise lose) */
601             update_bitmap(staletextbitmap, booltextbitmap, x1, y1, x2, y2, 1);
602             ret = true;
603         } else {
604             /* we already know that the current text section is
605                above the current bitmap section- now just new
606                bitmap data *and* new text data was drawn, and
607                *again* it's above the current bitmap. */
608             msg("<verbose> Text is still above current bitmap/polygon data");
609             update_bitmap(staletextbitmap, booltextbitmap, x1, y1, x2, y2, 0);
610         }
611     }  else {
612         update_bitmap(staletextbitmap, booltextbitmap, x1, y1, x2, y2, 0);
613     }
614     
615     /* clear the thing we just drew from our temporary drawing bitmap */
616     clearBooleanBitmap(booltextbitmap, x1, y1, x2, y2);
617
618     return ret;
619 }
620 GBool BitmapOutputDev::checkNewBitmap(int x1, int y1, int x2, int y2)
621 {
622     /* similar to checkNewText() above, only in reverse */
623     msg("<trace> Testing new graphics data against current text data, state=%s, counter=%d\n", STATE_NAME[layerstate], dbg_btm_counter);
624
625     GBool ret = false;
626     if(intersection(boolpolybitmap, staletextbitmap, x1,y1,x2,y2)) {
627         if(layerstate==STATE_PARALLEL) {
628             msg("<verbose> Bitmap is above current text data");
629             layerstate=STATE_BITMAP_IS_ABOVE;
630             update_bitmap(stalepolybitmap, boolpolybitmap, x1, y1, x2, y2, 0);
631         } else if(layerstate==STATE_TEXT_IS_ABOVE) {
632             msg("<verbose> Bitmap is above current text data (which is above some bitmap)");
633             flushBitmap();
634             layerstate=STATE_BITMAP_IS_ABOVE;
635             clearBoolPolyDev();
636             update_bitmap(stalepolybitmap, boolpolybitmap, x1, y1, x2, y2, 1);
637             ret = true;
638         } else {
639             msg("<verbose> Bitmap is still above current text data");
640             update_bitmap(stalepolybitmap, boolpolybitmap, x1, y1, x2, y2, 0);
641         }
642     }  else {
643         update_bitmap(stalepolybitmap, boolpolybitmap, x1, y1, x2, y2, 0);
644     }
645     
646     /* clear the thing we just drew from our temporary drawing bitmap */
647     clearBooleanBitmap(boolpolybitmap, x1, y1, x2, y2);
648
649     return ret;
650 }
651
652 //void checkNewText() {
653 //    Guchar*alpha = rgbbitmap->getAlphaPtr();
654 //    Guchar*charpixels = clip1bitmap->getDataPtr();
655 //    int xx,yy;
656 //    for(yy=0;yy<height;yy++) {
657 //        Guchar*aline = &alpha[yy*width];
658 //        Guchar*cline = &charpixels[yy*width8];
659 //        for(xx=0;xx<width;xx++) {
660 //            int bit = xx&7;
661 //            int bytepos = xx>>3;
662 //            /* TODO: is the bit order correct? */
663 //            if(aline[xx] && (cline[bytepos]&(1<<bit))) 
664 //              break;
665 //        }
666 //        if(xx!=width)
667 //            break;
668 //}
669
670 GBool BitmapOutputDev::clip0and1differ(int x1,int y1,int x2,int y2)
671 {
672     if(clip0bitmap->getMode()==splashModeMono1) {
673         int width = clip0bitmap->getWidth();
674         int width8 = (width+7)/8;
675         int height = clip0bitmap->getHeight();
676
677         if(!fixBBox(&x1,&y1,&x2,&y2,width,height)) {
678             /* area is outside or null */
679             return gFalse;
680         }
681         
682         SplashBitmap*clip0 = clip0bitmap;
683         SplashBitmap*clip1 = clip1bitmap;
684         int x18 = x1/8;
685         int x28 = (x2+7)/8;
686         int y;
687
688         for(y=y1;y<y2;y++) {
689             unsigned char*row1 = &clip0bitmap->getDataPtr()[width8*y+x18];
690             unsigned char*row2 = &clip1bitmap->getDataPtr()[width8*y+x18];
691             if(memcmp(row1, row2, x28-x18)) {
692                 return gTrue;
693             }
694         }
695         return gFalse;
696     } else {
697         SplashBitmap*clip0 = clip0bitmap;
698         SplashBitmap*clip1 = clip1bitmap;
699         int width = clip0->getAlphaRowSize();
700         int height = clip0->getHeight();
701
702         if(!fixBBox(&x1, &y1, &x2, &y2, width, height)) {
703             x1=y1=0;x2=y2=1;
704         }
705
706         Guchar*a0 = clip0->getAlphaPtr();
707         Guchar*a1 = clip1->getAlphaPtr();
708         int x,y;
709         char differs=0;
710         for(y=y1;y<y2;y++) {
711             for(x=x1;x<x2;x++) {
712                 if(a0[y*width+x]!=a1[y*width+x]) {
713                     differs=1;
714                     break;
715                 }
716             }
717             if(differs)
718                 break;
719         }
720         char differs2 = memcmp(a0, a1, width*height);
721         if(differs && !differs2) 
722             msg("<warning> Strange internal error (2)");
723         else if(!differs && differs2) {
724             msg("<warning> Bad Bounding Box: Difference in clip0 and clip1 outside bbox");
725             msg("<warning> %d %d %d %d", x1, y1, x2, y2);
726         }
727         return differs2;
728     }
729 }
730
731 GBool compare8(unsigned char*data1, unsigned char*data2, int len)
732 {
733     if(!len)
734         return 0;
735     if(((ptroff_t)data1&7)==((ptroff_t)data2&7)) {
736         // oh good, we can align both to 8 byte
737         while((ptroff_t)data1&7) {
738             if(*data1&*data2)
739                 return 1;
740             data1++;
741             data2++;
742             if(!--len)
743                 return 0;
744         }
745     }
746     /* use 64 bit for the (hopefully aligned) middle section */
747     int l8 = len/8;
748     long long unsigned int*d1 = (long long unsigned int*)data1;
749     long long unsigned int*d2 = (long long unsigned int*)data2;
750     long long unsigned int x = 0;
751     int t;
752     for(t=0;t<l8;t++) {
753         x |= d1[t]&d2[t];
754     }
755     if(x)
756         return 1;
757
758     data1+=l8*8;
759     data2+=l8*8;
760     len -= l8*8;
761     for(t=0;t<len;t++) {
762         if(data1[t]&data2[t]) {
763             return 1;
764         }
765     }
766     return 0;
767 }
768
769 GBool BitmapOutputDev::intersection(SplashBitmap*boolpoly, SplashBitmap*booltext, int x1, int y1, int x2, int y2)
770 {
771     if(boolpoly->getMode()==splashModeMono1) {
772         /* alternative implementation, using one bit per pixel-
773            needs the no-dither patch in xpdf */
774         
775         int width = boolpoly->getWidth();
776         int height = boolpoly->getHeight();
777
778         if(!fixBBox(&x1,&y1,&x2,&y2, width, height)) {
779             return gFalse;
780         }
781
782         Guchar*polypixels = boolpoly->getDataPtr();
783         Guchar*textpixels = booltext->getDataPtr();
784
785         int width8 = (width+7)/8;
786         int runx = width8;
787         int runy = height;
788         
789         if(x1|y1|x2|y2) {
790             polypixels+=y1*width8+x1/8;
791             textpixels+=y1*width8+x1/8;
792             runx=(x2+7)/8 - x1/8;
793             runy=y2-y1;
794         }
795         
796         int t;
797         unsigned char c=0;
798         
799         /*assert(sizeof(unsigned long long int)==8);
800         if(((ptroff_t)polypixels&7) || ((ptroff_t)textpixels&7)) {
801             //msg("<warning> Non-optimal alignment");
802         }*/
803
804         int x,y;
805         unsigned char*data1 = (unsigned char*)polypixels;
806         unsigned char*data2 = (unsigned char*)textpixels;
807         msg("<verbose> Testing area (%d,%d,%d,%d), runx=%d,runy=%d", x1,y1,x2,y2, runx, runy);
808         for(y=0;y<runy;y++) {
809             if(compare8(data1,data2,runx))
810                 return gTrue;
811             data1+=width8;
812             data2+=width8;
813         }
814         return gFalse;
815     } else {
816         int width = boolpoly->getAlphaRowSize();
817         int height = boolpoly->getHeight();
818
819         if(!fixBBox(&x1, &y1, &x2, &y2, width, height)) {
820             x1=y1=0;x2=y2=1;
821         }
822         Guchar*polypixels = boolpoly->getAlphaPtr();
823         Guchar*textpixels = booltext->getAlphaPtr();
824
825         int x,y;
826         char overlap1 = 0;
827         char overlap2 = 0;
828         for(x=x1;x<x2;x++) {
829             for(y=y1;y<y2;y++) {
830                 if(polypixels[width*y+x]&&textpixels[width*y+x])
831                     overlap1 = 1;
832             }
833         }
834         int ax1=0,ay1=0,ax2=0,ay2=0;
835         for(y=0;y<height;y++) {
836             for(x=0;x<width;x++) {
837                 if(polypixels[width*y+x]&&textpixels[width*y+x]) {
838                     overlap2 = 1;
839                     if(!(ax1|ay1|ax2|ay2)) {
840                         ax1 = ax2 = x;
841                         ay1 = ay2 = y;
842                     } else {
843                         ax1 = ax1<x?ax1:x;
844                         ay1 = ay1<y?ay1:y;
845                         ax2 = ax2>x?ax2:x;
846                         ay2 = ay2>y?ay2:y;
847                     }
848                 }
849             }
850         }
851         if(overlap1 && !overlap2)
852             msg("<warning> strange internal error");
853         if(!overlap1 && overlap2) {
854             msg("<warning> Bad bounding box: intersection outside bbox");
855             msg("<warning> given bbox: %d %d %d %d", x1, y1, x2, y2);
856             msg("<warning> changed area: %d %d %d %d", ax1, ay1, ax2, ay2);
857         }
858         return overlap2;
859     }
860 }
861
862 GBool BitmapOutputDev::checkPageSlice(Page *page, double hDPI, double vDPI,
863              int rotate, GBool useMediaBox, GBool crop,
864              int sliceX, int sliceY, int sliceW, int sliceH,
865              GBool printing, Catalog *catalog,
866              GBool (*abortCheckCbk)(void *data),
867              void *abortCheckCbkData)
868 {
869     this->setPage(page);
870     gfxdev->setPage(page);
871     return gTrue;
872 }
873
874 void BitmapOutputDev::startPage(int pageNum, GfxState *state)
875 {
876     PDFRectangle *r = this->page->getCropBox();
877     double x1,y1,x2,y2;
878     state->transform(r->x1,r->y1,&x1,&y1);
879     state->transform(r->x2,r->y2,&x2,&y2);
880     if(x2<x1) {double x3=x1;x1=x2;x2=x3;}
881     if(y2<y1) {double y3=y1;y1=y2;y2=y3;}
882     
883     this->movex = -(int)x1 - user_movex;
884     this->movey = -(int)y1 - user_movey;
885     
886     if(user_clipx1|user_clipy1|user_clipx2|user_clipy2) {
887         x1 = user_clipx1;
888         x2 = user_clipx2;
889         y1 = user_clipy1;
890         y2 = user_clipy2;
891     }
892     this->width = (int)(x2-x1);
893     this->height = (int)(y2-y1);
894
895     rgbdev->startPage(pageNum, state);
896     boolpolydev->startPage(pageNum, state);
897     booltextdev->startPage(pageNum, state);
898     clip0dev->startPage(pageNum, state);
899     clip1dev->startPage(pageNum, state);
900     gfxdev->startPage(pageNum, state);
901
902     boolpolybitmap = boolpolydev->getBitmap();
903     stalepolybitmap = new SplashBitmap(boolpolybitmap->getWidth(), boolpolybitmap->getHeight(), 1, boolpolybitmap->getMode(), 0);
904     assert(stalepolybitmap->getRowSize() == boolpolybitmap->getRowSize());
905
906     booltextbitmap = booltextdev->getBitmap();
907     staletextbitmap = new SplashBitmap(booltextbitmap->getWidth(), booltextbitmap->getHeight(), 1, booltextbitmap->getMode(), 0);
908     assert(staletextbitmap->getRowSize() == booltextbitmap->getRowSize());
909     
910     msg("<debug> startPage %dx%d (%dx%d)", this->width, this->height, booltextbitmap->getWidth(), booltextbitmap->getHeight());
911
912     clip0bitmap = clip0dev->getBitmap();
913     clip1bitmap = clip1dev->getBitmap();
914     rgbbitmap = rgbdev->getBitmap();
915     
916     flushText(); // write out the initial clipping rectangle
917
918     /* just in case any device did draw a white background rectangle 
919        into the device */
920     clearBoolTextDev();
921     clearBoolPolyDev();
922
923     this->layerstate = STATE_PARALLEL;
924     this->emptypage = 1;
925     msg("<debug> startPage done");
926 }
927
928 void BitmapOutputDev::endPage()
929 {
930     msg("<verbose> endPage (BitmapOutputDev)");
931
932     /* notice: we're not fully done yet with this page- there might still be 
933        a few calls to drawLink() yet to come */
934 }
935 void BitmapOutputDev::finishPage()
936 {
937     msg("<verbose> finishPage (BitmapOutputDev)");
938     gfxdev->endPage();
939    
940     flushEverything();
941
942     /* splash will now destroy alpha, and paint the 
943        background color into the "holes" in the bitmap */
944     boolpolydev->endPage();
945     booltextdev->endPage();
946     rgbdev->endPage();
947     clip0dev->endPage();
948     clip1dev->endPage();
949 }
950
951 GBool BitmapOutputDev::upsideDown()
952 {
953     boolpolydev->upsideDown();
954     booltextdev->upsideDown();
955     clip0dev->upsideDown();
956     clip1dev->upsideDown();
957     return rgbdev->upsideDown();
958 }
959
960 GBool BitmapOutputDev::useDrawChar()
961 {
962     boolpolydev->useDrawChar();
963     booltextdev->useDrawChar();
964     clip0dev->useDrawChar();
965     clip1dev->useDrawChar();
966     return rgbdev->useDrawChar();
967 }
968
969 GBool BitmapOutputDev::useTilingPatternFill()
970 {
971     boolpolydev->useTilingPatternFill();
972     booltextdev->useTilingPatternFill();
973     clip0dev->useTilingPatternFill();
974     clip1dev->useTilingPatternFill();
975     return rgbdev->useTilingPatternFill();
976 }
977
978 GBool BitmapOutputDev::useShadedFills()
979 {
980     boolpolydev->useShadedFills();
981     booltextdev->useShadedFills();
982     clip0dev->useShadedFills();
983     clip1dev->useShadedFills();
984     return rgbdev->useShadedFills();
985 }
986
987 GBool BitmapOutputDev::useDrawForm()
988 {
989     boolpolydev->useDrawForm();
990     booltextdev->useDrawForm();
991     clip0dev->useDrawForm();
992     clip1dev->useDrawForm();
993     return rgbdev->useDrawForm();
994 }
995
996 GBool BitmapOutputDev::interpretType3Chars()
997 {
998     boolpolydev->interpretType3Chars();
999     booltextdev->interpretType3Chars();
1000     clip0dev->interpretType3Chars();
1001     clip1dev->interpretType3Chars();
1002     return rgbdev->interpretType3Chars();
1003 }
1004
1005 GBool BitmapOutputDev::needNonText() 
1006 {
1007     boolpolydev->needNonText();
1008     booltextdev->needNonText();
1009     clip0dev->needNonText();
1010     clip1dev->needNonText();
1011     return rgbdev->needNonText();
1012 }
1013 void BitmapOutputDev::setDefaultCTM(double *ctm) 
1014 {
1015     boolpolydev->setDefaultCTM(ctm);
1016     booltextdev->setDefaultCTM(ctm);
1017     rgbdev->setDefaultCTM(ctm);
1018     clip0dev->setDefaultCTM(ctm);
1019     clip1dev->setDefaultCTM(ctm);
1020     gfxdev->setDefaultCTM(ctm);
1021 }
1022 void BitmapOutputDev::saveState(GfxState *state) 
1023 {
1024     boolpolydev->saveState(state);
1025     booltextdev->saveState(state);
1026     rgbdev->saveState(state);
1027     clip0dev->saveState(state);
1028     clip1dev->saveState(state);
1029
1030     /*ClipState*cstate = new ClipState();
1031     cstate->next = this->clipstates;
1032     this->clipstates = cstate;*/
1033 }
1034 void BitmapOutputDev::restoreState(GfxState *state) 
1035 {
1036     boolpolydev->restoreState(state);
1037     booltextdev->restoreState(state);
1038     rgbdev->restoreState(state);
1039     clip0dev->restoreState(state);
1040     clip1dev->restoreState(state);
1041
1042     /*if(this->clipstates) {
1043         ClipState*old = this->clipstates;
1044         if(old->written) {
1045             gfxdev->restoreState(state);
1046         }
1047         this->clipstates = this->clipstates->next;
1048         delete(old);
1049     } else {
1050         msg("<error> invalid restoreState()");
1051     }*/
1052 }
1053 void BitmapOutputDev::updateAll(GfxState *state)
1054 {
1055     boolpolydev->updateAll(state);
1056     booltextdev->updateAll(state);
1057     rgbdev->updateAll(state);
1058     clip0dev->updateAll(state);
1059     clip1dev->updateAll(state);
1060     gfxdev->updateAll(state);
1061 }
1062 void BitmapOutputDev::updateCTM(GfxState *state, double m11, double m12, double m21, double m22, double m31, double m32)
1063 {
1064     boolpolydev->updateCTM(state,m11,m12,m21,m22,m31,m32);
1065     booltextdev->updateCTM(state,m11,m12,m21,m22,m31,m32);
1066     rgbdev->updateCTM(state,m11,m12,m21,m22,m31,m32);
1067     clip0dev->updateCTM(state,m11,m12,m21,m22,m31,m32);
1068     clip1dev->updateCTM(state,m11,m12,m21,m22,m31,m32);
1069     gfxdev->updateCTM(state,m11,m12,m21,m22,m31,m32);
1070 }
1071 void BitmapOutputDev::updateLineDash(GfxState *state)
1072 {
1073     boolpolydev->updateLineDash(state);
1074     booltextdev->updateLineDash(state);
1075     rgbdev->updateLineDash(state);
1076     clip0dev->updateLineDash(state);
1077     clip1dev->updateLineDash(state);
1078     gfxdev->updateLineDash(state);
1079 }
1080 void BitmapOutputDev::updateFlatness(GfxState *state)
1081 {
1082     boolpolydev->updateFlatness(state);
1083     booltextdev->updateFlatness(state);
1084     rgbdev->updateFlatness(state);
1085     clip0dev->updateFlatness(state);
1086     clip1dev->updateFlatness(state);
1087     gfxdev->updateFlatness(state);
1088 }
1089 void BitmapOutputDev::updateLineJoin(GfxState *state)
1090 {
1091     boolpolydev->updateLineJoin(state);
1092     booltextdev->updateLineJoin(state);
1093     rgbdev->updateLineJoin(state);
1094     clip0dev->updateLineJoin(state);
1095     clip1dev->updateLineJoin(state);
1096     gfxdev->updateLineJoin(state);
1097 }
1098 void BitmapOutputDev::updateLineCap(GfxState *state)
1099 {
1100     boolpolydev->updateLineCap(state);
1101     booltextdev->updateLineCap(state);
1102     rgbdev->updateLineCap(state);
1103     clip0dev->updateLineCap(state);
1104     clip1dev->updateLineCap(state);
1105     gfxdev->updateLineCap(state);
1106 }
1107 void BitmapOutputDev::updateMiterLimit(GfxState *state)
1108 {
1109     boolpolydev->updateMiterLimit(state);
1110     booltextdev->updateMiterLimit(state);
1111     rgbdev->updateMiterLimit(state);
1112     clip0dev->updateMiterLimit(state);
1113     clip1dev->updateMiterLimit(state);
1114     gfxdev->updateMiterLimit(state);
1115 }
1116 void BitmapOutputDev::updateLineWidth(GfxState *state)
1117 {
1118     boolpolydev->updateLineWidth(state);
1119     booltextdev->updateLineWidth(state);
1120     rgbdev->updateLineWidth(state);
1121     clip0dev->updateLineWidth(state);
1122     clip1dev->updateLineWidth(state);
1123     gfxdev->updateLineWidth(state);
1124 }
1125 void BitmapOutputDev::updateStrokeAdjust(GfxState *state)
1126 {
1127     boolpolydev->updateStrokeAdjust(state);
1128     booltextdev->updateStrokeAdjust(state);
1129     rgbdev->updateStrokeAdjust(state);
1130     clip0dev->updateStrokeAdjust(state);
1131     clip1dev->updateStrokeAdjust(state);
1132     gfxdev->updateStrokeAdjust(state);
1133 }
1134 void BitmapOutputDev::updateFillColorSpace(GfxState *state)
1135 {
1136     boolpolydev->updateFillColorSpace(state);
1137     booltextdev->updateFillColorSpace(state);
1138     rgbdev->updateFillColorSpace(state);
1139     clip0dev->updateFillColorSpace(state);
1140     clip1dev->updateFillColorSpace(state);
1141     gfxdev->updateFillColorSpace(state);
1142 }
1143 void BitmapOutputDev::updateStrokeColorSpace(GfxState *state)
1144 {
1145     boolpolydev->updateStrokeColorSpace(state);
1146     booltextdev->updateStrokeColorSpace(state);
1147     rgbdev->updateStrokeColorSpace(state);
1148     clip0dev->updateStrokeColorSpace(state);
1149     clip1dev->updateStrokeColorSpace(state);
1150     gfxdev->updateStrokeColorSpace(state);
1151 }
1152 void BitmapOutputDev::updateFillColor(GfxState *state)
1153 {
1154     boolpolydev->updateFillColor(state);
1155     booltextdev->updateFillColor(state);
1156     rgbdev->updateFillColor(state);
1157     clip0dev->updateFillColor(state);
1158     clip1dev->updateFillColor(state);
1159     gfxdev->updateFillColor(state);
1160 }
1161 void BitmapOutputDev::updateStrokeColor(GfxState *state)
1162 {
1163     boolpolydev->updateStrokeColor(state);
1164     booltextdev->updateStrokeColor(state);
1165     rgbdev->updateStrokeColor(state);
1166     clip0dev->updateStrokeColor(state);
1167     clip1dev->updateStrokeColor(state);
1168     gfxdev->updateStrokeColor(state);
1169 }
1170 void BitmapOutputDev::updateBlendMode(GfxState *state)
1171 {
1172     boolpolydev->updateBlendMode(state);
1173     booltextdev->updateBlendMode(state);
1174     rgbdev->updateBlendMode(state);
1175     clip0dev->updateBlendMode(state);
1176     clip1dev->updateBlendMode(state);
1177     gfxdev->updateBlendMode(state);
1178 }
1179 void BitmapOutputDev::updateFillOpacity(GfxState *state)
1180 {
1181     boolpolydev->updateFillOpacity(state);
1182     booltextdev->updateFillOpacity(state);
1183     rgbdev->updateFillOpacity(state);
1184     clip0dev->updateFillOpacity(state);
1185     clip1dev->updateFillOpacity(state);
1186     gfxdev->updateFillOpacity(state);
1187 }
1188 void BitmapOutputDev::updateStrokeOpacity(GfxState *state)
1189 {
1190     boolpolydev->updateStrokeOpacity(state);
1191     booltextdev->updateStrokeOpacity(state);
1192     rgbdev->updateStrokeOpacity(state);
1193     clip0dev->updateStrokeOpacity(state);
1194     clip1dev->updateStrokeOpacity(state);
1195     gfxdev->updateStrokeOpacity(state);
1196 }
1197 void BitmapOutputDev::updateFillOverprint(GfxState *state)
1198 {
1199     boolpolydev->updateFillOverprint(state);
1200     booltextdev->updateFillOverprint(state);
1201     rgbdev->updateFillOverprint(state);
1202     clip0dev->updateFillOverprint(state);
1203     clip1dev->updateFillOverprint(state);
1204     gfxdev->updateFillOverprint(state);
1205 }
1206 void BitmapOutputDev::updateStrokeOverprint(GfxState *state)
1207 {
1208     boolpolydev->updateStrokeOverprint(state);
1209     booltextdev->updateStrokeOverprint(state);
1210     rgbdev->updateStrokeOverprint(state);
1211     clip0dev->updateStrokeOverprint(state);
1212     clip1dev->updateStrokeOverprint(state);
1213     gfxdev->updateStrokeOverprint(state);
1214 }
1215 void BitmapOutputDev::updateTransfer(GfxState *state)
1216 {
1217     boolpolydev->updateTransfer(state);
1218     booltextdev->updateTransfer(state);
1219     rgbdev->updateTransfer(state);
1220     clip0dev->updateTransfer(state);
1221     clip1dev->updateTransfer(state);
1222     gfxdev->updateTransfer(state);
1223 }
1224
1225 void BitmapOutputDev::updateFont(GfxState *state)
1226 {
1227     boolpolydev->updateFont(state);
1228     booltextdev->updateFont(state);
1229     rgbdev->updateFont(state);
1230     clip0dev->updateFont(state);
1231     clip1dev->updateFont(state);
1232     gfxdev->updateFont(state);
1233 }
1234 void BitmapOutputDev::updateTextMat(GfxState *state)
1235 {
1236     boolpolydev->updateTextMat(state);
1237     booltextdev->updateTextMat(state);
1238     rgbdev->updateTextMat(state);
1239     clip0dev->updateTextMat(state);
1240     clip1dev->updateTextMat(state);
1241     gfxdev->updateTextMat(state);
1242 }
1243 void BitmapOutputDev::updateCharSpace(GfxState *state)
1244 {
1245     boolpolydev->updateCharSpace(state);
1246     booltextdev->updateCharSpace(state);
1247     rgbdev->updateCharSpace(state);
1248     clip0dev->updateCharSpace(state);
1249     clip1dev->updateCharSpace(state);
1250     gfxdev->updateCharSpace(state);
1251 }
1252 void BitmapOutputDev::updateRender(GfxState *state)
1253 {
1254     boolpolydev->updateRender(state);
1255     booltextdev->updateRender(state);
1256     rgbdev->updateRender(state);
1257     clip0dev->updateRender(state);
1258     clip1dev->updateRender(state);
1259     gfxdev->updateRender(state);
1260 }
1261 void BitmapOutputDev::updateRise(GfxState *state)
1262 {
1263     boolpolydev->updateRise(state);
1264     booltextdev->updateRise(state);
1265     rgbdev->updateRise(state);
1266     clip0dev->updateRise(state);
1267     clip1dev->updateRise(state);
1268     gfxdev->updateRise(state);
1269 }
1270 void BitmapOutputDev::updateWordSpace(GfxState *state)
1271 {
1272     boolpolydev->updateWordSpace(state);
1273     booltextdev->updateWordSpace(state);
1274     rgbdev->updateWordSpace(state);
1275     clip0dev->updateWordSpace(state);
1276     clip1dev->updateWordSpace(state);
1277     gfxdev->updateWordSpace(state);
1278 }
1279 void BitmapOutputDev::updateHorizScaling(GfxState *state)
1280 {
1281     boolpolydev->updateHorizScaling(state);
1282     booltextdev->updateHorizScaling(state);
1283     rgbdev->updateHorizScaling(state);
1284     clip0dev->updateHorizScaling(state);
1285     clip1dev->updateHorizScaling(state);
1286     gfxdev->updateHorizScaling(state);
1287 }
1288 void BitmapOutputDev::updateTextPos(GfxState *state)
1289 {
1290     boolpolydev->updateTextPos(state);
1291     booltextdev->updateTextPos(state);
1292     rgbdev->updateTextPos(state);
1293     clip0dev->updateTextPos(state);
1294     clip1dev->updateTextPos(state);
1295     gfxdev->updateTextPos(state);
1296 }
1297 void BitmapOutputDev::updateTextShift(GfxState *state, double shift)
1298 {
1299     boolpolydev->updateTextShift(state, shift);
1300     booltextdev->updateTextShift(state, shift);
1301     rgbdev->updateTextShift(state, shift);
1302     clip0dev->updateTextShift(state, shift);
1303     clip1dev->updateTextShift(state, shift);
1304     gfxdev->updateTextShift(state, shift);
1305 }
1306
1307 double max(double x, double y) 
1308 {
1309     return x>y?x:y;
1310 }
1311 double min(double x, double y) 
1312 {
1313     return x<y?x:y;
1314 }
1315
1316 gfxbbox_t BitmapOutputDev::getBBox(GfxState*state)
1317 {
1318     GfxPath * path = state->getPath();
1319     int num = path->getNumSubpaths();
1320     gfxbbox_t bbox = {0,0,1,1};
1321     char valid=0;
1322     int t;
1323     for(t = 0; t < num; t++) {
1324         GfxSubpath *subpath = path->getSubpath(t);
1325         int subnum = subpath->getNumPoints();
1326         int s;
1327         for(s=0;s<subnum;s++) {
1328            double x,y;
1329            state->transform(subpath->getX(s),subpath->getY(s),&x,&y);
1330            if(!valid) {
1331                bbox.xmin = x; bbox.ymin = y;
1332                bbox.xmax = x; bbox.ymax = y;
1333                valid = 1;
1334            } else {
1335                bbox.xmin = min(bbox.xmin, x);
1336                bbox.ymin = min(bbox.ymin, y);
1337                bbox.xmax = max(bbox.xmax, x);
1338                bbox.ymax = max(bbox.ymax, y);
1339            }
1340         }
1341     }
1342     return bbox;
1343 }
1344
1345 void BitmapOutputDev::stroke(GfxState *state)
1346 {
1347     msg("<debug> stroke");
1348     boolpolydev->stroke(state);
1349     gfxbbox_t bbox = getBBox(state);
1350     double width = state->getTransformedLineWidth();
1351     bbox.xmin -= width; bbox.ymin -= width;
1352     bbox.xmax += width; bbox.ymax += width;
1353     checkNewBitmap(bbox.xmin, bbox.ymin, ceil(bbox.xmax), ceil(bbox.ymax));
1354     rgbdev->stroke(state);
1355     dbg_newdata("stroke");
1356 }
1357
1358 extern gfxcolor_t getFillColor(GfxState * state);
1359
1360 char area_is_plain_colored(GfxState*state, SplashBitmap*boolpoly, SplashBitmap*rgbbitmap, int x1, int y1, int x2, int y2)
1361 {
1362     int width = boolpoly->getWidth();
1363     int height = boolpoly->getHeight();
1364     if(!fixBBox(&x1, &y1, &x2, &y2, width, height)) {
1365         return 0;
1366     }
1367     gfxcolor_t color = getFillColor(state);
1368     SplashColorPtr rgb = rgbbitmap->getDataPtr() 
1369                        + (y1*width+x1)*sizeof(SplashColor);
1370     int width8 = (width+7)/8;
1371     unsigned char*bits = (unsigned char*)boolpoly->getDataPtr() 
1372                          + (y1*width8+x1);
1373     int x,y;
1374     int w = x2-x1;
1375     int h = y2-y1;
1376     for(y=0;y<h;y++) {
1377         for(x=0;x<w;x++) {
1378             if(rgb[x*3+0] != color.r ||
1379                rgb[x*3+1] != color.g ||
1380                rgb[x*3+2] != color.b)
1381                 return 0;
1382         }
1383         rgb += width*sizeof(SplashColor);
1384     }
1385     return 1;
1386 }
1387
1388 void BitmapOutputDev::fill(GfxState *state)
1389 {
1390     msg("<debug> fill");
1391     boolpolydev->fill(state);
1392     gfxbbox_t bbox = getBBox(state);
1393     if(config_optimizeplaincolorfills) {
1394         if(area_is_plain_colored(state, boolpolybitmap, rgbbitmap, bbox.xmin, bbox.ymin, bbox.xmax, bbox.ymax)) {
1395             return;
1396         }
1397     }
1398     checkNewBitmap(bbox.xmin, bbox.ymin, ceil(bbox.xmax), ceil(bbox.ymax));
1399     rgbdev->fill(state);
1400     dbg_newdata("fill");
1401 }
1402 void BitmapOutputDev::eoFill(GfxState *state)
1403 {
1404     msg("<debug> eoFill");
1405     boolpolydev->eoFill(state);
1406     gfxbbox_t bbox = getBBox(state);
1407     checkNewBitmap(bbox.xmin, bbox.ymin, ceil(bbox.xmax), ceil(bbox.ymax));
1408     rgbdev->eoFill(state);
1409     dbg_newdata("eofill");
1410 }
1411
1412 POPPLER_TILING_PATERN_RETURN BitmapOutputDev::tilingPatternFill(GfxState *state, POPPLER_TILING_PATERN_GFX Object *str,
1413                                int paintType, Dict *resDict,
1414                                double *mat, double *bbox,
1415                                int x0, int y0, int x1, int y1,
1416                                double xStep, double yStep) 
1417 {
1418     msg("<debug> tilingPatternFill");
1419     boolpolydev->tilingPatternFill(state, POPPLER_TILING_PATERN_GFX_ARG str, paintType, resDict, mat,
1420                                    bbox, x0, y0, x1, y1, xStep, yStep);
1421     checkNewBitmap(UNKNOWN_BOUNDING_BOX);
1422     rgbdev->tilingPatternFill(state, POPPLER_TILING_PATERN_GFX_ARG str, paintType, resDict, mat,
1423                               bbox, x0, y0, x1, y1, xStep, yStep);
1424     dbg_newdata("tilingpatternfill");
1425 #ifdef HAVE_POPPLER
1426     return gTrue;
1427 #endif
1428 }
1429
1430 GBool BitmapOutputDev::functionShadedFill(GfxState *state, GfxFunctionShading *shading) 
1431 {
1432     msg("<debug> functionShadedFill");
1433     boolpolydev->functionShadedFill(state, shading);
1434     checkNewBitmap(UNKNOWN_BOUNDING_BOX);
1435     return rgbdev->functionShadedFill(state, shading);
1436 }
1437 GBool BitmapOutputDev::axialShadedFill(GfxState *state, GfxAxialShading *shading)
1438 {
1439     msg("<debug> axialShadedFill");
1440     boolpolydev->axialShadedFill(state, shading);
1441     checkNewBitmap(UNKNOWN_BOUNDING_BOX);
1442     return rgbdev->axialShadedFill(state, shading);
1443 }
1444 GBool BitmapOutputDev::radialShadedFill(GfxState *state, GfxRadialShading *shading)
1445 {
1446     msg("<debug> radialShadedFill");
1447     boolpolydev->radialShadedFill(state, shading);
1448     checkNewBitmap(UNKNOWN_BOUNDING_BOX);
1449     return rgbdev->radialShadedFill(state, shading);
1450 }
1451
1452 SplashColor black = {0,0,0};
1453 SplashColor white = {255,255,255};
1454
1455 void BitmapOutputDev::clip(GfxState *state)
1456 {
1457     msg("<debug> clip");
1458     boolpolydev->clip(state);
1459     booltextdev->clip(state);
1460     rgbdev->clip(state);
1461     clip1dev->clip(state);
1462 }
1463 void BitmapOutputDev::eoClip(GfxState *state)
1464 {
1465     msg("<debug> eoClip");
1466     boolpolydev->eoClip(state);
1467     booltextdev->eoClip(state);
1468     rgbdev->eoClip(state);
1469     clip1dev->eoClip(state);
1470 }
1471 void BitmapOutputDev::clipToStrokePath(GfxState *state)
1472 {
1473     msg("<debug> clipToStrokePath");
1474     boolpolydev->clipToStrokePath(state);
1475     booltextdev->clipToStrokePath(state);
1476     rgbdev->clipToStrokePath(state);
1477     clip1dev->clipToStrokePath(state);
1478 }
1479
1480 void BitmapOutputDev::beginStringOp(GfxState *state)
1481 {
1482     msg("<debug> beginStringOp");
1483     clip0dev->beginStringOp(state);
1484     clip1dev->beginStringOp(state);
1485     booltextdev->beginStringOp(state);
1486     gfxdev->beginStringOp(state);
1487 }
1488 void BitmapOutputDev::beginString(GfxState *state, GString *s)
1489 {
1490     msg("<debug> beginString");
1491     clip0dev->beginString(state, s);
1492     clip1dev->beginString(state, s);
1493     booltextdev->beginString(state, s);
1494     gfxdev->beginString(state, s);
1495 }
1496
1497 void BitmapOutputDev::clearClips()
1498 {
1499     clearBooleanBitmap(clip0bitmap, 0, 0, 0, 0);
1500     clearBooleanBitmap(clip1bitmap, 0, 0, 0, 0);
1501 }
1502 void BitmapOutputDev::clearBoolPolyDev()
1503 {
1504     clearBooleanBitmap(stalepolybitmap, 0, 0, stalepolybitmap->getWidth(), stalepolybitmap->getHeight());
1505 }
1506 void BitmapOutputDev::clearBoolTextDev()
1507 {
1508     clearBooleanBitmap(staletextbitmap, 0, 0, staletextbitmap->getWidth(), staletextbitmap->getHeight());
1509 }
1510 void BitmapOutputDev::drawChar(GfxState *state, double x, double y,
1511                       double dx, double dy,
1512                       double originX, double originY,
1513                       CharCode code, int nBytes, Unicode *u, int uLen)
1514 {
1515     msg("<debug> drawChar render=%d", state->getRender());
1516
1517     if(state->getRender()&RENDER_CLIP) {
1518         //char is just a clipping boundary
1519         rgbdev->drawChar(state, x, y, dx, dy, originX, originY, code, nBytes, u, uLen);
1520         boolpolydev->drawChar(state, x, y, dx, dy, originX, originY, code, nBytes, u, uLen);
1521         booltextdev->drawChar(state, x, y, dx, dy, originX, originY, code, nBytes, u, uLen);
1522         clip1dev->drawChar(state, x, y, dx, dy, originX, originY, code, nBytes, u, uLen);
1523     } else if(state->getRender()&RENDER_STROKE) {
1524         // we're drawing as stroke
1525         boolpolydev->drawChar(state, x, y, dx, dy, originX, originY, code, nBytes, u, uLen);
1526         rgbdev->drawChar(state, x, y, dx, dy, originX, originY, code, nBytes, u, uLen);
1527     } else if(rgbbitmap != rgbdev->getBitmap()) {
1528         // we're doing softmasking or transparency grouping
1529         boolpolydev->drawChar(state, x, y, dx, dy, originX, originY, code, nBytes, u, uLen);
1530         rgbdev->drawChar(state, x, y, dx, dy, originX, originY, code, nBytes, u, uLen);
1531     } else {
1532         // we're drawing a regular char
1533         clearClips();
1534         clip0dev->drawChar(state, x, y, dx, dy, originX, originY, code, nBytes, u, uLen);
1535         clip1dev->drawChar(state, x, y, dx, dy, originX, originY, code, nBytes, u, uLen);
1536    
1537         /* calculate the bbox of this character */
1538         int x1 = (int)x, x2 = (int)x+1, y1 = (int)y, y2 = (int)y+1;
1539         SplashFont*font = clip0dev->getCurrentFont();
1540         SplashPath*path = font?font->getGlyphPath(code):NULL;
1541         x-=originX;
1542         y-=originY;
1543         if(path) {
1544             path->offset((SplashCoord)x, (SplashCoord)y);
1545             int t;
1546             for(t=0;t<path->getLength();t++) {
1547                 double xx,yy;
1548                 Guchar f;
1549                 path->getPoint(t,&xx,&yy,&f);
1550                 state->transform(xx,yy,&xx,&yy);
1551                 if(xx<x1) x1=(int)xx;
1552                 if(yy<y1) y1=(int)yy;
1553                 if(xx>=x2) x2=(int)xx+1;
1554                 if(yy>=y2) y2=(int)yy+1;
1555             }
1556             delete(path);path=0;
1557         }
1558
1559         /* if this character is affected somehow by the various clippings (i.e., it looks
1560            different on a device without clipping), then draw it on the bitmap, not as
1561            text */
1562         if(clip0and1differ(x1,y1,x2,y2)) {
1563             msg("<verbose> Char %d is affected by clipping", code);
1564             boolpolydev->drawChar(state, x, y, dx, dy, originX, originY, code, nBytes, u, uLen);
1565             checkNewBitmap(x1,y1,x2,y2);
1566             rgbdev->drawChar(state, x, y, dx, dy, originX, originY, code, nBytes, u, uLen);
1567             if(config_extrafontdata) {
1568                 int oldrender = state->getRender();
1569                 state->setRender(3); //invisible
1570                 gfxdev->drawChar(state, x, y, dx, dy, originX, originY, code, nBytes, u, uLen);
1571                 state->setRender(oldrender);
1572             }
1573         } else {
1574
1575             /* this char is not at all affected by clipping. 
1576                Now just dump out the bitmap we're currently working on, if necessary. */
1577             booltextdev->drawChar(state, x, y, dx, dy, originX, originY, code, nBytes, u, uLen);
1578             checkNewText(x1,y1,x2,y2);
1579             /* use polygonal output device to do the actual text handling */
1580             gfxdev->drawChar(state, x, y, dx, dy, originX, originY, code, nBytes, u, uLen);
1581         }
1582     }
1583     dbg_newdata("text");
1584 }
1585 void BitmapOutputDev::drawString(GfxState *state, GString *s)
1586 {
1587     msg("<error> internal error: drawString not implemented");
1588     return;
1589 }
1590 void BitmapOutputDev::endTextObject(GfxState *state)
1591 {
1592     msg("<debug> endTextObject");
1593     rgbdev->endTextObject(state);
1594     clip0dev->endTextObject(state);
1595     clip1dev->endTextObject(state);
1596     booltextdev->endTextObject(state);
1597     /* the only thing "drawn" here is clipping */
1598     //checkNewText(UNKNOWN_BOUNDING_BOX);
1599     gfxdev->endTextObject(state);
1600     dbg_newdata("endtextobject");
1601 }
1602 void BitmapOutputDev::endString(GfxState *state)
1603 {
1604     msg("<debug> endString");
1605     clip0dev->endString(state);
1606     clip1dev->endString(state);
1607     booltextdev->endString(state);
1608     int render = state->getRender();
1609     if(render != RENDER_INVISIBLE && render != RENDER_FILL) {
1610         /* xpdf draws things like stroke text or fill+stroke text in the
1611            endString() method */
1612         checkNewText(UNKNOWN_BOUNDING_BOX);
1613     }
1614     gfxdev->endString(state);
1615     dbg_newdata("endstring");
1616 }
1617 void BitmapOutputDev::endStringOp(GfxState *state)
1618 {
1619     msg("<debug> endStringOp");
1620     clip0dev->endStringOp(state);
1621     clip1dev->endStringOp(state);
1622     booltextdev->endStringOp(state);
1623     gfxdev->endStringOp(state);
1624     dbg_newdata("endstringop");
1625 }
1626
1627 /* TODO: these four operations below *should* do nothing, as type3
1628          chars are drawn using operations like fill() */
1629 GBool BitmapOutputDev::beginType3Char(GfxState *state, double x, double y,
1630                              double dx, double dy,
1631                              CharCode code, Unicode *u, int uLen)
1632 {
1633     msg("<debug> beginType3Char");
1634     /* call gfxdev so that it can generate "invisible" characters
1635        on top of the actual graphic content, for text extraction */
1636     return gfxdev->beginType3Char(state, x, y, dx, dy, code, u, uLen);
1637 }
1638 void BitmapOutputDev::type3D0(GfxState *state, double wx, double wy)
1639 {
1640     msg("<debug> type3D0");
1641     return gfxdev->type3D0(state, wx, wy);
1642 }
1643 void BitmapOutputDev::type3D1(GfxState *state, double wx, double wy, double llx, double lly, double urx, double ury)
1644 {
1645     msg("<debug> type3D1");
1646     return gfxdev->type3D1(state, wx, wy, llx, lly, urx, ury);
1647 }
1648 void BitmapOutputDev::endType3Char(GfxState *state)
1649 {
1650     msg("<debug> endType3Char");
1651     gfxdev->endType3Char(state);
1652 }
1653
1654 class CopyStream: public Object
1655 {
1656     Dict*dict;
1657     char*buf;
1658     MemStream*memstream;
1659     public:
1660     CopyStream(Stream*str, int len)
1661     {
1662         buf = 0;
1663         str->reset();
1664         if(len) {
1665             buf = (char*)malloc(len);
1666             int t;
1667             for (t=0; t<len; t++)
1668               buf[t] = str->getChar();
1669         }
1670         str->close();
1671         this->dict = str->getDict();
1672         this->memstream = new MemStream(buf, 0, len, this);
1673     }
1674     ~CopyStream() 
1675     {
1676         ::free(this->buf);this->buf = 0;
1677         delete this->memstream;
1678     }
1679     Dict* getDict() {return dict;}
1680     Stream* getStream() {return this->memstream;};
1681 };
1682
1683 gfxbbox_t BitmapOutputDev::getImageBBox(GfxState*state)
1684 {
1685     gfxbbox_t bbox;
1686     double x,y;
1687     state->transform(0, 1, &x, &y);
1688     bbox.xmin=bbox.xmax = x;
1689     bbox.ymin=bbox.ymax = y;
1690     state->transform(0, 0, &x, &y);
1691     bbox.xmin=min(bbox.xmin,x);
1692     bbox.ymin=min(bbox.ymin,y);
1693     bbox.xmax=max(bbox.xmax,x);
1694     bbox.ymax=max(bbox.ymax,y);
1695     state->transform(1, 0, &x, &y);
1696     bbox.xmin=min(bbox.xmin,x);
1697     bbox.ymin=min(bbox.ymin,y);
1698     bbox.xmax=max(bbox.xmax,x);
1699     bbox.ymax=max(bbox.ymax,y);
1700     state->transform(1, 1, &x, &y);
1701     bbox.xmin=min(bbox.xmin,x);
1702     bbox.ymin=min(bbox.ymin,y);
1703     bbox.xmax=max(bbox.xmax,x);
1704     bbox.ymax=max(bbox.ymax,y);
1705     return bbox;
1706 }
1707
1708 GBool invalid_size(int width, int height)
1709 {
1710     if((U64)width*(U64)height > 0x7fffffffll)
1711         return 1;
1712     return 0;
1713 }
1714
1715 void BitmapOutputDev::drawImageMask(GfxState *state, Object *ref, Stream *str,
1716                            int width, int height, GBool invert,
1717                            GBool inlineImg)
1718 {
1719     msg("<debug> drawImageMask streamkind=%d", str->getKind());
1720     if(invalid_size(width,height)) return;
1721
1722     CopyStream*cpystr = new CopyStream(str, height * ((width + 7) / 8));
1723     str = cpystr->getStream();
1724     
1725     boolpolydev->drawImageMask(state, ref, str, width, height, invert, inlineImg);
1726     gfxbbox_t bbox = getImageBBox(state);
1727     checkNewBitmap(bbox.xmin, bbox.ymin, ceil(bbox.xmax), ceil(bbox.ymax));
1728     rgbdev->drawImageMask(state, ref, str, width, height, invert, inlineImg);
1729     delete cpystr;
1730     dbg_newdata("imagemask");
1731 }
1732 void BitmapOutputDev::drawImage(GfxState *state, Object *ref, Stream *str,
1733                        int width, int height, GfxImageColorMap *colorMap,
1734                        int *maskColors, GBool inlineImg)
1735 {
1736     msg("<debug> drawImage streamkind=%d", str->getKind());
1737     if(invalid_size(width,height)) return;
1738         
1739     CopyStream*cpystr = new CopyStream(str, height * ((width * colorMap->getNumPixelComps() * colorMap->getBits() + 7) / 8));
1740     str = cpystr->getStream();
1741
1742     boolpolydev->drawImage(state, ref, str, width, height, colorMap, maskColors, inlineImg);
1743     gfxbbox_t bbox=getImageBBox(state);
1744     checkNewBitmap(bbox.xmin, bbox.ymin, ceil(bbox.xmax), ceil(bbox.ymax));
1745     rgbdev->drawImage(state, ref, str, width, height, colorMap, maskColors, inlineImg);
1746     delete cpystr;
1747     dbg_newdata("image");
1748 }
1749 void BitmapOutputDev::drawMaskedImage(GfxState *state, Object *ref, Stream *str,
1750                              int width, int height,
1751                              GfxImageColorMap *colorMap,
1752                              Stream *maskStr, int maskWidth, int maskHeight,
1753                              GBool maskInvert)
1754 {
1755     msg("<debug> drawMaskedImage streamkind=%d", str->getKind());
1756     if(invalid_size(width,height)) return;
1757     
1758     CopyStream*cpystr = new CopyStream(str, height * ((width * colorMap->getNumPixelComps() * colorMap->getBits() + 7) / 8));
1759     str = cpystr->getStream();
1760
1761     boolpolydev->drawMaskedImage(state, ref, str, width, height, colorMap, maskStr, maskWidth, maskHeight, maskInvert);
1762     gfxbbox_t bbox=getImageBBox(state);
1763     checkNewBitmap(bbox.xmin, bbox.ymin, ceil(bbox.xmax), ceil(bbox.ymax));
1764     rgbdev->drawMaskedImage(state, ref, str, width, height, colorMap, maskStr, maskWidth, maskHeight, maskInvert);
1765     delete cpystr;
1766     dbg_newdata("maskedimage");
1767 }
1768 void BitmapOutputDev::drawSoftMaskedImage(GfxState *state, Object *ref, Stream *str,
1769                                  int width, int height,
1770                                  GfxImageColorMap *colorMap,
1771                                  Stream *maskStr,
1772                                  int maskWidth, int maskHeight,
1773                                  GfxImageColorMap *maskColorMap)
1774 {
1775     msg("<debug> drawSoftMaskedImage %dx%d (%dx%d) streamkind=%d", width, height, maskWidth, maskHeight, str->getKind());
1776     if(invalid_size(width,height)) return;
1777
1778     CopyStream*cpystr = new CopyStream(str, height * ((width * colorMap->getNumPixelComps() * colorMap->getBits() + 7) / 8));
1779     str = cpystr->getStream();
1780
1781     boolpolydev->drawSoftMaskedImage(state, ref, str, width, height, colorMap, maskStr, maskWidth, maskHeight, maskColorMap);
1782     gfxbbox_t bbox=getImageBBox(state);
1783     checkNewBitmap(bbox.xmin, bbox.ymin, ceil(bbox.xmax), ceil(bbox.ymax));
1784     rgbdev->drawSoftMaskedImage(state, ref, str, width, height, colorMap, maskStr, maskWidth, maskHeight, maskColorMap);
1785     delete cpystr;
1786     dbg_newdata("softmaskimage");
1787 }
1788 void BitmapOutputDev::drawForm(Ref id)
1789 {
1790     msg("<debug> drawForm");
1791     boolpolydev->drawForm(id);
1792     checkNewBitmap(UNKNOWN_BOUNDING_BOX);
1793     rgbdev->drawForm(id);
1794 }
1795
1796 void BitmapOutputDev::processLink(Link *link, Catalog *catalog)
1797 {
1798     msg("<debug> processLink");
1799     flushEverything();
1800     gfxdev->processLink(link, catalog);
1801 }
1802 void BitmapOutputDev::flushEverything()
1803 {
1804     if(layerstate == STATE_BITMAP_IS_ABOVE) {
1805         this->flushText();
1806         this->flushBitmap();
1807     } else {
1808         this->flushBitmap();
1809         this->flushText();
1810     }
1811 }
1812
1813 void BitmapOutputDev::beginTransparencyGroup(GfxState *state, double *bbox,
1814                                     GfxColorSpace *blendingColorSpace,
1815                                     GBool isolated, GBool knockout,
1816                                     GBool forSoftMask)
1817 {
1818     msg("<debug> beginTransparencyGroup");
1819 #if (xpdfMajorVersion*10000 + xpdfMinorVersion*100 + xpdfUpdateVersion) < 30207
1820     GfxState*state1 = state->copy();
1821     GfxState*state2 = state->copy();
1822     state1->setPath(0);
1823     state1->setPath(state->getPath()->copy());
1824     state2->setPath(0);
1825     state2->setPath(state->getPath()->copy());
1826 #else
1827     GfxState*state1 = state->copy(gTrue);
1828     GfxState*state2 = state->copy(gTrue);
1829 #endif
1830     boolpolydev->beginTransparencyGroup(state1, bbox, blendingColorSpace, isolated, knockout, forSoftMask);
1831     rgbdev->beginTransparencyGroup(state2, bbox, blendingColorSpace, isolated, knockout, forSoftMask);
1832     clip1dev->beginTransparencyGroup(state, bbox, blendingColorSpace, isolated, knockout, forSoftMask);
1833     delete state1;
1834     delete state2;
1835     dbg_newdata("endtransparencygroup");
1836 }
1837 void BitmapOutputDev::endTransparencyGroup(GfxState *state)
1838 {
1839     msg("<debug> endTransparencyGroup");
1840 #if (xpdfMajorVersion*10000 + xpdfMinorVersion*100 + xpdfUpdateVersion) < 30207
1841     GfxState*state1 = state->copy();
1842     GfxState*state2 = state->copy();
1843     state1->setPath(0);
1844     state1->setPath(state->getPath()->copy());
1845     state2->setPath(0);
1846     state2->setPath(state->getPath()->copy());
1847 #else
1848     GfxState*state1 = state->copy(gTrue);
1849     GfxState*state2 = state->copy(gTrue);
1850 #endif
1851     boolpolydev->endTransparencyGroup(state1);
1852     checkNewBitmap(UNKNOWN_BOUNDING_BOX);
1853     rgbdev->endTransparencyGroup(state2);
1854     delete state1;
1855     delete state2;
1856     clip1dev->endTransparencyGroup(state);
1857     dbg_newdata("endtransparencygroup");
1858 }
1859 void BitmapOutputDev::paintTransparencyGroup(GfxState *state, double *bbox)
1860 {
1861     msg("<debug> paintTransparencyGroup");
1862     boolpolydev->paintTransparencyGroup(state,bbox);
1863     checkNewBitmap(UNKNOWN_BOUNDING_BOX);
1864     rgbdev->paintTransparencyGroup(state,bbox);
1865     clip1dev->paintTransparencyGroup(state,bbox);
1866     dbg_newdata("painttransparencygroup");
1867 }
1868 void BitmapOutputDev::setSoftMask(GfxState *state, double *bbox, GBool alpha, Function *transferFunc, GfxColor *backdropColor)
1869 {
1870     msg("<debug> setSoftMask");
1871     boolpolydev->setSoftMask(state, bbox, alpha, transferFunc, backdropColor);
1872     checkNewBitmap(UNKNOWN_BOUNDING_BOX);
1873     rgbdev->setSoftMask(state, bbox, alpha, transferFunc, backdropColor);
1874     clip1dev->setSoftMask(state, bbox, alpha, transferFunc, backdropColor);
1875     dbg_newdata("setsoftmask");
1876 }
1877 void BitmapOutputDev::clearSoftMask(GfxState *state)
1878 {
1879     msg("<debug> clearSoftMask");
1880     boolpolydev->clearSoftMask(state);
1881     checkNewBitmap(UNKNOWN_BOUNDING_BOX);
1882     rgbdev->clearSoftMask(state);
1883     clip1dev->clearSoftMask(state);
1884     dbg_newdata("clearsoftmask");
1885 }