static void
fz_drawbegingroup(void *user, fz_rect rect, int isolated, int knockout, fz_blendmode blendmode, float alpha)
{
fz_drawdevice *dev = user;
fz_colorspace *model = dev->dest->colorspace;
fz_bbox bbox;
fz_pixmap *dest;
if (dev->top == STACKSIZE)
{
fz_warn("assert: too many buffers on stack");
return;
}
bbox = fz_roundrect(rect);
bbox = fz_intersectbbox(bbox, dev->scissor);
dest = fz_newpixmapwithrect(model, bbox);
fz_clearpixmap(dest, 0);
dev->stack[dev->top].alpha = alpha;
dev->stack[dev->top].blendmode = blendmode;
dev->stack[dev->top].scissor = dev->scissor;
dev->stack[dev->top].dest = dev->dest;
dev->top++;
dev->scissor = bbox;
dev->dest = dest;
}
static void
fz_drawfillpath(void *user, fz_path *path, int evenodd, fz_matrix ctm,
fz_colorspace *colorspace, float *color, float alpha)
{
fz_drawdevice *dev = user;
fz_colorspace *model = dev->dest->colorspace;
float expansion = fz_matrixexpansion(ctm);
float flatness = 0.3f / expansion;
unsigned char colorbv[FZ_MAXCOLORS + 1];
float colorfv[FZ_MAXCOLORS];
fz_bbox bbox;
int i;
fz_resetgel(dev->gel, dev->scissor);
fz_fillpath(dev->gel, path, ctm, flatness);
fz_sortgel(dev->gel);
bbox = fz_boundgel(dev->gel);
bbox = fz_intersectbbox(bbox, dev->scissor);
if (fz_isemptyrect(bbox))
return;
fz_convertcolor(colorspace, color, model, colorfv);
for (i = 0; i < model->n; i++)
colorbv[i] = colorfv[i] * 255;
colorbv[i] = alpha * 255;
fz_scanconvert(dev->gel, dev->ael, evenodd, bbox, dev->dest, colorbv);
}
static void
fz_drawbeginmask(void *user, fz_rect rect, int luminosity, fz_colorspace *colorspace, float *colorfv)
{
fz_drawdevice *dev = user;
fz_pixmap *dest;
fz_bbox bbox;
if (dev->top == STACKSIZE)
{
fz_warn("assert: too many buffers on stack");
return;
}
bbox = fz_roundrect(rect);
bbox = fz_intersectbbox(bbox, dev->scissor);
dest = fz_newpixmapwithrect(fz_devicegray, bbox);
if (luminosity)
{
/* SumatraPDF: pass a Luminosity softmask's background color */
float gray = 1.0;
fz_convertcolor(colorspace, colorfv, fz_devicegray, &gray);
fz_clearpixmap(dest, gray * 255);
}
else
fz_clearpixmap(dest, 0);
dev->stack[dev->top].scissor = dev->scissor;
dev->stack[dev->top].dest = dev->dest;
dev->stack[dev->top].luminosity = luminosity;
dev->top++;
dev->scissor = bbox;
dev->dest = dest;
}
static void
drawglyph(unsigned char *colorbv, fz_pixmap *dst, fz_pixmap *msk,
int xorig, int yorig, fz_bbox scissor)
{
unsigned char *dp, *mp;
fz_bbox bbox;
int x, y, w, h;
bbox = fz_boundpixmap(msk);
bbox.x0 += xorig;
bbox.y0 += yorig;
bbox.x1 += xorig;
bbox.y1 += yorig;
bbox = fz_intersectbbox(bbox, scissor); /* scissor < dst */
x = bbox.x0;
y = bbox.y0;
w = bbox.x1 - bbox.x0;
h = bbox.y1 - bbox.y0;
mp = msk->samples + ((y - msk->y - yorig) * msk->w + (x - msk->x - xorig));
dp = dst->samples + ((y - dst->y) * dst->w + (x - dst->x)) * dst->n;
assert(msk->n == 1);
while (h--)
{
if (dst->colorspace)
fz_paintspancolor(dp, mp, dst->n, w, colorbv);
else
fz_paintspan(dp, mp, 1, w, 255);
dp += dst->w * dst->n;
mp += msk->w;
}
}
static void
fz_drawclippath(void *user, fz_path *path, int evenodd, fz_matrix ctm)
{
fz_drawdevice *dev = user;
fz_colorspace *model = dev->dest->colorspace;
float expansion = fz_matrixexpansion(ctm);
float flatness = 0.3f / expansion;
fz_pixmap *mask, *dest;
fz_bbox bbox;
if (dev->top == STACKSIZE)
{
fz_warn("assert: too many buffers on stack");
return;
}
fz_resetgel(dev->gel, dev->scissor);
fz_fillpath(dev->gel, path, ctm, flatness);
fz_sortgel(dev->gel);
bbox = fz_boundgel(dev->gel);
bbox = fz_intersectbbox(bbox, dev->scissor);
if (fz_isemptyrect(bbox) || fz_isrectgel(dev->gel))
{
dev->stack[dev->top].scissor = dev->scissor;
dev->stack[dev->top].mask = nil;
dev->stack[dev->top].dest = nil;
dev->scissor = bbox;
dev->top++;
return;
}
mask = fz_newpixmapwithrect(nil, bbox);
dest = fz_newpixmapwithrect(model, bbox);
fz_clearpixmap(mask, 0);
fz_clearpixmap(dest, 0);
fz_scanconvert(dev->gel, dev->ael, evenodd, bbox, mask, nil);
dev->stack[dev->top].scissor = dev->scissor;
dev->stack[dev->top].mask = mask;
dev->stack[dev->top].dest = dev->dest;
dev->scissor = bbox;
dev->dest = dest;
dev->top++;
}
static void
fz_drawclipstrokepath(void *user, fz_path *path, fz_strokestate *stroke, fz_matrix ctm)
{
fz_drawdevice *dev = user;
fz_colorspace *model = dev->dest->colorspace;
float expansion = fz_matrixexpansion(ctm);
float flatness = 0.3f / expansion;
float linewidth = stroke->linewidth;
fz_pixmap *mask, *dest;
fz_bbox bbox;
if (dev->top == STACKSIZE)
{
fz_warn("assert: too many buffers on stack");
return;
}
if (linewidth * expansion < 0.1f)
linewidth = 1 / expansion;
fz_resetgel(dev->gel, dev->scissor);
if (stroke->dashlen > 0)
fz_dashpath(dev->gel, path, stroke, ctm, flatness, linewidth);
else
fz_strokepath(dev->gel, path, stroke, ctm, flatness, linewidth);
fz_sortgel(dev->gel);
bbox = fz_boundgel(dev->gel);
bbox = fz_intersectbbox(bbox, dev->scissor);
mask = fz_newpixmapwithrect(nil, bbox);
dest = fz_newpixmapwithrect(model, bbox);
fz_clearpixmap(mask, 0);
fz_clearpixmap(dest, 0);
if (!fz_isemptyrect(bbox))
fz_scanconvert(dev->gel, dev->ael, 0, bbox, mask, nil);
dev->stack[dev->top].scissor = dev->scissor;
dev->stack[dev->top].mask = mask;
dev->stack[dev->top].dest = dev->dest;
dev->scissor = bbox;
dev->dest = dest;
dev->top++;
}
static void
fz_drawstrokepath(void *user, fz_path *path, fz_strokestate *stroke, fz_matrix ctm,
fz_colorspace *colorspace, float *color, float alpha)
{
fz_drawdevice *dev = user;
fz_colorspace *model = dev->dest->colorspace;
float expansion = fz_matrixexpansion(ctm);
float flatness = 0.3f / expansion;
float linewidth = stroke->linewidth;
unsigned char colorbv[FZ_MAXCOLORS + 1];
float colorfv[FZ_MAXCOLORS];
fz_bbox bbox;
int i;
if (linewidth * expansion < 0.1f)
linewidth = 1 / expansion;
fz_resetgel(dev->gel, dev->scissor);
if (stroke->dashlen > 0)
fz_dashpath(dev->gel, path, stroke, ctm, flatness, linewidth);
else
fz_strokepath(dev->gel, path, stroke, ctm, flatness, linewidth);
fz_sortgel(dev->gel);
bbox = fz_boundgel(dev->gel);
bbox = fz_intersectbbox(bbox, dev->scissor);
if (fz_isemptyrect(bbox))
return;
fz_convertcolor(colorspace, color, model, colorfv);
for (i = 0; i < model->n; i++)
colorbv[i] = colorfv[i] * 255;
colorbv[i] = alpha * 255;
fz_scanconvert(dev->gel, dev->ael, 0, bbox, dev->dest, colorbv);
}
static void
fz_drawclipimagemask(void *user, fz_pixmap *image, fz_matrix ctm)
{
fz_drawdevice *dev = user;
fz_colorspace *model = dev->dest->colorspace;
fz_bbox bbox;
fz_pixmap *mask, *dest;
fz_pixmap *scaled = nil;
int dx, dy;
if (dev->top == STACKSIZE)
{
fz_warn("assert: too many buffers on stack");
return;
}
if (image->w == 0 || image->h == 0)
{
dev->stack[dev->top].scissor = dev->scissor;
dev->stack[dev->top].mask = nil;
dev->stack[dev->top].dest = nil;
dev->scissor = fz_emptybbox;
dev->top++;
return;
}
bbox = fz_roundrect(fz_transformrect(ctm, fz_unitrect));
bbox = fz_intersectbbox(bbox, dev->scissor);
mask = fz_newpixmapwithrect(nil, bbox);
dest = fz_newpixmapwithrect(model, bbox);
fz_clearpixmap(mask, 0);
fz_clearpixmap(dest, 0);
#ifdef SMOOTHSCALE
dx = sqrtf(ctm.a * ctm.a + ctm.b * ctm.b);
dy = sqrtf(ctm.c * ctm.c + ctm.d * ctm.d);
if (dx < image->w && dy < image->h)
{
scaled = fz_smoothtransformpixmap(image, &ctm, dev->dest->x, dev->dest->y, dx, dy);
if (scaled == NULL)
{
if (dx < 1)
dx = 1;
if (dy < 1)
dy = 1;
scaled = fz_smoothscalepixmap(image, image->x, image->y, dx, dy);
}
if (scaled != NULL)
image = scaled;
}
#else
if (fz_calcimagescale(image, ctm, &dx, &dy))
{
scaled = fz_scalepixmap(image, dx, dy);
image = scaled;
}
#endif
fz_paintimage(mask, bbox, image, ctm, 255);
if (scaled)
fz_droppixmap(scaled);
dev->stack[dev->top].scissor = dev->scissor;
dev->stack[dev->top].mask = mask;
dev->stack[dev->top].dest = dev->dest;
dev->scissor = bbox;
dev->dest = dest;
dev->top++;
}
static void
fz_drawfillshade(void *user, fz_shade *shade, fz_matrix ctm, float alpha)
{
fz_drawdevice *dev = user;
fz_colorspace *model = dev->dest->colorspace;
fz_pixmap *dest = dev->dest;
fz_rect bounds;
fz_bbox bbox;
float colorfv[FZ_MAXCOLORS];
unsigned char colorbv[FZ_MAXCOLORS + 1];
bounds = fz_boundshade(shade, ctm);
bbox = fz_intersectbbox(fz_roundrect(bounds), dev->scissor);
// TODO: proper clip by shade->bbox
if (!fz_isemptyrect(shade->bbox))
{
bounds = fz_transformrect(fz_concat(shade->matrix, ctm), shade->bbox);
bbox = fz_intersectbbox(fz_roundrect(bounds), bbox);
}
if (fz_isemptyrect(bbox))
return;
if (!model)
{
fz_warn("cannot render shading directly to an alpha mask");
return;
}
if (alpha < 1)
{
dest = fz_newpixmapwithrect(dev->dest->colorspace, bbox);
fz_clearpixmap(dest, 0);
}
if (shade->usebackground)
{
unsigned char *s;
int x, y, n, i;
fz_convertcolor(shade->cs, shade->background, model, colorfv);
for (i = 0; i < model->n; i++)
colorbv[i] = colorfv[i] * 255;
colorbv[i] = 255;
n = dest->n;
for (y = bbox.y0; y < bbox.y1; y++)
{
s = dest->samples + ((bbox.x0 - dest->x) + (y - dest->y) * dest->w) * dest->n;
for (x = bbox.x0; x < bbox.x1; x++)
{
for (i = 0; i < n; i++)
*s++ = colorbv[i];
}
}
}
fz_rendershade(shade, ctm, dest, bbox);
if (alpha < 1)
{
fz_paintpixmap(dev->dest, dest, alpha * 255);
fz_droppixmap(dest);
}
}
static void
fz_drawclipstroketext(void *user, fz_text *text, fz_strokestate *stroke, fz_matrix ctm)
{
fz_drawdevice *dev = user;
fz_colorspace *model = dev->dest->colorspace;
fz_bbox bbox;
fz_pixmap *mask, *dest;
fz_matrix tm, trm;
fz_pixmap *glyph;
int i, x, y, gid;
if (dev->top == STACKSIZE)
{
fz_warn("assert: too many buffers on stack");
return;
}
/* make the mask the exact size needed */
bbox = fz_roundrect(fz_boundtext(text, ctm));
bbox = fz_intersectbbox(bbox, dev->scissor);
mask = fz_newpixmapwithrect(nil, bbox);
dest = fz_newpixmapwithrect(model, bbox);
fz_clearpixmap(mask, 0);
fz_clearpixmap(dest, 0);
dev->stack[dev->top].scissor = dev->scissor;
dev->stack[dev->top].mask = mask;
dev->stack[dev->top].dest = dev->dest;
dev->scissor = bbox;
dev->dest = dest;
dev->top++;
if (!fz_isemptyrect(bbox))
{
tm = text->trm;
for (i = 0; i < text->len; i++)
{
gid = text->els[i].gid;
if (gid < 0)
continue;
tm.e = text->els[i].x;
tm.f = text->els[i].y;
trm = fz_concat(tm, ctm);
x = floorf(trm.e);
y = floorf(trm.f);
trm.e = QUANT(trm.e - floorf(trm.e), HSUBPIX);
trm.f = QUANT(trm.f - floorf(trm.f), VSUBPIX);
glyph = fz_renderstrokedglyph(dev->cache, text->font, gid, trm, ctm, stroke);
if (glyph)
{
drawglyph(nil, mask, glyph, x, y, bbox);
fz_droppixmap(glyph);
}
}
}
}
static void
fz_drawcliptext(void *user, fz_text *text, fz_matrix ctm, int accumulate)
{
fz_drawdevice *dev = user;
fz_colorspace *model = dev->dest->colorspace;
fz_bbox bbox;
fz_pixmap *mask, *dest;
fz_matrix tm, trm;
fz_pixmap *glyph;
int i, x, y, gid;
/* If accumulate == 0 then this text object is guaranteed complete */
/* If accumulate == 1 then this text object is the first (or only) in a sequence */
/* If accumulate == 2 then this text object is a continuation */
if (dev->top == STACKSIZE)
{
fz_warn("assert: too many buffers on stack");
return;
}
if (accumulate == 0)
{
/* make the mask the exact size needed */
bbox = fz_roundrect(fz_boundtext(text, ctm));
bbox = fz_intersectbbox(bbox, dev->scissor);
}
else
{
/* be conservative about the size of the mask needed */
bbox = dev->scissor;
}
if (accumulate == 0 || accumulate == 1)
{
mask = fz_newpixmapwithrect(nil, bbox);
dest = fz_newpixmapwithrect(model, bbox);
fz_clearpixmap(mask, 0);
fz_clearpixmap(dest, 0);
dev->stack[dev->top].scissor = dev->scissor;
dev->stack[dev->top].mask = mask;
dev->stack[dev->top].dest = dev->dest;
dev->scissor = bbox;
dev->dest = dest;
dev->top++;
}
else
{
mask = dev->stack[dev->top-1].mask;
}
if (!fz_isemptyrect(bbox))
{
tm = text->trm;
for (i = 0; i < text->len; i++)
{
gid = text->els[i].gid;
if (gid < 0)
continue;
tm.e = text->els[i].x;
tm.f = text->els[i].y;
trm = fz_concat(tm, ctm);
x = floorf(trm.e);
y = floorf(trm.f);
trm.e = QUANT(trm.e - floorf(trm.e), HSUBPIX);
trm.f = QUANT(trm.f - floorf(trm.f), VSUBPIX);
glyph = fz_renderglyph(dev->cache, text->font, gid, trm);
if (glyph)
{
drawglyph(nil, mask, glyph, x, y, bbox);
fz_droppixmap(glyph);
}
}
}
}
fz_error
pdf_loadpage(pdf_page **pagep, pdf_xref *xref, fz_obj *dict)
{
fz_error error;
pdf_page *page;
fz_obj *obj;
fz_bbox bbox;
pdf_logpage("load page {\n");
// TODO: move this to a more appropriate place
/* Ensure that we have a store for resource objects */
if (!xref->store)
xref->store = pdf_newstore();
page = fz_malloc(sizeof(pdf_page));
page->resources = nil;
page->contents = nil;
page->transparency = 0;
page->list = nil;
page->text = nil;
page->links = nil;
page->annots = nil;
obj = fz_dictgets(dict, "MediaBox");
bbox = fz_roundrect(pdf_torect(obj));
if (fz_isemptyrect(pdf_torect(obj)))
{
fz_warn("cannot find page bounds, guessing page bounds.");
bbox.x0 = 0;
bbox.y0 = 0;
bbox.x1 = 612;
bbox.y1 = 792;
}
obj = fz_dictgets(dict, "CropBox");
if (fz_isarray(obj))
{
fz_bbox cropbox = fz_roundrect(pdf_torect(obj));
bbox = fz_intersectbbox(bbox, cropbox);
}
page->mediabox.x0 = MIN(bbox.x0, bbox.x1);
page->mediabox.y0 = MIN(bbox.y0, bbox.y1);
page->mediabox.x1 = MAX(bbox.x0, bbox.x1);
page->mediabox.y1 = MAX(bbox.y0, bbox.y1);
if (page->mediabox.x1 - page->mediabox.x0 < 1 || page->mediabox.y1 - page->mediabox.y0 < 1)
return fz_throw("invalid page size");
page->rotate = fz_toint(fz_dictgets(dict, "Rotate"));
pdf_logpage("bbox [%d %d %d %d]\n", bbox.x0, bbox.y0, bbox.x1, bbox.y1);
pdf_logpage("rotate %d\n", page->rotate);
obj = fz_dictgets(dict, "Annots");
if (obj)
{
pdf_loadlinks(&page->links, xref, obj);
pdf_loadannots(&page->annots, xref, obj);
}
page->resources = fz_dictgets(dict, "Resources");
if (page->resources)
fz_keepobj(page->resources);
obj = fz_dictgets(dict, "Contents");
error = pdf_loadpagecontents(&page->contents, xref, obj);
if (error)
{
pdf_freepage(page);
return fz_rethrow(error, "cannot load page contents (%d %d R)", fz_tonum(obj), fz_togen(obj));
}
if (page->resources && pdf_resourcesuseblending(page->resources))
page->transparency = 1;
pdf_logpage("} %p\n", page);
*pagep = page;
return fz_okay;
}
