#endif
//xpdf header files
#include "config.h"
+#ifdef HAVE_POPPLER
+#include <goo/GooString.h>
+#include <goo/gfile.h>
+#else
#include "gfile.h"
#include "GString.h"
-#include "gmem.h"
+#endif
#include "Object.h"
#include "Stream.h"
#include "Array.h"
#include "OutputDev.h"
#include "GfxFont.h"
#include "GfxState.h"
-#include "CharCodeToUnicode.h"
#include "NameToUnicodeTable.h"
#include "GlobalParams.h"
-#include "FoFiType1C.h"
-#include "FoFiTrueType.h"
-#include "GHash.h"
#include "GFXOutputDev.h"
// swftools header files
static int verbose = 0;
-static int dbgindent = 0;
+static int dbgindent = 1;
static void dbg(const char*format, ...)
{
char buf[1024];
fflush(stdout);
}
+GFXOutputGlobals*gfxglobals=0;
-void GFXOutputDev::showfeature(const char*feature, char fully, char warn)
+GFXOutputGlobals::GFXOutputGlobals()
+{
+ this->featurewarnings = 0;
+ this->jpeginfo = 0;
+ this->textmodeinfo = 0;
+ this->linkinfo = 0;
+ this->pbminfo = 0;
+}
+GFXOutputGlobals::~GFXOutputGlobals()
{
feature_t*f = this->featurewarnings;
while(f) {
+ feature_t*next = f->next;
+ if(f->string) {
+ free(f->string);f->string =0;
+ }
+ f->next = 0;
+ free(f);
+ f = next;
+ }
+ this->featurewarnings = 0;
+}
+
+void GFXOutputDev::showfeature(const char*feature, char fully, char warn)
+{
+ feature_t*f = gfxglobals->featurewarnings;
+ while(f) {
if(!strcmp(feature, f->string))
return;
f = f->next;
}
f = (feature_t*)malloc(sizeof(feature_t));
f->string = strdup(feature);
- f->next = this->featurewarnings;
- this->featurewarnings = f;
+ f->next = gfxglobals->featurewarnings;
+ gfxglobals->featurewarnings = f;
if(warn) {
msg("<warning> %s not yet %ssupported!",feature,fully?"fully ":"");
if(this->config_break_on_warning) {
static int fcinitcalled = 0;
GFXGlobalParams::GFXGlobalParams()
-: GlobalParams("")
+: GlobalParams((char*)"")
{
//setupBaseFonts(char *dir); //not tested yet
}
GFXOutputDev::GFXOutputDev(InfoOutputDev*info, PDFDoc*doc)
{
+ if(!gfxglobals)
+ gfxglobals = new GFXOutputGlobals();
+
this->info = info;
this->doc = doc;
this->xref = doc->getXRef();
-
- this->jpeginfo = 0;
- this->textmodeinfo = 0;
- this->linkinfo = 0;
- this->pbminfo = 0;
+
this->type3active = 0;
this->statepos = 0;
this->xref = 0;
- this->substitutepos = 0;
- this->type3Warning = 0;
this->user_movex = 0;
this->user_movey = 0;
this->clipmovex = 0;
this->current_text_stroke = 0;
this->current_text_clip = 0;
this->outer_clip_box = 0;
- this->pages = 0;
- this->pagebuflen = 0;
- this->pagepos = 0;
+ this->config_bigchar=0;
this->config_convertgradients=1;
this->config_break_on_warning=0;
this->config_remapunicode=0;
this->config_transparent=0;
this->config_extrafontdata = 0;
- this->config_fontquality = 10;
this->config_optimize_polygons = 0;
-
- this->gfxfontlist = gfxfontlist_create();
+ this->config_multiply = 1;
+ this->dashPattern = 0;
+ this->page2page = 0;
+ this->num_pages = 0;
memset(states, 0, sizeof(states));
- this->featurewarnings = 0;
};
void GFXOutputDev::setParameter(const char*key, const char*value)
this->config_extrafontdata = atoi(value);
} else if(!strcmp(key,"convertgradients")) {
this->config_convertgradients = atoi(value);
+ } else if(!strcmp(key,"multiply")) {
+ this->config_multiply = atoi(value);
+ if(this->config_multiply<1)
+ this->config_multiply=1;
} else if(!strcmp(key,"optimize_polygons")) {
this->config_optimize_polygons = atoi(value);
- } else if(!strcmp(key,"fontquality")) {
- this->config_fontquality = atof(value);
- if(this->config_fontquality<=1)
- this->config_fontquality=1;
- } else if(!strcmp(key,"help")) {
- printf("\nPDF layer options:\n");
- printf("breakonwarning=0/1 Abort conversion if graphic objects are found which\n");
- printf(" are not 100%% supported\n");
- printf("transparent=0/1 Make PDF transparent (alpha background)\n");
- printf("extrafontdata=0/1 Store Type3 characters and capture characters\n");
- printf("fontquality=1..100 Curve approximation quality of the fonts\n");
}
-
}
void GFXOutputDev::setDevice(gfxdevice_t*dev)
m.ty = (y0 + y1)/2 - 0.5;
device->fillgradient(device, &p1, g, gfxgradient_linear, &m);
+
+ free(g);
return gTrue;
}
this->transformXY(state, 1, 1, &tx2, &ty2);
double f = sqrt(sqr(tx2-tx1)+sqr(ty2-ty1)) / SQRT2;
- f = 1.0; //disable dash length transform for now
-
msg("<trace> %d dashes", this->dashLength);
msg("<trace> | phase: %f", this->dashStart);
for(t=0;t<this->dashLength;t++) {
dash[t] = (float)this->dashPattern[t] * f;
+ if(!dash[t])
+ dash[t] = 1e-37;
msg("<trace> | d%-3d: %f", t, this->dashPattern[t]);
}
dash[this->dashLength] = -1;
GFXOutputDev::~GFXOutputDev()
{
finish();
-
- if(this->pages) {
- free(this->pages); this->pages = 0;
- }
-
- feature_t*f = this->featurewarnings;
- while(f) {
- feature_t*next = f->next;
- if(f->string) {
- free(f->string);f->string =0;
- }
- f->next = 0;
- free(f);
- f = next;
+ if(this->dashPattern) {
+ free(this->dashPattern);this->dashPattern = 0;
}
- this->featurewarnings = 0;
-
- gfxfontlist_free(this->gfxfontlist, 1);this->gfxfontlist = 0;
};
GBool GFXOutputDev::upsideDown()
{
tmp_printstr[len] = 0;
return tmp_printstr;
}
-#define INTERNAL_FONT_SIZE 1024.0
void GFXOutputDev::updateFontMatrix(GfxState*state)
{
double* ctm = state->getCTM();
msg("<debug> drawChar(%f,%f,c='%c' (%d), u=%d <%d>) CID=%d render=%d glyphid=%d font=%08x",x,y,(charid&127)>=32?charid:'?', charid, u, uLen, font->isCIDFont(), render, glyphid, current_gfxfont);
gfxmatrix_t m = this->current_font_matrix;
- this->transformXY(state, x, y, &m.tx, &m.ty);
+ this->transformXY(state, x-originX, y-originY, &m.tx, &m.ty);
+ //m.tx += originX; m.ty += originY;
if(render == RENDER_FILL || render == RENDER_INVISIBLE) {
device->drawchar(device, current_gfxfont, glyphid, &col, &m);
} else {
msg("<debug> Drawing glyph %d as shape", charid);
- if(!textmodeinfo) {
+ if(!gfxglobals->textmodeinfo) {
msg("<notice> Some texts will be rendered as shape");
- textmodeinfo = 1;
+ gfxglobals->textmodeinfo = 1;
}
gfxline_t*glyph = current_gfxfont->glyphs[glyphid].line;
gfxline_t*tglyph = gfxline_clone(glyph);
}
else if(strstr(s, "last") || strstr(s, "end"))
{
- if(pages && pagepos>0)
- page = pages[pagepos-1];
+ if(this->page2page && this->num_pages) {
+ page = this->page2page[this->num_pages-1];
+ }
}
else if(strstr(s, "first") || strstr(s, "top"))
{
msg("<trace> drawlink s=%s", s);
- if(!linkinfo && (page || s))
+ if(!gfxglobals->linkinfo && (page || s))
{
msg("<notice> File contains links");
- linkinfo = 1;
+ gfxglobals->linkinfo = 1;
}
- if(page>0)
- {
+ if(page>0) {
int t;
int lpage = -1;
- for(t=1;t<=pagepos;t++) {
- if(pages[t]==page) {
+ for(t=1;t<=this->num_pages;t++) {
+ if(this->page2page[t]==page) {
lpage = t;
break;
}
}
if(lpage<0) {
lpage = page;
- }
+ }
+
char buf[80];
sprintf(buf, "page%d", lpage);
device->drawlink(device, points, buf);
}
void GFXOutputDev::saveState(GfxState *state) {
- dbg("saveState"); dbgindent+=2;
+ dbg("saveState %08x", state); dbgindent+=2;
- msg("<trace> saveState");
+ msg("<trace> saveState %08x", state);
updateAll(state);
if(statepos>=64) {
- msg("<error> Too many nested states in pdf.");
- return;
+ msg("<fatal> Too many nested states in pdf.");
+ exit(1);
}
statepos ++;
+ states[statepos].state = state;
states[statepos].createsoftmask = states[statepos-1].createsoftmask;
states[statepos].transparencygroup = states[statepos-1].transparencygroup;
states[statepos].clipping = 0;
+ states[statepos].olddevice = 0;
states[statepos].clipbbox = states[statepos-1].clipbbox;
};
void GFXOutputDev::restoreState(GfxState *state) {
- dbgindent-=2; dbg("restoreState");
+ dbgindent-=2; dbg("restoreState %08x", state);
if(statepos==0) {
- msg("<error> Invalid restoreState");
- return;
+ msg("<fatal> Invalid restoreState");
+ exit(1);
}
- msg("<trace> restoreState%s%s", states[statepos].softmask?" (end softmask)":"",
+ msg("<trace> restoreState %08x%s%s", state,
+ states[statepos].softmask?" (end softmask)":"",
states[statepos].clipping?" (end clipping)":"");
if(states[statepos].softmask) {
clearSoftMask(state);
}
updateAll(state);
+
while(states[statepos].clipping) {
device->endclip(device);
states[statepos].clipping--;
}
+ if(states[statepos].state!=state) {
+ msg("<fatal> bad state nesting");
+ exit(1);
+ }
+ states[statepos].state=0;
statepos--;
}
void GFXOutputDev::updateLineDash(GfxState *state)
{
- state->getLineDash(&this->dashPattern, &this->dashLength, &this->dashStart);
+ if(this->dashPattern) {
+ free(this->dashPattern);this->dashPattern = 0;
+ }
+ double *pattern = 0;
+ state->getLineDash(&pattern, &this->dashLength, &this->dashStart);
msg("<debug> updateLineDash, %d dashes", this->dashLength);
if(!this->dashLength) {
this->dashPattern = 0;
+ } else {
+ double*p = (double*)malloc(this->dashLength*sizeof(this->dashPattern[0]));
+ memcpy(p, pattern, this->dashLength*sizeof(this->dashPattern[0]));
+ this->dashPattern = p;
}
}
+
+void GFXOutputDev::setPageMap(int*page2page, int num_pages)
+{
+ this->page2page = page2page;
+ this->num_pages = num_pages;
+}
void GFXOutputDev::updateLineWidth(GfxState *state)
{
state->getStrokeRGB(&rgb);
}
-
-static gfxfont_t* createGfxFont(GfxFont*xpdffont, FontInfo*src, double config_fontquality)
-{
- gfxfont_t*font = (gfxfont_t*)malloc(sizeof(gfxfont_t));
- memset(font, 0, sizeof(gfxfont_t));
-
- font->glyphs = (gfxglyph_t*)malloc(sizeof(gfxglyph_t)*src->num_glyphs);
- memset(font->glyphs, 0, sizeof(gfxglyph_t)*src->num_glyphs);
- font->id = 0;
- int t;
-
- double quality = (INTERNAL_FONT_SIZE * 200 / config_fontquality) / src->max_size;
- double scale = 1;
- //printf("%d glyphs\n", font->num_glyphs);
- font->num_glyphs = 0;
- for(t=0;t<src->num_glyphs;t++) {
- if(src->glyphs[t]) {
- SplashPath*path = src->glyphs[t]->path;
- int len = path?path->getLength():0;
- //printf("glyph %d) %08x (%d line segments)\n", t, path, len);
- gfxglyph_t*glyph = &font->glyphs[font->num_glyphs];
- src->glyphs[t]->glyphid = font->num_glyphs;
- glyph->unicode = src->glyphs[t]->unicode;
- if(glyph->unicode >= font->max_unicode)
- font->max_unicode = glyph->unicode+1;
- gfxdrawer_t drawer;
- gfxdrawer_target_gfxline(&drawer);
- int s;
- int count = 0;
- double xmax = 0;
- for(s=0;s<len;s++) {
- Guchar f;
- double x, y;
- path->getPoint(s, &x, &y, &f);
- if(!s || x > xmax)
- xmax = x;
- if(f&splashPathFirst) {
- drawer.moveTo(&drawer, x*scale, y*scale);
- }
- if(f&splashPathCurve) {
- double x2,y2;
- path->getPoint(++s, &x2, &y2, &f);
- if(f&splashPathCurve) {
- double x3,y3;
- path->getPoint(++s, &x3, &y3, &f);
- gfxdraw_cubicTo(&drawer, x*scale, y*scale, x2*scale, y2*scale, x3*scale, y3*scale, quality);
- } else {
- drawer.splineTo(&drawer, x*scale, y*scale, x2*scale, y2*scale);
- }
- } else {
- drawer.lineTo(&drawer, x*scale, y*scale);
- }
- // printf("%f %f %s %s\n", x, y, (f&splashPathCurve)?"curve":"",
- // (f&splashPathFirst)?"first":"",
- // (f&splashPathLast)?"last":"");
- }
- glyph->line = (gfxline_t*)drawer.result(&drawer);
- glyph->advance = xmax*scale; // we don't know the real advance value, so this'll have to do
- font->num_glyphs++;
- }
- }
- font->unicode2glyph = (int*)malloc(sizeof(int)*font->max_unicode);
- memset(font->unicode2glyph, -1, sizeof(int)*font->max_unicode);
- for(t=0;t<font->num_glyphs;t++) {
- if(font->glyphs[t].unicode>0 && font->glyphs[t].unicode<font->max_unicode) {
- font->unicode2glyph[font->glyphs[t].unicode] = t;
- }
-
- }
- msg("<trace> %d glyphs.", t, font->num_glyphs);
- return font;
-}
-
void GFXOutputDev::updateFont(GfxState *state)
{
GfxFont* gfxFont = state->getFont();
if(!this->current_fontinfo->seen) {
dumpFontInfo("<verbose>", gfxFont);
}
-
- gfxfont_t*font = gfxfontlist_findfont(this->gfxfontlist,id);
- if(!font) {
- font = createGfxFont(gfxFont, current_fontinfo, this->config_fontquality);
- font->id = strdup(id);
- this->gfxfontlist = gfxfontlist_addfont(this->gfxfontlist, font);
- }
- device->addfont(device, font);
- current_gfxfont = font;
+ current_gfxfont = this->current_fontinfo->gfxfont;
+ device->addfont(device, current_gfxfont);
free(id);
updateFontMatrix(state);
unsigned char* antialize(unsigned char*data, int width, int height, int newwidth, int newheight, int palettesize)
{
- if((newwidth<2 || newheight<2) ||
+ if((newwidth<1 || newheight<1) ||
(width<=newwidth || height<=newheight))
return 0;
unsigned char*newdata;
double ex = px + fx;
int fromx = (int)px;
int tox = (int)ex;
- int xweight1 = (int)(((fromx+1)-px)*256);
+ int xweight1 = (int)((1-(px-fromx))*256);
int xweight2 = (int)((ex-tox)*256);
double py =0;
for(y=0;y<newheight;y++) {
double ey = py + fy;
int fromy = (int)py;
int toy = (int)ey;
- int yweight1 = (int)(((fromy+1)-py)*256);
+ int yweight1 = (int)((1-(py-fromy))*256);
int yweight2 = (int)((ey-toy)*256);
int a = 0;
int xx,yy;
- for(xx=fromx;xx<tox;xx++)
- for(yy=fromy;yy<toy;yy++) {
+ if(tox>=width)
+ tox = width-1;
+ if(toy>=height)
+ toy = height-1;
+ for(xx=fromx;xx<=tox;xx++)
+ for(yy=fromy;yy<=toy;yy++) {
int b = 1-data[width*yy+xx];
int weight=256;
if(xx==fromx) weight = (weight*xweight1)/256;
double x1,double y1,
double x2,double y2,
double x3,double y3,
- double x4,double y4, int type)
+ double x4,double y4, int type, int multiply)
{
gfxcolor_t*newpic=0;
p5.x = (int)(p5.x*20)/20.0;
p5.y = (int)(p5.y*20)/20.0;
}
-
+
gfxmatrix_t m;
m.m00 = (p4.x-p1.x)/sizex; m.m10 = (p2.x-p1.x)/sizey;
m.m01 = (p4.y-p1.y)/sizex; m.m11 = (p2.y-p1.y)/sizey;
- m.tx = p1.x - 0.5;
- m.ty = p1.y - 0.5;
+
+ m.tx = p1.x - 0.5*multiply;
+ m.ty = p1.y - 0.5*multiply;
gfximage_t img;
img.data = (gfxcolor_t*)data;
/* TODO: pass image_dpi to device instead */
dev->setparameter(dev, "next_bitmap_is_jpeg", "1");
+ dump_outline(&p1);
dev->fillbitmap(dev, &p1, &img, &m, 0);
}
void drawimagejpeg(gfxdevice_t*dev, gfxcolor_t*mem, int sizex,int sizey,
- double x1,double y1, double x2,double y2, double x3,double y3, double x4,double y4)
+ double x1,double y1, double x2,double y2, double x3,double y3, double x4,double y4, int multiply)
{
- drawimage(dev,mem,sizex,sizey,x1,y1,x2,y2,x3,y3,x4,y4, IMAGE_TYPE_JPEG);
+ drawimage(dev,mem,sizex,sizey,x1,y1,x2,y2,x3,y3,x4,y4, IMAGE_TYPE_JPEG, multiply);
}
void drawimagelossless(gfxdevice_t*dev, gfxcolor_t*mem, int sizex,int sizey,
- double x1,double y1, double x2,double y2, double x3,double y3, double x4,double y4)
+ double x1,double y1, double x2,double y2, double x3,double y3, double x4,double y4, int multiply)
{
- drawimage(dev,mem,sizex,sizey,x1,y1,x2,y2,x3,y3,x4,y4, IMAGE_TYPE_LOSSLESS);
+ drawimage(dev,mem,sizex,sizey,x1,y1,x2,y2,x3,y3,x4,y4, IMAGE_TYPE_LOSSLESS, multiply);
}
GBool inlineImg, int mask, int*maskColors,
Stream *maskStr, int maskWidth, int maskHeight, GBool maskInvert, GfxImageColorMap*maskColorMap)
{
+ /* the code in this function is *old*. It's not pretty, but it works. */
+
double x1,y1,x2,y2,x3,y3,x4,y4;
ImageStream *imgStr;
Guchar pixBuf[4];
imgStr = new ImageStream(str, width, ncomps,bits);
imgStr->reset();
- if(!width || !height || (height<=1 && width<=1 && maskWidth<=1 && maskHeight<=1))
+ if(!width || !height || ((height+width)<=1 && (maskWidth+maskHeight)<=1))
{
msg("<verbose> Ignoring %d by %d image", width, height);
unsigned char buf[8];
return;
}
- this->transformXY(state, 0, 1, &x1, &y1); x1 = (int)(x1);y1 = (int)(y1);
- this->transformXY(state, 0, 0, &x2, &y2); x2 = (int)(x2);y2 = (int)(y2);
- this->transformXY(state, 1, 0, &x3, &y3); x3 = (int)(x3);y3 = (int)(y3);
- this->transformXY(state, 1, 1, &x4, &y4); x4 = (int)(x4);y4 = (int)(y4);
+ this->transformXY(state, 0, 1, &x1, &y1);
+ this->transformXY(state, 0, 0, &x2, &y2);
+ this->transformXY(state, 1, 0, &x3, &y3);
+ this->transformXY(state, 1, 1, &x4, &y4);
+
+ if(type3active) {
+ /* as type 3 bitmaps are antialized, we need to place them
+ at integer coordinates, otherwise flash player's antializing
+ will kick in and make everything blurry */
+ x1 = (int)(x1);y1 = (int)(y1);
+ x2 = (int)(x2);y2 = (int)(y2);
+ x3 = (int)(x3);y3 = (int)(y3);
+ x4 = (int)(x4);y4 = (int)(y4);
+ }
- if(!pbminfo && !(str->getKind()==strDCT)) {
+ if(!gfxglobals->pbminfo && !(str->getKind()==strDCT)) {
if(!type3active) {
msg("<notice> File contains pbm pictures %s",mask?"(masked)":"");
- pbminfo = 1;
+ gfxglobals->pbminfo = 1;
}
if(mask)
msg("<verbose> drawing %d by %d masked picture", width, height);
}
- if(!jpeginfo && (str->getKind()==strDCT)) {
+ if(!gfxglobals->jpeginfo && (str->getKind()==strDCT)) {
msg("<notice> File contains jpeg pictures");
- jpeginfo = 1;
+ gfxglobals->jpeginfo = 1;
}
if(mask) {
buf[0]=1-buf[0];
pic[width*y+x] = buf[0];
}
-
- /* the size of the drawn image is added to the identifier
- as the same image may require different bitmaps if displayed
- at different sizes (due to antialiasing): */
- int found = -1;
+
if(type3active) {
unsigned char*pic2 = 0;
numpalette = 16;
pic2[width*y+x] = pal[pic[y*width+x]];
}
}
- drawimagelossless(device, pic2, width, height, x1,y1,x2,y2,x3,y3,x4,y4);
+ drawimagelossless(device, pic2, width, height, x1,y1,x2,y2,x3,y3,x4,y4, config_multiply);
delete[] pic2;
delete[] pic;
delete imgStr;
pic[width*y+x].b = (unsigned char)(colToByte(rgb.b));
pic[width*y+x].a = 255;//(U8)(rgb.a * 255 + 0.5);
if(maskbitmap) {
- pic[width*y+x].a = maskbitmap[(y*maskHeight/height)*maskWidth+(x*maskWidth/width)];
+ int x1 = x*maskWidth/width;
+ int y1 = y*maskHeight/height;
+ int x2 = (x+1)*maskWidth/width;
+ int y2 = (y+1)*maskHeight/height;
+ int xx,yy;
+ unsigned int alpha=0;
+ unsigned int count=0;
+ for(xx=x1;xx<x2;xx++)
+ for(yy=y1;yy<y2;yy++) {
+ alpha += maskbitmap[yy*maskWidth+xx];
+ count ++;
+ }
+ if(count) {
+ pic[width*y+x].a = alpha / count;
+ } else {
+ pic[width*y+x].a = maskbitmap[y1*maskWidth+x1];
+ }
}
}
}
if(str->getKind()==strDCT)
- drawimagejpeg(device, pic, width, height, x1,y1,x2,y2,x3,y3,x4,y4);
+ drawimagejpeg(device, pic, width, height, x1,y1,x2,y2,x3,y3,x4,y4, config_multiply);
else
- drawimagelossless(device, pic, width, height, x1,y1,x2,y2,x3,y3,x4,y4);
+ drawimagelossless(device, pic, width, height, x1,y1,x2,y2,x3,y3,x4,y4, config_multiply);
delete[] pic;
delete imgStr;
if(maskbitmap) free(maskbitmap);
height = maskHeight;
}
}
- drawimagelossless(device, pic, width, height, x1,y1,x2,y2,x3,y3,x4,y4);
+ drawimagelossless(device, pic, width, height, x1,y1,x2,y2,x3,y3,x4,y4, config_multiply);
delete[] pic;
delete imgStr;
#endif
}
-void GFXOutputDev::preparePage(int pdfpage, int outputpage)
-{
- if(pdfpage < 0)
- return;
-
- if(!this->pages) {
- this->pagebuflen = 1024;
- this->pages = (int*)malloc(this->pagebuflen*sizeof(int));
- memset(this->pages, -1, this->pagebuflen*sizeof(int));
- } else {
- while(pdfpage >= this->pagebuflen)
- {
- int oldlen = this->pagebuflen;
- this->pagebuflen+=1024;
- this->pages = (int*)realloc(this->pages, this->pagebuflen*sizeof(int));
- memset(&this->pages[oldlen], -1, (this->pagebuflen-oldlen)*sizeof(int));
- }
- }
- this->pages[pdfpage] = outputpage;
- if(pdfpage>this->pagepos)
- this->pagepos = pdfpage;
-}
-
void GFXOutputDev::beginTransparencyGroup(GfxState *state, double *bbox,
GfxColorSpace *blendingColorSpace,
GBool isolated, GBool knockout,
states[statepos].olddevice = this->device;
this->device = (gfxdevice_t*)rfx_calloc(sizeof(gfxdevice_t));
+ dbg("this->device now %08x (old: %08x)", this->device, states[statepos].olddevice);
gfxdevice_record_init(this->device);
dbgindent-=2;
gfxdevice_t*r = this->device;
+ dbg("endTransparencyGroup this->device now back to %08x (destroying %08x)", states[statepos].olddevice, this->device);
+
this->device = states[statepos].olddevice;
+ if(!this->device) {
+ msg("<fatal> bad state nesting in transparency group- PDF file broken?");
+ /* if these errors occur more often, we should build a seperate
+ transparency group stack, like xpdf/SplashOutputDev.cc does */
+ restoreState(state);
+ this->device = states[statepos].olddevice;
+ }
+ states[statepos].olddevice = 0;
gfxresult_t*recording = r->finish(r);
- dbg("endTransparencyGroup forsoftmask=%d recording=%08x/%08x", states[statepos].createsoftmask, r, recording);
+ dbg(" forsoftmask=%d recording=%08x/%08x", states[statepos].createsoftmask, r, recording);
msg("<verbose> endTransparencyGroup forsoftmask=%d recording=%08x/%08x", states[statepos].createsoftmask, r, recording);
if(states[statepos].createsoftmask) {
"colordodge","colorburn","hardlight","softlight","difference",
"exclusion","hue","saturation","color","luminosity"};
- dbg("paintTransparencyGroup blend=%s softmaskon=%d", blendmodes[state->getBlendMode()], states[statepos].softmask);
+ dbg("paintTransparencyGroup blend=%s softmaskon=%d recording=%08x", blendmodes[state->getBlendMode()], states[statepos].softmask, states[statepos].grouprecording);
msg("<verbose> paintTransparencyGroup blend=%s softmaskon=%d", blendmodes[state->getBlendMode()], states[statepos].softmask);
-
+
if(state->getBlendMode() == gfxBlendNormal)
infofeature("transparency groups");
else {
if(blendmode == gfxBlendMultiply && alpha>200)
alpha = 128;
gfxdevice_t ops;
+ dbg("this->device=%08x, this->device->name=%s\n", this->device, this->device->name);
gfxdevice_ops_init(&ops, this->device, alpha);
gfxresult_record_replay(grouprecording, &ops);
ops.finish(&ops);
infofeature("soft masks");
else
warnfeature("soft masks from alpha channel",0);
-
+
+ if(states[statepos].olddevice) {
+ msg("<fatal> Internal error: badly balanced softmasks/transparency groups");
+ exit(1);
+ }
states[statepos].olddevice = this->device;
this->device = (gfxdevice_t*)rfx_calloc(sizeof(gfxdevice_t));
gfxdevice_record_init(this->device);
git.asbjorn.biz / swftools.git / blobdiff