From c2a1de276f2c4e97ce8e017fab038e99bcea72aa Mon Sep 17 00:00:00 2001 From: kramm Date: Fri, 26 Sep 2008 11:30:36 +0000 Subject: [PATCH] if we're inside a transparency group, draw glyphs on bitmap --- lib/pdf/BitmapOutputDev.cc | 287 ++++++++++++++++++++++++++++++++++---------- 1 file changed, 226 insertions(+), 61 deletions(-) diff --git a/lib/pdf/BitmapOutputDev.cc b/lib/pdf/BitmapOutputDev.cc index 43fb89a..6ed165d 100644 --- a/lib/pdf/BitmapOutputDev.cc +++ b/lib/pdf/BitmapOutputDev.cc @@ -30,6 +30,8 @@ #include "../png.h" #include "../devices/record.h" +#define UNKNOWN_BOUNDING_BOX 0,0,0,0 + static SplashColor splash_white = {255,255,255}; static SplashColor splash_black = {0,0,0}; @@ -194,6 +196,7 @@ void BitmapOutputDev::flushBitmap() SplashColorPtr rgb = rgbbitmap->getDataPtr(); Guchar*alpha = rgbbitmap->getAlphaPtr(); + Guchar*alpha2 = boolpolybitmap->getAlphaPtr(); int xmin,ymin,xmax,ymax; getBitmapBBox(alpha, width, height, &xmin,&ymin,&xmax,&ymax); @@ -216,7 +219,7 @@ void BitmapOutputDev::flushBitmap() //xmin = ymin = 0; //xmax = width; //ymax = height; - + int rangex = xmax-xmin; int rangey = ymax-ymin; gfximage_t*img = (gfximage_t*)malloc(sizeof(gfximage_t)); @@ -228,6 +231,7 @@ void BitmapOutputDev::flushBitmap() SplashColorPtr in=&rgb[((y+ymin)*width+xmin)*sizeof(SplashColor)]; gfxcolor_t*out = &img->data[y*rangex]; Guchar*ain = &alpha[(y+ymin)*width+xmin]; + Guchar*ain2 = &alpha2[(y+ymin)*width+xmin]; if(this->emptypage) { for(x=0;xemptypage = 0; } +void writeBitmap(SplashBitmap*bitmap, char*filename) +{ + int y,x; + + int width = bitmap->getWidth(); + int height = bitmap->getHeight(); + + gfxcolor_t*data = (gfxcolor_t*)malloc(sizeof(gfxcolor_t)*width*height); + + for(y=0;ygetPixel(x,y,c); + int a = bitmap->getAlpha(x,y); + line[x].r = c[0]; + line[x].g = c[1]; + line[x].b = c[2]; + line[x].a = a; + } + } + writePNG(filename, (unsigned char*)data, width, height); + free(data); +} + void writeAlpha(SplashBitmap*bitmap, char*filename) { int y,x; @@ -307,7 +341,39 @@ static int dbg_btm_counter=1; static const char*STATE_NAME[] = {"parallel", "textabovebitmap", "bitmapabovetext"}; -void BitmapOutputDev::checkNewText() +int checkAlphaSanity(SplashBitmap*boolbtm, SplashBitmap*alphabtm) +{ + assert(boolbtm->getWidth() == alphabtm->getWidth()); + assert(boolbtm->getHeight() == alphabtm->getHeight()); + if(boolbtm->getMode()==splashModeMono1) { + return 1; + } + + int width = boolbtm->getWidth(); + int height = boolbtm->getHeight(); + + int bad=0; + int x,y; + for(y=0;ygetAlpha(x,y); + int a2 = boolbtm->getAlpha(x,y); + if(a1!=a2) { + bad++; + } + } + } + double badness = bad/(double)(width*height); + if(badness>0.2) { + msg(" Bitmaps don't correspond: %d out of %d pixels wrong (%.2f%%)", bad, width*height, + badness*100.0); + return 0; + } + msg(" %f", badness); + return 1; +} + +GBool BitmapOutputDev::checkNewText(int x1, int y1, int x2, int y2) { /* called once some new text was drawn on booltextdev, and before the same thing is drawn on gfxdev */ @@ -316,22 +382,27 @@ void BitmapOutputDev::checkNewText() char filename1[80]; char filename2[80]; - sprintf(filename1, "state%dbitmap_afternewtext.png", dbg_btm_counter); - sprintf(filename2, "state%dtext_afternewtext.png", dbg_btm_counter); + char filename3[80]; + sprintf(filename1, "state%dboolbitmap_afternewtext.png", dbg_btm_counter); + sprintf(filename2, "state%dbooltext_afternewtext.png", dbg_btm_counter); + sprintf(filename3, "state%dbitmap_afternewtext.png", dbg_btm_counter); if(0) { + msg(" %s %s %s", filename1, filename2, filename3); writeAlpha(boolpolybitmap, filename1); writeAlpha(booltextbitmap, filename2); + writeBitmap(rgbdev->getBitmap(), filename3); } dbg_btm_counter++; - if(intersection()) { + GBool ret = false; + if(intersection(x1,y1,x2,y2)) { if(layerstate==STATE_PARALLEL) { /* the new text is above the bitmap. So record that fact, and also clear the bitmap buffer, so we can check for new intersections */ msg(" Text is above current bitmap/polygon data"); layerstate=STATE_TEXT_IS_ABOVE; - clearBoolPolyDev(); + clearBoolPolyDev(x1,y1,x2,y2); } else if(layerstate==STATE_BITMAP_IS_ABOVE) { /* there's a bitmap above the (old) text. So we need to flush out that text, and record that the *new* @@ -343,8 +414,12 @@ void BitmapOutputDev::checkNewText() /* clear both bool devices- the text device because we just dumped out all the (old) text, and the poly dev so we can check for new intersections */ - clearBoolPolyDev(); - clearBoolTextDev(); + clearBoolPolyDev(x1,y1,x2,y2); + /* FIXME this destroys the text pixels we just + drew to test for the intersection- however we need + those to check for the *new* intersections */ + clearBoolTextDev(x1,y1,x2,y2); + ret = true; } else { /* we already know that the current text section is above the current bitmap section- now just new @@ -353,42 +428,54 @@ void BitmapOutputDev::checkNewText() the polygon bitmap again, so we can check for new intersections */ msg(" Text is still above current bitmap/polygon data"); - clearBoolPolyDev(); + clearBoolPolyDev(x1,y1,x2,y2); } } + return ret; } -void BitmapOutputDev::checkNewBitmap() +GBool BitmapOutputDev::checkNewBitmap(int x1, int y1, int x2, int y2) { /* similar to checkNewText() above, only in reverse */ msg(" Testing new graphics data against current text data, state=%s, counter=%d\n", STATE_NAME[layerstate], dbg_btm_counter); char filename1[80]; char filename2[80]; - sprintf(filename1, "state%dbitmap_afternewgfx.png", dbg_btm_counter); - sprintf(filename2, "state%dtext_afternewgfx.png", dbg_btm_counter); + char filename3[80]; + sprintf(filename1, "state%dboolbitmap_afternewgfx.png", dbg_btm_counter); + sprintf(filename2, "state%dbooltext_afternewgfx.png", dbg_btm_counter); + sprintf(filename3, "state%dbitmap_afternewgfx.png", dbg_btm_counter); + if(0) { + msg(" %s %s %s", filename1, filename2, filename3); writeAlpha(boolpolybitmap, filename1); writeAlpha(booltextbitmap, filename2); + writeBitmap(rgbdev->getBitmap(), filename3); } dbg_btm_counter++; - if(intersection()) { + GBool ret = false; + if(intersection(x1,y1,x2,y2)) { if(layerstate==STATE_PARALLEL) { msg(" Bitmap is above current text data"); layerstate=STATE_BITMAP_IS_ABOVE; - clearBoolTextDev(); + clearBoolTextDev(x1,y1,x2,y2); } else if(layerstate==STATE_TEXT_IS_ABOVE) { msg(" Bitmap is above current text data (which is above some bitmap)"); flushBitmap(); layerstate=STATE_BITMAP_IS_ABOVE; - clearBoolTextDev(); - clearBoolPolyDev(); + clearBoolTextDev(x1,y1,x2,y2); + /* FIXME this destroys the polygon pixels we just + drew to test for the intersection- however we need + those to check for the *new* intersections */ + clearBoolPolyDev(x1,y1,x2,y2); + ret = true; } else { msg(" Bitmap is still above current text data"); - clearBoolTextDev(); + clearBoolTextDev(x1,y1,x2,y2); } } + return ret; } //void checkNewText() { @@ -409,14 +496,46 @@ void BitmapOutputDev::checkNewBitmap() // break; //} -GBool BitmapOutputDev::clip0and1differ() +GBool BitmapOutputDev::clip0and1differ(int x1,int y1,int x2,int y2) { if(clip0bitmap->getMode()==splashModeMono1) { + if(x2<=x1) + return gFalse; + if(x2<0) + return gFalse; + if(x1<0) + x1 = 0; + if(x1>=clip0bitmap->getWidth()) + return gFalse; + if(x2>clip0bitmap->getWidth()) + x2=clip0bitmap->getWidth(); + + if(y2<=y1) + return gFalse; + if(y2<0) + return gFalse; + if(y1<0) + y1 = 0; + if(y1>=clip0bitmap->getHeight()) + return gFalse; + if(y2>clip0bitmap->getHeight()) + y2=clip0bitmap->getHeight(); + SplashBitmap*clip0 = clip0bitmap; SplashBitmap*clip1 = clip1bitmap; - int width8 = (clip0->getWidth()+7)/8; - int height = clip0->getHeight(); - return memcmp(clip0->getDataPtr(), clip1->getDataPtr(), width8*height); + int width8 = (clip0bitmap->getWidth()+7)/8; + int height = clip0bitmap->getHeight(); + int x18 = x1/8; + int x28 = (x2+7)/8; + int y; + + for(y=y1;ygetDataPtr()[width8*y+x18]; + unsigned char*row2 = &clip1bitmap->getDataPtr()[width8*y+x28]; + if(memcmp(row1, row2, x28-x18)) + return gTrue; + } + return gFalse; } else { SplashBitmap*clip0 = clip0bitmap; SplashBitmap*clip1 = clip1bitmap; @@ -426,8 +545,13 @@ GBool BitmapOutputDev::clip0and1differ() } } -static void clearBooleanBitmap(SplashBitmap*btm) +static void clearBooleanBitmap(SplashBitmap*btm, int x1, int y1, int x2, int y2) { + if(!(x1|y1|x2|y2)) { + x1 = y1 = 0; + x2 = btm->getWidth(); + y2 = btm->getHeight(); + } if(btm->getMode()==splashModeMono1) { int width8 = (btm->getWidth()+7)/8; int width = btm->getWidth(); @@ -450,7 +574,7 @@ long long unsigned int compare64(long long unsigned int*data1, long long unsigne return c; } -GBool BitmapOutputDev::intersection() +GBool BitmapOutputDev::intersection(int x1, int y1, int x2, int y2) { SplashBitmap*boolpoly = boolpolybitmap; SplashBitmap*booltext = booltextbitmap; @@ -461,17 +585,25 @@ GBool BitmapOutputDev::intersection() Guchar*polypixels = boolpoly->getDataPtr(); Guchar*textpixels = booltext->getDataPtr(); - + int width8 = (width+7)/8; int height = boolpoly->getHeight(); + if(x1|y1|x2|y2) { + if(y1>=0 && y1<=y2 && y2<=height) { + polypixels+=y1*width8; + textpixels+=y1*width8; + height=y2-y1; + } + } + int t; int len = height*width8; unsigned long long int c=0; assert(sizeof(unsigned long long int)==8); { if(((int)polypixels&7) || ((int)textpixels&7)) { - msg(" Non-optimal alignment"); + //msg(" Non-optimal alignment"); } int l2 = len; len /= sizeof(unsigned long long int); @@ -552,8 +684,8 @@ void BitmapOutputDev::startPage(int pageNum, GfxState *state, double crop_x1, do /* just in case any device did draw a white background rectangle into the device */ - clearBoolTextDev(); - clearBoolPolyDev(); + clearBoolTextDev(UNKNOWN_BOUNDING_BOX); + clearBoolPolyDev(UNKNOWN_BOUNDING_BOX); this->layerstate = STATE_PARALLEL; this->emptypage = 1; @@ -871,6 +1003,7 @@ void BitmapOutputDev::updateTransfer(GfxState *state) clip1dev->updateTransfer(state); gfxdev->updateTransfer(state); } + void BitmapOutputDev::updateFont(GfxState *state) { boolpolydev->updateFont(state); @@ -957,21 +1090,25 @@ void BitmapOutputDev::stroke(GfxState *state) { msg(" stroke"); boolpolydev->stroke(state); - checkNewBitmap(); + checkNewBitmap(UNKNOWN_BOUNDING_BOX); rgbdev->stroke(state); } void BitmapOutputDev::fill(GfxState *state) { msg(" fill"); boolpolydev->fill(state); - checkNewBitmap(); + if(checkNewBitmap(UNKNOWN_BOUNDING_BOX)) { + boolpolydev->fill(state); + } rgbdev->fill(state); } void BitmapOutputDev::eoFill(GfxState *state) { msg(" eoFill"); boolpolydev->eoFill(state); - checkNewBitmap(); + if(checkNewBitmap(UNKNOWN_BOUNDING_BOX)) { + boolpolydev->eoFill(state); + } rgbdev->eoFill(state); } #if (xpdfMajorVersion*10000 + xpdfMinorVersion*100 + xpdfUpdateVersion) < 30207 @@ -983,7 +1120,7 @@ void BitmapOutputDev::tilingPatternFill(GfxState *state, Object *str, { msg(" tilingPatternFill"); boolpolydev->tilingPatternFill(state, str, paintType, resDict, mat, bbox, x0, y0, x1, y1, xStep, yStep); - checkNewBitmap(); + checkNewBitmap(UNKNOWN_BOUNDING_BOX); rgbdev->tilingPatternFill(state, str, paintType, resDict, mat, bbox, x0, y0, x1, y1, xStep, yStep); } #else @@ -995,7 +1132,7 @@ void BitmapOutputDev::tilingPatternFill(GfxState *state, Gfx *gfx, Object *str, { msg(" tilingPatternFill"); boolpolydev->tilingPatternFill(state, gfx, str, paintType, resDict, mat, bbox, x0, y0, x1, y1, xStep, yStep); - checkNewBitmap(); + checkNewBitmap(UNKNOWN_BOUNDING_BOX); rgbdev->tilingPatternFill(state, gfx, str, paintType, resDict, mat, bbox, x0, y0, x1, y1, xStep, yStep); } #endif @@ -1004,21 +1141,21 @@ GBool BitmapOutputDev::functionShadedFill(GfxState *state, GfxFunctionShading *s { msg(" functionShadedFill"); boolpolydev->functionShadedFill(state, shading); - checkNewBitmap(); + checkNewBitmap(UNKNOWN_BOUNDING_BOX); return rgbdev->functionShadedFill(state, shading); } GBool BitmapOutputDev::axialShadedFill(GfxState *state, GfxAxialShading *shading) { msg(" axialShadedFill"); boolpolydev->axialShadedFill(state, shading); - checkNewBitmap(); + checkNewBitmap(UNKNOWN_BOUNDING_BOX); return rgbdev->axialShadedFill(state, shading); } GBool BitmapOutputDev::radialShadedFill(GfxState *state, GfxRadialShading *shading) { msg(" radialShadedFill"); boolpolydev->radialShadedFill(state, shading); - checkNewBitmap(); + checkNewBitmap(UNKNOWN_BOUNDING_BOX); return rgbdev->radialShadedFill(state, shading); } @@ -1064,7 +1201,7 @@ void BitmapOutputDev::endStringOp(GfxState *state) clip0dev->endStringOp(state); clip1dev->endStringOp(state); booltextdev->endStringOp(state); - checkNewText(); + checkNewText(UNKNOWN_BOUNDING_BOX); gfxdev->endStringOp(state); } void BitmapOutputDev::beginString(GfxState *state, GString *s) @@ -1081,43 +1218,70 @@ void BitmapOutputDev::endString(GfxState *state) clip0dev->endString(state); clip1dev->endString(state); booltextdev->endString(state); - checkNewText(); + checkNewText(UNKNOWN_BOUNDING_BOX); gfxdev->endString(state); } void BitmapOutputDev::clearClips() { - clearBooleanBitmap(clip0bitmap); - clearBooleanBitmap(clip1bitmap); + clearBooleanBitmap(clip0bitmap, 0, 0, 0, 0); + clearBooleanBitmap(clip1bitmap, 0, 0, 0, 0); } -void BitmapOutputDev::clearBoolPolyDev() +void BitmapOutputDev::clearBoolPolyDev(int x1, int y1, int x2, int y2) { - clearBooleanBitmap(boolpolybitmap); + clearBooleanBitmap(boolpolybitmap, x1, y1, x2, y2); } -void BitmapOutputDev::clearBoolTextDev() +void BitmapOutputDev::clearBoolTextDev(int x1, int y1, int x2, int y2) { - clearBooleanBitmap(booltextbitmap); + clearBooleanBitmap(booltextbitmap, x1, y1, x2, y2); } void BitmapOutputDev::drawChar(GfxState *state, double x, double y, double dx, double dy, double originX, double originY, CharCode code, int nBytes, Unicode *u, int uLen) { - msg(" drawChar"); + msg(" drawChar render=%d", state->getRender()); + if(state->getRender()&RENDER_CLIP) { + //char is just a clipping boundary + rgbdev->drawChar(state, x, y, dx, dy, originX, originY, code, nBytes, u, uLen); + boolpolydev->drawChar(state, x, y, dx, dy, originX, originY, code, nBytes, u, uLen); + booltextdev->drawChar(state, x, y, dx, dy, originX, originY, code, nBytes, u, uLen); + clip1dev->drawChar(state, x, y, dx, dy, originX, originY, code, nBytes, u, uLen); + } else if(rgbbitmap != rgbdev->getBitmap()) { + // we're doing softmasking or transparency grouping + boolpolydev->drawChar(state, x, y, dx, dy, originX, originY, code, nBytes, u, uLen); + checkNewBitmap(UNKNOWN_BOUNDING_BOX); rgbdev->drawChar(state, x, y, dx, dy, originX, originY, code, nBytes, u, uLen); } else { + // we're drawing a regular char clearClips(); clip0dev->drawChar(state, x, y, dx, dy, originX, originY, code, nBytes, u, uLen); clip1dev->drawChar(state, x, y, dx, dy, originX, originY, code, nBytes, u, uLen); + + /* calculate the bbox of this character */ + int x1 = (int)x, x2 = (int)x+1, y1 = (int)y, y2 = (int)y+1; + SplashPath*path = clip0dev->getCurrentFont()->getGlyphPath(code); + int t; + for(t=0;tgetLength();t++) { + double xx,yy; + Guchar f; + path->getPoint(t,&xx,&yy,&f); + xx+=x; + yy+=y; + if(xxx2) x2=(int)xx+1; + if(yy>y2) y2=(int)yy+1; + } /* if this character is affected somehow by the various clippings (i.e., it looks different on a device without clipping), then draw it on the bitmap, not as text */ - if(clip0and1differ()) { + if(clip0and1differ(x1,y1,x2,y2)) { msg(" Char %d is affected by clipping", code); boolpolydev->drawChar(state, x, y, dx, dy, originX, originY, code, nBytes, u, uLen); - checkNewBitmap(); + checkNewBitmap(UNKNOWN_BOUNDING_BOX); rgbdev->drawChar(state, x, y, dx, dy, originX, originY, code, nBytes, u, uLen); if(config_extrafontdata) { int oldrender = state->getRender(); @@ -1129,7 +1293,7 @@ void BitmapOutputDev::drawChar(GfxState *state, double x, double y, /* this char is not at all affected by clipping. Now just dump out the bitmap we're currently working on, if necessary. */ booltextdev->drawChar(state, x, y, dx, dy, originX, originY, code, nBytes, u, uLen); - checkNewText(); + checkNewText(x1,y1,x2,y2); /* use polygonal output device to do the actual text handling */ gfxdev->drawChar(state, x, y, dx, dy, originX, originY, code, nBytes, u, uLen); } @@ -1151,7 +1315,8 @@ void BitmapOutputDev::endTextObject(GfxState *state) clip0dev->endTextObject(state); clip1dev->endTextObject(state); booltextdev->endTextObject(state); - checkNewText(); + /* TODO: do this only if rendermode!=0 */ + checkNewText(UNKNOWN_BOUNDING_BOX); gfxdev->endTextObject(state); } @@ -1222,7 +1387,7 @@ void BitmapOutputDev::drawImageMask(GfxState *state, Object *ref, Stream *str, str = cpystr->getStream(); } boolpolydev->drawImageMask(state, ref, str, width, height, invert, inlineImg); - checkNewBitmap(); + checkNewBitmap(UNKNOWN_BOUNDING_BOX); rgbdev->drawImageMask(state, ref, str, width, height, invert, inlineImg); if(cpystr) delete cpystr; @@ -1238,7 +1403,7 @@ void BitmapOutputDev::drawImage(GfxState *state, Object *ref, Stream *str, str = cpystr->getStream(); } boolpolydev->drawImage(state, ref, str, width, height, colorMap, maskColors, inlineImg); - checkNewBitmap(); + checkNewBitmap(UNKNOWN_BOUNDING_BOX); rgbdev->drawImage(state, ref, str, width, height, colorMap, maskColors, inlineImg); if(cpystr) delete cpystr; @@ -1251,7 +1416,7 @@ void BitmapOutputDev::drawMaskedImage(GfxState *state, Object *ref, Stream *str, { msg(" drawMaskedImage streamkind=%d", str->getKind()); boolpolydev->drawMaskedImage(state, ref, str, width, height, colorMap, maskStr, maskWidth, maskHeight, maskInvert); - checkNewBitmap(); + checkNewBitmap(UNKNOWN_BOUNDING_BOX); rgbdev->drawMaskedImage(state, ref, str, width, height, colorMap, maskStr, maskWidth, maskHeight, maskInvert); } void BitmapOutputDev::drawSoftMaskedImage(GfxState *state, Object *ref, Stream *str, @@ -1263,14 +1428,14 @@ void BitmapOutputDev::drawSoftMaskedImage(GfxState *state, Object *ref, Stream * { msg(" drawSoftMaskedImage %dx%d (%dx%d) streamkind=%d", width, height, maskWidth, maskHeight, str->getKind()); boolpolydev->drawSoftMaskedImage(state, ref, str, width, height, colorMap, maskStr, maskWidth, maskHeight, maskColorMap); - checkNewBitmap(); + checkNewBitmap(UNKNOWN_BOUNDING_BOX); rgbdev->drawSoftMaskedImage(state, ref, str, width, height, colorMap, maskStr, maskWidth, maskHeight, maskColorMap); } void BitmapOutputDev::drawForm(Ref id) { msg(" drawForm"); boolpolydev->drawForm(id); - checkNewBitmap(); + checkNewBitmap(UNKNOWN_BOUNDING_BOX); rgbdev->drawForm(id); } @@ -1318,7 +1483,7 @@ void BitmapOutputDev::endTransparencyGroup(GfxState *state) GfxState*state2 = state->copy(gTrue); #endif boolpolydev->endTransparencyGroup(state1); - checkNewBitmap(); + checkNewBitmap(UNKNOWN_BOUNDING_BOX); rgbdev->endTransparencyGroup(state2); delete state1; delete state2; @@ -1328,7 +1493,7 @@ void BitmapOutputDev::paintTransparencyGroup(GfxState *state, double *bbox) { msg(" paintTransparencyGroup"); boolpolydev->paintTransparencyGroup(state,bbox); - checkNewBitmap(); + checkNewBitmap(UNKNOWN_BOUNDING_BOX); rgbdev->paintTransparencyGroup(state,bbox); clip1dev->paintTransparencyGroup(state,bbox); } @@ -1336,7 +1501,7 @@ void BitmapOutputDev::setSoftMask(GfxState *state, double *bbox, GBool alpha, Fu { msg(" setSoftMask"); boolpolydev->setSoftMask(state, bbox, alpha, transferFunc, backdropColor); - checkNewBitmap(); + checkNewBitmap(UNKNOWN_BOUNDING_BOX); rgbdev->setSoftMask(state, bbox, alpha, transferFunc, backdropColor); clip1dev->setSoftMask(state, bbox, alpha, transferFunc, backdropColor); } @@ -1344,7 +1509,7 @@ void BitmapOutputDev::clearSoftMask(GfxState *state) { msg(" clearSoftMask"); boolpolydev->clearSoftMask(state); - checkNewBitmap(); + checkNewBitmap(UNKNOWN_BOUNDING_BOX); rgbdev->clearSoftMask(state); clip1dev->clearSoftMask(state); } -- 1.7.10.4