lib/pdf/FullBitmapOutputDev.cc

   1 /* FullBitmapOutputDev.cc
   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 "FullBitmapOutputDev.h"
  23 #include "GFXOutputDev.h"
  24
  25 #ifdef HAVE_POPPLER
  26   #include "splash/SplashBitmap.h"
  27   #include "splash/SplashPattern.h"
  28   #include "splash/Splash.h"
  29 #else
  30   #include "xpdf/config.h"
  31   #include "SplashBitmap.h"
  32   #include "SplashPattern.h"
  33   #include "Splash.h"
  34 #endif
  35
  36 #include "../log.h"
  37 #include "../png.h"
  38 #include "../devices/record.h"
  39
  40 static SplashColor splash_white = {255,255,255};
  41 static SplashColor splash_black = {0,0,0};
  42
  43 FullBitmapOutputDev::FullBitmapOutputDev(InfoOutputDev*info, PDFDoc*doc)
  44 {
  45     this->doc = doc;
  46     this->xref = doc->getXRef();
  47
  48     msg("<verbose> Rendering everything to a bitmap");
  49
  50     /* color graphic output device, for creating bitmaps */
  51     this->rgbdev = new SplashOutputDev(splashModeRGB8, 1, gFalse, splash_white, gTrue, gTrue);
  52
  53     /* device for handling links */
  54     this->gfxdev = new GFXOutputDev(info, this->doc);
  55
  56     this->rgbdev->startDoc(this->xref);
  57 }
  58 FullBitmapOutputDev::~FullBitmapOutputDev()
  59 {
  60     if(this->rgbdev) {
  61         delete this->rgbdev;this->rgbdev = 0;
  62     }
  63     if(this->gfxdev) {
  64         delete this->gfxdev;this->gfxdev= 0;
  65     }
  66 }
  67
  68 GBool FullBitmapOutputDev::getVectorAntialias()
  69 {
  70     return this->rgbdev->getVectorAntialias();
  71 }
  72 void FullBitmapOutputDev::setVectorAntialias(GBool vaa)
  73 {
  74     this->rgbdev->setVectorAntialias(vaa);
  75 }
  76 void FullBitmapOutputDev::setDevice(gfxdevice_t*dev)
  77 {
  78     this->dev = dev;
  79     gfxdev->setDevice(dev);
  80 }
  81 void FullBitmapOutputDev::setMove(int x,int y)
  82 {
  83     this->user_movex = x;
  84     this->user_movey = y;
  85     gfxdev->setMove(x,y);
  86 }
  87 void FullBitmapOutputDev::setClip(int x1,int y1,int x2,int y2)
  88 {
  89     this->user_clipx1 = x1;
  90     this->user_clipy1 = y1;
  91     this->user_clipx2 = x2;
  92     this->user_clipy2 = y2;
  93     gfxdev->setClip(x1,y1,x2,y2);
  94 }
  95 void FullBitmapOutputDev::setParameter(const char*key, const char*value)
  96 {
  97 }
  98 void FullBitmapOutputDev::setPageMap(int*pagemap, int pagemap_len)
  99 {
 100     gfxdev->setPageMap(pagemap, pagemap_len);
 101 }
 102
 103 static void getBitmapBBox(Guchar*alpha, int width, int height, int*xmin, int*ymin, int*xmax, int*ymax)
 104 {
 105     *ymin = -1;
 106     *xmin = width;
 107     *xmax = 0;
 108     int x,y;
 109     for(y=0;y<height;y++) {
 110         Guchar*a = &alpha[y*width];
 111         for(x=0;x<width;x++) {
 112             if(a[x]) break;
 113         }
 114         int left = x; //first occupied pixel from left
 115         int right = x+1; //last non-occupied pixel from right
 116         for(;x<width;x++) {
 117             if(a[x]) right=x+1;
 118         }
 119
 120         if(left!=width) {
 121             if(*ymin<0)
 122                 *ymin=y;
 123             *ymax=y+1;
 124             if(left<*xmin) *xmin = left;
 125             if(right>*xmax) *xmax = right;
 126         }
 127     }
 128     if(*xmin>=*xmax || *ymin>=*ymax) {
 129         *xmin = 0;
 130         *ymin = 0;
 131         *xmax = 0;
 132         *ymax = 0;
 133     }
 134 }
 135
 136 void FullBitmapOutputDev::flushBitmap()
 137 {
 138     int width = rgbdev->getBitmapWidth();
 139     int height = rgbdev->getBitmapHeight();
 140
 141     SplashColorPtr rgb = rgbdev->getBitmap()->getDataPtr();
 142     Guchar*alpha = rgbdev->getBitmap()->getAlphaPtr();
 143
 144     int xmin,ymin,xmax,ymax;
 145     getBitmapBBox(alpha, width, height, &xmin,&ymin,&xmax,&ymax);
 146
 147     /* clip against (-movex, -movey, -movex+width, -movey+height) */
 148     if(xmin < -this->movex) xmin = -this->movex;
 149     if(ymin < -this->movey) ymin = -this->movey;
 150     if(xmax > -this->movex + width) xmax = -this->movex+this->width;
 151     if(ymax > -this->movey + height) ymax = -this->movey+this->height;
 152
 153     msg("<verbose> Flushing bitmap (bbox: %d,%d,%d,%d)", xmin,ymin,xmax,ymax);
 154
 155     if((xmax-xmin)<=0 || (ymax-ymin)<=0) // no bitmap, nothing to do
 156         return;
 157
 158     if(sizeof(SplashColor)!=3) {
 159         msg("<error> sizeof(SplashColor)!=3");
 160         return;
 161     }
 162     //xmin = ymin = 0;
 163     //xmax = width;
 164     //ymax = height;
 165
 166     int rangex = xmax-xmin;
 167     int rangey = ymax-ymin;
 168     gfximage_t*img = (gfximage_t*)malloc(sizeof(gfximage_t));
 169     img->data = (gfxcolor_t*)malloc(rangex * rangey * 4);
 170     img->width = rangex;
 171     img->height = rangey;
 172     int x,y;
 173     for(y=0;y<rangey;y++) {
 174         SplashColorPtr in=&rgb[((y+ymin)*width+xmin)*sizeof(SplashColor)];
 175         gfxcolor_t*out = &img->data[y*rangex];
 176         Guchar*ain = &alpha[(y+ymin)*width+xmin];
 177         for(x=0;x<rangex;x++) {
 178             // blend against a white background
 179             out[x].r = (in[x*3+0]*ain[x])/255 + 255-ain[x];
 180             out[x].g = (in[x*3+1]*ain[x])/255 + 255-ain[x];
 181             out[x].b = (in[x*3+2]*ain[x])/255 + 255-ain[x];
 182             out[x].a = 255;//ain[x];
 183         }
 184     }
 185     /* transform bitmap rectangle to "device space" */
 186     xmin += movex;
 187     ymin += movey;
 188     xmax += movex;
 189     ymax += movey;
 190
 191     gfxmatrix_t m;
 192     m.tx = xmin;
 193     m.ty = ymin;
 194     m.m00 = m.m11 = 1;
 195     m.m10 = m.m01 = 0;
 196
 197     gfxline_t* line = gfxline_makerectangle(xmin, ymin, xmax, ymax);
 198     dev->fillbitmap(dev, line, img, &m, 0);
 199     gfxline_free(line);
 200
 201     free(img->data);img->data=0;free(img);img=0;
 202 }
 203
 204 GBool FullBitmapOutputDev::checkPageSlice(Page *page, double hDPI, double vDPI,
 205              int rotate, GBool useMediaBox, GBool crop,
 206              int sliceX, int sliceY, int sliceW, int sliceH,
 207              GBool printing, Catalog *catalog,
 208              GBool (*abortCheckCbk)(void *data),
 209              void *abortCheckCbkData)
 210 {
 211     this->setPage(page);
 212     gfxdev->setPage(page);
 213     return gTrue;
 214 }
 215
 216 void FullBitmapOutputDev::startPage(int pageNum, GfxState *state)
 217 {
 218     double x1,y1,x2,y2;
 219     PDFRectangle *r = page->getCropBox();
 220     state->transform(r->x1,r->y1,&x1,&y1);
 221     state->transform(r->x2,r->y2,&x2,&y2);
 222     if(x2<x1) {double x3=x1;x1=x2;x2=x3;}
 223     if(y2<y1) {double y3=y1;y1=y2;y2=y3;}
 224
 225     this->movex = -(int)x1 - user_movex;
 226     this->movey = -(int)y1 - user_movey;
 227
 228     if(user_clipx1|user_clipy1|user_clipx2|user_clipy2) {
 229         x1 = user_clipx1;
 230         x2 = user_clipx2;
 231         y1 = user_clipy1;
 232         y2 = user_clipy2;
 233     }
 234     this->width = (int)(x2-x1);
 235     this->height = (int)(y2-y1);
 236
 237     msg("<debug> startPage");
 238     rgbdev->startPage(pageNum, state);
 239     gfxdev->startPage(pageNum, state);
 240 }
 241
 242 void FullBitmapOutputDev::endPage()
 243 {
 244     msg("<verbose> endPage (FullBitmapOutputDev)");
 245     flushBitmap();
 246     rgbdev->endPage();
 247     gfxdev->endPage();
 248 }
 249 GBool FullBitmapOutputDev::upsideDown()
 250 {
 251     return rgbdev->upsideDown();
 252 }
 253 GBool FullBitmapOutputDev::useDrawChar()
 254 {
 255     return rgbdev->useDrawChar();
 256 }
 257 GBool FullBitmapOutputDev::useTilingPatternFill()
 258 {
 259     return rgbdev->useTilingPatternFill();
 260 }
 261 GBool FullBitmapOutputDev::useShadedFills()
 262 {
 263     return rgbdev->useShadedFills();
 264 }
 265 GBool FullBitmapOutputDev::useDrawForm()
 266 {
 267     return rgbdev->useDrawForm();
 268 }
 269 GBool FullBitmapOutputDev::interpretType3Chars()
 270 {
 271     return rgbdev->interpretType3Chars();
 272 }
 273 GBool FullBitmapOutputDev::needNonText()
 274 {
 275     return rgbdev->needNonText();
 276 }
 277 void FullBitmapOutputDev::setDefaultCTM(double *ctm)
 278 {
 279     rgbdev->setDefaultCTM(ctm);
 280     gfxdev->setDefaultCTM(ctm);
 281 }
 282 void FullBitmapOutputDev::saveState(GfxState *state)
 283 {
 284     rgbdev->saveState(state);
 285 }
 286 void FullBitmapOutputDev::restoreState(GfxState *state)
 287 {
 288     rgbdev->restoreState(state);
 289 }
 290 void FullBitmapOutputDev::updateAll(GfxState *state)
 291 {
 292     rgbdev->updateAll(state);
 293 }
 294 void FullBitmapOutputDev::updateCTM(GfxState *state, double m11, double m12, double m21, double m22, double m31, double m32)
 295 {
 296     rgbdev->updateCTM(state,m11,m12,m21,m22,m31,m32);
 297     gfxdev->updateCTM(state,m11,m12,m21,m22,m31,m32);
 298 }
 299 void FullBitmapOutputDev::updateLineDash(GfxState *state)
 300 {
 301     rgbdev->updateLineDash(state);
 302 }
 303 void FullBitmapOutputDev::updateFlatness(GfxState *state)
 304 {
 305     rgbdev->updateFlatness(state);
 306 }
 307 void FullBitmapOutputDev::updateLineJoin(GfxState *state)
 308 {
 309     rgbdev->updateLineJoin(state);
 310 }
 311 void FullBitmapOutputDev::updateLineCap(GfxState *state)
 312 {
 313     rgbdev->updateLineCap(state);
 314 }
 315 void FullBitmapOutputDev::updateMiterLimit(GfxState *state)
 316 {
 317     rgbdev->updateMiterLimit(state);
 318 }
 319 void FullBitmapOutputDev::updateLineWidth(GfxState *state)
 320 {
 321     rgbdev->updateLineWidth(state);
 322 }
 323 void FullBitmapOutputDev::updateStrokeAdjust(GfxState *state)
 324 {
 325     rgbdev->updateStrokeAdjust(state);
 326 }
 327 void FullBitmapOutputDev::updateFillColorSpace(GfxState *state)
 328 {
 329     rgbdev->updateFillColorSpace(state);
 330 }
 331 void FullBitmapOutputDev::updateStrokeColorSpace(GfxState *state)
 332 {
 333     rgbdev->updateStrokeColorSpace(state);
 334 }
 335 void FullBitmapOutputDev::updateFillColor(GfxState *state)
 336 {
 337     rgbdev->updateFillColor(state);
 338 }
 339 void FullBitmapOutputDev::updateStrokeColor(GfxState *state)
 340 {
 341     rgbdev->updateStrokeColor(state);
 342 }
 343 void FullBitmapOutputDev::updateBlendMode(GfxState *state)
 344 {
 345     rgbdev->updateBlendMode(state);
 346 }
 347 void FullBitmapOutputDev::updateFillOpacity(GfxState *state)
 348 {
 349     rgbdev->updateFillOpacity(state);
 350 }
 351 void FullBitmapOutputDev::updateStrokeOpacity(GfxState *state)
 352 {
 353     rgbdev->updateStrokeOpacity(state);
 354 }
 355 void FullBitmapOutputDev::updateFillOverprint(GfxState *state)
 356 {
 357     rgbdev->updateFillOverprint(state);
 358 }
 359 void FullBitmapOutputDev::updateStrokeOverprint(GfxState *state)
 360 {
 361     rgbdev->updateStrokeOverprint(state);
 362 }
 363 void FullBitmapOutputDev::updateTransfer(GfxState *state)
 364 {
 365     rgbdev->updateTransfer(state);
 366 }
 367 void FullBitmapOutputDev::updateFont(GfxState *state)
 368 {
 369     rgbdev->updateFont(state);
 370 }
 371 void FullBitmapOutputDev::updateTextMat(GfxState *state)
 372 {
 373     rgbdev->updateTextMat(state);
 374 }
 375 void FullBitmapOutputDev::updateCharSpace(GfxState *state)
 376 {
 377     rgbdev->updateCharSpace(state);
 378 }
 379 void FullBitmapOutputDev::updateRender(GfxState *state)
 380 {
 381     rgbdev->updateRender(state);
 382 }
 383 void FullBitmapOutputDev::updateRise(GfxState *state)
 384 {
 385     rgbdev->updateRise(state);
 386 }
 387 void FullBitmapOutputDev::updateWordSpace(GfxState *state)
 388 {
 389     rgbdev->updateWordSpace(state);
 390 }
 391 void FullBitmapOutputDev::updateHorizScaling(GfxState *state)
 392 {
 393     rgbdev->updateHorizScaling(state);
 394 }
 395 void FullBitmapOutputDev::updateTextPos(GfxState *state)
 396 {
 397     rgbdev->updateTextPos(state);
 398 }
 399 void FullBitmapOutputDev::updateTextShift(GfxState *state, double shift)
 400 {
 401     rgbdev->updateTextShift(state, shift);
 402 }
 403
 404 void FullBitmapOutputDev::stroke(GfxState *state)
 405 {
 406     msg("<debug> stroke");
 407     rgbdev->stroke(state);
 408 }
 409 void FullBitmapOutputDev::fill(GfxState *state)
 410 {
 411     msg("<debug> fill");
 412     rgbdev->fill(state);
 413 }
 414 void FullBitmapOutputDev::eoFill(GfxState *state)
 415 {
 416     msg("<debug> eoFill");
 417     rgbdev->eoFill(state);
 418 }
 419 POPPLER_TILING_PATERN_RETURN FullBitmapOutputDev::tilingPatternFill(GfxState *state, POPPLER_TILING_PATERN_GFX
 420              Object *str,
 421                                int paintType, Dict *resDict,
 422                                double *mat, double *bbox,
 423                                int x0, int y0, int x1, int y1,
 424                                double xStep, double yStep)
 425 {
 426     msg("<debug> tilingPatternFill");
 427 #ifdef HAVE_POPPLER
 428     return
 429 #endif
 430     rgbdev->tilingPatternFill(state, POPPLER_TILING_PATERN_GFX_ARG str, paintType, resDict, mat, bbox, x0, y0, x1, y1, xStep, yStep);
 431 }
 432
 433 GBool FullBitmapOutputDev::functionShadedFill(GfxState *state, GfxFunctionShading *shading)
 434 {
 435     msg("<debug> functionShadedFill");
 436     return rgbdev->functionShadedFill(state, shading);
 437 }
 438 GBool FullBitmapOutputDev::axialShadedFill(GfxState *state, GfxAxialShading *shading)
 439 {
 440     msg("<debug> axialShadedFill");
 441     return rgbdev->axialShadedFill(state, shading);
 442 }
 443 GBool FullBitmapOutputDev::radialShadedFill(GfxState *state, GfxRadialShading *shading)
 444 {
 445     msg("<debug> radialShadedFill");
 446     return rgbdev->radialShadedFill(state, shading);
 447 }
 448
 449 void FullBitmapOutputDev::clip(GfxState *state)
 450 {
 451     msg("<debug> clip");
 452     rgbdev->clip(state);
 453 }
 454 void FullBitmapOutputDev::eoClip(GfxState *state)
 455 {
 456     msg("<debug> eoClip");
 457     rgbdev->eoClip(state);
 458 }
 459 void FullBitmapOutputDev::clipToStrokePath(GfxState *state)
 460 {
 461     msg("<debug> clipToStrokePath");
 462     rgbdev->clipToStrokePath(state);
 463 }
 464
 465 void FullBitmapOutputDev::beginStringOp(GfxState *state)
 466 {
 467     msg("<debug> beginStringOp");
 468     rgbdev->beginStringOp(state);
 469 }
 470 void FullBitmapOutputDev::endStringOp(GfxState *state)
 471 {
 472     msg("<debug> endStringOp");
 473     rgbdev->endStringOp(state);
 474 }
 475 void FullBitmapOutputDev::beginString(GfxState *state, GString *s)
 476 {
 477     msg("<debug> beginString");
 478     rgbdev->beginString(state, s);
 479 }
 480 void FullBitmapOutputDev::endString(GfxState *state)
 481 {
 482     msg("<debug> endString");
 483     rgbdev->endString(state);
 484 }
 485 void FullBitmapOutputDev::drawChar(GfxState *state, double x, double y,
 486                       double dx, double dy,
 487                       double originX, double originY,
 488                       CharCode code, int nBytes, Unicode *u, int uLen)
 489 {
 490     msg("<debug> drawChar");
 491     rgbdev->drawChar(state, x, y, dx, dy, originX, originY, code, nBytes, u, uLen);
 492 }
 493 void FullBitmapOutputDev::drawString(GfxState *state, GString *s)
 494 {
 495     msg("<error> internal error: drawString not implemented");
 496     rgbdev->drawString(state, s);
 497 }
 498 void FullBitmapOutputDev::endTextObject(GfxState *state)
 499 {
 500     /* FIXME: the below might render things (stroke outlines etc.) to gfxdev which
 501               might end up unflushed- should be handled similarily as
 502               drawChar() above
 503      */
 504     msg("<debug> endTextObject");
 505     rgbdev->endTextObject(state);
 506 }
 507
 508 /* TODO: these four operations below *should* do nothing, as type3
 509          chars are drawn using operations like fill() */
 510 GBool FullBitmapOutputDev::beginType3Char(GfxState *state, double x, double y,
 511                              double dx, double dy,
 512                              CharCode code, Unicode *u, int uLen)
 513 {
 514     msg("<debug> beginType3Char");
 515     return rgbdev->beginType3Char(state, x, y, dx, dy, code, u, uLen);
 516 }
 517 void FullBitmapOutputDev::type3D0(GfxState *state, double wx, double wy)
 518 {
 519     msg("<debug> type3D0");
 520     rgbdev->type3D0(state, wx, wy);
 521 }
 522 void FullBitmapOutputDev::type3D1(GfxState *state, double wx, double wy, double llx, double lly, double urx, double ury)
 523 {
 524     msg("<debug> type3D1");
 525     rgbdev->type3D1(state, wx, wy, llx, lly, urx, ury);
 526 }
 527 void FullBitmapOutputDev::endType3Char(GfxState *state)
 528 {
 529     msg("<debug> endType3Char");
 530     rgbdev->endType3Char(state);
 531 }
 532 void FullBitmapOutputDev::drawImageMask(GfxState *state, Object *ref, Stream *str,
 533                            int width, int height, GBool invert, POPPLER_INTERPOLATE
 534                            GBool inlineImg)
 535 {
 536     msg("<debug> drawImageMask");
 537     rgbdev->drawImageMask(state, ref, str, width, height, invert, POPPLER_INTERPOLATE_ARG inlineImg);
 538 }
 539 void FullBitmapOutputDev::drawImage(GfxState *state, Object *ref, Stream *str,
 540                        int width, int height, GfxImageColorMap *colorMap, POPPLER_INTERPOLATE
 541                        int *maskColors, GBool inlineImg)
 542 {
 543     msg("<debug> drawImage");
 544     rgbdev->drawImage(state, ref, str, width, height, colorMap,
 545       POPPLER_INTERPOLATE_ARG maskColors, inlineImg);
 546 }
 547 void FullBitmapOutputDev::drawMaskedImage(GfxState *state, Object *ref, Stream *str,
 548                              int width, int height,
 549                              GfxImageColorMap *colorMap, POPPLER_INTERPOLATE
 550                              Stream *maskStr, int maskWidth, int maskHeight,
 551                              GBool maskInvert POPPLER_MASK_INTERPOLATE)
 552 {
 553     msg("<debug> drawMaskedImage");
 554     rgbdev->drawMaskedImage(state, ref, str, width, height, colorMap,
 555       POPPLER_INTERPOLATE_ARG maskStr, maskWidth, maskHeight,
 556       maskInvert POPPLER_MASK_INTERPOLATE_ARG);
 557 }
 558 void FullBitmapOutputDev::drawSoftMaskedImage(GfxState *state, Object *ref, Stream *str,
 559                                  int width, int height,
 560                                  GfxImageColorMap *colorMap, POPPLER_INTERPOLATE
 561                                  Stream *maskStr, int maskWidth, int maskHeight,
 562                                  GfxImageColorMap *maskColorMap POPPLER_MASK_INTERPOLATE)
 563 {
 564     msg("<debug> drawSoftMaskedImage");
 565     rgbdev->drawSoftMaskedImage(state, ref, str, width, height, colorMap,
 566       POPPLER_INTERPOLATE_ARG maskStr, maskWidth, maskHeight,
 567       maskColorMap POPPLER_MASK_INTERPOLATE_ARG);
 568 }
 569 void FullBitmapOutputDev::drawForm(Ref id)
 570 {
 571     msg("<debug> drawForm");
 572     rgbdev->drawForm(id);
 573 }
 574
 575 void FullBitmapOutputDev::processLink(Link *link, Catalog *catalog)
 576 {
 577     msg("<debug> processLink");
 578     gfxdev->processLink(link, catalog);
 579 }
 580
 581 void FullBitmapOutputDev::beginTransparencyGroup(GfxState *state, double *bbox,
 582                                     GfxColorSpace *blendingColorSpace,
 583                                     GBool isolated, GBool knockout,
 584                                     GBool forSoftMask)
 585 {
 586     msg("<debug> beginTransparencyGroup");
 587     rgbdev->beginTransparencyGroup(state, bbox, blendingColorSpace, isolated, knockout, forSoftMask);
 588 }
 589 void FullBitmapOutputDev::endTransparencyGroup(GfxState *state)
 590 {
 591     msg("<debug> endTransparencyGroup");
 592     rgbdev->endTransparencyGroup(state);
 593 }
 594 void FullBitmapOutputDev::paintTransparencyGroup(GfxState *state, double *bbox)
 595 {
 596     msg("<debug> paintTransparencyGroup");
 597     rgbdev->paintTransparencyGroup(state,bbox);
 598 }
 599 void FullBitmapOutputDev::setSoftMask(GfxState *state, double *bbox, GBool alpha, Function *transferFunc, GfxColor *backdropColor)
 600 {
 601     msg("<debug> setSoftMask");
 602     rgbdev->setSoftMask(state, bbox, alpha, transferFunc, backdropColor);
 603 }
 604 void FullBitmapOutputDev::clearSoftMask(GfxState *state)
 605 {
 606     msg("<debug> clearSoftMask");
 607     rgbdev->clearSoftMask(state);
 608 }
 609
 610
 611