X-Git-Url: http://git.asbjorn.biz/?p=swftools.git;a=blobdiff_plain;f=lib%2Fpdf%2FBitmapOutputDev.cc;h=49f5e3cda539b2178ac39a8eabae3a2fe4cbfc95;hp=d0dafa81e06f3514edaf8461fd3b5f043e13704e;hb=bd6e5cd809f4fa605f8505fa06712981b3443537;hpb=b3c3a691bfb5d1d06c086744f1ba7d8061379772 diff --git a/lib/pdf/BitmapOutputDev.cc b/lib/pdf/BitmapOutputDev.cc index d0dafa8..49f5e3c 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); @@ -70,7 +75,7 @@ BitmapOutputDev::BitmapOutputDev(InfoOutputDev*info, PDFDoc*doc) this->clip1dev->startDoc(this->xref); this->gfxoutput = (gfxdevice_t*)malloc(sizeof(gfxdevice_t)); - gfxdevice_record_init(this->gfxoutput); + gfxdevice_record_init(this->gfxoutput, 0); this->gfxdev->setDevice(this->gfxoutput); @@ -98,6 +103,12 @@ BitmapOutputDev::~BitmapOutputDev() if(this->boolpolydev) { delete this->boolpolydev;this->boolpolydev = 0; } + if(this->stalepolybitmap) { + delete this->stalepolybitmap;this->stalepolybitmap = 0; + } + if(this->staletextbitmap) { + delete this->staletextbitmap;this->staletextbitmap = 0; + } if(this->booltextdev) { delete this->booltextdev;this->booltextdev = 0; } @@ -149,129 +160,212 @@ 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; - } -} +static int dbg_btm_counter=1; 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++;*/ + + /*static int counter=0; + char filename[160]; + sprintf(filename, "test%d.png", counter++); + writeBitmap(rgbbitmap, filename);*/ + + SplashColorPtr rgb = rgbbitmap->getDataPtr(); + Guchar*alpha = rgbbitmap->getAlphaPtr(); + + Guchar*alpha2 = stalepolybitmap->getDataPtr(); + int width8 = (stalepolybitmap->getWidth()+7)/8; + + /*char filename[80]; + sprintf(filename, "flush%d_mask.png", dbg_btm_counter); + writeAlpha(stalepolybitmap, filename); + sprintf(filename, "flush%d_alpha.png", dbg_btm_counter); + writeAlpha(rgbbitmap, filename); + sprintf(filename, "flush%d_bitmap.png", dbg_btm_counter); + writeBitmap(rgbbitmap, filename);*/ + + ibbox_t* boxes = get_bitmap_bboxes((unsigned char*)alpha, width, height); + ibbox_t*b; + + for(b=boxes;b;b=b->next) { + int xmin = b->xmin; + int ymin = b->ymin; + int xmax = b->xmax; + int ymax = b->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 + 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+xmin)&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, this + data has non-premultiplied alpha, which is exactly what the output device + expects, so don't premultiply it here, either. + */ + out[x].r = in[x*3+0]; + out[x].g = in[x*3+1]; + out[x].b = in[x*3+2]; + out[x].a = ain[x]; + } + } + } + } - gfxline_t* line = gfxline_makerectangle(xmin, ymin, xmax, ymax); - dev->fillbitmap(dev, line, img, &m, 0); - gfxline_free(line); + /* 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(rgbdev->getBitmap()->getAlphaPtr(), 0, rgbdev->getBitmap()->getWidth()*rgbdev->getBitmap()->getHeight()); - memset(rgbdev->getBitmap()->getDataPtr(), 0, rgbdev->getBitmap()->getRowSize()*rgbdev->getBitmap()->getHeight()); + memset(rgbbitmap->getAlphaPtr(), 0, rgbbitmap->getWidth()*rgbbitmap->getHeight()); + memset(rgbbitmap->getDataPtr(), 0, rgbbitmap->getRowSize()*rgbbitmap->getHeight()); - free(img->data);img->data=0;free(img);img=0; + this->emptypage = 0; } void BitmapOutputDev::flushText() { - msg(" Flushing text/polygons"); + msg(" Flushing text"); 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].b = d[x].a = 255; + d[x].g = 0; + } else { + d[x].r = d[x].g = d[x].b = d[x].a = 0; + } + } + } + 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); @@ -280,95 +374,248 @@ void writeAlpha(SplashBitmap*bitmap, char*filename) for(x=0;xgetAlpha(x,y); line[x].r = a; - line[x].g = a; + line[x].g = 0; line[x].b = a; - line[x].a = 255; + line[x].a = a; } } writePNG(filename, (unsigned char*)data, width, height); free(data); } -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; +} + +static inline GBool fixBBox(int*x1, int*y1, int*x2, int*y2, int width, int 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; +} + +static void update_bitmap(SplashBitmap*bitmap, SplashBitmap*update, int x1, int y1, int x2, int y2, char overwrite) +{ + assert(bitmap->getMode()==splashModeMono1); + assert(update->getMode()==splashModeMono1); + + int width8 = (bitmap->getWidth()+7)/8; + assert(width8 == bitmap->getRowSize()); + assert(width8 == update->getRowSize()); + int height = bitmap->getHeight(); + assert(height == update->getHeight()); + + if(!fixBBox(&x1, &y1, &x2, &y2, bitmap->getWidth(), bitmap->getHeight())) + return; + + Guchar*b = bitmap->getDataPtr() + y1*width8 + x1/8; + Guchar*u = update->getDataPtr() + y1*width8 + x1/8; + int yspan = y2-y1; + int xspan = (x2+7)/8 - x1/8; + int size = (y2-y1)*width8; + + if(overwrite) { + int y; + for(y=0;ygetWidth(), btm->getHeight())) + return; + + if(btm->getMode()==splashModeMono1) { + int width8 = (btm->getWidth()+7)/8; + assert(width8 == btm->getRowSize()); + int width = btm->getWidth(); + int height = btm->getHeight(); + Guchar*data = btm->getDataPtr(); + memset(data+y1*width8, 0, width8*(y2-y1)); + } else { + int width = btm->getAlphaRowSize(); + int height = btm->getHeight(); + memset(btm->getAlphaPtr(), 0, width*height); + } +} + +void BitmapOutputDev::dbg_newdata(char*newdata) +{ + if(0) { + char filename1[80]; + char filename2[80]; + char filename3[80]; + sprintf(filename1, "state%03dboolbitmap_after%s.png", dbg_btm_counter, newdata); + sprintf(filename2, "state%03dbooltext_after%s.png", dbg_btm_counter, newdata); + sprintf(filename3, "state%03dbitmap_after%s.png", dbg_btm_counter, newdata); + msg(" %s %s %s", filename1, filename2, filename3); + writeAlpha(stalepolybitmap, filename1); + writeAlpha(booltextbitmap, filename2); + writeBitmap(rgbdev->getBitmap(), filename3); + } + dbg_btm_counter++; +} + +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); - dbg_btm_counter++; - - if(intersection()) { - msg(" Text is above current bitmap/polygon data"); + GBool ret = false; + if(intersection(booltextbitmap, stalepolybitmap, 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 */ + /* the new text is above the bitmap. So record that fact. */ + msg(" Text is above current bitmap/polygon data"); layerstate=STATE_TEXT_IS_ABOVE; - clearBoolPolyDev(); + update_bitmap(staletextbitmap, booltextbitmap, x1, y1, x2, y2, 0); } 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(); + /* re-apply the update (which we would otherwise lose) */ + update_bitmap(staletextbitmap, booltextbitmap, x1, y1, x2, y2, 1); + ret = true; } else { /* we already know that the current text section is above the current bitmap section- now just new bitmap data *and* new text data was drawn, and - *again* it's above the current bitmap- so clear - the polygon bitmap again, so we can check for - new intersections */ - clearBoolPolyDev(); + *again* it's above the current bitmap. */ + msg(" Text is still above current bitmap/polygon data"); + update_bitmap(staletextbitmap, booltextbitmap, x1, y1, x2, y2, 0); } - } -} + } else { + update_bitmap(staletextbitmap, booltextbitmap, x1, y1, x2, y2, 0); + } + + /* clear the thing we just drew from our temporary drawing bitmap */ + clearBooleanBitmap(booltextbitmap, x1, y1, x2, y2); -void BitmapOutputDev::checkNewBitmap() + return ret; +} +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); - dbg_btm_counter++; + msg(" Testing new graphics data against current text data, state=%s, counter=%d\n", STATE_NAME[layerstate], dbg_btm_counter); - if(intersection()) { - msg(" Bitmap is above current text data"); + GBool ret = false; + if(intersection(boolpolybitmap, staletextbitmap, x1,y1,x2,y2)) { if(layerstate==STATE_PARALLEL) { + msg(" Bitmap is above current text data"); layerstate=STATE_BITMAP_IS_ABOVE; - clearBoolTextDev(); + update_bitmap(stalepolybitmap, boolpolybitmap, x1, y1, x2, y2, 0); } 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(); + update_bitmap(stalepolybitmap, boolpolybitmap, x1, y1, x2, y2, 1); + ret = true; } else { - clearBoolTextDev(); + msg(" Bitmap is still above current text data"); + update_bitmap(stalepolybitmap, boolpolybitmap, x1, y1, x2, y2, 0); } - } + } else { + update_bitmap(stalepolybitmap, boolpolybitmap, x1, y1, x2, y2, 0); + } + + /* clear the thing we just drew from our temporary drawing bitmap */ + clearBooleanBitmap(boolpolybitmap, 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(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) -{ - SplashBitmap*btm = dev->getBitmap(); - if(btm->getMode()==splashModeMono1) { - int width8 = (btm->getWidth()+7)/8; - int width = btm->getWidth(); - int height = btm->getHeight(); - memset(btm->getDataPtr(), 0, width8*height); - } else { - int width = btm->getAlphaRowSize(); - int height = btm->getHeight(); - memset(btm->getAlphaPtr(), 0, width*height); +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 align both to 8 byte + 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(); - 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); + } + return overlap2; } } @@ -507,6 +852,18 @@ 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(); + stalepolybitmap = new SplashBitmap(boolpolybitmap->getWidth(), boolpolybitmap->getHeight(), 1, boolpolybitmap->getMode(), 0); + assert(stalepolybitmap->getRowSize() == boolpolybitmap->getRowSize()); + + booltextbitmap = booltextdev->getBitmap(); + staletextbitmap = new SplashBitmap(booltextbitmap->getWidth(), booltextbitmap->getHeight(), 1, booltextbitmap->getMode(), 0); + assert(staletextbitmap->getRowSize() == booltextbitmap->getRowSize()); + + 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 @@ -515,11 +872,21 @@ void BitmapOutputDev::startPage(int pageNum, GfxState *state, double crop_x1, do clearBoolPolyDev(); 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 +903,6 @@ void BitmapOutputDev::endPage() rgbdev->endPage(); clip0dev->endPage(); clip1dev->endPage(); - gfxdev->endPage(); } GBool BitmapOutputDev::upsideDown() @@ -821,6 +1187,7 @@ void BitmapOutputDev::updateTransfer(GfxState *state) clip1dev->updateTransfer(state); gfxdev->updateTransfer(state); } + void BitmapOutputDev::updateFont(GfxState *state) { boolpolydev->updateFont(state); @@ -903,26 +1270,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); + dbg_newdata("stroke"); } void BitmapOutputDev::fill(GfxState *state) { msg(" fill"); boolpolydev->fill(state); - checkNewBitmap(); + gfxbbox_t bbox = getBBox(state); + checkNewBitmap(bbox.xmin, bbox.ymin, ceil(bbox.xmax), ceil(bbox.ymax)); rgbdev->fill(state); + dbg_newdata("fill"); } void BitmapOutputDev::eoFill(GfxState *state) { msg(" eoFill"); boolpolydev->eoFill(state); - checkNewBitmap(); + gfxbbox_t bbox = getBBox(state); + checkNewBitmap(bbox.xmin, bbox.ymin, ceil(bbox.xmax), ceil(bbox.ymax)); rgbdev->eoFill(state); + dbg_newdata("eofill"); } #if (xpdfMajorVersion*10000 + xpdfMinorVersion*100 + xpdfUpdateVersion) < 30207 void BitmapOutputDev::tilingPatternFill(GfxState *state, Object *str, @@ -933,8 +1347,9 @@ 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); + dbg_newdata("tilingpatternfill"); } #else void BitmapOutputDev::tilingPatternFill(GfxState *state, Gfx *gfx, Object *str, @@ -945,8 +1360,9 @@ 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); + dbg_newdata("tilingpatternfill"); } #endif @@ -954,21 +1370,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 +1424,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 +1432,72 @@ 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() { - clearBooleanDev(boolpolydev); + clearBooleanBitmap(stalepolybitmap, 0, 0, stalepolybitmap->getWidth(), stalepolybitmap->getHeight()); } void BitmapOutputDev::clearBoolTextDev() { - clearBooleanDev(booltextdev); + clearBooleanBitmap(staletextbitmap, 0, 0, staletextbitmap->getWidth(), staletextbitmap->getHeight()); } 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); 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; + x-=originX; + y-=originY; + if(path) { + 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; + } + delete(path);path=0; + } /* 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,32 +1506,57 @@ 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); } } + dbg_newdata("text"); } void BitmapOutputDev::drawString(GfxState *state, GString *s) { msg(" internal error: drawString not implemented"); return; - clip0dev->drawString(state, s); - clip1dev->drawString(state, s); - booltextdev->drawString(state, s); - gfxdev->drawString(state, 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); + dbg_newdata("endtextobject"); +} +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) { + /* xpdf draws things like stroke text or fill+stroke text in the + endString() method */ + checkNewText(UNKNOWN_BOUNDING_BOX); + } + gfxdev->endString(state); + dbg_newdata("endstring"); +} +void BitmapOutputDev::endStringOp(GfxState *state) +{ + msg(" endStringOp"); + clip0dev->endStringOp(state); + clip1dev->endStringOp(state); + booltextdev->endStringOp(state); + gfxdev->endStringOp(state); + dbg_newdata("endstringop"); } /* TODO: these four operations below *should* do nothing, as type3 @@ -1130,23 +1585,91 @@ 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 = y; + state->transform(0, 0, &x, &y); + bbox.xmin=min(bbox.xmin,x); + bbox.ymin=min(bbox.ymin,y); + bbox.xmax=max(bbox.xmax,x); + bbox.ymax=max(bbox.ymax,y); + state->transform(1, 0, &x, &y); + bbox.xmin=min(bbox.xmin,x); + bbox.ymin=min(bbox.ymin,y); + bbox.xmax=max(bbox.xmax,x); + bbox.ymax=max(bbox.ymax,y); + state->transform(1, 1, &x, &y); + 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::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 = 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); + delete cpystr; + dbg_newdata("imagemask"); } 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 = 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); + delete cpystr; + dbg_newdata("image"); } void BitmapOutputDev::drawMaskedImage(GfxState *state, Object *ref, Stream *str, int width, int height, @@ -1154,10 +1677,17 @@ 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()); + + CopyStream*cpystr = new CopyStream(str, height * ((width * colorMap->getNumPixelComps() * colorMap->getBits() + 7) / 8)); + str = cpystr->getStream(); + 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); + delete cpystr; + dbg_newdata("maskedimage"); } void BitmapOutputDev::drawSoftMaskedImage(GfxState *state, Object *ref, Stream *str, int width, int height, @@ -1166,16 +1696,23 @@ 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()); + + CopyStream*cpystr = new CopyStream(str, height * ((width * colorMap->getNumPixelComps() * colorMap->getBits() + 7) / 8)); + str = cpystr->getStream(); + 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); + delete cpystr; + dbg_newdata("softmaskimage"); } void BitmapOutputDev::drawForm(Ref id) { msg(" drawForm"); boolpolydev->drawForm(id); - checkNewBitmap(); + checkNewBitmap(UNKNOWN_BOUNDING_BOX); rgbdev->drawForm(id); } @@ -1191,47 +1728,70 @@ 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); delete state1; delete state2; + dbg_newdata("endtransparencygroup"); } 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; clip1dev->endTransparencyGroup(state); + dbg_newdata("endtransparencygroup"); } 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); + dbg_newdata("painttransparencygroup"); } void BitmapOutputDev::setSoftMask(GfxState *state, double *bbox, GBool alpha, Function *transferFunc, GfxColor *backdropColor) { 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); + dbg_newdata("setsoftmask"); } void BitmapOutputDev::clearSoftMask(GfxState *state) { msg(" clearSoftMask"); boolpolydev->clearSoftMask(state); - checkNewBitmap(); + checkNewBitmap(UNKNOWN_BOUNDING_BOX); rgbdev->clearSoftMask(state); clip1dev->clearSoftMask(state); + dbg_newdata("clearsoftmask"); }