X-Git-Url: http://git.asbjorn.biz/?p=swftools.git;a=blobdiff_plain;f=lib%2Fpdf%2FBitmapOutputDev.cc;h=6eaea6bcb461ff4c9b68c82464c85a37a25f7113;hp=d0dafa81e06f3514edaf8461fd3b5f043e13704e;hb=b43d07ef45012438211d2ed4b588e77b73a1994c;hpb=b3c3a691bfb5d1d06c086744f1ba7d8061379772 diff --git a/lib/pdf/BitmapOutputDev.cc b/lib/pdf/BitmapOutputDev.cc index d0dafa8..6eaea6b 100644 --- a/lib/pdf/BitmapOutputDev.cc +++ b/lib/pdf/BitmapOutputDev.cc @@ -19,6 +19,7 @@ #include #include #include +#include #include "config.h" #include "BitmapOutputDev.h" #include "GFXOutputDev.h" @@ -28,6 +29,10 @@ #include "../log.h" #include "../png.h" #include "../devices/record.h" +#include "../types.h" +#include "bbox.h" + +#define UNKNOWN_BOUNDING_BOX 0,0,0,0 static SplashColor splash_white = {255,255,255}; static SplashColor splash_black = {0,0,0}; @@ -49,7 +54,7 @@ BitmapOutputDev::BitmapOutputDev(InfoOutputDev*info, PDFDoc*doc) this->rgbdev = new SplashOutputDev(splashModeRGB8, 1, gFalse, splash_white, gTrue, gTrue); /* color mode for binary bitmaps */ - SplashColorMode colorMode = splashModeMono8; + SplashColorMode colorMode = splashModeMono1; /* two devices for testing things against clipping: one clips, the other doesn't */ this->clip0dev = new SplashOutputDev(colorMode, 1, gFalse, splash_black, gTrue, gFalse); @@ -149,129 +154,196 @@ void BitmapOutputDev::setParameter(const char*key, const char*value) } this->gfxdev->setParameter(key, value); } -void BitmapOutputDev::preparePage(int pdfpage, int outputpage) +void BitmapOutputDev::setPageMap(int*page2page, int num_pages) { + this->gfxdev->setPageMap(page2page, num_pages); } -static void getBitmapBBox(Guchar*alpha, int width, int height, int*xmin, int*ymin, int*xmax, int*ymax) -{ - *ymin = -1; - *xmin = width; - *xmax = 0; - int x,y; - for(y=0;y*xmax) *xmax = right; - } - } - if(*xmin>=*xmax || *ymin>=*ymax) { - *xmin = 0; - *ymin = 0; - *xmax = 0; - *ymax = 0; - } -} +void writeBitmap(SplashBitmap*bitmap, char*filename); void BitmapOutputDev::flushBitmap() { int width = rgbdev->getBitmapWidth(); int height = rgbdev->getBitmapHeight(); - - SplashColorPtr rgb = rgbdev->getBitmap()->getDataPtr(); - Guchar*alpha = rgbdev->getBitmap()->getAlphaPtr(); - - int xmin,ymin,xmax,ymax; - getBitmapBBox(alpha, width, height, &xmin,&ymin,&xmax,&ymax); - - /* clip against (-movex, -movey, -movex+width, -movey+height) */ - if(xmin < -this->movex) xmin = -this->movex; - if(ymin < -this->movey) ymin = -this->movey; - if(xmax > -this->movex + width) xmax = -this->movex+this->width; - if(ymax > -this->movey + height) ymax = -this->movey+this->height; - - msg(" Flushing bitmap (bbox: %d,%d,%d,%d)", xmin,ymin,xmax,ymax); - - if((xmax-xmin)<=0 || (ymax-ymin)<=0) // no bitmap, nothing to do - return; if(sizeof(SplashColor)!=3) { msg(" sizeof(SplashColor)!=3"); return; } - //xmin = ymin = 0; - //xmax = width; - //ymax = height; - - int rangex = xmax-xmin; - int rangey = ymax-ymin; - gfximage_t*img = (gfximage_t*)malloc(sizeof(gfximage_t)); - img->data = (gfxcolor_t*)malloc(rangex * rangey * 4); - img->width = rangex; - img->height = rangey; - int x,y; - for(y=0;ydata[y*rangex]; - Guchar*ain = &alpha[(y+ymin)*width+xmin]; - for(x=0;xgetBitmap(), "test.png"); + } counter++;*/ + + SplashColorPtr rgb = rgbbitmap->getDataPtr(); + Guchar*alpha = rgbbitmap->getAlphaPtr(); + + Guchar*alpha2 = boolpolybitmap->getDataPtr(); + int width8 = (boolpolybitmap->getWidth()+7)/8; + + ibbox_t* boxes = get_bitmap_bboxes((unsigned char*)alpha, width, height); + ibbox_t*b; - gfxline_t* line = gfxline_makerectangle(xmin, ymin, xmax, ymax); - dev->fillbitmap(dev, line, img, &m, 0); - gfxline_free(line); - memset(rgbdev->getBitmap()->getAlphaPtr(), 0, rgbdev->getBitmap()->getWidth()*rgbdev->getBitmap()->getHeight()); - memset(rgbdev->getBitmap()->getDataPtr(), 0, rgbdev->getBitmap()->getRowSize()*rgbdev->getBitmap()->getHeight()); + for(b=boxes;b;b=b->next) { + int xmin = b->xmin; + int ymin = b->ymin; + int xmax = b->xmax; + int ymax = b->ymax; - free(img->data);img->data=0;free(img);img=0; + /* clip against (-movex, -movey, -movex+width, -movey+height) */ + if(xmin < -this->movex) xmin = -this->movex; + if(ymin < -this->movey) ymin = -this->movey; + if(xmax > -this->movex + width) xmax = -this->movex+this->width; + if(ymax > -this->movey + height) ymax = -this->movey+this->height; + + msg(" Flushing bitmap (bbox: %d,%d,%d,%d)", xmin,ymin,xmax,ymax); + + if((xmax-xmin)<=0 || (ymax-ymin)<=0) // no bitmap, nothing to do + continue; + + int rangex = xmax-xmin; + int rangey = ymax-ymin; + gfximage_t*img = (gfximage_t*)malloc(sizeof(gfximage_t)); + img->data = (gfxcolor_t*)malloc(rangex * rangey * 4); + img->width = rangex; + img->height = rangey; + int x,y; + for(y=0;ydata[y*rangex]; + Guchar*ain = &alpha[(y+ymin)*width+xmin]; + Guchar*ain2 = &alpha2[(y+ymin)*width8]; + if(this->emptypage) { + for(x=0;x>(x&7)))) { + /* cut away pixels that we don't remember drawing (i.e., that are + not in the monochrome bitmap. Prevents some "hairlines" showing + up to the left and right of bitmaps */ + out[x].r = 0;out[x].g = 0;out[x].b = 0;out[x].a = 0; + } else { + /* according to endPage()/compositeBackground() in xpdf/SplashOutputDev.cc, we + have to premultiply alpha (mix background and pixel according to the alpha channel). + */ + out[x].r = (in[x*3+0]*ain[x])/255; + out[x].g = (in[x*3+1]*ain[x])/255; + out[x].b = (in[x*3+2]*ain[x])/255; + out[x].a = ain[x]; + } + } + } + } + + /* transform bitmap rectangle to "device space" */ + xmin += movex; + ymin += movey; + xmax += movex; + ymax += movey; + + gfxmatrix_t m; + m.tx = xmin; + m.ty = ymin; + m.m00 = m.m11 = 1; + m.m10 = m.m01 = 0; + m.tx -= 0.5; + m.ty -= 0.5; + + gfxline_t* line = gfxline_makerectangle(xmin, ymin, xmax, ymax); + dev->fillbitmap(dev, line, img, &m, 0); + gfxline_free(line); + + free(img->data);img->data=0;free(img);img=0; + } + ibbox_destroy(boxes); + + memset(rgbbitmap->getAlphaPtr(), 0, rgbbitmap->getWidth()*rgbbitmap->getHeight()); + memset(rgbbitmap->getDataPtr(), 0, rgbbitmap->getRowSize()*rgbbitmap->getHeight()); + + this->emptypage = 0; } void BitmapOutputDev::flushText() { msg(" Flushing text/polygons"); gfxdevice_record_flush(this->gfxoutput, this->dev); + + this->emptypage = 0; +} + +void writeMonoBitmap(SplashBitmap*btm, char*filename) +{ + int width8 = (btm->getWidth()+7)/8; + int width = btm->getWidth(); + int height = btm->getHeight(); + gfxcolor_t*b = (gfxcolor_t*)malloc(sizeof(gfxcolor_t)*width*height); + unsigned char*data = btm->getDataPtr(); + int x,y; + for(y=0;y>3]&(128>>(x&7))) { + d[x].r = d[x].g = d[x].b = 255; + } else { + d[x].r = d[x].g = d[x].b = 0; + } + d[x].a = 255; + } + } + writePNG(filename, (unsigned char*)b, width, height); + free(b); +} + +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); + + if(bitmap->getMode()==splashModeMono1) { + writeMonoBitmap(bitmap, filename); + return; + } + + for(y=0;ygetPixel(x,y,c); + line[x].r = c[0]; + line[x].g = c[1]; + line[x].b = c[2]; + line[x].a = bitmap->getAlpha(x,y); + } + } + writePNG(filename, (unsigned char*)data, width, height); + free(data); } void writeAlpha(SplashBitmap*bitmap, char*filename) { - return; int y,x; int width = bitmap->getWidth(); int height = bitmap->getHeight(); + + if(bitmap->getMode()==splashModeMono1) { + writeMonoBitmap(bitmap, filename); + return; + } gfxcolor_t*data = (gfxcolor_t*)malloc(sizeof(gfxcolor_t)*width*height); @@ -290,41 +362,87 @@ void writeAlpha(SplashBitmap*bitmap, char*filename) } static int dbg_btm_counter=1; -void BitmapOutputDev::checkNewText() +static const char*STATE_NAME[] = {"parallel", "textabovebitmap", "bitmapabovetext"}; + +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 */ - msg(" Testing new text data against current bitmap data, state=%d, counter=%d\n", layerstate, dbg_btm_counter); + msg(" Testing new text data against current bitmap data, state=%s, counter=%d\n", STATE_NAME[layerstate], dbg_btm_counter); - char filename1[80]; - char filename2[80]; - sprintf(filename1, "state%dbitmap_newtext.png", dbg_btm_counter); - sprintf(filename2, "state%dtext_newtext.png", dbg_btm_counter); - writeAlpha(boolpolydev->getBitmap(), filename1); - writeAlpha(booltextdev->getBitmap(), filename2); + if(0) { + char filename1[80]; + char filename2[80]; + 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); + msg(" %s %s %s", filename1, filename2, filename3); + writeAlpha(boolpolybitmap, filename1); + writeAlpha(booltextbitmap, filename2); + writeBitmap(rgbdev->getBitmap(), filename3); + } dbg_btm_counter++; - if(intersection()) { - msg(" Text is above current bitmap/polygon data"); + 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* text is now *above* the bitmap */ + msg(" Text is above current bitmap/polygon data (which is above some other text)"); flushText(); layerstate=STATE_TEXT_IS_ABOVE; /* 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 @@ -332,43 +450,59 @@ void BitmapOutputDev::checkNewText() *again* it's above the current bitmap- so clear the polygon bitmap again, so we can check for new intersections */ - clearBoolPolyDev(); + msg(" Text is still above current bitmap/polygon data"); + 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=%d, counter=%d\n", layerstate, dbg_btm_counter); - - char filename1[80]; - char filename2[80]; - sprintf(filename1, "state%dbitmap_newbitmap.png", dbg_btm_counter); - sprintf(filename2, "state%dtext_newbitmap.png", dbg_btm_counter); - writeAlpha(boolpolydev->getBitmap(), filename1); - writeAlpha(booltextdev->getBitmap(), filename2); + msg(" Testing new graphics data against current text data, state=%s, counter=%d\n", STATE_NAME[layerstate], dbg_btm_counter); + + if(0) { + char filename1[80]; + char filename2[80]; + 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); + msg(" %s %s %s", filename1, filename2, filename3); + writeAlpha(boolpolybitmap, filename1); + writeAlpha(booltextbitmap, filename2); + writeBitmap(rgbdev->getBitmap(), filename3); + } dbg_btm_counter++; - if(intersection()) { - msg(" Bitmap is above current text data"); + 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 { - clearBoolTextDev(); + msg(" Bitmap is still above current text data"); + clearBoolTextDev(x1,y1,x2,y2); } } + return ret; } //void checkNewText() { -// Guchar*alpha = rgbdev->getBitmap()->getAlphaPtr(); -// Guchar*charpixels = clip1dev->getBitmap()->getDataPtr(); +// Guchar*alpha = rgbbitmap->getAlphaPtr(); +// Guchar*charpixels = clip1bitmap->getDataPtr(); // int xx,yy; // for(yy=0;yygetBitmap()->getMode()==splashModeMono1) { - SplashBitmap*clip0 = clip0dev->getBitmap(); - SplashBitmap*clip1 = clip1dev->getBitmap(); - int width8 = (clip0->getWidth()+7)/8; - int height = clip0->getHeight(); - return memcmp(clip0->getDataPtr(), clip1->getDataPtr(), width8*height); + if(!(*x1|*y1|*x2|*y2)) { + // undefined bbox + *x1 = *y1 = 0; + *x2 = width; + *y2 = height; + return gTrue; + } + if(*x2<=*x1) return gFalse; + if(*x2<0) return gFalse; + if(*x1<0) *x1 = 0; + if(*x1>=width) return gFalse; + if(*x2>width) *x2=width; + + if(*y2<=*y1) return gFalse; + if(*y2<0) return gFalse; + if(*y1<0) *y1 = 0; + if(*y1>=height) return gFalse; + if(*y2>height) *y2=height; + return gTrue; +} + +GBool BitmapOutputDev::clip0and1differ(int x1,int y1,int x2,int y2) +{ + if(clip0bitmap->getMode()==splashModeMono1) { + int width = clip0bitmap->getWidth(); + int width8 = (width+7)/8; + int height = clip0bitmap->getHeight(); + + if(!fixBBox(&x1,&y1,&x2,&y2,width,height)) { + /* area is outside or null */ + return gFalse; + } + + SplashBitmap*clip0 = clip0bitmap; + SplashBitmap*clip1 = clip1bitmap; + 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+x18]; + if(memcmp(row1, row2, x28-x18)) { + return gTrue; + } + } + return gFalse; } else { - SplashBitmap*clip0 = clip0dev->getBitmap(); - SplashBitmap*clip1 = clip1dev->getBitmap(); + SplashBitmap*clip0 = clip0bitmap; + SplashBitmap*clip1 = clip1bitmap; int width = clip0->getAlphaRowSize(); int height = clip0->getHeight(); - return memcmp(clip0->getAlphaPtr(), clip1->getAlphaPtr(), width*height); + + if(!fixBBox(&x1, &y1, &x2, &y2, width, height)) { + x1=y1=0;x2=y2=1; + } + + Guchar*a0 = clip0->getAlphaPtr(); + Guchar*a1 = clip1->getAlphaPtr(); + int x,y; + char differs=0; + for(y=y1;y Strange internal error (2)"); + else if(!differs && differs2) { + msg(" Bad Bounding Box: Difference in clip0 and clip1 outside bbox"); + msg(" %d %d %d %d", x1, y1, x2, y2); + } + return differs2; } } -static void clearBooleanDev(SplashOutputDev*dev) +static void clearBooleanBitmap(SplashBitmap*btm, int x1, int y1, int x2, int y2) { - SplashBitmap*btm = dev->getBitmap(); + 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(); @@ -416,65 +621,138 @@ static void clearBooleanDev(SplashOutputDev*dev) } } -GBool BitmapOutputDev::intersection() +GBool compare8(unsigned char*data1, unsigned char*data2, int len) +{ + if(!len) + return 0; + if(((ptroff_t)data1&7)==((ptroff_t)data2&7)) { + // oh good, we can do aligning + while((ptroff_t)data1&7) { + if(*data1&*data2) + return 1; + data1++; + data2++; + if(!--len) + return 0; + } + } + /* use 64 bit for the (hopefully aligned) middle section */ + int l8 = len/8; + long long unsigned int*d1 = (long long unsigned int*)data1; + long long unsigned int*d2 = (long long unsigned int*)data2; + long long unsigned int x = 0; + int t; + for(t=0;tgetBitmap(); - SplashBitmap*booltext = booltextdev->getBitmap(); - + SplashBitmap*boolpoly = boolpolybitmap; + SplashBitmap*booltext = booltextbitmap; + if(boolpoly->getMode()==splashModeMono1) { /* alternative implementation, using one bit per pixel- - would work if xpdf wouldn't try to dither everything */ + needs the no-dither patch in xpdf */ + + int width = boolpoly->getWidth(); + int height = boolpoly->getHeight(); + + if(!fixBBox(&x1,&y1,&x2,&y2, width, height)) { + return gFalse; + } Guchar*polypixels = boolpoly->getDataPtr(); Guchar*textpixels = booltext->getDataPtr(); - - int width8 = (width+7)/8; - int height = boolpoly->getHeight(); + + int width8 = (width+7)/8; + int runx = width8; + int runy = height; - int t; - int len = height*width8; - unsigned int c=0; - if(len & (sizeof(unsigned int)-1)) { - Guchar c2=0; - for(t=0;tgetAlphaPtr(); - Guchar*textpixels = booltext->getAlphaPtr(); + int t; + unsigned char c=0; + + /*assert(sizeof(unsigned long long int)==8); + if(((ptroff_t)polypixels&7) || ((ptroff_t)textpixels&7)) { + //msg(" Non-optimal alignment"); + }*/ + + int x,y; + unsigned char*data1 = (unsigned char*)polypixels; + unsigned char*data2 = (unsigned char*)textpixels; + msg(" Testing area (%d,%d,%d,%d), runx=%d,runy=%d", x1,y1,x2,y2, runx, runy); + for(y=0;ygetAlphaRowSize(); int height = boolpoly->getHeight(); - - int t; - int len = height*width; - unsigned int c=0; - if(len & (sizeof(unsigned int)-1)) { - Guchar c2=0; - for(t=0;tgetAlphaPtr(); + Guchar*textpixels = booltext->getAlphaPtr(); + + int x,y; + char overlap1 = 0; + char overlap2 = 0; + for(x=x1;xx?ax2:x; + ay2 = ay2>y?ay2:y; + } + } + } + } + if(overlap1 && !overlap2) + msg(" strange internal error"); + if(!overlap1 && overlap2) { + msg(" Bad bounding box: intersection outside bbox"); + msg(" given bbox: %d %d %d %d", x1, y1, x2, y2); + msg(" changed area: %d %d %d %d", ax1, ay1, ax2, ay2); + //writeAlpha(booltextbitmap, "alpha.png"); + } + return overlap2; } } @@ -507,19 +785,35 @@ void BitmapOutputDev::startPage(int pageNum, GfxState *state, double crop_x1, do clip1dev->startPage(pageNum, state, crop_x1, crop_y1, crop_x2, crop_y2); gfxdev->startPage(pageNum, state, crop_x1, crop_y1, crop_x2, crop_y2); + boolpolybitmap = boolpolydev->getBitmap(); + booltextbitmap = booltextdev->getBitmap(); + clip0bitmap = clip0dev->getBitmap(); + clip1bitmap = clip1dev->getBitmap(); + rgbbitmap = rgbdev->getBitmap(); + flushText(); // write out the initial clipping rectangle /* 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; + msg(" startPage done"); } void BitmapOutputDev::endPage() { msg(" endPage (BitmapOutputDev)"); + + /* notice: we're not fully done yet with this page- there might still be + a few calls to drawLink() yet to come */ +} +void BitmapOutputDev::finishPage() +{ + msg(" finishPage (BitmapOutputDev)"); + gfxdev->endPage(); if(layerstate == STATE_BITMAP_IS_ABOVE) { this->flushText(); @@ -536,7 +830,6 @@ void BitmapOutputDev::endPage() rgbdev->endPage(); clip0dev->endPage(); clip1dev->endPage(); - gfxdev->endPage(); } GBool BitmapOutputDev::upsideDown() @@ -821,6 +1114,7 @@ void BitmapOutputDev::updateTransfer(GfxState *state) clip1dev->updateTransfer(state); gfxdev->updateTransfer(state); } + void BitmapOutputDev::updateFont(GfxState *state) { boolpolydev->updateFont(state); @@ -903,25 +1197,73 @@ void BitmapOutputDev::updateTextShift(GfxState *state, double shift) gfxdev->updateTextShift(state, shift); } +double max(double x, double y) +{ + return x>y?x:y; +} +double min(double x, double y) +{ + return xgetPath(); + int num = path->getNumSubpaths(); + gfxbbox_t bbox = {0,0,1,1}; + char valid=0; + int t; + for(t = 0; t < num; t++) { + GfxSubpath *subpath = path->getSubpath(t); + int subnum = subpath->getNumPoints(); + int s; + for(s=0;stransform(subpath->getX(s),subpath->getY(s),&x,&y); + if(!valid) { + bbox.xmin = x; bbox.ymin = y; + bbox.xmax = x; bbox.ymax = y; + valid = 1; + } else { + bbox.xmin = min(bbox.xmin, x); + bbox.ymin = min(bbox.ymin, y); + bbox.xmax = max(bbox.xmax, x); + bbox.ymax = max(bbox.ymax, y); + } + } + } + return bbox; +} + void BitmapOutputDev::stroke(GfxState *state) { msg(" stroke"); boolpolydev->stroke(state); - checkNewBitmap(); + gfxbbox_t bbox = getBBox(state); + double width = state->getTransformedLineWidth(); + bbox.xmin -= width; bbox.ymin -= width; + bbox.xmax += width; bbox.ymax += width; + checkNewBitmap(bbox.xmin, bbox.ymin, ceil(bbox.xmax), ceil(bbox.ymax)); rgbdev->stroke(state); } void BitmapOutputDev::fill(GfxState *state) { msg(" fill"); boolpolydev->fill(state); - checkNewBitmap(); + gfxbbox_t bbox = getBBox(state); + if(checkNewBitmap(bbox.xmin, bbox.ymin, ceil(bbox.xmax), ceil(bbox.ymax))) { + boolpolydev->fill(state); + } rgbdev->fill(state); } void BitmapOutputDev::eoFill(GfxState *state) { msg(" eoFill"); boolpolydev->eoFill(state); - checkNewBitmap(); + gfxbbox_t bbox = getBBox(state); + if(checkNewBitmap(bbox.xmin, bbox.ymin, ceil(bbox.xmax), ceil(bbox.ymax))) { + boolpolydev->eoFill(state); + } rgbdev->eoFill(state); } #if (xpdfMajorVersion*10000 + xpdfMinorVersion*100 + xpdfUpdateVersion) < 30207 @@ -933,7 +1275,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 @@ -945,7 +1287,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 @@ -954,21 +1296,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); } @@ -1008,15 +1350,6 @@ void BitmapOutputDev::beginStringOp(GfxState *state) booltextdev->beginStringOp(state); gfxdev->beginStringOp(state); } -void BitmapOutputDev::endStringOp(GfxState *state) -{ - msg(" endStringOp"); - clip0dev->endStringOp(state); - clip1dev->endStringOp(state); - booltextdev->endStringOp(state); - checkNewText(); - gfxdev->endStringOp(state); -} void BitmapOutputDev::beginString(GfxState *state, GString *s) { msg(" beginString"); @@ -1025,49 +1358,76 @@ void BitmapOutputDev::beginString(GfxState *state, GString *s) booltextdev->beginString(state, s); gfxdev->beginString(state, s); } -void BitmapOutputDev::endString(GfxState *state) -{ - msg(" endString"); - clip0dev->endString(state); - clip1dev->endString(state); - booltextdev->endString(state); - checkNewText(); - gfxdev->endString(state); -} void BitmapOutputDev::clearClips() { - clearBooleanDev(clip0dev); - clearBooleanDev(clip1dev); + 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) { - clearBooleanDev(boolpolydev); + clearBooleanBitmap(boolpolybitmap, x1, y1, x2, y2); } -void BitmapOutputDev::clearBoolTextDev() +void BitmapOutputDev::clearBoolTextDev(int x1, int y1, int x2, int y2) { - clearBooleanDev(booltextdev); + 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"); - if(state->getRender()&4 /*clip*/ ) { + 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; + SplashFont*font = clip0dev->getCurrentFont(); + SplashPath*path = font?font->getGlyphPath(code):NULL; + + if(!path) { + if(code) + msg(" couldn't create outline for char %d", code); + return; + } + x-=originX; + y-=originY; + path->offset((SplashCoord)x, (SplashCoord)y); + int t; + for(t=0;tgetLength();t++) { + double xx,yy; + Guchar f; + path->getPoint(t,&xx,&yy,&f); + state->transform(xx,yy,&xx,&yy); + if(xx=x2) 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(x1,y1,x2,y2); rgbdev->drawChar(state, x, y, dx, dy, originX, originY, code, nBytes, u, uLen); if(config_extrafontdata) { int oldrender = state->getRender(); @@ -1076,10 +1436,11 @@ void BitmapOutputDev::drawChar(GfxState *state, double x, double y, state->setRender(oldrender); } } else { + /* 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); } @@ -1097,12 +1458,34 @@ void BitmapOutputDev::drawString(GfxState *state, GString *s) void BitmapOutputDev::endTextObject(GfxState *state) { msg(" endTextObject"); + rgbdev->endTextObject(state); clip0dev->endTextObject(state); clip1dev->endTextObject(state); booltextdev->endTextObject(state); - checkNewText(); + /* the only thing "drawn" here is clipping */ + //checkNewText(UNKNOWN_BOUNDING_BOX); gfxdev->endTextObject(state); } +void BitmapOutputDev::endString(GfxState *state) +{ + msg(" endString"); + clip0dev->endString(state); + clip1dev->endString(state); + booltextdev->endString(state); + int render = state->getRender(); + if(render != RENDER_INVISIBLE && render != RENDER_FILL) { + checkNewText(UNKNOWN_BOUNDING_BOX); + } + gfxdev->endString(state); +} +void BitmapOutputDev::endStringOp(GfxState *state) +{ + msg(" endStringOp"); + clip0dev->endStringOp(state); + clip1dev->endStringOp(state); + booltextdev->endStringOp(state); + gfxdev->endStringOp(state); +} /* TODO: these four operations below *should* do nothing, as type3 chars are drawn using operations like fill() */ @@ -1130,23 +1513,93 @@ void BitmapOutputDev::endType3Char(GfxState *state) msg(" endType3Char"); gfxdev->endType3Char(state); } + +class CopyStream: public Object +{ + Dict*dict; + char*buf; + MemStream*memstream; + public: + CopyStream(Stream*str, int len) + { + buf = 0; + str->reset(); + if(len) { + buf = (char*)malloc(len); + int t; + for (t=0; tgetChar(); + } + str->close(); + this->dict = str->getDict(); + this->memstream = new MemStream(buf, 0, len, this); + } + ~CopyStream() + { + ::free(this->buf);this->buf = 0; + delete this->memstream; + } + Dict* getDict() {return dict;} + Stream* getStream() {return this->memstream;}; +}; + +gfxbbox_t BitmapOutputDev::getImageBBox(GfxState*state) +{ + gfxbbox_t bbox; + double x,y; + state->transform(0, 1, &x, &y); + bbox.xmin=bbox.xmax = x; + bbox.ymin=bbox.ymax = x; + state->transform(0, 0, &x, &y); + bbox.xmin=min(bbox.xmin,x); + bbox.ymin=min(bbox.ymin,y); + bbox.xmax=max(bbox.xmin,x); + bbox.ymax=max(bbox.ymin,y); + state->transform(1, 0, &x, &y); + bbox.xmin=min(bbox.xmin,x); + bbox.ymin=min(bbox.ymin,y); + bbox.xmax=max(bbox.xmin,x); + bbox.ymax=max(bbox.ymin,y); + state->transform(1, 1, &x, &y); + bbox.xmin=min(bbox.xmin,x); + bbox.ymin=min(bbox.ymin,y); + bbox.xmax=max(bbox.xmin,x); + bbox.ymax=max(bbox.ymin,y); + return bbox; +} void BitmapOutputDev::drawImageMask(GfxState *state, Object *ref, Stream *str, int width, int height, GBool invert, GBool inlineImg) { - msg(" drawImageMask"); + msg(" drawImageMask streamkind=%d", str->getKind()); + CopyStream*cpystr = 0; + if(inlineImg) { + cpystr = new CopyStream(str, height * ((width + 7) / 8)); + str = cpystr->getStream(); + } boolpolydev->drawImageMask(state, ref, str, width, height, invert, inlineImg); - checkNewBitmap(); + gfxbbox_t bbox = getImageBBox(state); + checkNewBitmap(bbox.xmin, bbox.ymin, ceil(bbox.xmax), ceil(bbox.ymax)); rgbdev->drawImageMask(state, ref, str, width, height, invert, inlineImg); + if(cpystr) + delete cpystr; } void BitmapOutputDev::drawImage(GfxState *state, Object *ref, Stream *str, int width, int height, GfxImageColorMap *colorMap, int *maskColors, GBool inlineImg) { - msg(" drawImage"); + msg(" drawImage streamkind=%d", str->getKind()); + CopyStream*cpystr = 0; + if(inlineImg) { + cpystr = new CopyStream(str, height * ((width * colorMap->getNumPixelComps() * colorMap->getBits() + 7) / 8)); + str = cpystr->getStream(); + } boolpolydev->drawImage(state, ref, str, width, height, colorMap, maskColors, inlineImg); - checkNewBitmap(); + gfxbbox_t bbox=getImageBBox(state); + checkNewBitmap(bbox.xmin, bbox.ymin, ceil(bbox.xmax), ceil(bbox.ymax)); rgbdev->drawImage(state, ref, str, width, height, colorMap, maskColors, inlineImg); + if(cpystr) + delete cpystr; } void BitmapOutputDev::drawMaskedImage(GfxState *state, Object *ref, Stream *str, int width, int height, @@ -1154,9 +1607,10 @@ void BitmapOutputDev::drawMaskedImage(GfxState *state, Object *ref, Stream *str, Stream *maskStr, int maskWidth, int maskHeight, GBool maskInvert) { - msg(" drawMaskedImage"); + msg(" drawMaskedImage streamkind=%d", str->getKind()); boolpolydev->drawMaskedImage(state, ref, str, width, height, colorMap, maskStr, maskWidth, maskHeight, maskInvert); - checkNewBitmap(); + gfxbbox_t bbox=getImageBBox(state); + checkNewBitmap(bbox.xmin, bbox.ymin, ceil(bbox.xmax), ceil(bbox.ymax)); rgbdev->drawMaskedImage(state, ref, str, width, height, colorMap, maskStr, maskWidth, maskHeight, maskInvert); } void BitmapOutputDev::drawSoftMaskedImage(GfxState *state, Object *ref, Stream *str, @@ -1166,16 +1620,17 @@ void BitmapOutputDev::drawSoftMaskedImage(GfxState *state, Object *ref, Stream * int maskWidth, int maskHeight, GfxImageColorMap *maskColorMap) { - msg(" drawSoftMaskedImage"); + 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(); + gfxbbox_t bbox=getImageBBox(state); + checkNewBitmap(bbox.xmin, bbox.ymin, ceil(bbox.xmax), ceil(bbox.ymax)); 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); } @@ -1191,8 +1646,17 @@ void BitmapOutputDev::beginTransparencyGroup(GfxState *state, double *bbox, GBool forSoftMask) { msg(" beginTransparencyGroup"); +#if (xpdfMajorVersion*10000 + xpdfMinorVersion*100 + xpdfUpdateVersion) < 30207 + GfxState*state1 = state->copy(); + GfxState*state2 = state->copy(); + state1->setPath(0); + state1->setPath(state->getPath()->copy()); + state2->setPath(0); + state2->setPath(state->getPath()->copy()); +#else GfxState*state1 = state->copy(gTrue); GfxState*state2 = state->copy(gTrue); +#endif boolpolydev->beginTransparencyGroup(state1, bbox, blendingColorSpace, isolated, knockout, forSoftMask); rgbdev->beginTransparencyGroup(state2, bbox, blendingColorSpace, isolated, knockout, forSoftMask); clip1dev->beginTransparencyGroup(state, bbox, blendingColorSpace, isolated, knockout, forSoftMask); @@ -1202,10 +1666,19 @@ void BitmapOutputDev::beginTransparencyGroup(GfxState *state, double *bbox, void BitmapOutputDev::endTransparencyGroup(GfxState *state) { msg(" endTransparencyGroup"); +#if (xpdfMajorVersion*10000 + xpdfMinorVersion*100 + xpdfUpdateVersion) < 30207 + GfxState*state1 = state->copy(); + GfxState*state2 = state->copy(); + state1->setPath(0); + state1->setPath(state->getPath()->copy()); + state2->setPath(0); + state2->setPath(state->getPath()->copy()); +#else GfxState*state1 = state->copy(gTrue); GfxState*state2 = state->copy(gTrue); +#endif boolpolydev->endTransparencyGroup(state1); - checkNewBitmap(); + checkNewBitmap(UNKNOWN_BOUNDING_BOX); rgbdev->endTransparencyGroup(state2); delete state1; delete state2; @@ -1215,7 +1688,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); } @@ -1223,7 +1696,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); } @@ -1231,7 +1704,7 @@ void BitmapOutputDev::clearSoftMask(GfxState *state) { msg(" clearSoftMask"); boolpolydev->clearSoftMask(state); - checkNewBitmap(); + checkNewBitmap(UNKNOWN_BOUNDING_BOX); rgbdev->clearSoftMask(state); clip1dev->clearSoftMask(state); }