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 fz_error *
renderpath(fz_renderer *gc, fz_pathnode *path, fz_matrix ctm)
{
fz_error *error;
float flatness;
fz_irect gbox;
fz_irect clip;
flatness = 0.3 / fz_matrixexpansion(ctm);
if (flatness < 0.1)
flatness = 0.1;
fz_resetgel(gc->gel, HS, VS);
if (path->paint == FZ_STROKE)
{
if (path->dash)
error = fz_dashpath(gc->gel, path, ctm, flatness);
else
error = fz_strokepath(gc->gel, path, ctm, flatness);
}
else
error = fz_fillpath(gc->gel, path, ctm, flatness);
if (error)
return error;
fz_sortgel(gc->gel);
gbox = fz_boundgel(gc->gel);
clip = fz_intersectirects(gc->clip, gbox);
if (fz_isemptyrect(clip))
return nil;
DEBUG("path %s;\n", path->paint == FZ_STROKE ? "stroke" : "fill");
if (gc->flag & FRGB)
{
return fz_scanconvert(gc->gel, gc->ael, path->paint == FZ_EOFILL,
clip, gc->over, gc->rgb, 1);
}
else if (gc->flag & FOVER)
{
return fz_scanconvert(gc->gel, gc->ael, path->paint == FZ_EOFILL,
clip, gc->over, nil, 1);
}
else
{
error = fz_newpixmapwithrect(&gc->dest, clip, 1);
if (error)
return error;
fz_clearpixmap(gc->dest);
return fz_scanconvert(gc->gel, gc->ael, path->paint == FZ_EOFILL,
clip, gc->dest, nil, 0);
}
}
static fz_error *
rendertext(fz_renderer *gc, fz_textnode *text, fz_matrix ctm)
{
fz_error *error;
fz_irect tbox;
fz_irect clip;
fz_matrix tm, trm;
fz_glyph glyph;
int i, x, y, cid;
tbox = fz_roundrect(fz_boundnode((fz_node*)text, ctm));
clip = fz_intersectirects(gc->clip, tbox);
DEBUG("text %s n=%d [%g %g %g %g];\n",
text->font->name, text->len,
text->trm.a, text->trm.b, text->trm.c, text->trm.d);
if (fz_isemptyrect(clip))
return fz_okay;
if (!(gc->flag & FOVER))
{
error = fz_newpixmapwithrect(&gc->dest, clip, 1);
if (error)
return error;
fz_clearpixmap(gc->dest);
}
tm = text->trm;
for (i = 0; i < text->len; i++)
{
cid = text->els[i].cid;
tm.e = text->els[i].x;
tm.f = text->els[i].y;
trm = fz_concat(tm, ctm);
x = fz_floor(trm.e);
y = fz_floor(trm.f);
trm.e = QUANT(trm.e - fz_floor(trm.e), HSUBPIX);
trm.f = QUANT(trm.f - fz_floor(trm.f), VSUBPIX);
error = fz_renderglyph(gc->cache, &glyph, text->font, cid, trm);
if (error)
return error;
if (!(gc->flag & FOVER))
drawglyph(gc, gc->dest, &glyph, x, y);
else
drawglyph(gc, gc->over, &glyph, x, y);
}
return fz_okay;
}
static int fitsinside(fz_node *node, fz_rect clip)
{
fz_rect bbox;
bbox = fz_boundnode(node, fz_identity());
if (fz_isinfiniterect(bbox)) return 0;
if (fz_isemptyrect(bbox)) return 1;
if (bbox.x0 < clip.x0) return 0;
if (bbox.x1 > clip.x1) return 0;
if (bbox.y0 < clip.y0) return 0;
if (bbox.y1 > clip.y1) return 0;
return 1;
}
bool
isInsideRect(
fz_rect maxRect,
fz_rect checkRect
)
{
if (fz_isinfiniterect(checkRect) || fz_isemptyrect(checkRect))
return true;
return ((maxRect.x0 <= checkRect.x0) &&
(maxRect.y0 <= checkRect.y0) &&
(maxRect.x1 >= checkRect.x1) &&
(maxRect.y1 >= checkRect.y1));
}
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);
}
fz_error*
processPage(
soPdfFile* inFile,
int pageNo,
fz_rect *bbRect,
int rectCount
)
{
fz_error *error;
fz_obj *pageRef;
pdf_page *pdfPage;
fz_rect contentBox;
fz_rect mediaBox;
// Initialize
for (int ctr = 0; ctr < rectCount; ctr++)
bbRect[ctr] = fz_emptyrect;
// Get the page reference and load the page contents
pageRef = pdf_getpageobject(inFile->pageTree, pageNo);
error = pdf_loadpage(&pdfPage, inFile->xref, pageRef);
if (error != NULL)
{
// Ideally pdf_loadpage should render all the pages
// and this should never happen
return processErrorPage(inFile, pageRef, pageNo, bbRect, error);
}
// Get the bounding box for the page
mediaBox = pdfPage->mediabox;
float mbHeight = mediaBox.y1 - mediaBox.y0;
// calculate the bounding box for all the elements in the page
contentBox = fz_boundnode(pdfPage->tree->root, fz_identity());
float cbHeight = contentBox.y1 - contentBox.y0;
// If there is nothing on the page we return nothing.
// should we return an empty page instead ???
if (fz_isemptyrect(contentBox))
goto Cleanup;
// if contentBox is bigger than mediaBox then there are some
// elements that should not be display and hence we reset the
// content box to media box
if ((cbHeight > mbHeight) || ((contentBox.x1 - contentBox.x0) > (mediaBox.x1 - mediaBox.x0)))
{
// Calculate the new content box based on the content that is
// inside the the media box and recalculate cbHeight
contentBox = getContainingRect(pdfPage->tree->root, mediaBox);
cbHeight = contentBox.y1 - contentBox.y0;
}
#ifdef _blahblah
printf("-->Page %d\n", pageNo);
bbdump(pdfPage->tree->root, 1);
#endif
// The rotation takes place when we insert the page into destination
// If only the mupdf renderer could give accurate values of the
// bounding box of all the elements in a page, the splitting would
// be so much more easier without overlapping, cutting text, etc
switch(p_mode)
{
case FitHeight:
case FitWidth:
bbRect[0] = contentBox;
goto Cleanup;
case Fit2xHeight:
case Fit2xWidth:
// Let the processing happen.
break;
case SmartFitHeight:
case SmartFitWidth:
default:
return fz_throw("Mode(%d) not yet implemented.", p_mode);
break;
}
// If the contentBox is 60% of mediaBox then do not split
if (((cbHeight / mbHeight) * 100) <= 55)
{
bbRect[0] = contentBox;
goto Cleanup;
}
// Get the first split contents from top. The box we specify is
// top 55% (bottom + 45) of the contents
bbRect[0] = contentBox;
bbRect[0].y0 = bbRect[0].y0 + (float)(0.45 * cbHeight);
bbRect[0] = getContainingRect(pdfPage->tree->root, bbRect[0]);
// Check if the contents we got in first split is more than 40%
// of the total contents
float bbRect0Height = bbRect[0].y1 - bbRect[0].y0;
if (((bbRect0Height / cbHeight) * 100) >= 40)
{
// The content is more than 40%. Put the rest of the
// content in the second split and exit
bbRect[1] = contentBox;
bbRect[1].y1 = bbRect[1].y1 - bbRect0Height;
// Adjust the split box height by X points to make sure
// we get everything and dont have annoying tail cuts
bbRect[0].y0 -= 2;
goto Cleanup;
}
// Since the contents we got in first split is less than 40%
// of the total contents, split the content in half with overlap
float overlap = (cbHeight * (float)(p_overlap / 100)) / 2;
bbRect[0] = contentBox;
bbRect[0].y0 = bbRect[0].y0 + (float)(0.5 * cbHeight) - overlap;
bbRect[1] = contentBox;
bbRect[1].y1 = bbRect[1].y1 - (float)(0.5 * cbHeight) + overlap;
Cleanup:
// This function can overflow the stack when the pdf page
// to be rendered is very complex. I had to increase the
// stack size reserved for exe using compiler option
pdf_droppage(pdfPage);
return error;
}
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_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_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;
}
static fz_error *
renderpath(fz_renderer *gc, fz_pathnode *path, fz_matrix ctm)
{
fz_error *error;
float flatness;
fz_irect gbox;
fz_irect clip;
float expansion = fz_matrixexpansion(ctm);
flatness = 0.3 / expansion;
if (flatness < 0.1)
flatness = 0.1;
fz_resetgel(gc->gel, gc->clip);
if (path->paint == FZ_STROKE)
{
float lw = path->linewidth;
/* Check for hairline */
if (lw * expansion < 0.1) {
lw = 1.0f / expansion;
}
if (path->dash)
error = fz_dashpath(gc->gel, path, ctm, flatness, lw);
else
error = fz_strokepath(gc->gel, path, ctm, flatness, lw);
}
else
error = fz_fillpath(gc->gel, path, ctm, flatness);
if (error)
return error;
fz_sortgel(gc->gel);
gbox = fz_boundgel(gc->gel);
clip = fz_intersectirects(gc->clip, gbox);
if (fz_isemptyrect(clip))
return fz_okay;
DEBUG("path %s;\n", path->paint == FZ_STROKE ? "stroke" : "fill");
if (gc->flag & FRGB)
{
DEBUG(" path rgb %d %d %d %d, %d %d %d\n", gc->argb[0], gc->argb[1], gc->argb[2], gc->argb[3], gc->argb[4], gc->argb[5], gc->argb[6]);
return fz_scanconvert(gc->gel, gc->ael, path->paint == FZ_EOFILL,
clip, gc->over, gc->argb, 1);
}
else if (gc->flag & FOVER)
{
return fz_scanconvert(gc->gel, gc->ael, path->paint == FZ_EOFILL,
clip, gc->over, nil, 1);
}
else
{
error = fz_newpixmapwithrect(&gc->dest, clip, 1);
if (error)
return error;
fz_clearpixmap(gc->dest);
return fz_scanconvert(gc->gel, gc->ael, path->paint == FZ_EOFILL,
clip, gc->dest, nil, 0);
}
}
static fz_error *
renderimage(fz_renderer *gc, fz_imagenode *node, fz_matrix ctm)
{
fz_error *error;
fz_image *image = node->image;
fz_irect bbox;
fz_irect clip;
int dx, dy;
fz_pixmap *tile;
fz_pixmap *temp;
fz_matrix imgmat;
fz_matrix invmat;
int fa, fb, fc, fd;
int u0, v0;
int x0, y0;
int w, h;
int tileheight;
DEBUG("image %dx%d %d+%d %s\n{\n", image->w, image->h, image->n, image->a, image->cs?image->cs->name:"(nil)");
bbox = fz_roundrect(fz_boundnode((fz_node*)node, ctm));
clip = fz_intersectirects(gc->clip, bbox);
if (fz_isemptyrect(clip))
return fz_okay;
if (image->w == 0 || image->h == 0)
return fz_okay;
if (image->n + image->a == 0)
return fz_okay;
calcimagescale(ctm, image->w, image->h, &dx, &dy);
/* try to fit tile into a typical L2 cachce */
tileheight = 512 * 1024 / (image->w * (image->n + image->a));
/* tileheight must be an even multiple of dy, except for last band */
tileheight = (tileheight + dy - 1) / dy * dy;
if ((dx != 1 || dy != 1) && image->h > tileheight) {
int y = 0;
DEBUG(" load image tile size = %dx%d\n", image->w, tileheight);
error = fz_newpixmap(&tile, 0, 0, image->w,
tileheight, image->n + 1);
if (error)
return error;
error = fz_newscaledpixmap(&temp, image->w, image->h, image->n + 1, dx, dy);
if (error)
goto cleanup;
do {
if (y + tileheight > image->h)
tileheight = image->h - y;
tile->y = y;
tile->h = tileheight;
DEBUG(" tile xywh=%d %d %d %d sxsy=1/%d 1/%d\n",
0, y, image->w, tileheight, dx, dy);
error = image->loadtile(image, tile);
if (error)
goto cleanup1;
error = fz_scalepixmaptile(temp, 0, y, tile, dx, dy);
if (error)
goto cleanup1;
y += tileheight;
} while (y < image->h);
fz_droppixmap(tile);
tile = temp;
}
else {
DEBUG(" load image\n");
error = fz_newpixmap(&tile, 0, 0, image->w, image->h, image->n + 1);
if (error)
return error;
error = image->loadtile(image, tile);
if (error)
goto cleanup;
if (dx != 1 || dy != 1)
{
DEBUG(" scale image 1/%d 1/%d\n", dx, dy);
error = fz_scalepixmap(&temp, tile, dx, dy);
if (error)
goto cleanup;
fz_droppixmap(tile);
tile = temp;
}
}
if (image->cs && image->cs != gc->model)
{
DEBUG(" convert from %s to %s\n", image->cs->name, gc->model->name);
error = fz_newpixmap(&temp, tile->x, tile->y, tile->w, tile->h, gc->model->n + 1);
if (error)
goto cleanup;
fz_convertpixmap(image->cs, tile, gc->model, temp);
fz_droppixmap(tile);
tile = temp;
}
imgmat.a = 1.0 / tile->w;
imgmat.b = 0.0;
imgmat.c = 0.0;
imgmat.d = -1.0 / tile->h;
imgmat.e = 0.0;
imgmat.f = 1.0;
invmat = fz_invertmatrix(fz_concat(imgmat, ctm));
w = clip.x1 - clip.x0;
h = clip.y1 - clip.y0;
x0 = clip.x0;
y0 = clip.y0;
u0 = (invmat.a * (x0+0.5) + invmat.c * (y0+0.5) + invmat.e) * 65536;
v0 = (invmat.b * (x0+0.5) + invmat.d * (y0+0.5) + invmat.f) * 65536;
fa = invmat.a * 65536;
fb = invmat.b * 65536;
fc = invmat.c * 65536;
fd = invmat.d * 65536;
#define PSRC tile->samples, tile->w, tile->h
#define PDST(p) p->samples + ((y0-p->y) * p->w + (x0-p->x)) * p->n, p->w * p->n
#define PCTM u0, v0, fa, fb, fc, fd, w, h
switch (gc->flag)
{
case FNONE:
{
DEBUG(" fnone %d x %d\n", w, h);
if (image->cs)
error = fz_newpixmapwithrect(&gc->dest, clip, gc->model->n + 1);
else
error = fz_newpixmapwithrect(&gc->dest, clip, 1);
if (error)
goto cleanup;
if (image->cs)
fz_img_4c4(PSRC, PDST(gc->dest), PCTM);
else
fz_img_1c1(PSRC, PDST(gc->dest), PCTM);
}
break;
case FOVER:
{
DEBUG(" fover %d x %d\n", w, h);
if (image->cs)
fz_img_4o4(PSRC, PDST(gc->over), PCTM);
else
fz_img_1o1(PSRC, PDST(gc->over), PCTM);
}
break;
case FOVER | FRGB:
DEBUG(" fover+rgb %d x %d\n", w, h);
fz_img_w4i1o4(gc->argb, PSRC, PDST(gc->over), PCTM);
break;
default:
assert(!"impossible flag in image span function");
}
DEBUG("}\n");
fz_droppixmap(tile);
return fz_okay;
cleanup1:
fz_droppixmap(temp);
cleanup:
fz_droppixmap(tile);
return error;
}
int
copyPdfFile(
soPdfFile* inFile,
soPdfFile* outFile
)
{
fz_error *error;
int pageTreeNum, pageTreeGen;
assert(inFile != NULL);
assert(outFile != NULL);
//
// Process every page in the source file
//
{
printf("\nProcessing input page : ");
for (int pageNo = 0; pageNo < pdf_getpagecount(inFile->pageTree); pageNo++)
{
displayPageNumber(pageNo + 1, !pageNo);
// Get the page object from the source
fz_obj *pageRef = inFile->pageTree->pref[pageNo];
fz_obj *pageObj = pdf_getpageobject(inFile->pageTree, pageNo);
//
// Process the page. Each page can be split into up-to 3 pages
//
fz_rect bbRect[3];
error = processPage(inFile, pageNo, bbRect, 3);
if (error)
return soPdfError(error);
for (int ctr = 0; ctr < 3; ctr++)
{
// Check if this was a blank page
if (fz_isemptyrect(bbRect[ctr]))
break;
//
// copy the source page dictionary entry. The way this is done is basically
// by making a copy of the page dict object in the source file, and adding
// the copy in the source file. Then the copied page dict object is
// referenced and added to the destination file.
//
// This convoluted procedure is done because the copy is done by pdf_transplant
// function that accepts a source and destination. Whatever is referenced by
// destination object is deep copied
//
// allocate an object id and generation id in source file
//
// There is a bug in mupdf where the object allocation returns
// 0 oid and 0 gid when the input pdf file has iref stream
// so to work around the issue, we wrap the pdf_allocojbect
// in a for loop 10 times to get the number
//
int sNum, sGen, tries;
for (tries = 0; tries < 10; tries++)
{
error = pdf_allocobject(inFile->xref, &sNum, &sGen);
if (error)
return soPdfError(error);
// If sNum is non zero then the allocation was successful
if (sNum != 0)
break;
pdf_updateobject(inFile->xref, sNum, sGen, pageObj);
}
// If we didn't succeed even after 10 tries then this file
// is not going to work.
if (tries >= 10)
return soPdfError(fz_throw("cannot allocate object because of mupdf bug"));
// make a deep copy of the original page dict
fz_obj *pageObj2;
error = fz_deepcopydict(&pageObj2, pageObj);
if (error)
return soPdfError(error);
// update the source file with the duplicate page object
pdf_updateobject(inFile->xref, sNum, sGen, pageObj2);
fz_dropobj(pageObj2);
// create an indirect reference to the page object
fz_obj *pageRef2;
error = fz_newindirect(&pageRef2, sNum, sGen);
if (error)
return soPdfError(error);
// delete the parent dictionary entry
// Do we need to delete any other dictionary entry
// like annot, tabs, metadata, etc
fz_dictdels(pageObj2, "Parent");
// Set the media box
setPageMediaBox(inFile->xref, pageObj2, bbRect[ctr]);
// Set the rotation based on input
switch(p_mode)
{
// no rotation if fit height
case FitHeight:
case Fit2xHeight:
break;
// rotate -90 deg if fit width
case Fit2xWidth:
case FitWidth:
setPageRotate(pageObj2, p_reverseLandscape ? 90 : -90);
break;
case SmartFitHeight:
case SmartFitWidth:
default:
return soPdfError(fz_throw("Mode(%d) not yet implemented.", p_mode));
break;
}
// push the indirect reference to the destination list for copy by pdf_transplant
error = fz_arraypush(outFile->editobjs, pageRef2);
if (error)
return soPdfError(error);
}
}
}
// flush the objects into destination from source
{
fz_obj *results;
int outPages;
printf("\nCopying output page : ");
error = pdf_transplant(outFile->xref, inFile->xref, &results, outFile->editobjs);
if (error)
return soPdfError(error);
outPages = fz_arraylen(results);
for (int ctr = 0; ctr < outPages; ctr++)
{
displayPageNumber(ctr + 1, !ctr);
error = fz_arraypush(outFile->pagelist, fz_arrayget(results,
p_reverseLandscape ? outPages - 1 - ctr : ctr));
if (error)
return soPdfError(error);
}
fz_dropobj(results);
}
// flush page tree
// Create page tree and add back-links
{
fz_obj *pageTreeObj;
fz_obj *pageTreeRef;
// allocate a new object in out file for pageTree object
error = pdf_allocobject(outFile->xref, &pageTreeNum, &pageTreeGen);
if (error)
return soPdfError(error);
// Create a page tree object
error = fz_packobj(&pageTreeObj, "<</Type/Pages/Count %i/Kids %o>>",
fz_arraylen(outFile->pagelist), outFile->pagelist);
if (error)
return soPdfError(error);
// Update the xref entry with the pageTree object
pdf_updateobject(outFile->xref, pageTreeNum, pageTreeGen, pageTreeObj);
fz_dropobj(pageTreeObj);
// Create a reference to the pageTree object
error = fz_newindirect(&pageTreeRef, pageTreeNum, pageTreeGen);
if (error)
return soPdfError(error);
//
// For every page in the output file, update the parent entry
//
for (int ctr = 0; ctr < fz_arraylen(outFile->pagelist); ctr++)
{
fz_obj *pageObj;
int num = fz_tonum(fz_arrayget(outFile->pagelist, ctr));
int gen = fz_togen(fz_arrayget(outFile->pagelist, ctr));
// Get the page object from xreft
error = pdf_loadobject(&pageObj, outFile->xref, num, gen);
if (error)
return soPdfError(error);
// Update the parent entry in the page dictionary
error = fz_dictputs(pageObj, "Parent", pageTreeRef);
if (error)
return soPdfError(error);
// Update the entry with the updated page object
pdf_updateobject(outFile->xref, num, gen, pageObj);
fz_dropobj(pageObj);
}
}
// Create catalog and root entries
{
fz_obj *catObj, *infoObj;
int rootNum, rootGen;
int infoNum, infoGen;
//
// Copy the info catalog to the destination
// alloc an object id and gen id in destination file
error = pdf_allocobject(outFile->xref, &infoNum, &infoGen);
if (error)
return soPdfError(error);
// make a deep copy of the original page dict
error = fz_deepcopydict(&infoObj, inFile->xref->info);
if (error)
return soPdfError(error);
// update the dest file with object
pdf_updateobject(outFile->xref, infoNum, infoGen, infoObj);
outFile->xref->info = infoObj;
fz_dropobj(infoObj);
//
// root/catalog object creation
error = pdf_allocobject(outFile->xref, &rootNum, &rootGen);
if (error)
return soPdfError(error);
error = fz_packobj(&catObj, "<</Type/Catalog /Pages %r>>", pageTreeNum, pageTreeGen);
if (error)
return soPdfError(error);
pdf_updateobject(outFile->xref, rootNum, rootGen, catObj);
fz_dropobj(catObj);
// Create trailer
error = fz_packobj(&outFile->xref->trailer, "<</Root %r /Info %r>>",
rootNum, rootGen, infoNum, infoGen);
if (error)
return soPdfError(error);
}
// Update the info in the target file and save the xref
printf("\nSaving.\n");
error = setPageInfo(inFile, outFile);
if (error)
return soPdfError(error);
error = pdf_savexref(outFile->xref, outFile->fileName, NULL);
if (error)
return soPdfError(error);
if (g_errorCount != 0)
{
printf("\nFollowing issues encounted were ignored.\n\n");
for (int ctr = g_errorCount - 1; ctr >= 0; ctr--)
soPdfError(g_errorList[ctr]);
}
printf("\nSaved.\n");
return 0;
}
static fz_error *
renderimage(fz_renderer *gc, fz_imagenode *node, fz_matrix ctm)
{
fz_error *error;
fz_image *image = node->image;
fz_irect bbox;
fz_irect clip;
int dx, dy;
fz_pixmap *tile;
fz_pixmap *temp;
fz_matrix imgmat;
fz_matrix invmat;
int fa, fb, fc, fd;
int u0, v0;
int x0, y0;
int w, h;
DEBUG("image %dx%d %d+%d %s\n{\n", image->w, image->h, image->n, image->a, image->cs?image->cs->name:"(nil)");
bbox = fz_roundrect(fz_boundnode((fz_node*)node, ctm));
clip = fz_intersectirects(gc->clip, bbox);
if (fz_isemptyrect(clip))
return nil;
calcimagescale(ctm, image->w, image->h, &dx, &dy);
DEBUG(" load image\n");
error = fz_newpixmap(&tile, 0, 0, image->w, image->h, image->n + 1);
if (error)
return error;
error = image->loadtile(image, tile);
if (error)
goto cleanup;
if (dx != 1 || dy != 1)
{
DEBUG(" scale image 1/%d 1/%d\n", dx, dy);
error = fz_scalepixmap(&temp, tile, dx, dy);
if (error)
goto cleanup;
fz_droppixmap(tile);
tile = temp;
}
if (image->cs && image->cs != gc->model)
{
DEBUG(" convert from %s to %s\n", image->cs->name, gc->model->name);
error = fz_newpixmap(&temp, tile->x, tile->y, tile->w, tile->h, gc->model->n + 1);
if (error)
goto cleanup;
fz_convertpixmap(image->cs, tile, gc->model, temp);
fz_droppixmap(tile);
tile = temp;
}
imgmat.a = 1.0 / tile->w;
imgmat.b = 0.0;
imgmat.c = 0.0;
imgmat.d = -1.0 / tile->h;
imgmat.e = 0.0;
imgmat.f = 1.0;
invmat = fz_invertmatrix(fz_concat(imgmat, ctm));
w = clip.x1 - clip.x0;
h = clip.y1 - clip.y0;
x0 = clip.x0;
y0 = clip.y0;
u0 = (invmat.a * (x0+0.5) + invmat.c * (y0+0.5) + invmat.e) * 65536;
v0 = (invmat.b * (x0+0.5) + invmat.d * (y0+0.5) + invmat.f) * 65536;
fa = invmat.a * 65536;
fb = invmat.b * 65536;
fc = invmat.c * 65536;
fd = invmat.d * 65536;
#define PSRC tile->samples, tile->w, tile->h
#define PDST(p) p->samples + ((y0-p->y) * p->w + (x0-p->x)) * p->n, p->w * p->n
#define PCTM u0, v0, fa, fb, fc, fd, w, h
switch (gc->flag)
{
case FNONE:
{
DEBUG(" fnone %d x %d\n", w, h);
if (image->cs)
error = fz_newpixmapwithrect(&gc->dest, clip, gc->model->n + 1);
else
error = fz_newpixmapwithrect(&gc->dest, clip, 1);
if (error)
goto cleanup;
if (image->cs)
fz_img_4c4(PSRC, PDST(gc->dest), PCTM);
else
fz_img_1c1(PSRC, PDST(gc->dest), PCTM);
}
break;
case FOVER:
{
DEBUG(" fover %d x %d\n", w, h);
if (image->cs)
fz_img_4o4(PSRC, PDST(gc->over), PCTM);
else
fz_img_1o1(PSRC, PDST(gc->over), PCTM);
}
break;
case FOVER | FRGB:
DEBUG(" fover+rgb %d x %d\n", w, h);
fz_img_w3i1o4(gc->rgb, PSRC, PDST(gc->over), PCTM);
break;
default:
assert(!"impossible flag in image span function");
}
DEBUG("}\n");
fz_droppixmap(tile);
return nil;
cleanup:
fz_droppixmap(tile);
return error;
}
static fz_error *
rendermask(fz_renderer *gc, fz_masknode *mask, fz_matrix ctm)
{
fz_error *error;
int oldmaskonly;
fz_pixmap *oldover;
fz_irect oldclip;
fz_irect bbox;
fz_irect clip;
fz_pixmap *shapepix = nil;
fz_pixmap *colorpix = nil;
fz_node *shape;
fz_node *color;
float rgb[3];
shape = mask->super.first;
color = shape->next;
/* special case black voodo */
if (gc->flag & FOVER)
{
if (fz_issolidnode(color))
{
fz_solidnode *solid = (fz_solidnode*)color;
fz_convertcolor(solid->cs, solid->samples, gc->model, rgb);
gc->argb[0] = solid->a * 255;
gc->argb[1] = rgb[0] * solid->a * 255;
gc->argb[2] = rgb[1] * solid->a * 255;
gc->argb[3] = rgb[2] * solid->a * 255;
gc->argb[4] = rgb[0] * 255;
gc->argb[5] = rgb[1] * 255;
gc->argb[6] = rgb[2] * 255;
gc->flag |= FRGB;
/* we know these can handle the FRGB shortcut */
if (fz_ispathnode(shape))
return renderpath(gc, (fz_pathnode*)shape, ctm);
if (fz_istextnode(shape))
return rendertext(gc, (fz_textnode*)shape, ctm);
if (fz_isimagenode(shape))
return renderimage(gc, (fz_imagenode*)shape, ctm);
}
}
oldclip = gc->clip;
oldover = gc->over;
bbox = fz_roundrect(fz_boundnode(shape, ctm));
clip = fz_intersectirects(bbox, gc->clip);
bbox = fz_roundrect(fz_boundnode(color, ctm));
clip = fz_intersectirects(bbox, clip);
if (fz_isemptyrect(clip))
return fz_okay;
DEBUG("mask [%d %d %d %d]\n{\n", clip.x0, clip.y0, clip.x1, clip.y1);
{
fz_irect sbox = fz_roundrect(fz_boundnode(shape, ctm));
fz_irect cbox = fz_roundrect(fz_boundnode(color, ctm));
if (cbox.x0 >= sbox.x0 && cbox.x1 <= sbox.x1)
if (cbox.y0 >= sbox.y0 && cbox.y1 <= sbox.y1)
DEBUG("potentially useless mask\n");
}
gc->clip = clip;
gc->over = nil;
oldmaskonly = gc->maskonly;
gc->maskonly = 1;
error = rendernode(gc, shape, ctm);
if (error)
goto cleanup;
shapepix = gc->dest;
gc->dest = nil;
gc->maskonly = oldmaskonly;
error = rendernode(gc, color, ctm);
if (error)
goto cleanup;
colorpix = gc->dest;
gc->dest = nil;
gc->clip = oldclip;
gc->over = oldover;
if (shapepix && colorpix)
{
if (gc->over)
{
blendmask(gc, colorpix, shapepix, gc->over, 1);
}
else
{
clip.x0 = MAX(colorpix->x, shapepix->x);
clip.y0 = MAX(colorpix->y, shapepix->y);
clip.x1 = MIN(colorpix->x+colorpix->w, shapepix->x+shapepix->w);
clip.y1 = MIN(colorpix->y+colorpix->h, shapepix->y+shapepix->h);
error = fz_newpixmapwithrect(&gc->dest, clip, colorpix->n);
if (error)
goto cleanup;
blendmask(gc, colorpix, shapepix, gc->dest, 0);
}
}
DEBUG("}\n");
if (shapepix) fz_droppixmap(shapepix);
if (colorpix) fz_droppixmap(colorpix);
return fz_okay;
cleanup:
if (shapepix) fz_droppixmap(shapepix);
if (colorpix) fz_droppixmap(colorpix);
return error;
}