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