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
  33 static SplashColor splash_white = {255,255,255};
  34 static SplashColor splash_black = {0,0,0};
  35
  36 ClipState::ClipState()
  37 {
  38     this->next = 0;
  39     this->clipbitmap = 0;
  40     this->written = 0;
  41 }
  42
  43 BitmapOutputDev::BitmapOutputDev(InfoOutputDev*info, PDFDoc*doc)
  44 {
  45     this->info = info;
  46     this->doc = doc;
  47     this->xref = doc->getXRef();
  48
  49     /* color graphic output device, for creating bitmaps */
  50     this->rgbdev = new SplashOutputDev(splashModeRGB8, 1, gFalse, splash_white, gTrue, gTrue);
  51
  52     /* color mode for binary bitmaps */
  53     SplashColorMode colorMode = splashModeMono8;
  54
  55     /* two devices for testing things against clipping: one clips, the other doesn't */
  56     this->clip0dev = new SplashOutputDev(colorMode, 1, gFalse, splash_black, gTrue, gFalse);
  57     this->clip1dev = new SplashOutputDev(colorMode, 1, gFalse, splash_black, gTrue, gFalse);
  58
  59     /* device indicating where polygonal pixels were drawn */
  60     this->boolpolydev = new SplashOutputDev(colorMode, 1, gFalse, splash_black, gTrue, gFalse);
  61     /* device indicating where text pixels were drawn */
  62     this->booltextdev = new SplashOutputDev(colorMode, 1, gFalse, splash_black, gTrue, gFalse);
  63
  64     /* device for handling texts and links */
  65     this->gfxdev = new GFXOutputDev(info, this->doc);
  66
  67     this->rgbdev->startDoc(this->xref);
  68     this->boolpolydev->startDoc(this->xref);
  69     this->booltextdev->startDoc(this->xref);
  70     this->clip0dev->startDoc(this->xref);
  71     this->clip1dev->startDoc(this->xref);
  72
  73     this->gfxoutput = (gfxdevice_t*)malloc(sizeof(gfxdevice_t));
  74     gfxdevice_record_init(this->gfxoutput);
  75
  76     this->gfxdev->setDevice(this->gfxoutput);
  77
  78     this->config_extrafontdata = 0;
  79     this->bboxpath = 0;
  80     //this->clipdev = 0;
  81     //this->clipstates = 0;
  82 }
  83 BitmapOutputDev::~BitmapOutputDev()
  84 {
  85     if(this->gfxoutput) {
  86         gfxresult_t*r = this->gfxoutput->finish(this->gfxoutput);
  87         r->destroy(r);
  88         free(this->gfxoutput);this->gfxoutput = 0;
  89     }
  90     if(this->bboxpath) {
  91         delete this->bboxpath;this->bboxpath = 0;
  92     }
  93     if(this->rgbdev) {
  94         delete this->rgbdev;this->rgbdev = 0;
  95     }
  96     if(this->gfxdev) {
  97         delete this->gfxdev;this->gfxdev= 0;
  98     }
  99     if(this->boolpolydev) {
 100         delete this->boolpolydev;this->boolpolydev = 0;
 101     }
 102     if(this->booltextdev) {
 103         delete this->booltextdev;this->booltextdev = 0;
 104     }
 105     if(this->clip0dev) {
 106         delete this->clip0dev;this->clip0dev = 0;
 107     }
 108     if(this->clip1dev) {
 109         delete this->clip1dev;this->clip1dev = 0;
 110     }
 111     //if(this->clipbitmap) {
 112     //    delete this->clipbitmap;this->clipbitmap = 0;
 113     //}
 114     //if(this->clipdev) {
 115     //    delete this->clipdev;this->clipdev = 0;
 116     //}
 117
 118 }
 119
 120 GBool BitmapOutputDev::getVectorAntialias()
 121 {
 122     return this->rgbdev->getVectorAntialias();
 123 }
 124 void BitmapOutputDev::setVectorAntialias(GBool vaa)
 125 {
 126     this->rgbdev->setVectorAntialias(vaa);
 127 }
 128 void BitmapOutputDev::setDevice(gfxdevice_t*dev)
 129 {
 130     this->dev = dev;
 131 }
 132 void BitmapOutputDev::setMove(int x,int y)
 133 {
 134     this->gfxdev->setMove(x,y);
 135     this->user_movex = x;
 136     this->user_movey = y;
 137 }
 138 void BitmapOutputDev::setClip(int x1,int y1,int x2,int y2)
 139 {
 140     this->gfxdev->setClip(x1,y1,x2,y2);
 141     this->user_clipx1 = x1;
 142     this->user_clipy1 = y1;
 143     this->user_clipx2 = x2;
 144     this->user_clipy2 = y2;
 145 }
 146 void BitmapOutputDev::setParameter(const char*key, const char*value)
 147 {
 148     if(!strcmp(key, "extrafontdata")) {
 149         this->config_extrafontdata = atoi(value);
 150     }
 151     this->gfxdev->setParameter(key, value);
 152 }
 153 void BitmapOutputDev::preparePage(int pdfpage, int outputpage)
 154 {
 155 }
 156
 157 static void getBitmapBBox(Guchar*alpha, int width, int height, int*xmin, int*ymin, int*xmax, int*ymax)
 158 {
 159     *ymin = -1;
 160     *xmin = width;
 161     *xmax = 0;
 162     int x,y;
 163     for(y=0;y<height;y++) {
 164         Guchar*a = &alpha[y*width];
 165         for(x=0;x<width;x++) {
 166             if(a[x]) break;
 167         }
 168         int left = x; //first occupied pixel from left
 169         int right = x+1; //last non-occupied pixel from right
 170         for(;x<width;x++) {
 171             if(a[x]) right=x+1;
 172         }
 173
 174         if(left!=width) {
 175             if(*ymin<0)
 176                 *ymin=y;
 177             *ymax=y+1;
 178             if(left<*xmin) *xmin = left;
 179             if(right>*xmax) *xmax = right;
 180         }
 181     }
 182     if(*xmin>=*xmax || *ymin>=*ymax) {
 183         *xmin = 0;
 184         *ymin = 0;
 185         *xmax = 0;
 186         *ymax = 0;
 187     }
 188 }
 189
 190 void BitmapOutputDev::flushBitmap()
 191 {
 192     int width = rgbdev->getBitmapWidth();
 193     int height = rgbdev->getBitmapHeight();
 194
 195     SplashColorPtr rgb = rgbbitmap->getDataPtr();
 196     Guchar*alpha = rgbbitmap->getAlphaPtr();
 197
 198     int xmin,ymin,xmax,ymax;
 199     getBitmapBBox(alpha, width, height, &xmin,&ymin,&xmax,&ymax);
 200
 201     /* clip against (-movex, -movey, -movex+width, -movey+height) */
 202     if(xmin < -this->movex) xmin = -this->movex;
 203     if(ymin < -this->movey) ymin = -this->movey;
 204     if(xmax > -this->movex + width) xmax = -this->movex+this->width;
 205     if(ymax > -this->movey + height) ymax = -this->movey+this->height;
 206
 207     msg("<verbose> Flushing bitmap (bbox: %d,%d,%d,%d)", xmin,ymin,xmax,ymax);
 208
 209     if((xmax-xmin)<=0 || (ymax-ymin)<=0) // no bitmap, nothing to do
 210         return;
 211
 212     if(sizeof(SplashColor)!=3) {
 213         msg("<error> sizeof(SplashColor)!=3");
 214         return;
 215     }
 216     //xmin = ymin = 0;
 217     //xmax = width;
 218     //ymax = height;
 219
 220     int rangex = xmax-xmin;
 221     int rangey = ymax-ymin;
 222     gfximage_t*img = (gfximage_t*)malloc(sizeof(gfximage_t));
 223     img->data = (gfxcolor_t*)malloc(rangex * rangey * 4);
 224     img->width = rangex;
 225     img->height = rangey;
 226     int x,y;
 227     for(y=0;y<rangey;y++) {
 228         SplashColorPtr in=&rgb[((y+ymin)*width+xmin)*sizeof(SplashColor)];
 229         gfxcolor_t*out = &img->data[y*rangex];
 230         Guchar*ain = &alpha[(y+ymin)*width+xmin];
 231         if(this->emptypage) {
 232             for(x=0;x<rangex;x++) {
 233                 /* the first bitmap on the page doesn't need to have an alpha channel-
 234                    blend against a white background*/
 235                 out[x].r = (in[x*3+0]*ain[x])/255 + 255-ain[x];
 236                 out[x].g = (in[x*3+1]*ain[x])/255 + 255-ain[x];
 237                 out[x].b = (in[x*3+2]*ain[x])/255 + 255-ain[x];
 238                 out[x].a = 255;
 239             }
 240         } else {
 241             for(x=0;x<rangex;x++) {
 242                 /* according to endPage()/compositeBackground() in xpdf/SplashOutputDev.cc, we
 243                    have to premultiply alpha (mix background and pixel according to the alpha channel).
 244                 */
 245                 out[x].r = (in[x*3+0]*ain[x])/255;
 246                 out[x].g = (in[x*3+1]*ain[x])/255;
 247                 out[x].b = (in[x*3+2]*ain[x])/255;
 248                 out[x].a = ain[x];
 249             }
 250         }
 251     }
 252     /* transform bitmap rectangle to "device space" */
 253     xmin += movex;
 254     ymin += movey;
 255     xmax += movex;
 256     ymax += movey;
 257
 258     gfxmatrix_t m;
 259     m.tx = xmin;
 260     m.ty = ymin;
 261     m.m00 = m.m11 = 1;
 262     m.m10 = m.m01 = 0;
 263
 264     gfxline_t* line = gfxline_makerectangle(xmin, ymin, xmax, ymax);
 265     dev->fillbitmap(dev, line, img, &m, 0);
 266     gfxline_free(line);
 267
 268     memset(rgbbitmap->getAlphaPtr(), 0, rgbbitmap->getWidth()*rgbbitmap->getHeight());
 269     memset(rgbbitmap->getDataPtr(), 0, rgbbitmap->getRowSize()*rgbbitmap->getHeight());
 270
 271     free(img->data);img->data=0;free(img);img=0;
 272
 273     this->emptypage = 0;
 274 }
 275
 276 void BitmapOutputDev::flushText()
 277 {
 278     msg("<verbose> Flushing text/polygons");
 279     gfxdevice_record_flush(this->gfxoutput, this->dev);
 280
 281     this->emptypage = 0;
 282 }
 283
 284 void writeAlpha(SplashBitmap*bitmap, char*filename)
 285 {
 286     int y,x;
 287
 288     int width = bitmap->getWidth();
 289     int height = bitmap->getHeight();
 290
 291     gfxcolor_t*data = (gfxcolor_t*)malloc(sizeof(gfxcolor_t)*width*height);
 292
 293     for(y=0;y<height;y++) {
 294         gfxcolor_t*line = &data[y*width];
 295         for(x=0;x<width;x++) {
 296             int a = bitmap->getAlpha(x,y);
 297             line[x].r = a;
 298             line[x].g = a;
 299             line[x].b = a;
 300             line[x].a = 255;
 301         }
 302     }
 303     writePNG(filename, (unsigned char*)data, width, height);
 304     free(data);
 305 }
 306 static int dbg_btm_counter=1;
 307
 308 static const char*STATE_NAME[] = {"parallel", "textabovebitmap", "bitmapabovetext"};
 309
 310 void BitmapOutputDev::checkNewText()
 311 {
 312     /* called once some new text was drawn on booltextdev, and
 313        before the same thing is drawn on gfxdev */
 314
 315     msg("<trace> Testing new text data against current bitmap data, state=%s, counter=%d\n", STATE_NAME[layerstate], dbg_btm_counter);
 316
 317     char filename1[80];
 318     char filename2[80];
 319     sprintf(filename1, "state%dbitmap_afternewtext.png", dbg_btm_counter);
 320     sprintf(filename2, "state%dtext_afternewtext.png", dbg_btm_counter);
 321     if(0) {
 322         writeAlpha(boolpolybitmap, filename1);
 323         writeAlpha(booltextbitmap, filename2);
 324     }
 325     dbg_btm_counter++;
 326
 327     if(intersection()) {
 328         if(layerstate==STATE_PARALLEL) {
 329             /* the new text is above the bitmap. So record that fact,
 330                and also clear the bitmap buffer, so we can check for
 331                new intersections */
 332             msg("<verbose> Text is above current bitmap/polygon data");
 333             layerstate=STATE_TEXT_IS_ABOVE;
 334             clearBoolPolyDev();
 335         } else if(layerstate==STATE_BITMAP_IS_ABOVE) {
 336             /* there's a bitmap above the (old) text. So we need
 337                to flush out that text, and record that the *new*
 338                text is now *above* the bitmap
 339              */
 340             msg("<verbose> Text is above current bitmap/polygon data (which is above some other text)");
 341             flushText();
 342             layerstate=STATE_TEXT_IS_ABOVE;
 343             /* clear both bool devices- the text device because
 344                we just dumped out all the (old) text, and the
 345                poly dev so we can check for new intersections */
 346             clearBoolPolyDev();
 347             clearBoolTextDev();
 348         } else {
 349             /* we already know that the current text section is
 350                above the current bitmap section- now just new
 351                bitmap data *and* new text data was drawn, and
 352                *again* it's above the current bitmap- so clear
 353                the polygon bitmap again, so we can check for
 354                new intersections */
 355             msg("<verbose> Text is still above current bitmap/polygon data");
 356             clearBoolPolyDev();
 357         }
 358     }
 359 }
 360
 361 void BitmapOutputDev::checkNewBitmap()
 362 {
 363     /* similar to checkNewText() above, only in reverse */
 364     msg("<trace> Testing new graphics data against current text data, state=%s, counter=%d\n", STATE_NAME[layerstate], dbg_btm_counter);
 365
 366     char filename1[80];
 367     char filename2[80];
 368     sprintf(filename1, "state%dbitmap_afternewgfx.png", dbg_btm_counter);
 369     sprintf(filename2, "state%dtext_afternewgfx.png", dbg_btm_counter);
 370     if(0) {
 371         writeAlpha(boolpolybitmap, filename1);
 372         writeAlpha(booltextbitmap, filename2);
 373     }
 374     dbg_btm_counter++;
 375
 376     if(intersection()) {
 377         if(layerstate==STATE_PARALLEL) {
 378             msg("<verbose> Bitmap is above current text data");
 379             layerstate=STATE_BITMAP_IS_ABOVE;
 380             clearBoolTextDev();
 381         } else if(layerstate==STATE_TEXT_IS_ABOVE) {
 382             msg("<verbose> Bitmap is above current text data (which is above some bitmap)");
 383             flushBitmap();
 384             layerstate=STATE_BITMAP_IS_ABOVE;
 385             clearBoolTextDev();
 386             clearBoolPolyDev();
 387         } else {
 388             msg("<verbose> Bitmap is still above current text data");
 389             clearBoolTextDev();
 390         }
 391     }
 392 }
 393
 394 //void checkNewText() {
 395 //    Guchar*alpha = rgbbitmap->getAlphaPtr();
 396 //    Guchar*charpixels = clip1bitmap->getDataPtr();
 397 //    int xx,yy;
 398 //    for(yy=0;yy<height;yy++) {
 399 //        Guchar*aline = &alpha[yy*width];
 400 //        Guchar*cline = &charpixels[yy*width8];
 401 //        for(xx=0;xx<width;xx++) {
 402 //            int bit = xx&7;
 403 //            int bytepos = xx>>3;
 404 //            /* TODO: is the bit order correct? */
 405 //            if(aline[xx] && (cline[bytepos]&(1<<bit)))
 406 //              break;
 407 //        }
 408 //        if(xx!=width)
 409 //            break;
 410 //}
 411
 412 GBool BitmapOutputDev::clip0and1differ()
 413 {
 414     if(clip0bitmap->getMode()==splashModeMono1) {
 415         SplashBitmap*clip0 = clip0bitmap;
 416         SplashBitmap*clip1 = clip1bitmap;
 417         int width8 = (clip0->getWidth()+7)/8;
 418         int height = clip0->getHeight();
 419         return memcmp(clip0->getDataPtr(), clip1->getDataPtr(), width8*height);
 420     } else {
 421         SplashBitmap*clip0 = clip0bitmap;
 422         SplashBitmap*clip1 = clip1bitmap;
 423         int width = clip0->getAlphaRowSize();
 424         int height = clip0->getHeight();
 425         return memcmp(clip0->getAlphaPtr(), clip1->getAlphaPtr(), width*height);
 426     }
 427 }
 428
 429 static void clearBooleanBitmap(SplashBitmap*btm)
 430 {
 431     if(btm->getMode()==splashModeMono1) {
 432         int width8 = (btm->getWidth()+7)/8;
 433         int width = btm->getWidth();
 434         int height = btm->getHeight();
 435         memset(btm->getDataPtr(), 0, width8*height);
 436     } else {
 437         int width = btm->getAlphaRowSize();
 438         int height = btm->getHeight();
 439         memset(btm->getAlphaPtr(), 0, width*height);
 440     }
 441 }
 442
 443 GBool BitmapOutputDev::intersection()
 444 {
 445     SplashBitmap*boolpoly = boolpolybitmap;
 446     SplashBitmap*booltext = booltextbitmap;
 447
 448     if(boolpoly->getMode()==splashModeMono1) {
 449         /* alternative implementation, using one bit per pixel-
 450            would work if xpdf wouldn't try to dither everything */
 451
 452         Guchar*polypixels = boolpoly->getDataPtr();
 453         Guchar*textpixels = booltext->getDataPtr();
 454
 455         int width8 = (width+7)/8;
 456         int height = boolpoly->getHeight();
 457
 458         int t;
 459         int len = height*width8;
 460         unsigned int c=0;
 461         if(len & (sizeof(unsigned int)-1)) {
 462             Guchar c2=0;
 463             for(t=0;t<len;t++) {
 464                 c2 |= polypixels[t]&textpixels[t];
 465             }
 466             c = c2;
 467         } else {
 468             len /= sizeof(unsigned int);
 469             for(t=0;t<len;t++) {
 470                 c |= (((unsigned int*)polypixels)[t]) & (((unsigned int*)textpixels)[t]);
 471             }
 472         }
 473         if(c)
 474             /* if graphic data and the characters overlap, they have common bits */
 475             return gTrue;
 476         else
 477             return gFalse;
 478     } else {
 479         Guchar*polypixels = boolpoly->getAlphaPtr();
 480         Guchar*textpixels = booltext->getAlphaPtr();
 481
 482         int width = boolpoly->getAlphaRowSize();
 483         int height = boolpoly->getHeight();
 484
 485         int t;
 486         int len = height*width;
 487         unsigned int c=0;
 488         if(len & (sizeof(unsigned int)-1)) {
 489             Guchar c2=0;
 490             for(t=0;t<len;t++) {
 491                 if(polypixels[t]&&textpixels[t])
 492                     return gTrue;
 493             }
 494         } else {
 495             len /= sizeof(unsigned int);
 496             for(t=0;t<len;t++) {
 497                 if((((unsigned int*)polypixels)[t]) & (((unsigned int*)textpixels)[t]))
 498                     return gTrue;
 499             }
 500         }
 501         return gFalse;
 502     }
 503 }
 504
 505
 506 void BitmapOutputDev::startPage(int pageNum, GfxState *state, double crop_x1, double crop_y1, double crop_x2, double crop_y2)
 507 {
 508     double x1,y1,x2,y2;
 509     state->transform(crop_x1,crop_y1,&x1,&y1);
 510     state->transform(crop_x2,crop_y2,&x2,&y2);
 511     if(x2<x1) {double x3=x1;x1=x2;x2=x3;}
 512     if(y2<y1) {double y3=y1;y1=y2;y2=y3;}
 513
 514     this->movex = -(int)x1 - user_movex;
 515     this->movey = -(int)y1 - user_movey;
 516
 517     if(user_clipx1|user_clipy1|user_clipx2|user_clipy2) {
 518         x1 = user_clipx1;
 519         x2 = user_clipx2;
 520         y1 = user_clipy1;
 521         y2 = user_clipy2;
 522     }
 523     this->width = (int)(x2-x1);
 524     this->height = (int)(y2-y1);
 525
 526     msg("<debug> startPage");
 527     rgbdev->startPage(pageNum, state, crop_x1, crop_y1, crop_x2, crop_y2);
 528     boolpolydev->startPage(pageNum, state, crop_x1, crop_y1, crop_x2, crop_y2);
 529     booltextdev->startPage(pageNum, state, crop_x1, crop_y1, crop_x2, crop_y2);
 530     clip0dev->startPage(pageNum, state, crop_x1, crop_y1, crop_x2, crop_y2);
 531     clip1dev->startPage(pageNum, state, crop_x1, crop_y1, crop_x2, crop_y2);
 532     gfxdev->startPage(pageNum, state, crop_x1, crop_y1, crop_x2, crop_y2);
 533
 534     boolpolybitmap = boolpolydev->getBitmap();
 535     booltextbitmap = booltextdev->getBitmap();
 536     clip0bitmap = clip0dev->getBitmap();
 537     clip1bitmap = clip1dev->getBitmap();
 538     rgbbitmap = rgbdev->getBitmap();
 539
 540     flushText(); // write out the initial clipping rectangle
 541
 542     /* just in case any device did draw a white background rectangle
 543        into the device */
 544     clearBoolTextDev();
 545     clearBoolPolyDev();
 546
 547     this->layerstate = STATE_PARALLEL;
 548     this->emptypage = 1;
 549     msg("<debug> startPage done");
 550 }
 551
 552 void BitmapOutputDev::endPage()
 553 {
 554     msg("<verbose> endPage (BitmapOutputDev)");
 555
 556     if(layerstate == STATE_BITMAP_IS_ABOVE) {
 557         this->flushText();
 558         this->flushBitmap();
 559     } else {
 560         this->flushBitmap();
 561         this->flushText();
 562     }
 563
 564     /* splash will now destroy alpha, and paint the
 565        background color into the "holes" in the bitmap */
 566     boolpolydev->endPage();
 567     booltextdev->endPage();
 568     rgbdev->endPage();
 569     clip0dev->endPage();
 570     clip1dev->endPage();
 571     gfxdev->endPage();
 572 }
 573
 574 GBool BitmapOutputDev::upsideDown()
 575 {
 576     boolpolydev->upsideDown();
 577     booltextdev->upsideDown();
 578     clip0dev->upsideDown();
 579     clip1dev->upsideDown();
 580     return rgbdev->upsideDown();
 581 }
 582
 583 GBool BitmapOutputDev::useDrawChar()
 584 {
 585     boolpolydev->useDrawChar();
 586     booltextdev->useDrawChar();
 587     clip0dev->useDrawChar();
 588     clip1dev->useDrawChar();
 589     return rgbdev->useDrawChar();
 590 }
 591
 592 GBool BitmapOutputDev::useTilingPatternFill()
 593 {
 594     boolpolydev->useTilingPatternFill();
 595     booltextdev->useTilingPatternFill();
 596     clip0dev->useTilingPatternFill();
 597     clip1dev->useTilingPatternFill();
 598     return rgbdev->useTilingPatternFill();
 599 }
 600
 601 GBool BitmapOutputDev::useShadedFills()
 602 {
 603     boolpolydev->useShadedFills();
 604     booltextdev->useShadedFills();
 605     clip0dev->useShadedFills();
 606     clip1dev->useShadedFills();
 607     return rgbdev->useShadedFills();
 608 }
 609
 610 GBool BitmapOutputDev::useDrawForm()
 611 {
 612     boolpolydev->useDrawForm();
 613     booltextdev->useDrawForm();
 614     clip0dev->useDrawForm();
 615     clip1dev->useDrawForm();
 616     return rgbdev->useDrawForm();
 617 }
 618
 619 GBool BitmapOutputDev::interpretType3Chars()
 620 {
 621     boolpolydev->interpretType3Chars();
 622     booltextdev->interpretType3Chars();
 623     clip0dev->interpretType3Chars();
 624     clip1dev->interpretType3Chars();
 625     return rgbdev->interpretType3Chars();
 626 }
 627
 628 GBool BitmapOutputDev::needNonText()
 629 {
 630     boolpolydev->needNonText();
 631     booltextdev->needNonText();
 632     clip0dev->needNonText();
 633     clip1dev->needNonText();
 634     return rgbdev->needNonText();
 635 }
 636 /*GBool BitmapOutputDev::checkPageSlice(Page *page, double hDPI, double vDPI,
 637                            int rotate, GBool useMediaBox, GBool crop,
 638                            int sliceX, int sliceY, int sliceW, int sliceH,
 639                            GBool printing, Catalog *catalog,
 640                            GBool (*abortCheckCbk)(void *data),
 641                            void *abortCheckCbkData)
 642 {
 643     return gTrue;
 644 }*/
 645 void BitmapOutputDev::setDefaultCTM(double *ctm)
 646 {
 647     boolpolydev->setDefaultCTM(ctm);
 648     booltextdev->setDefaultCTM(ctm);
 649     rgbdev->setDefaultCTM(ctm);
 650     clip0dev->setDefaultCTM(ctm);
 651     clip1dev->setDefaultCTM(ctm);
 652     gfxdev->setDefaultCTM(ctm);
 653 }
 654 void BitmapOutputDev::saveState(GfxState *state)
 655 {
 656     boolpolydev->saveState(state);
 657     booltextdev->saveState(state);
 658     rgbdev->saveState(state);
 659     clip0dev->saveState(state);
 660     clip1dev->saveState(state);
 661
 662     /*ClipState*cstate = new ClipState();
 663     cstate->next = this->clipstates;
 664     this->clipstates = cstate;*/
 665 }
 666 void BitmapOutputDev::restoreState(GfxState *state)
 667 {
 668     boolpolydev->restoreState(state);
 669     booltextdev->restoreState(state);
 670     rgbdev->restoreState(state);
 671     clip0dev->restoreState(state);
 672     clip1dev->restoreState(state);
 673
 674     /*if(this->clipstates) {
 675         ClipState*old = this->clipstates;
 676         if(old->written) {
 677             gfxdev->restoreState(state);
 678         }
 679         this->clipstates = this->clipstates->next;
 680         delete(old);
 681     } else {
 682         msg("<error> invalid restoreState()");
 683     }*/
 684 }
 685 void BitmapOutputDev::updateAll(GfxState *state)
 686 {
 687     boolpolydev->updateAll(state);
 688     booltextdev->updateAll(state);
 689     rgbdev->updateAll(state);
 690     clip0dev->updateAll(state);
 691     clip1dev->updateAll(state);
 692     gfxdev->updateAll(state);
 693 }
 694 void BitmapOutputDev::updateCTM(GfxState *state, double m11, double m12, double m21, double m22, double m31, double m32)
 695 {
 696     boolpolydev->updateCTM(state,m11,m12,m21,m22,m31,m32);
 697     booltextdev->updateCTM(state,m11,m12,m21,m22,m31,m32);
 698     rgbdev->updateCTM(state,m11,m12,m21,m22,m31,m32);
 699     clip0dev->updateCTM(state,m11,m12,m21,m22,m31,m32);
 700     clip1dev->updateCTM(state,m11,m12,m21,m22,m31,m32);
 701     gfxdev->updateCTM(state,m11,m12,m21,m22,m31,m32);
 702 }
 703 void BitmapOutputDev::updateLineDash(GfxState *state)
 704 {
 705     boolpolydev->updateLineDash(state);
 706     booltextdev->updateLineDash(state);
 707     rgbdev->updateLineDash(state);
 708     clip0dev->updateLineDash(state);
 709     clip1dev->updateLineDash(state);
 710     gfxdev->updateLineDash(state);
 711 }
 712 void BitmapOutputDev::updateFlatness(GfxState *state)
 713 {
 714     boolpolydev->updateFlatness(state);
 715     booltextdev->updateFlatness(state);
 716     rgbdev->updateFlatness(state);
 717     clip0dev->updateFlatness(state);
 718     clip1dev->updateFlatness(state);
 719     gfxdev->updateFlatness(state);
 720 }
 721 void BitmapOutputDev::updateLineJoin(GfxState *state)
 722 {
 723     boolpolydev->updateLineJoin(state);
 724     booltextdev->updateLineJoin(state);
 725     rgbdev->updateLineJoin(state);
 726     clip0dev->updateLineJoin(state);
 727     clip1dev->updateLineJoin(state);
 728     gfxdev->updateLineJoin(state);
 729 }
 730 void BitmapOutputDev::updateLineCap(GfxState *state)
 731 {
 732     boolpolydev->updateLineCap(state);
 733     booltextdev->updateLineCap(state);
 734     rgbdev->updateLineCap(state);
 735     clip0dev->updateLineCap(state);
 736     clip1dev->updateLineCap(state);
 737     gfxdev->updateLineCap(state);
 738 }
 739 void BitmapOutputDev::updateMiterLimit(GfxState *state)
 740 {
 741     boolpolydev->updateMiterLimit(state);
 742     booltextdev->updateMiterLimit(state);
 743     rgbdev->updateMiterLimit(state);
 744     clip0dev->updateMiterLimit(state);
 745     clip1dev->updateMiterLimit(state);
 746     gfxdev->updateMiterLimit(state);
 747 }
 748 void BitmapOutputDev::updateLineWidth(GfxState *state)
 749 {
 750     boolpolydev->updateLineWidth(state);
 751     booltextdev->updateLineWidth(state);
 752     rgbdev->updateLineWidth(state);
 753     clip0dev->updateLineWidth(state);
 754     clip1dev->updateLineWidth(state);
 755     gfxdev->updateLineWidth(state);
 756 }
 757 void BitmapOutputDev::updateStrokeAdjust(GfxState *state)
 758 {
 759     boolpolydev->updateStrokeAdjust(state);
 760     booltextdev->updateStrokeAdjust(state);
 761     rgbdev->updateStrokeAdjust(state);
 762     clip0dev->updateStrokeAdjust(state);
 763     clip1dev->updateStrokeAdjust(state);
 764     gfxdev->updateStrokeAdjust(state);
 765 }
 766 void BitmapOutputDev::updateFillColorSpace(GfxState *state)
 767 {
 768     boolpolydev->updateFillColorSpace(state);
 769     booltextdev->updateFillColorSpace(state);
 770     rgbdev->updateFillColorSpace(state);
 771     clip0dev->updateFillColorSpace(state);
 772     clip1dev->updateFillColorSpace(state);
 773     gfxdev->updateFillColorSpace(state);
 774 }
 775 void BitmapOutputDev::updateStrokeColorSpace(GfxState *state)
 776 {
 777     boolpolydev->updateStrokeColorSpace(state);
 778     booltextdev->updateStrokeColorSpace(state);
 779     rgbdev->updateStrokeColorSpace(state);
 780     clip0dev->updateStrokeColorSpace(state);
 781     clip1dev->updateStrokeColorSpace(state);
 782     gfxdev->updateStrokeColorSpace(state);
 783 }
 784 void BitmapOutputDev::updateFillColor(GfxState *state)
 785 {
 786     boolpolydev->updateFillColor(state);
 787     booltextdev->updateFillColor(state);
 788     rgbdev->updateFillColor(state);
 789     clip0dev->updateFillColor(state);
 790     clip1dev->updateFillColor(state);
 791     gfxdev->updateFillColor(state);
 792 }
 793 void BitmapOutputDev::updateStrokeColor(GfxState *state)
 794 {
 795     boolpolydev->updateStrokeColor(state);
 796     booltextdev->updateStrokeColor(state);
 797     rgbdev->updateStrokeColor(state);
 798     clip0dev->updateStrokeColor(state);
 799     clip1dev->updateStrokeColor(state);
 800     gfxdev->updateStrokeColor(state);
 801 }
 802 void BitmapOutputDev::updateBlendMode(GfxState *state)
 803 {
 804     boolpolydev->updateBlendMode(state);
 805     booltextdev->updateBlendMode(state);
 806     rgbdev->updateBlendMode(state);
 807     clip0dev->updateBlendMode(state);
 808     clip1dev->updateBlendMode(state);
 809     gfxdev->updateBlendMode(state);
 810 }
 811 void BitmapOutputDev::updateFillOpacity(GfxState *state)
 812 {
 813     boolpolydev->updateFillOpacity(state);
 814     booltextdev->updateFillOpacity(state);
 815     rgbdev->updateFillOpacity(state);
 816     clip0dev->updateFillOpacity(state);
 817     clip1dev->updateFillOpacity(state);
 818     gfxdev->updateFillOpacity(state);
 819 }
 820 void BitmapOutputDev::updateStrokeOpacity(GfxState *state)
 821 {
 822     boolpolydev->updateStrokeOpacity(state);
 823     booltextdev->updateStrokeOpacity(state);
 824     rgbdev->updateStrokeOpacity(state);
 825     clip0dev->updateStrokeOpacity(state);
 826     clip1dev->updateStrokeOpacity(state);
 827     gfxdev->updateStrokeOpacity(state);
 828 }
 829 void BitmapOutputDev::updateFillOverprint(GfxState *state)
 830 {
 831     boolpolydev->updateFillOverprint(state);
 832     booltextdev->updateFillOverprint(state);
 833     rgbdev->updateFillOverprint(state);
 834     clip0dev->updateFillOverprint(state);
 835     clip1dev->updateFillOverprint(state);
 836     gfxdev->updateFillOverprint(state);
 837 }
 838 void BitmapOutputDev::updateStrokeOverprint(GfxState *state)
 839 {
 840     boolpolydev->updateStrokeOverprint(state);
 841     booltextdev->updateStrokeOverprint(state);
 842     rgbdev->updateStrokeOverprint(state);
 843     clip0dev->updateStrokeOverprint(state);
 844     clip1dev->updateStrokeOverprint(state);
 845     gfxdev->updateStrokeOverprint(state);
 846 }
 847 void BitmapOutputDev::updateTransfer(GfxState *state)
 848 {
 849     boolpolydev->updateTransfer(state);
 850     booltextdev->updateTransfer(state);
 851     rgbdev->updateTransfer(state);
 852     clip0dev->updateTransfer(state);
 853     clip1dev->updateTransfer(state);
 854     gfxdev->updateTransfer(state);
 855 }
 856 void BitmapOutputDev::updateFont(GfxState *state)
 857 {
 858     boolpolydev->updateFont(state);
 859     booltextdev->updateFont(state);
 860     rgbdev->updateFont(state);
 861     clip0dev->updateFont(state);
 862     clip1dev->updateFont(state);
 863     gfxdev->updateFont(state);
 864 }
 865 void BitmapOutputDev::updateTextMat(GfxState *state)
 866 {
 867     boolpolydev->updateTextMat(state);
 868     booltextdev->updateTextMat(state);
 869     rgbdev->updateTextMat(state);
 870     clip0dev->updateTextMat(state);
 871     clip1dev->updateTextMat(state);
 872     gfxdev->updateTextMat(state);
 873 }
 874 void BitmapOutputDev::updateCharSpace(GfxState *state)
 875 {
 876     boolpolydev->updateCharSpace(state);
 877     booltextdev->updateCharSpace(state);
 878     rgbdev->updateCharSpace(state);
 879     clip0dev->updateCharSpace(state);
 880     clip1dev->updateCharSpace(state);
 881     gfxdev->updateCharSpace(state);
 882 }
 883 void BitmapOutputDev::updateRender(GfxState *state)
 884 {
 885     boolpolydev->updateRender(state);
 886     booltextdev->updateRender(state);
 887     rgbdev->updateRender(state);
 888     clip0dev->updateRender(state);
 889     clip1dev->updateRender(state);
 890     gfxdev->updateRender(state);
 891 }
 892 void BitmapOutputDev::updateRise(GfxState *state)
 893 {
 894     boolpolydev->updateRise(state);
 895     booltextdev->updateRise(state);
 896     rgbdev->updateRise(state);
 897     clip0dev->updateRise(state);
 898     clip1dev->updateRise(state);
 899     gfxdev->updateRise(state);
 900 }
 901 void BitmapOutputDev::updateWordSpace(GfxState *state)
 902 {
 903     boolpolydev->updateWordSpace(state);
 904     booltextdev->updateWordSpace(state);
 905     rgbdev->updateWordSpace(state);
 906     clip0dev->updateWordSpace(state);
 907     clip1dev->updateWordSpace(state);
 908     gfxdev->updateWordSpace(state);
 909 }
 910 void BitmapOutputDev::updateHorizScaling(GfxState *state)
 911 {
 912     boolpolydev->updateHorizScaling(state);
 913     booltextdev->updateHorizScaling(state);
 914     rgbdev->updateHorizScaling(state);
 915     clip0dev->updateHorizScaling(state);
 916     clip1dev->updateHorizScaling(state);
 917     gfxdev->updateHorizScaling(state);
 918 }
 919 void BitmapOutputDev::updateTextPos(GfxState *state)
 920 {
 921     boolpolydev->updateTextPos(state);
 922     booltextdev->updateTextPos(state);
 923     rgbdev->updateTextPos(state);
 924     clip0dev->updateTextPos(state);
 925     clip1dev->updateTextPos(state);
 926     gfxdev->updateTextPos(state);
 927 }
 928 void BitmapOutputDev::updateTextShift(GfxState *state, double shift)
 929 {
 930     boolpolydev->updateTextShift(state, shift);
 931     booltextdev->updateTextShift(state, shift);
 932     rgbdev->updateTextShift(state, shift);
 933     clip0dev->updateTextShift(state, shift);
 934     clip1dev->updateTextShift(state, shift);
 935     gfxdev->updateTextShift(state, shift);
 936 }
 937
 938 void BitmapOutputDev::stroke(GfxState *state)
 939 {
 940     msg("<debug> stroke");
 941     boolpolydev->stroke(state);
 942     checkNewBitmap();
 943     rgbdev->stroke(state);
 944 }
 945 void BitmapOutputDev::fill(GfxState *state)
 946 {
 947     msg("<debug> fill");
 948     boolpolydev->fill(state);
 949     checkNewBitmap();
 950     rgbdev->fill(state);
 951 }
 952 void BitmapOutputDev::eoFill(GfxState *state)
 953 {
 954     msg("<debug> eoFill");
 955     boolpolydev->eoFill(state);
 956     checkNewBitmap();
 957     rgbdev->eoFill(state);
 958 }
 959 #if (xpdfMajorVersion*10000 + xpdfMinorVersion*100 + xpdfUpdateVersion) < 30207
 960 void BitmapOutputDev::tilingPatternFill(GfxState *state, Object *str,
 961                                int paintType, Dict *resDict,
 962                                double *mat, double *bbox,
 963                                int x0, int y0, int x1, int y1,
 964                                double xStep, double yStep)
 965 {
 966     msg("<debug> tilingPatternFill");
 967     boolpolydev->tilingPatternFill(state, str, paintType, resDict, mat, bbox, x0, y0, x1, y1, xStep, yStep);
 968     checkNewBitmap();
 969     rgbdev->tilingPatternFill(state, str, paintType, resDict, mat, bbox, x0, y0, x1, y1, xStep, yStep);
 970 }
 971 #else
 972 void BitmapOutputDev::tilingPatternFill(GfxState *state, Gfx *gfx, Object *str,
 973                                int paintType, Dict *resDict,
 974                                double *mat, double *bbox,
 975                                int x0, int y0, int x1, int y1,
 976                                double xStep, double yStep)
 977 {
 978     msg("<debug> tilingPatternFill");
 979     boolpolydev->tilingPatternFill(state, gfx, str, paintType, resDict, mat, bbox, x0, y0, x1, y1, xStep, yStep);
 980     checkNewBitmap();
 981     rgbdev->tilingPatternFill(state, gfx, str, paintType, resDict, mat, bbox, x0, y0, x1, y1, xStep, yStep);
 982 }
 983 #endif
 984
 985 GBool BitmapOutputDev::functionShadedFill(GfxState *state, GfxFunctionShading *shading)
 986 {
 987     msg("<debug> functionShadedFill");
 988     boolpolydev->functionShadedFill(state, shading);
 989     checkNewBitmap();
 990     return rgbdev->functionShadedFill(state, shading);
 991 }
 992 GBool BitmapOutputDev::axialShadedFill(GfxState *state, GfxAxialShading *shading)
 993 {
 994     msg("<debug> axialShadedFill");
 995     boolpolydev->axialShadedFill(state, shading);
 996     checkNewBitmap();
 997     return rgbdev->axialShadedFill(state, shading);
 998 }
 999 GBool BitmapOutputDev::radialShadedFill(GfxState *state, GfxRadialShading *shading)
