X-Git-Url: http://git.asbjorn.biz/?p=swftools.git;a=blobdiff_plain;f=lib%2Fpdf%2FBitmapOutputDev.cc;h=9e8123b10f4cb04c13a86f697dfee7a2eb4309ea;hp=d0129d260c63e168d10dd7d0bfaa05955dd763c0;hb=0e7d4e61b7bcef123fd8212884bda5dbd3440316;hpb=6a4e4086d9fb91474f4d8c7ae20ec2ad205a34d9 diff --git a/lib/pdf/BitmapOutputDev.cc b/lib/pdf/BitmapOutputDev.cc index d0129d2..9e8123b 100644 --- a/lib/pdf/BitmapOutputDev.cc +++ b/lib/pdf/BitmapOutputDev.cc @@ -29,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}; @@ -50,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); @@ -71,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); @@ -99,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; } @@ -150,143 +160,226 @@ 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 = rgbbitmap->getDataPtr(); - Guchar*alpha = rgbbitmap->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]; - if(this->emptypage) { - 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) */ + + msg(" Flushing bitmap (bbox: %d,%d,%d,%d %dx%d) (clipped against %d,%d,%d,%d)", xmin,ymin,xmax,ymax, xmax-xmin, ymax-ymin, + -this->movex, -this->movey, -this->movex+this->width, -this->movey+this->height); + + if(xmin < -this->movex) { + xmin = -this->movex; + if(xmax < -this->movex) continue; + } + if(ymin < -this->movey) { + ymin = -this->movey; + if(ymax < -this->movey) continue; + } + if(xmax >= -this->movex + this->width) { + xmax = -this->movex+this->width; + if(xmin >= -this->movex + this->width) continue; + } + if(ymax >= -this->movey + this->height) { + ymax = -this->movey+this->height; + if(ymin >= -this->movey + this->height) continue; + } + + 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]; + } + } } } + + /* 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; } - /* 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; - - gfxline_t* line = gfxline_makerectangle(xmin, ymin, xmax, ymax); - dev->fillbitmap(dev, line, img, &m, 0); - gfxline_free(line); + ibbox_destroy(boxes); 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) { 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); @@ -295,43 +388,183 @@ 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; static const char*STATE_NAME[] = {"parallel", "textabovebitmap", "bitmapabovetext"}; -void BitmapOutputDev::checkNewText() +int checkAlphaSanity(SplashBitmap*boolbtm, SplashBitmap*alphabtm) { - /* 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=%s, counter=%d\n", STATE_NAME[layerstate], dbg_btm_counter); + 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; - char filename1[80]; - char filename2[80]; - sprintf(filename1, "state%dbitmap_afternewtext.png", dbg_btm_counter); - sprintf(filename2, "state%dtext_afternewtext.png", dbg_btm_counter); + 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) { - writeAlpha(boolpolybitmap, filename1); + 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++; +} - if(intersection()) { +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=%s, counter=%d\n", STATE_NAME[layerstate], dbg_btm_counter); + + 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* @@ -340,55 +573,58 @@ void BitmapOutputDev::checkNewText() 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 */ + *again* it's above the current bitmap. */ msg(" Text is still above current bitmap/polygon data"); - clearBoolPolyDev(); + 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=%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); - if(0) { - writeAlpha(boolpolybitmap, filename1); - writeAlpha(booltextbitmap, filename2); - } - dbg_btm_counter++; - - if(intersection()) { + 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 { msg(" Bitmap is still above current text data"); - clearBoolTextDev(); + 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() { @@ -409,107 +645,195 @@ void BitmapOutputDev::checkNewBitmap() // break; //} -GBool BitmapOutputDev::clip0and1differ() +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 width8 = (clip0->getWidth()+7)/8; - int height = clip0->getHeight(); - return memcmp(clip0->getDataPtr(), clip1->getDataPtr(), width8*height); + 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 = clip0bitmap; SplashBitmap*clip1 = clip1bitmap; int width = clip0->getAlphaRowSize(); int height = clip0->getHeight(); - return memcmp(clip0->getAlphaPtr(), clip1->getAlphaPtr(), width*height); - } -} -static void clearBooleanBitmap(SplashBitmap*btm) -{ - 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); + 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; } } -long long unsigned int compare64(long long unsigned int*data1, long long unsigned int*data2, int len) -{ - long long unsigned int c; +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;tgetMode()==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 long long int c=0; - assert(sizeof(unsigned long long int)==8); - { - if((polypixels&7) || (textpixels&7)) { - msg(" Non-optimal alignment"); - } - int l2 = len; - len /= sizeof(unsigned long long int); - c = compare64((unsigned long long int*)polypixels, (unsigned long long int*)textpixels, len); - int l1 = len*sizeof(unsigned long long int); - for(t=l1;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; } } @@ -534,7 +858,6 @@ void BitmapOutputDev::startPage(int pageNum, GfxState *state, double crop_x1, do this->width = (int)(x2-x1); this->height = (int)(y2-y1); - msg(" startPage"); rgbdev->startPage(pageNum, state, crop_x1, crop_y1, crop_x2, crop_y2); boolpolydev->startPage(pageNum, state, crop_x1, crop_y1, crop_x2, crop_y2); booltextdev->startPage(pageNum, state, crop_x1, crop_y1, crop_x2, crop_y2); @@ -543,7 +866,15 @@ void BitmapOutputDev::startPage(int pageNum, GfxState *state, double crop_x1, do 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()); + + msg(" startPage %dx%d (%dx%d)", this->width, this->height, booltextbitmap->getWidth(), booltextbitmap->getHeight()); + clip0bitmap = clip0dev->getBitmap(); clip1bitmap = clip1dev->getBitmap(); rgbbitmap = rgbdev->getBitmap(); @@ -871,6 +1202,7 @@ void BitmapOutputDev::updateTransfer(GfxState *state) clip1dev->updateTransfer(state); gfxdev->updateTransfer(state); } + void BitmapOutputDev::updateFont(GfxState *state) { boolpolydev->updateFont(state); @@ -953,26 +1285,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, @@ -983,8 +1362,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, @@ -995,8 +1375,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 @@ -1004,21 +1385,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); } @@ -1058,15 +1439,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"); @@ -1075,49 +1447,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() { - clearBooleanBitmap(clip0bitmap); - clearBooleanBitmap(clip1bitmap); + clearBooleanBitmap(clip0bitmap, 0, 0, 0, 0); + clearBooleanBitmap(clip1bitmap, 0, 0, 0, 0); } void BitmapOutputDev::clearBoolPolyDev() { - clearBooleanBitmap(boolpolybitmap); + clearBooleanBitmap(stalepolybitmap, 0, 0, stalepolybitmap->getWidth(), stalepolybitmap->getHeight()); } void BitmapOutputDev::clearBoolTextDev() { - clearBooleanBitmap(booltextbitmap); + 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"); + 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(state->getRender()&RENDER_STROKE) { + // we're drawing as stroke + 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 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(); @@ -1126,23 +1525,21 @@ 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) { @@ -1151,8 +1548,34 @@ void BitmapOutputDev::endTextObject(GfxState *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 @@ -1211,37 +1634,61 @@ class CopyStream: public Object 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 streamkind=%d", str->getKind()); - CopyStream*cpystr = 0; - if(inlineImg) { - cpystr = new CopyStream(str, height * ((width + 7) / 8)); - str = cpystr->getStream(); - } + + 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); - if(cpystr) - delete cpystr; + 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 streamkind=%d", str->getKind()); - CopyStream*cpystr = 0; - if(inlineImg) { - cpystr = new CopyStream(str, height * ((width * colorMap->getNumPixelComps() * colorMap->getBits() + 7) / 8)); - str = cpystr->getStream(); - } + + 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); - if(cpystr) - delete cpystr; + delete cpystr; + dbg_newdata("image"); } void BitmapOutputDev::drawMaskedImage(GfxState *state, Object *ref, Stream *str, int width, int height, @@ -1250,9 +1697,16 @@ void BitmapOutputDev::drawMaskedImage(GfxState *state, Object *ref, Stream *str, GBool maskInvert) { 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, @@ -1262,15 +1716,22 @@ void BitmapOutputDev::drawSoftMaskedImage(GfxState *state, Object *ref, Stream * GfxImageColorMap *maskColorMap) { 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); } @@ -1302,6 +1763,7 @@ void BitmapOutputDev::beginTransparencyGroup(GfxState *state, double *bbox, clip1dev->beginTransparencyGroup(state, bbox, blendingColorSpace, isolated, knockout, forSoftMask); delete state1; delete state2; + dbg_newdata("endtransparencygroup"); } void BitmapOutputDev::endTransparencyGroup(GfxState *state) { @@ -1318,33 +1780,37 @@ 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; 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"); }