1000 {
1001     msg("<debug> radialShadedFill");
1002     boolpolydev->radialShadedFill(state, shading);
1003     checkNewBitmap();
1004     return rgbdev->radialShadedFill(state, shading);
1005 }
1006
1007 SplashColor black = {0,0,0};
1008 SplashColor white = {255,255,255};
1009
1010 void BitmapOutputDev::clip(GfxState *state)
1011 {
1012     msg("<debug> clip");
1013     boolpolydev->clip(state);
1014     booltextdev->clip(state);
1015     rgbdev->clip(state);
1016     clip1dev->clip(state);
1017 }
1018 void BitmapOutputDev::eoClip(GfxState *state)
1019 {
1020     return;
1021     msg("<debug> eoClip");
1022     boolpolydev->eoClip(state);
1023     booltextdev->eoClip(state);
1024     rgbdev->eoClip(state);
1025     clip1dev->eoClip(state);
1026 }
1027 void BitmapOutputDev::clipToStrokePath(GfxState *state)
1028 {
1029     msg("<debug> clipToStrokePath");
1030     boolpolydev->clipToStrokePath(state);
1031     booltextdev->clipToStrokePath(state);
1032     rgbdev->clipToStrokePath(state);
1033     clip1dev->clipToStrokePath(state);
1034 }
1035
1036 void BitmapOutputDev::beginStringOp(GfxState *state)
1037 {
1038     msg("<debug> beginStringOp");
1039     clip0dev->beginStringOp(state);
1040     clip1dev->beginStringOp(state);
1041     booltextdev->beginStringOp(state);
1042     gfxdev->beginStringOp(state);
1043 }
1044 void BitmapOutputDev::endStringOp(GfxState *state)
1045 {
1046     msg("<debug> endStringOp");
1047     clip0dev->endStringOp(state);
1048     clip1dev->endStringOp(state);
1049     booltextdev->endStringOp(state);
1050     checkNewText();
1051     gfxdev->endStringOp(state);
1052 }
1053 void BitmapOutputDev::beginString(GfxState *state, GString *s)
1054 {
1055     msg("<debug> beginString");
1056     clip0dev->beginString(state, s);
1057     clip1dev->beginString(state, s);
1058     booltextdev->beginString(state, s);
1059     gfxdev->beginString(state, s);
1060 }
1061 void BitmapOutputDev::endString(GfxState *state)
1062 {
1063     msg("<debug> endString");
1064     clip0dev->endString(state);
1065     clip1dev->endString(state);
1066     booltextdev->endString(state);
1067     checkNewText();
1068     gfxdev->endString(state);
1069 }
1070
1071 void BitmapOutputDev::clearClips()
1072 {
1073     clearBooleanBitmap(clip0bitmap);
1074     clearBooleanBitmap(clip1bitmap);
1075 }
1076 void BitmapOutputDev::clearBoolPolyDev()
1077 {
1078     clearBooleanBitmap(boolpolybitmap);
1079 }
1080 void BitmapOutputDev::clearBoolTextDev()
1081 {
1082     clearBooleanBitmap(booltextbitmap);
1083 }
1084 void BitmapOutputDev::drawChar(GfxState *state, double x, double y,
1085                       double dx, double dy,
1086                       double originX, double originY,
1087                       CharCode code, int nBytes, Unicode *u, int uLen)
1088 {
1089     msg("<debug> drawChar");
1090     if(state->getRender()&RENDER_CLIP) {
1091         rgbdev->drawChar(state, x, y, dx, dy, originX, originY, code, nBytes, u, uLen);
1092     } else {
1093         clearClips();
1094         clip0dev->drawChar(state, x, y, dx, dy, originX, originY, code, nBytes, u, uLen);
1095         clip1dev->drawChar(state, x, y, dx, dy, originX, originY, code, nBytes, u, uLen);
1096
1097         /* if this character is affected somehow by the various clippings (i.e., it looks
1098            different on a device without clipping), then draw it on the bitmap, not as
1099            text */
1100         if(clip0and1differ()) {
1101             msg("<verbose> Char %d is affected by clipping", code);
1102             boolpolydev->drawChar(state, x, y, dx, dy, originX, originY, code, nBytes, u, uLen);
1103             checkNewBitmap();
1104             rgbdev->drawChar(state, x, y, dx, dy, originX, originY, code, nBytes, u, uLen);
1105             if(config_extrafontdata) {
1106                 int oldrender = state->getRender();
1107                 state->setRender(3); //invisible
1108                 gfxdev->drawChar(state, x, y, dx, dy, originX, originY, code, nBytes, u, uLen);
1109                 state->setRender(oldrender);
1110             }
1111         } else {
1112             /* this char is not at all affected by clipping.
1113                Now just dump out the bitmap we're currently working on, if necessary. */
1114             booltextdev->drawChar(state, x, y, dx, dy, originX, originY, code, nBytes, u, uLen);
1115             checkNewText();
1116             /* use polygonal output device to do the actual text handling */
1117             gfxdev->drawChar(state, x, y, dx, dy, originX, originY, code, nBytes, u, uLen);
1118         }
1119     }
1120 }
1121 void BitmapOutputDev::drawString(GfxState *state, GString *s)
1122 {
1123     msg("<error> internal error: drawString not implemented");
1124     return;
1125     clip0dev->drawString(state, s);
1126     clip1dev->drawString(state, s);
1127     booltextdev->drawString(state, s);
1128     gfxdev->drawString(state, s);
1129 }
1130 void BitmapOutputDev::endTextObject(GfxState *state)
1131 {
1132     msg("<debug> endTextObject");
1133     rgbdev->endTextObject(state);
1134     clip0dev->endTextObject(state);
1135     clip1dev->endTextObject(state);
1136     booltextdev->endTextObject(state);
1137     checkNewText();
1138     gfxdev->endTextObject(state);
1139 }
1140
1141 /* TODO: these four operations below *should* do nothing, as type3
1142          chars are drawn using operations like fill() */
1143 GBool BitmapOutputDev::beginType3Char(GfxState *state, double x, double y,
1144                              double dx, double dy,
1145                              CharCode code, Unicode *u, int uLen)
1146 {
1147     msg("<debug> beginType3Char");
1148     /* call gfxdev so that it can generate "invisible" characters
1149        on top of the actual graphic content, for text extraction */
1150     return gfxdev->beginType3Char(state, x, y, dx, dy, code, u, uLen);
1151 }
1152 void BitmapOutputDev::type3D0(GfxState *state, double wx, double wy)
1153 {
1154     msg("<debug> type3D0");
1155     return gfxdev->type3D0(state, wx, wy);
1156 }
1157 void BitmapOutputDev::type3D1(GfxState *state, double wx, double wy, double llx, double lly, double urx, double ury)
1158 {
1159     msg("<debug> type3D1");
1160     return gfxdev->type3D1(state, wx, wy, llx, lly, urx, ury);
1161 }
1162 void BitmapOutputDev::endType3Char(GfxState *state)
1163 {
1164     msg("<debug> endType3Char");
1165     gfxdev->endType3Char(state);
1166 }
1167
1168 class CopyStream: public Object
1169 {
1170     Dict*dict;
1171     char*buf;
1172     MemStream*memstream;
1173     public:
1174     CopyStream(Stream*str, int len)
1175     {
1176         buf = 0;
1177         str->reset();
1178         if(len) {
1179             buf = (char*)malloc(len);
1180             int t;
1181             for (t=0; t<len; t++)
1182               buf[t] = str->getChar();
1183         }
1184         str->close();
1185         this->dict = str->getDict();
1186         this->memstream = new MemStream(buf, 0, len, this);
1187     }
1188     ~CopyStream()
1189     {
1190         ::free(this->buf);this->buf = 0;
1191         delete this->memstream;
1192     }
1193     Dict* getDict() {return dict;}
1194     Stream* getStream() {return this->memstream;};
1195 };
1196
1197 void BitmapOutputDev::drawImageMask(GfxState *state, Object *ref, Stream *str,
1198                            int width, int height, GBool invert,
1199                            GBool inlineImg)
1200 {
1201     msg("<debug> drawImageMask streamkind=%d", str->getKind());
1202     CopyStream*cpystr = 0;
1203     if(inlineImg) {
1204         cpystr = new CopyStream(str, height * ((width + 7) / 8));
1205         str = cpystr->getStream();
1206     }
1207     boolpolydev->drawImageMask(state, ref, str, width, height, invert, inlineImg);
1208     checkNewBitmap();
1209     rgbdev->drawImageMask(state, ref, str, width, height, invert, inlineImg);
1210     if(cpystr)
1211         delete cpystr;
1212 }
1213 void BitmapOutputDev::drawImage(GfxState *state, Object *ref, Stream *str,
1214                        int width, int height, GfxImageColorMap *colorMap,
1215                        int *maskColors, GBool inlineImg)
1216 {
1217     msg("<debug> drawImage streamkind=%d", str->getKind());
1218     CopyStream*cpystr = 0;
1219     if(inlineImg) {
1220         cpystr = new CopyStream(str, height * ((width * colorMap->getNumPixelComps() * colorMap->getBits() + 7) / 8));
1221         str = cpystr->getStream();
1222     }
1223     boolpolydev->drawImage(state, ref, str, width, height, colorMap, maskColors, inlineImg);
1224     checkNewBitmap();
1225     rgbdev->drawImage(state, ref, str, width, height, colorMap, maskColors, inlineImg);
1226     if(cpystr)
1227         delete cpystr;
1228 }
1229 void BitmapOutputDev::drawMaskedImage(GfxState *state, Object *ref, Stream *str,
1230                              int width, int height,
1231                              GfxImageColorMap *colorMap,
1232                              Stream *maskStr, int maskWidth, int maskHeight,
1233                              GBool maskInvert)
1234 {
1235     msg("<debug> drawMaskedImage streamkind=%d", str->getKind());
1236     boolpolydev->drawMaskedImage(state, ref, str, width, height, colorMap, maskStr, maskWidth, maskHeight, maskInvert);
1237     checkNewBitmap();
1238     rgbdev->drawMaskedImage(state, ref, str, width, height, colorMap, maskStr, maskWidth, maskHeight, maskInvert);
1239 }
1240 void BitmapOutputDev::drawSoftMaskedImage(GfxState *state, Object *ref, Stream *str,
1241                                  int width, int height,
1242                                  GfxImageColorMap *colorMap,
1243                                  Stream *maskStr,
1244                                  int maskWidth, int maskHeight,
1245                                  GfxImageColorMap *maskColorMap)
1246 {
1247     msg("<debug> drawSoftMaskedImage %dx%d (%dx%d) streamkind=%d", width, height, maskWidth, maskHeight, str->getKind());
1248     boolpolydev->drawSoftMaskedImage(state, ref, str, width, height, colorMap, maskStr, maskWidth, maskHeight, maskColorMap);
1249     checkNewBitmap();
1250     rgbdev->drawSoftMaskedImage(state, ref, str, width, height, colorMap, maskStr, maskWidth, maskHeight, maskColorMap);
1251 }
1252 void BitmapOutputDev::drawForm(Ref id)
1253 {
1254     msg("<debug> drawForm");
1255     boolpolydev->drawForm(id);
1256     checkNewBitmap();
1257     rgbdev->drawForm(id);
1258 }
1259
1260 void BitmapOutputDev::processLink(Link *link, Catalog *catalog)
1261 {
1262     msg("<debug> processLink");
1263     gfxdev->processLink(link, catalog);
1264 }
1265
1266 void BitmapOutputDev::beginTransparencyGroup(GfxState *state, double *bbox,
1267                                     GfxColorSpace *blendingColorSpace,
1268                                     GBool isolated, GBool knockout,
1269                                     GBool forSoftMask)
1270 {
1271     msg("<debug> beginTransparencyGroup");
1272     GfxState*state1 = state->copy(gTrue);
1273     GfxState*state2 = state->copy(gTrue);
1274     boolpolydev->beginTransparencyGroup(state1, bbox, blendingColorSpace, isolated, knockout, forSoftMask);
1275     rgbdev->beginTransparencyGroup(state2, bbox, blendingColorSpace, isolated, knockout, forSoftMask);
1276     clip1dev->beginTransparencyGroup(state, bbox, blendingColorSpace, isolated, knockout, forSoftMask);
1277     delete state1;
1278     delete state2;
1279 }
1280 void BitmapOutputDev::endTransparencyGroup(GfxState *state)
1281 {
1282     msg("<debug> endTransparencyGroup");
1283     GfxState*state1 = state->copy(gTrue);
1284     GfxState*state2 = state->copy(gTrue);
1285     boolpolydev->endTransparencyGroup(state1);
1286     checkNewBitmap();
1287     rgbdev->endTransparencyGroup(state2);
1288     delete state1;
1289     delete state2;
1290     clip1dev->endTransparencyGroup(state);
1291 }
1292 void BitmapOutputDev::paintTransparencyGroup(GfxState *state, double *bbox)
1293 {
1294     msg("<debug> paintTransparencyGroup");
1295     boolpolydev->paintTransparencyGroup(state,bbox);
1296     checkNewBitmap();
1297     rgbdev->paintTransparencyGroup(state,bbox);
1298     clip1dev->paintTransparencyGroup(state,bbox);
1299 }
1300 void BitmapOutputDev::setSoftMask(GfxState *state, double *bbox, GBool alpha, Function *transferFunc, GfxColor *backdropColor)
1301 {
1302     msg("<debug> setSoftMask");
1303     boolpolydev->setSoftMask(state, bbox, alpha, transferFunc, backdropColor);
1304     checkNewBitmap();
1305     rgbdev->setSoftMask(state, bbox, alpha, transferFunc, backdropColor);
1306     clip1dev->setSoftMask(state, bbox, alpha, transferFunc, backdropColor);
1307 }
1308 void BitmapOutputDev::clearSoftMask(GfxState *state)
1309 {
1310     msg("<debug> clearSoftMask");
1311     boolpolydev->clearSoftMask(state);
1312     checkNewBitmap();
1313     rgbdev->clearSoftMask(state);
1314     clip1dev->clearSoftMask(state);
1315 }