static fz_error
pdf_loadxref(pdf_xref *xref, char *buf, int bufsize)
{
fz_error error;
fz_obj *size;
int i;
error = pdf_loadversion(xref);
if (error)
return fz_rethrow(error, "cannot read version marker");
error = pdf_readstartxref(xref);
if (error)
return fz_rethrow(error, "cannot read startxref");
error = pdf_readtrailer(xref, buf, bufsize);
if (error)
return fz_rethrow(error, "cannot read trailer");
size = fz_dictgets(xref->trailer, "Size");
if (!size)
return fz_throw("trailer missing Size entry");
pdf_logxref("\tsize %d at 0x%x\n", fz_toint(size), xref->startxref);
xref->len = fz_toint(size);
xref->cap = xref->len + 1; /* for hack to allow broken pdf generators with off-by-one errors */
xref->table = fz_malloc(xref->cap * sizeof(pdf_xrefentry));
for (i = 0; i < xref->cap; i++)
{
xref->table[i].ofs = 0;
xref->table[i].gen = 0;
xref->table[i].stmofs = 0;
xref->table[i].obj = nil;
xref->table[i].type = 0;
}
error = pdf_readxrefsections(xref, xref->startxref, buf, bufsize);
if (error)
return fz_rethrow(error, "cannot read xref");
/* broken pdfs where first object is not free */
if (xref->table[0].type != 'f')
return fz_throw("first object in xref is not free");
/* broken pdfs where object offsets are out of range */
for (i = 0; i < xref->len; i++)
if (xref->table[i].type == 'n')
if (xref->table[i].ofs <= 0 || xref->table[i].ofs >= xref->filesize)
return fz_throw("object offset out of range: %d", xref->table[i].ofs);
return fz_okay;
}
fz_filter *
fz_newpredictd(fz_obj *params)
{
fz_obj *obj;
FZ_NEWFILTER(fz_predict, p, predict);
p->predictor = 1;
p->columns = 1;
p->colors = 1;
p->bpc = 8;
obj = fz_dictgets(params, "Predictor");
if (obj)
p->predictor = fz_toint(obj);
if (p->predictor != 1 && p->predictor != 2 &&
p->predictor != 10 && p->predictor != 11 &&
p->predictor != 12 && p->predictor != 13 &&
p->predictor != 14 && p->predictor != 15)
{
fz_warn("invalid predictor: %d", p->predictor);
p->predictor = 1;
}
obj = fz_dictgets(params, "Columns");
if (obj)
p->columns = fz_toint(obj);
obj = fz_dictgets(params, "Colors");
if (obj)
p->colors = fz_toint(obj);
obj = fz_dictgets(params, "BitsPerComponent");
if (obj)
p->bpc = fz_toint(obj);
p->stride = (p->bpc * p->colors * p->columns + 7) / 8;
p->bpp = (p->bpc * p->colors + 7) / 8;
if (p->predictor >= 10)
{
p->ref = fz_malloc(p->stride);
memset(p->ref, 0, p->stride);
}
else
{
p->ref = nil;
}
return (fz_filter*)p;
}
static fz_error
gathershadings(int page, fz_obj *pageobj, fz_obj *dict)
{
int i;
for (i = 0; i < fz_dictlen(dict); i++)
{
fz_obj *ref;
fz_obj *shade;
fz_obj *type;
int k;
shade = ref = fz_dictgetval(dict, i);
if (!fz_isdict(shade))
return fz_throw("not a shading dict (%d %d R)", fz_tonum(ref), fz_togen(ref));
type = fz_dictgets(shade, "ShadingType");
if (!fz_isint(type) || fz_toint(type) < 1 || fz_toint(type) > 7)
{
fz_warn("not a shading type (%d %d R)", fz_tonum(ref), fz_togen(ref));
type = nil;
}
for (k = 0; k < shadings; k++)
if (fz_tonum(shading[k]->ref) == fz_tonum(ref) &&
fz_togen(shading[k]->ref) == fz_togen(ref))
break;
if (k < shadings)
continue;
shadings++;
shading = fz_realloc(shading, shadings * sizeof (struct info *));
if (!shading)
return fz_throw("out of memory");
shading[shadings - 1] = fz_malloc(sizeof (struct info));
if (!shading[shadings - 1])
return fz_throw("out of memory");
shading[shadings - 1]->page = page;
shading[shadings - 1]->pageobj = pageobj;
shading[shadings - 1]->ref = ref;
shading[shadings - 1]->u.shading.type = type;
}
return fz_okay;
}
static fz_error *
loadiccbased(fz_colorspace **csp, pdf_xref *xref, fz_obj *ref)
{
fz_error *error;
fz_obj *dict;
int n;
pdf_logrsrc("load ICCBased\n");
error = pdf_loadindirect(&dict, xref, ref);
if (error)
return error;
n = fz_toint(fz_dictgets(dict, "N"));
fz_dropobj(dict);
switch (n)
{
case 1: *csp = pdf_devicegray; return nil;
case 3: *csp = pdf_devicergb; return nil;
case 4: *csp = pdf_devicecmyk; return nil;
}
return fz_throw("syntaxerror: ICCBased must have 1, 3 or 4 components");
}
fz_error
pdf_loadfontdescriptor(pdf_fontdesc *fontdesc, pdf_xref *xref, fz_obj *dict, char *collection)
{
fz_error error;
fz_obj *obj1, *obj2, *obj3, *obj;
fz_rect bbox;
char *fontname;
pdf_logfont("load fontdescriptor {\n");
fontname = fz_toname(fz_dictgets(dict, "FontName"));
pdf_logfont("fontname '%s'\n", fontname);
fontdesc->flags = fz_toint(fz_dictgets(dict, "Flags"));
fontdesc->italicangle = fz_toreal(fz_dictgets(dict, "ItalicAngle"));
fontdesc->ascent = fz_toreal(fz_dictgets(dict, "Ascent"));
fontdesc->descent = fz_toreal(fz_dictgets(dict, "Descent"));
fontdesc->capheight = fz_toreal(fz_dictgets(dict, "CapHeight"));
fontdesc->xheight = fz_toreal(fz_dictgets(dict, "XHeight"));
fontdesc->missingwidth = fz_toreal(fz_dictgets(dict, "MissingWidth"));
bbox = pdf_torect(fz_dictgets(dict, "FontBBox"));
pdf_logfont("bbox [%g %g %g %g]\n",
bbox.x0, bbox.y0,
bbox.x1, bbox.y1);
pdf_logfont("flags %d\n", fontdesc->flags);
obj1 = fz_dictgets(dict, "FontFile");
obj2 = fz_dictgets(dict, "FontFile2");
obj3 = fz_dictgets(dict, "FontFile3");
obj = obj1 ? obj1 : obj2 ? obj2 : obj3;
if (getenv("NOFONT"))
obj = nil;
if (fz_isindirect(obj))
{
error = pdf_loadembeddedfont(fontdesc, xref, obj);
if (error)
{
fz_catch(error, "ignored error when loading embedded font, attempting to load system font");
error = pdf_loadsystemfont(fontdesc, fontname, collection);
if (error)
return fz_rethrow(error, "cannot load font descriptor");
}
}
else
{
error = pdf_loadsystemfont(fontdesc, fontname, collection);
if (error)
return fz_rethrow(error, "cannot load font descriptor");
}
pdf_logfont("}\n");
return fz_okay;
}
fz_error
fz_newlzwe(fz_filter **fp, fz_obj *params)
{
FZ_NEWFILTER(fz_lzwe, lzw, lzwe);
lzw->earlychange = 0;
if (params)
{
fz_obj *obj;
obj = fz_dictgets(params, "EarlyChange");
if (obj) lzw->earlychange = fz_toint(obj) != 0;
}
lzw->bidx = 0;
lzw->bsave = 0;
lzw->resume = 0;
lzw->code = -1;
lzw->hcode = -1;
lzw->fcode = -1;
lzw->codebits = MINBITS;
lzw->nextcode = LZW_FIRST;
lzw->oldcode = -1; /* generates LZW_CLEAR */
clearhash(lzw);
return fz_okay;
}
fz_error
pdf_loadpagetree(pdf_xref *xref)
{
struct info info;
fz_obj *catalog = fz_dictgets(xref->trailer, "Root");
fz_obj *pages = fz_dictgets(catalog, "Pages");
fz_obj *count = fz_dictgets(pages, "Count");
if (!fz_isdict(pages))
return fz_throw("missing page tree");
if (!fz_isint(count))
return fz_throw("missing page count");
xref->pagecap = fz_toint(count);
xref->pagelen = 0;
xref->pagerefs = fz_malloc(sizeof(fz_obj*) * xref->pagecap);
xref->pageobjs = fz_malloc(sizeof(fz_obj*) * xref->pagecap);
info.resources = nil;
info.mediabox = nil;
info.cropbox = nil;
info.rotate = nil;
pdf_loadpagetreenode(xref, pages, info);
return fz_okay;
}
fz_error *
fz_newpredict(fz_filter **fp, fz_obj *params, int encode)
{
fz_obj *obj;
FZ_NEWFILTER(fz_predict, p, predict);
p->encode = encode;
p->predictor = 1;
p->columns = 1;
p->colors = 1;
p->bpc = 8;
obj = fz_dictgets(params, "Predictor");
if (obj) p->predictor = fz_toint(obj);
obj = fz_dictgets(params, "Columns");
if (obj) p->columns = fz_toint(obj);
obj = fz_dictgets(params, "Colors");
if (obj) p->colors = fz_toint(obj);
obj = fz_dictgets(params, "BitsPerComponent");
if (obj) p->bpc = fz_toint(obj);
p->stride = (p->bpc * p->colors * p->columns + 7) / 8;
p->bpp = (p->bpc * p->colors + 7) / 8;
if (p->predictor >= 10) {
p->ref = fz_malloc(p->stride);
if (!p->ref) { fz_free(p); return fz_throw("outofmem: predictor reference buffer"); }
memset(p->ref, 0, p->stride);
}
else {
p->ref = nil;
}
return fz_okay;
}
static fz_error
pdf_readxrefsections(pdf_xref *xref, int ofs, char *buf, int cap)
{
fz_error error;
fz_obj *trailer;
fz_obj *prev;
fz_obj *xrefstm;
error = pdf_readxref(&trailer, xref, ofs, buf, cap);
if (error)
return fz_rethrow(error, "cannot read xref section");
/* FIXME: do we overwrite free entries properly? */
xrefstm = fz_dictgets(trailer, "XRefStm");
if (xrefstm)
{
pdf_logxref("load xrefstm\n");
error = pdf_readxrefsections(xref, fz_toint(xrefstm), buf, cap);
if (error)
{
fz_dropobj(trailer);
return fz_rethrow(error, "cannot read /XRefStm xref section");
}
}
prev = fz_dictgets(trailer, "Prev");
if (prev)
{
pdf_logxref("load prev at 0x%x\n", fz_toint(prev));
error = pdf_readxrefsections(xref, fz_toint(prev), buf, cap);
if (error)
{
fz_dropobj(trailer);
return fz_rethrow(error, "cannot read /Prev xref section");
}
}
fz_dropobj(trailer);
return fz_okay;
}
int
epdf_index_item_page_get(const Epdf_Document *doc, const Epdf_Index_Item *item)
{
fz_obj *dest;
int p;
int n;
int g;
if (!item || !item->link)
return -1;
if (PDF_LGOTO != item->link->kind)
return -1;
dest = item->link->dest;
p = 0;
if (fz_isint(dest))
{
p = fz_toint(dest);
return p;
}
if (fz_isdict(dest))
{
/* The destination is linked from a Go-To action's D array */
fz_obj *D;
D = fz_dictgets(dest, "D");
if (D && fz_isarray(D))
dest = fz_arrayget(D, 0);
}
n = fz_tonum(dest);
g = fz_togen(dest);
for (p = 1; p <= epdf_document_page_count_get(doc); p++)
{
fz_obj *page;
int np;
int gp;
page = pdf_getpageobject(doc->xref, p);
if (!page)
continue;
np = fz_tonum(page);
gp = fz_togen(page);
if (n == np && g == gp)
return p-1;
}
return 0;
}
static fz_error
pdf_repairobjstm(pdf_xref *xref, int num, int gen)
{
fz_error error;
fz_obj *obj;
fz_stream *stm;
int tok;
int i, n, count;
char buf[256];
error = pdf_loadobject(&obj, xref, num, gen);
if (error)
return fz_rethrow(error, "cannot load object stream object (%d %d R)", num, gen);
count = fz_toint(fz_dictgets(obj, "N"));
fz_dropobj(obj);
error = pdf_openstream(&stm, xref, num, gen);
if (error)
return fz_rethrow(error, "cannot open object stream object (%d %d R)", num, gen);
for (i = 0; i < count; i++)
{
error = pdf_lex(&tok, stm, buf, sizeof buf, &n);
if (error || tok != PDF_TINT)
{
fz_close(stm);
return fz_rethrow(error, "corrupt object stream (%d %d R)", num, gen);
}
n = atoi(buf);
if (n >= xref->len)
pdf_resizexref(xref, n + 1);
xref->table[n].ofs = num;
xref->table[n].gen = i;
xref->table[n].stmofs = 0;
xref->table[n].obj = nil;
xref->table[n].type = 'o';
error = pdf_lex(&tok, stm, buf, sizeof buf, &n);
if (error || tok != PDF_TINT)
{
fz_close(stm);
return fz_rethrow(error, "corrupt object stream (%d %d R)", num, gen);
}
}
fz_close(stm);
return fz_okay;
}
static pdf_outline *
pdf_loadoutlineimp(pdf_xref *xref, fz_obj *dict)
{
pdf_outline *node;
fz_obj *obj;
if (fz_isnull(dict))
return nil;
node = fz_malloc(sizeof(pdf_outline));
node->title = nil;
node->link = nil;
node->child = nil;
node->next = nil;
node->count = 0;
pdf_logpage("load outline {\n");
obj = fz_dictgets(dict, "Title");
if (obj)
{
node->title = pdf_toutf8(obj);
pdf_logpage("title %s\n", node->title);
}
obj = fz_dictgets(dict, "Count");
if (obj)
{
node->count = fz_toint(obj);
}
if (fz_dictgets(dict, "Dest") || fz_dictgets(dict, "A"))
{
node->link = pdf_loadlink(xref, dict);
}
obj = fz_dictgets(dict, "First");
if (obj)
{
node->child = pdf_loadoutlineimp(xref, obj);
}
pdf_logpage("}\n");
obj = fz_dictgets(dict, "Next");
if (obj)
{
node->next = pdf_loadoutlineimp(xref, obj);
}
return node;
}
fz_filter *
fz_newdctd(fz_obj *params)
{
fz_obj *obj;
int colortransform;
FZ_NEWFILTER(fz_dctd, d, dctd);
colortransform = -1; /* "unset" */
if (params)
{
obj = fz_dictgets(params, "ColorTransform");
if (obj)
colortransform = fz_toint(obj);
}
d->colortransform = colortransform;
d->stage = 0;
/* setup error callback first thing */
myiniterr(&d->err);
d->cinfo.err = (struct jpeg_error_mgr*) &d->err;
if (setjmp(d->err.jb))
fz_warn("cannot initialise jpeg: %s", d->err.msg);
/* create decompression object. this zeroes cinfo except for err. */
jpeg_create_decompress(&d->cinfo);
/* prepare source manager */
d->cinfo.src = (struct jpeg_source_mgr *)&d->src;
d->src.super.init_source = myinitsource;
d->src.super.fill_input_buffer = myfillinput;
d->src.super.skip_input_data = myskipinput;
d->src.super.resync_to_restart = jpeg_resync_to_restart;
d->src.super.term_source = mytermsource;
d->src.super.bytes_in_buffer = 0;
d->src.super.next_input_byte = nil;
d->src.skip = 0;
/* speed up jpeg decoding a bit */
d->cinfo.dct_method = JDCT_FASTEST;
d->cinfo.do_fancy_upsampling = FALSE;
return (fz_filter *)d;
}
/*
* Build a filter for reading raw stream data.
* This is a null filter to constrain reading to the
* stream length, followed by a decryption filter.
*/
static fz_error *
buildrawfilter(fz_filter **filterp, pdf_xref *xref, fz_obj *stmobj, int oid, int gen)
{
fz_error *error;
fz_filter *base;
fz_obj *stmlen;
int len;
stmlen = fz_dictgets(stmobj, "Length");
error = pdf_resolve(&stmlen, xref);
if (error)
return fz_rethrow(error, "cannot resolve stream /Length");
len = fz_toint(stmlen);
fz_dropobj(stmlen);
error = fz_newnullfilter(&base, len);
if (error)
return fz_rethrow(error, "cannot create null filter");
if (xref->crypt)
{
fz_filter *crypt;
fz_filter *pipe;
error = pdf_cryptstream(&crypt, xref->crypt, oid, gen);
if (error)
{
fz_dropfilter(base);
return fz_rethrow(error, "cannot create decryption filter");
}
error = fz_newpipeline(&pipe, base, crypt);
fz_dropfilter(base);
fz_dropfilter(crypt);
if (error)
return fz_rethrow(error, "cannot create pipeline filter");
*filterp = pipe;
}
else
{
*filterp = base;
}
return fz_okay;
}
fz_stream *
fz_opendctd(fz_stream *chain, fz_obj *params)
{
fz_dctd *state;
fz_obj *obj;
state = fz_malloc(sizeof(fz_dctd));
memset(state, 0, sizeof(fz_dctd));
state->chain = chain;
state->colortransform = -1; /* unset */
state->init = 0;
obj = fz_dictgets(params, "ColorTransform");
if (obj)
state->colortransform = fz_toint(obj);
return fz_newstream(state, readdctd, closedctd);
}
fz_stream *
fz_openlzwd(fz_stream *chain, fz_obj *params)
{
fz_lzwd *lzw;
fz_obj *obj;
int i;
lzw = fz_malloc(sizeof(fz_lzwd));
lzw->chain = chain;
lzw->eod = 0;
lzw->earlychange = 1;
obj = fz_dictgets(params, "EarlyChange");
if (obj)
lzw->earlychange = !!fz_toint(obj);
lzw->bidx = 32;
lzw->word = 0;
for (i = 0; i < 256; i++)
{
lzw->table[i].value = i;
lzw->table[i].firstchar = i;
lzw->table[i].length = 1;
lzw->table[i].prev = -1;
}
for (i = 256; i < NUMCODES; i++)
{
lzw->table[i].value = 0;
lzw->table[i].firstchar = 0;
lzw->table[i].length = 0;
lzw->table[i].prev = -1;
}
lzw->codebits = MINBITS;
lzw->code = -1;
lzw->nextcode = LZW_FIRST;
lzw->oldcode = -1;
lzw->rp = lzw->bp;
lzw->wp = lzw->bp;
return fz_newstream(lzw, readlzwd, closelzwd);
}
fz_error
fz_newlzwd(fz_filter **fp, fz_obj *params)
{
int i;
FZ_NEWFILTER(fz_lzwd, lzw, lzwd);
lzw->earlychange = 0;
if (params)
{
fz_obj *obj;
obj = fz_dictgets(params, "EarlyChange");
if (obj) lzw->earlychange = fz_toint(obj) != 0;
}
lzw->bidx = 32;
lzw->word = 0;
for (i = 0; i < 256; i++)
{
lzw->table[i].value = i;
lzw->table[i].firstchar = i;
lzw->table[i].length = 1;
lzw->table[i].prev = -1;
}
for (i = 256; i < NUMCODES; i++)
{
lzw->table[i].value = 0;
lzw->table[i].firstchar = 0;
lzw->table[i].length = 0;
lzw->table[i].prev = -1;
}
lzw->codebits = MINBITS;
lzw->code = -1;
lzw->nextcode = LZW_FIRST;
lzw->oldcode = -1;
lzw->resume = 0;
return fz_okay;
}
static fz_error
loadiccbased(fz_colorspace **csp, pdf_xref *xref, fz_obj *ref)
{
fz_obj *dict;
int n;
pdf_logrsrc("load ICCBased\n");
dict = fz_resolveindirect(ref);
n = fz_toint(fz_dictgets(dict, "N"));
switch (n)
{
case 1: *csp = pdf_devicegray; return fz_okay;
case 3: *csp = pdf_devicergb; return fz_okay;
case 4: *csp = pdf_devicecmyk; return fz_okay;
}
return fz_throw("syntaxerror: ICCBased must have 1, 3 or 4 components");
}
static void
loadcolorkey(int *colorkey, int bpc, int indexed, fz_obj *obj)
{
int scale = 1;
int i;
pdf_logimage("keyed mask\n");
if (!indexed)
{
switch (bpc)
{
case 1: scale = 255; break;
case 2: scale = 85; break;
case 4: scale = 17; break;
case 8: scale = 1; break;
}
}
for (i = 0; i < fz_arraylen(obj); i++)
colorkey[i] = fz_toint(fz_arrayget(obj, i)) * scale;
}
fz_error
pdf_loadpattern(pdf_pattern **patp, pdf_xref *xref, fz_obj *dict)
{
fz_error error;
pdf_pattern *pat;
fz_obj *obj;
if ((*patp = pdf_finditem(xref->store, pdf_droppattern, dict)))
{
pdf_keeppattern(*patp);
return fz_okay;
}
pdf_logrsrc("load pattern (%d %d R) {\n", fz_tonum(dict), fz_togen(dict));
pat = fz_malloc(sizeof(pdf_pattern));
pat->refs = 1;
pat->resources = nil;
pat->contents = nil;
/* Store pattern now, to avoid possible recursion if objects refer back to this one */
pdf_storeitem(xref->store, pdf_keeppattern, pdf_droppattern, dict, pat);
pat->ismask = fz_toint(fz_dictgets(dict, "PaintType")) == 2;
pat->xstep = fz_toreal(fz_dictgets(dict, "XStep"));
pat->ystep = fz_toreal(fz_dictgets(dict, "YStep"));
pdf_logrsrc("mask %d\n", pat->ismask);
pdf_logrsrc("xstep %g\n", pat->xstep);
pdf_logrsrc("ystep %g\n", pat->ystep);
obj = fz_dictgets(dict, "BBox");
pat->bbox = pdf_torect(obj);
pdf_logrsrc("bbox [%g %g %g %g]\n",
pat->bbox.x0, pat->bbox.y0,
pat->bbox.x1, pat->bbox.y1);
obj = fz_dictgets(dict, "Matrix");
if (obj)
pat->matrix = pdf_tomatrix(obj);
else
pat->matrix = fz_identity;
pdf_logrsrc("matrix [%g %g %g %g %g %g]\n",
pat->matrix.a, pat->matrix.b,
pat->matrix.c, pat->matrix.d,
pat->matrix.e, pat->matrix.f);
pat->resources = fz_dictgets(dict, "Resources");
if (pat->resources)
fz_keepobj(pat->resources);
error = pdf_loadstream(&pat->contents, xref, fz_tonum(dict), fz_togen(dict));
if (error)
{
pdf_removeitem(xref->store, pdf_droppattern, dict);
pdf_droppattern(pat);
return fz_rethrow(error, "cannot load pattern stream (%d %d R)", fz_tonum(dict), fz_togen(dict));
}
pdf_logrsrc("}\n");
*patp = pat;
return fz_okay;
}
static fz_error *
loadshadedict(fz_shade **shadep, pdf_xref *xref, fz_obj *dict, fz_obj *ref, fz_matrix matrix)
{
fz_error *error;
fz_shade *shade;
fz_obj *obj;
int type;
int i;
pdf_logshade("load shade dict %d %d {\n", fz_tonum(ref), fz_togen(ref));
shade = fz_malloc(sizeof(fz_shade));
if (!shade)
return fz_outofmem;
shade->refs = 1;
shade->usebackground = 0;
shade->usefunction = 0;
shade->matrix = matrix;
shade->bbox = fz_infiniterect;
shade->meshlen = 0;
shade->meshcap = 0;
shade->mesh = nil;
obj = fz_dictgets(dict, "ShadingType");
type = fz_toint(obj);
pdf_logshade("type %d\n", type);
/* TODO: flatten indexed... */
obj = fz_dictgets(dict, "ColorSpace");
if (obj)
{
shade->cs = pdf_finditem(xref->store, PDF_KCOLORSPACE, obj);
if (shade->cs)
fz_keepcolorspace(shade->cs);
else
{
error = pdf_resolve(&obj, xref);
if (error)
return error;
error = pdf_loadcolorspace(&shade->cs, xref, obj);
if (error)
return error;
fz_dropobj(obj);
}
}
pdf_logshade("colorspace %s\n", shade->cs->name);
obj = fz_dictgets(dict, "Background");
if (obj)
{
pdf_logshade("background\n");
shade->usebackground = 1;
for (i = 0; i < shade->cs->n; i++)
shade->background[i] = fz_toreal(fz_arrayget(obj, i));
}
obj = fz_dictgets(dict, "BBox");
if (fz_isarray(obj))
{
shade->bbox = pdf_torect(obj);
pdf_logshade("bbox [%g %g %g %g]\n",
shade->bbox.x0, shade->bbox.y0,
shade->bbox.x1, shade->bbox.y1);
}
switch(type)
{
case 1:
error = pdf_loadtype1shade(shade, xref, dict, ref);
if (error) goto cleanup;
break;
case 2:
error = pdf_loadtype2shade(shade, xref, dict, ref);
if (error) goto cleanup;
break;
case 3:
error = pdf_loadtype3shade(shade, xref, dict, ref);
if (error) goto cleanup;
break;
case 4:
error = pdf_loadtype4shade(shade, xref, dict, ref);
if (error) goto cleanup;
break;
case 5:
error = pdf_loadtype5shade(shade, xref, dict, ref);
if (error) goto cleanup;
break;
case 6:
error = pdf_loadtype6shade(shade, xref, dict, ref);
if (error) goto cleanup;
break;
case 7:
error = pdf_loadtype7shade(shade, xref, dict, ref);
if (error) goto cleanup;
break;
default:
fz_warn("syntaxerror: unknown shading type: %d", type);
break;
};
pdf_logshade("}\n");
*shadep = shade;
return nil;
cleanup:
fz_dropshade(shade);
return error;
}
void pdfmoz_open(pdfmoz_t *moz, char *filename)
{
SCROLLINFO si;
fz_error error;
fz_obj *obj;
fz_irect bbox;
int rot;
int i;
strcpy(moz->error, "");
error = fz_newrenderer(&moz->rast, pdf_devicergb, 0, 1024 * 512);
if (error)
pdfmoz_error(moz, error);
/*
* Open PDF and load xref table
*/
moz->filename = filename;
moz->xref = pdf_newxref();
error = pdf_loadxref(moz->xref, filename);
if (error)
{
error = pdf_repairxref(moz->xref, filename);
if (error)
pdfmoz_error(moz, error);
}
/*
* Handle encrypted PDF files
*/
error = pdf_decryptxref(moz->xref);
if (error)
pdfmoz_error(moz, error);
if (pdf_needspassword(moz->xref))
{
pdfmoz_warn(moz, "PDF file is encrypted and needs a password.");
}
moz->pagecount = pdf_getpagecount(moz->xref);
moz->pages = fz_malloc(sizeof(page_t) * moz->pagecount);
for (i = 0; i < moz->pagecount; i++)
{
fz_obj *pageobj;
pageobj = pdf_getpageobject(moz->xref, i);
moz->pages[i].obj = fz_keepobj(pageobj);
moz->pages[i].page = nil;
moz->pages[i].image = nil;
obj = fz_dictgets(moz->pages[i].obj, "CropBox");
if (!obj)
obj = fz_dictgets(moz->pages[i].obj, "MediaBox");
bbox = fz_roundrect(pdf_torect(obj));
moz->pages[i].w = bbox.x1 - bbox.x0;
moz->pages[i].h = bbox.y1 - bbox.y0;
rot = fz_toint(fz_dictgets(moz->pages[i].obj, "Rotate"));
if ((rot / 90) % 2)
{
int t = moz->pages[i].w;
moz->pages[i].w = moz->pages[i].h;
moz->pages[i].h = t;
}
moz->pages[i].px = 1 + PAD;
}
/*
* Load meta information
* TODO: move this into mupdf library
*/
obj = fz_dictgets(moz->xref->trailer, "Root");
moz->xref->root = fz_resolveindirect(obj);
if (!moz->xref->root)
pdfmoz_error(moz, fz_throw("syntaxerror: missing Root object"));
if (moz->xref->root)
fz_keepobj(moz->xref->root);
obj = fz_dictgets(moz->xref->trailer, "Info");
moz->xref->info = fz_resolveindirect(obj);
if (moz->xref->info)
fz_keepobj(moz->xref->info);
moz->doctitle = filename;
if (strrchr(moz->doctitle, '\\'))
moz->doctitle = strrchr(moz->doctitle, '\\') + 1;
if (strrchr(moz->doctitle, '/'))
moz->doctitle = strrchr(moz->doctitle, '/') + 1;
if (moz->xref->info)
{
obj = fz_dictgets(moz->xref->info, "Title");
if (obj)
moz->doctitle = pdf_toutf8(obj);
}
/*
* Start at first page
*/
si.cbSize = sizeof(si);
si.fMask = SIF_POS | SIF_RANGE; // XXX | SIF_PAGE;
si.nPos = 0;
si.nMin = 0;
si.nMax = 1;
si.nPage = 1;
SetScrollInfo(moz->hwnd, SB_VERT, &si, TRUE);
moz->scrollpage = 0;
moz->scrollyofs = 0;
InvalidateRect(moz->hwnd, NULL, FALSE);
}
fz_error
pdf_loadfontdescriptor(pdf_fontdesc *fontdesc, pdf_xref *xref, fz_obj *dict, char *collection, char *basefont)
{
fz_error error;
fz_obj *obj1, *obj2, *obj3, *obj;
fz_rect bbox;
char *fontname;
char *origname;
pdf_logfont("load fontdescriptor {\n");
/* cf. http://code.google.com/p/sumatrapdf/issues/detail?id=1014 */
if (!strchr(basefont, ',') || strchr(basefont, '+'))
origname = fz_toname(fz_dictgets(dict, "FontName"));
else
origname = basefont;
fontname = cleanfontname(origname);
pdf_logfont("fontname %s -> %s\n", origname, fontname);
fontdesc->flags = fz_toint(fz_dictgets(dict, "Flags"));
fontdesc->italicangle = fz_toreal(fz_dictgets(dict, "ItalicAngle"));
fontdesc->ascent = fz_toreal(fz_dictgets(dict, "Ascent"));
fontdesc->descent = fz_toreal(fz_dictgets(dict, "Descent"));
fontdesc->capheight = fz_toreal(fz_dictgets(dict, "CapHeight"));
fontdesc->xheight = fz_toreal(fz_dictgets(dict, "XHeight"));
fontdesc->missingwidth = fz_toreal(fz_dictgets(dict, "MissingWidth"));
bbox = pdf_torect(fz_dictgets(dict, "FontBBox"));
pdf_logfont("bbox [%g %g %g %g]\n", bbox.x0, bbox.y0, bbox.x1, bbox.y1);
pdf_logfont("flags %d\n", fontdesc->flags);
obj1 = fz_dictgets(dict, "FontFile");
obj2 = fz_dictgets(dict, "FontFile2");
obj3 = fz_dictgets(dict, "FontFile3");
obj = obj1 ? obj1 : obj2 ? obj2 : obj3;
if (getenv("NOFONT"))
obj = nil;
if (fz_isindirect(obj))
{
error = pdf_loadembeddedfont(fontdesc, xref, obj);
if (error)
{
fz_catch(error, "ignored error when loading embedded font, attempting to load system font");
if (origname != fontname)
error = pdf_loadbuiltinfont(fontdesc, fontname);
else
error = pdf_loadsystemfont(fontdesc, fontname, collection);
if (error)
return fz_rethrow(error, "cannot load font descriptor (%d %d R)", fz_tonum(dict), fz_togen(dict));
}
}
else
{
if (origname != fontname && 0 /* SumatraPDF: prefer system fonts to the built-in ones */)
error = pdf_loadbuiltinfont(fontdesc, fontname);
else
error = pdf_loadsystemfont(fontdesc, fontname, collection);
if (error)
return fz_rethrow(error, "cannot load font descriptor (%d %d R)", fz_tonum(dict), fz_togen(dict));
}
fz_strlcpy(fontdesc->font->name, fontname, sizeof fontdesc->font->name);
pdf_logfont("}\n");
return fz_okay;
}
static fz_error
loadcidfont(pdf_fontdesc **fontdescp, pdf_xref *xref, fz_obj *dict, fz_obj *encoding, fz_obj *tounicode)
{
fz_error error;
fz_obj *widths;
fz_obj *descriptor;
pdf_fontdesc *fontdesc;
FT_Face face;
fz_bbox bbox;
int kind;
char collection[256];
char *basefont;
int i, k, fterr;
fz_obj *obj;
int dw;
/* Get font name and CID collection */
basefont = fz_toname(fz_dictgets(dict, "BaseFont"));
{
fz_obj *cidinfo;
char tmpstr[64];
int tmplen;
cidinfo = fz_dictgets(dict, "CIDSystemInfo");
if (!cidinfo)
return fz_throw("cid font is missing info");
obj = fz_dictgets(cidinfo, "Registry");
tmplen = MIN(sizeof tmpstr - 1, fz_tostrlen(obj));
memcpy(tmpstr, fz_tostrbuf(obj), tmplen);
tmpstr[tmplen] = '\0';
fz_strlcpy(collection, tmpstr, sizeof collection);
fz_strlcat(collection, "-", sizeof collection);
obj = fz_dictgets(cidinfo, "Ordering");
tmplen = MIN(sizeof tmpstr - 1, fz_tostrlen(obj));
memcpy(tmpstr, fz_tostrbuf(obj), tmplen);
tmpstr[tmplen] = '\0';
fz_strlcat(collection, tmpstr, sizeof collection);
}
/* Load font file */
fontdesc = pdf_newfontdesc();
pdf_logfont("load cid font (%d %d R) ptr=%p {\n", fz_tonum(dict), fz_togen(dict), fontdesc);
pdf_logfont("basefont %s\n", basefont);
pdf_logfont("collection %s\n", collection);
descriptor = fz_dictgets(dict, "FontDescriptor");
if (descriptor)
error = pdf_loadfontdescriptor(fontdesc, xref, descriptor, collection, basefont);
else
error = fz_throw("syntaxerror: missing font descriptor");
if (error)
goto cleanup;
face = fontdesc->font->ftface;
kind = ftkind(face);
bbox.x0 = (face->bbox.xMin * 1000) / face->units_per_EM;
bbox.y0 = (face->bbox.yMin * 1000) / face->units_per_EM;
bbox.x1 = (face->bbox.xMax * 1000) / face->units_per_EM;
bbox.y1 = (face->bbox.yMax * 1000) / face->units_per_EM;
pdf_logfont("ft bbox [%d %d %d %d]\n", bbox.x0, bbox.y0, bbox.x1, bbox.y1);
if (bbox.x0 == bbox.x1)
fz_setfontbbox(fontdesc->font, -1000, -1000, 2000, 2000);
else
fz_setfontbbox(fontdesc->font, bbox.x0, bbox.y0, bbox.x1, bbox.y1);
/* Encoding */
error = fz_okay;
if (fz_isname(encoding))
{
pdf_logfont("encoding /%s\n", fz_toname(encoding));
if (!strcmp(fz_toname(encoding), "Identity-H"))
fontdesc->encoding = pdf_newidentitycmap(0, 2);
else if (!strcmp(fz_toname(encoding), "Identity-V"))
fontdesc->encoding = pdf_newidentitycmap(1, 2);
else
error = pdf_loadsystemcmap(&fontdesc->encoding, fz_toname(encoding));
}
else if (fz_isindirect(encoding))
{
pdf_logfont("encoding %d %d R\n", fz_tonum(encoding), fz_togen(encoding));
error = pdf_loadembeddedcmap(&fontdesc->encoding, xref, encoding);
}
else
{
error = fz_throw("syntaxerror: font missing encoding");
}
if (error)
goto cleanup;
pdf_setfontwmode(fontdesc, pdf_getwmode(fontdesc->encoding));
pdf_logfont("wmode %d\n", pdf_getwmode(fontdesc->encoding));
if (kind == TRUETYPE)
{
fz_obj *cidtogidmap;
cidtogidmap = fz_dictgets(dict, "CIDToGIDMap");
if (fz_isindirect(cidtogidmap))
{
fz_buffer *buf;
pdf_logfont("cidtogidmap stream\n");
error = pdf_loadstream(&buf, xref, fz_tonum(cidtogidmap), fz_togen(cidtogidmap));
if (error)
goto cleanup;
fontdesc->ncidtogid = (buf->len) / 2;
fontdesc->cidtogid = fz_malloc(fontdesc->ncidtogid * sizeof(unsigned short));
for (i = 0; i < fontdesc->ncidtogid; i++)
fontdesc->cidtogid[i] = (buf->data[i * 2] << 8) + buf->data[i * 2 + 1];
fz_dropbuffer(buf);
}
/* if truetype font is external, cidtogidmap should not be identity */
/* so we map from cid to unicode and then map that through the (3 1) */
/* unicode cmap to get a glyph id */
else if (fontdesc->font->ftsubstitute)
{
pdf_logfont("emulate ttf cidfont\n");
fterr = FT_Select_Charmap(face, ft_encoding_unicode);
if (fterr)
{
error = fz_throw("fonterror: no unicode cmap when emulating CID font: %s", ft_errorstring(fterr));
goto cleanup;
}
if (!strcmp(collection, "Adobe-CNS1"))
error = pdf_loadsystemcmap(&fontdesc->tottfcmap, "Adobe-CNS1-UCS2");
else if (!strcmp(collection, "Adobe-GB1"))
error = pdf_loadsystemcmap(&fontdesc->tottfcmap, "Adobe-GB1-UCS2");
else if (!strcmp(collection, "Adobe-Japan1"))
error = pdf_loadsystemcmap(&fontdesc->tottfcmap, "Adobe-Japan1-UCS2");
else if (!strcmp(collection, "Adobe-Japan2"))
error = pdf_loadsystemcmap(&fontdesc->tottfcmap, "Adobe-Japan2-UCS2");
else if (!strcmp(collection, "Adobe-Korea1"))
error = pdf_loadsystemcmap(&fontdesc->tottfcmap, "Adobe-Korea1-UCS2");
else
error = fz_okay;
if (error)
{
error = fz_rethrow(error, "cannot load system cmap %s", collection);
goto cleanup;
}
}
}
error = pdf_loadtounicode(fontdesc, xref, nil, collection, tounicode);
if (error)
goto cleanup;
/* Horizontal */
dw = 1000;
obj = fz_dictgets(dict, "DW");
if (obj)
dw = fz_toint(obj);
pdf_setdefaulthmtx(fontdesc, dw);
widths = fz_dictgets(dict, "W");
if (widths)
{
int c0, c1, w;
for (i = 0; i < fz_arraylen(widths); )
{
c0 = fz_toint(fz_arrayget(widths, i));
obj = fz_arrayget(widths, i + 1);
if (fz_isarray(obj))
{
for (k = 0; k < fz_arraylen(obj); k++)
{
w = fz_toint(fz_arrayget(obj, k));
pdf_addhmtx(fontdesc, c0 + k, c0 + k, w);
}
i += 2;
}
else
{
c1 = fz_toint(obj);
w = fz_toint(fz_arrayget(widths, i + 2));
pdf_addhmtx(fontdesc, c0, c1, w);
i += 3;
}
}
}
pdf_endhmtx(fontdesc);
/* Vertical */
if (pdf_getwmode(fontdesc->encoding) == 1)
{
int dw2y = 880;
int dw2w = -1000;
obj = fz_dictgets(dict, "DW2");
if (obj)
{
dw2y = fz_toint(fz_arrayget(obj, 0));
dw2w = fz_toint(fz_arrayget(obj, 1));
}
pdf_setdefaultvmtx(fontdesc, dw2y, dw2w);
widths = fz_dictgets(dict, "W2");
if (widths)
{
int c0, c1, w, x, y;
for (i = 0; i < fz_arraylen(widths); )
{
c0 = fz_toint(fz_arrayget(widths, i));
obj = fz_arrayget(widths, i + 1);
if (fz_isarray(obj))
{
for (k = 0; k < fz_arraylen(obj); k += 3)
{
w = fz_toint(fz_arrayget(obj, k + 0));
x = fz_toint(fz_arrayget(obj, k + 1));
y = fz_toint(fz_arrayget(obj, k + 2));
pdf_addvmtx(fontdesc, c0 + k, c0 + k, x, y, w);
}
i += 2;
}
else
{
c1 = fz_toint(obj);
w = fz_toint(fz_arrayget(widths, i + 2));
x = fz_toint(fz_arrayget(widths, i + 3));
y = fz_toint(fz_arrayget(widths, i + 4));
pdf_addvmtx(fontdesc, c0, c1, x, y, w);
i += 5;
}
}
}
pdf_endvmtx(fontdesc);
}
pdf_logfont("}\n");
*fontdescp = fontdesc;
return fz_okay;
cleanup:
pdf_dropfont(fontdesc);
return fz_rethrow(error, "cannot load cid font (%d %d R)", fz_tonum(dict), fz_togen(dict));
}
static fz_error
loadsimplefont(pdf_fontdesc **fontdescp, pdf_xref *xref, fz_obj *dict)
{
fz_error error;
fz_obj *descriptor;
fz_obj *encoding;
fz_obj *widths;
unsigned short *etable = nil;
pdf_fontdesc *fontdesc;
fz_bbox bbox;
FT_Face face;
FT_CharMap cmap;
int kind;
int symbolic;
char *basefont;
char *fontname;
char *estrings[256];
char ebuffer[256][32];
int i, k, n;
int fterr;
basefont = fz_toname(fz_dictgets(dict, "BaseFont"));
fontname = cleanfontname(basefont);
/* Load font file */
fontdesc = pdf_newfontdesc();
pdf_logfont("load simple font (%d %d R) ptr=%p {\n", fz_tonum(dict), fz_togen(dict), fontdesc);
pdf_logfont("basefont %s -> %s\n", basefont, fontname);
descriptor = fz_dictgets(dict, "FontDescriptor");
if (descriptor)
error = pdf_loadfontdescriptor(fontdesc, xref, descriptor, nil, basefont);
else
error = pdf_loadbuiltinfont(fontdesc, fontname);
if (error)
goto cleanup;
face = fontdesc->font->ftface;
kind = ftkind(face);
pdf_logfont("ft name '%s' '%s'\n", face->family_name, face->style_name);
bbox.x0 = (face->bbox.xMin * 1000) / face->units_per_EM;
bbox.y0 = (face->bbox.yMin * 1000) / face->units_per_EM;
bbox.x1 = (face->bbox.xMax * 1000) / face->units_per_EM;
bbox.y1 = (face->bbox.yMax * 1000) / face->units_per_EM;
pdf_logfont("ft bbox [%d %d %d %d]\n", bbox.x0, bbox.y0, bbox.x1, bbox.y1);
if (bbox.x0 == bbox.x1)
fz_setfontbbox(fontdesc->font, -1000, -1000, 2000, 2000);
else
fz_setfontbbox(fontdesc->font, bbox.x0, bbox.y0, bbox.x1, bbox.y1);
/* Encoding */
symbolic = fontdesc->flags & 4;
if (face->num_charmaps > 0)
cmap = face->charmaps[0];
else
cmap = nil;
for (i = 0; i < face->num_charmaps; i++)
{
FT_CharMap test = face->charmaps[i];
if (kind == TYPE1)
{
if (test->platform_id == 7)
cmap = test;
}
if (kind == TRUETYPE)
{
if (test->platform_id == 1 && test->encoding_id == 0)
cmap = test;
if (test->platform_id == 3 && test->encoding_id == 1)
cmap = test;
}
}
if (cmap)
{
fterr = FT_Set_Charmap(face, cmap);
if (fterr)
fz_warn("freetype could not set cmap: %s", ft_errorstring(fterr));
}
else
fz_warn("freetype could not find any cmaps");
etable = fz_malloc(sizeof(unsigned short) * 256);
for (i = 0; i < 256; i++)
{
estrings[i] = nil;
etable[i] = 0;
}
encoding = fz_dictgets(dict, "Encoding");
if (encoding)
{
if (fz_isname(encoding))
pdf_loadencoding(estrings, fz_toname(encoding));
if (fz_isdict(encoding))
{
fz_obj *base, *diff, *item;
base = fz_dictgets(encoding, "BaseEncoding");
if (fz_isname(base))
pdf_loadencoding(estrings, fz_toname(base));
else if (!fontdesc->isembedded && !symbolic)
pdf_loadencoding(estrings, "StandardEncoding");
/* cf. http://bugs.ghostscript.com/show_bug.cgi?id=690615 and http://code.google.com/p/sumatrapdf/issues/detail?id=687 */
/* try to extract an encoding from the font or synthesize a likely one */
/* note: FT_Get_Name_Index fails for symbolic CFF fonts, so let them be encoded by index */
else if (!fontdesc->encoding && !ftloadt1encoding(face, estrings) && !(symbolic && !strcmp(FT_Get_X11_Font_Format(face), "CFF")))
pdf_loadencoding(estrings, "StandardEncoding");
diff = fz_dictgets(encoding, "Differences");
if (fz_isarray(diff))
{
n = fz_arraylen(diff);
k = 0;
for (i = 0; i < n; i++)
{
item = fz_arrayget(diff, i);
if (fz_isint(item))
k = fz_toint(item);
if (fz_isname(item))
estrings[k++] = fz_toname(item);
if (k < 0) k = 0;
if (k > 255) k = 255;
}
}
}
}
/* start with the builtin encoding */
for (i = 0; i < 256; i++)
etable[i] = ftcharindex(face, i);
/* encode by glyph name where we can */
if (kind == TYPE1)
{
pdf_logfont("encode type1/cff by strings\n");
for (i = 0; i < 256; i++)
{
if (estrings[i])
{
etable[i] = FT_Get_Name_Index(face, estrings[i]);
if (etable[i] == 0)
{
int aglcode = pdf_lookupagl(estrings[i]);
char **aglnames = pdf_lookupaglnames(aglcode);
while (*aglnames)
{
etable[i] = FT_Get_Name_Index(face, *aglnames);
if (etable[i])
break;
aglnames++;
}
}
}
}
}
/* encode by glyph name where we can */
if (kind == TRUETYPE)
{
/* Unicode cmap */
if (!symbolic && face->charmap && face->charmap->platform_id == 3)
{
pdf_logfont("encode truetype via unicode\n");
for (i = 0; i < 256; i++)
{
if (estrings[i])
{
int aglcode = pdf_lookupagl(estrings[i]);
if (!aglcode)
etable[i] = FT_Get_Name_Index(face, estrings[i]);
else
etable[i] = ftcharindex(face, aglcode);
}
}
}
/* MacRoman cmap */
else if (!symbolic && face->charmap && face->charmap->platform_id == 1)
{
pdf_logfont("encode truetype via macroman\n");
for (i = 0; i < 256; i++)
{
if (estrings[i])
{
k = mrecode(estrings[i]);
if (k <= 0)
etable[i] = FT_Get_Name_Index(face, estrings[i]);
else
etable[i] = ftcharindex(face, k);
}
}
}
/* Symbolic cmap */
else
{
pdf_logfont("encode truetype symbolic\n");
for (i = 0; i < 256; i++)
{
if (estrings[i])
{
etable[i] = FT_Get_Name_Index(face, estrings[i]);
if (etable[i] == 0)
etable[i] = ftcharindex(face, i);
}
}
}
}
/* try to reverse the glyph names from the builtin encoding */
for (i = 0; i < 256; i++)
{
if (etable[i] && !estrings[i])
{
if (FT_HAS_GLYPH_NAMES(face))
{
fterr = FT_Get_Glyph_Name(face, etable[i], ebuffer[i], 32);
if (fterr)
fz_warn("freetype get glyph name (gid %d): %s", etable[i], ft_errorstring(fterr));
if (ebuffer[i][0])
estrings[i] = ebuffer[i];
}
else
{
estrings[i] = (char*) pdf_winansi[i]; /* discard const */
}
}
}
/* Prevent encoding Differences from being overwritten by reloading them */
/* cf. http://code.google.com/p/sumatrapdf/issues/detail?id=115 */
if (fz_isdict(encoding))
{
fz_obj *diff, *item;
diff = fz_dictgets(encoding, "Differences");
if (fz_isarray(diff))
{
n = fz_arraylen(diff);
k = 0;
for (i = 0; i < n; i++)
{
item = fz_arrayget(diff, i);
if (fz_isint(item))
k = fz_toint(item);
if (fz_isname(item))
estrings[k++] = fz_toname(item);
if (k < 0) k = 0;
if (k > 255) k = 255;
}
}
}
fontdesc->encoding = pdf_newidentitycmap(0, 1);
fontdesc->ncidtogid = 256;
fontdesc->cidtogid = etable;
error = pdf_loadtounicode(fontdesc, xref, estrings, nil, fz_dictgets(dict, "ToUnicode"));
if (error)
goto cleanup;
/* Widths */
pdf_setdefaulthmtx(fontdesc, fontdesc->missingwidth);
widths = fz_dictgets(dict, "Widths");
if (widths)
{
int first, last;
first = fz_toint(fz_dictgets(dict, "FirstChar"));
last = fz_toint(fz_dictgets(dict, "LastChar"));
if (first < 0 || last > 255 || first > last)
first = last = 0;
for (i = 0; i < last - first + 1; i++)
{
int wid = fz_toint(fz_arrayget(widths, i));
pdf_addhmtx(fontdesc, i + first, i + first, wid);
}
}
else
{
fterr = FT_Set_Char_Size(face, 1000, 1000, 72, 72);
if (fterr)
fz_warn("freetype set character size: %s", ft_errorstring(fterr));
for (i = 0; i < 256; i++)
{
pdf_addhmtx(fontdesc, i, i, ftwidth(fontdesc, i));
}
}
pdf_endhmtx(fontdesc);
pdf_logfont("}\n");
*fontdescp = fontdesc;
return fz_okay;
cleanup:
if (etable != fontdesc->cidtogid)
fz_free(etable);
pdf_dropfont(fontdesc);
return fz_rethrow(error, "cannot load simple font (%d %d R)", fz_tonum(dict), fz_togen(dict));
}
static fz_error
loadindexed(fz_colorspace **csp, pdf_xref *xref, fz_obj *array)
{
fz_error error;
pdf_indexed *cs;
fz_obj *baseobj = fz_arrayget(array, 1);
fz_obj *highobj = fz_arrayget(array, 2);
fz_obj *lookup = fz_arrayget(array, 3);
fz_colorspace *base;
int n;
pdf_logrsrc("load Indexed {\n");
error = pdf_loadcolorspace(&base, xref, baseobj);
if (error)
return fz_rethrow(error, "cannot load base colorspace");
pdf_logrsrc("base %s\n", base->name);
cs = fz_malloc(sizeof(pdf_indexed));
initcs((fz_colorspace*)cs, "Indexed", 1, nil, nil, freeindexed);
cs->base = fz_keepcolorspace(base);
cs->high = fz_toint(highobj);
fz_dropcolorspace(base);
n = base->n * (cs->high + 1);
cs->lookup = fz_malloc(n);
if (fz_isstring(lookup) && fz_tostrlen(lookup) == n)
{
unsigned char *buf;
int i;
pdf_logrsrc("string lookup\n");
buf = (unsigned char *) fz_tostrbuf(lookup);
for (i = 0; i < n; i++)
cs->lookup[i] = buf[i];
}
else if (fz_isindirect(lookup))
{
fz_buffer *buf;
int i;
pdf_logrsrc("stream lookup\n");
error = pdf_loadstream(&buf, xref, fz_tonum(lookup), fz_togen(lookup));
if (error)
{
fz_dropcolorspace((fz_colorspace*)cs);
return fz_rethrow(error, "cannot load colorpsace lookup table");
}
for (i = 0; i < n && i < (buf->wp - buf->rp); i++)
cs->lookup[i] = buf->rp[i];
fz_dropbuffer(buf);
}
else
return fz_throw("cannot parse colorspace lookup table");
pdf_logrsrc("}\n");
*csp = (fz_colorspace*)cs;
return fz_okay;
}
static fz_error
pdf_loadobjstm(pdf_xref *xref, int num, int gen, char *buf, int cap)
{
fz_error error;
fz_stream *stm;
fz_obj *objstm;
int *numbuf;
int *ofsbuf;
fz_obj *obj;
int first;
int count;
int i, n;
pdf_token_e tok;
pdf_logxref("loadobjstm (%d %d R)\n", num, gen);
error = pdf_loadobject(&objstm, xref, num, gen);
if (error)
return fz_rethrow(error, "cannot load object stream object (%d %d R)", num, gen);
count = fz_toint(fz_dictgets(objstm, "N"));
first = fz_toint(fz_dictgets(objstm, "First"));
pdf_logxref("\tcount %d\n", count);
numbuf = fz_malloc(count * sizeof(int));
ofsbuf = fz_malloc(count * sizeof(int));
error = pdf_openstream(&stm, xref, num, gen);
if (error)
{
error = fz_rethrow(error, "cannot open object stream (%d %d R)", num, gen);
goto cleanupbuf;
}
for (i = 0; i < count; i++)
{
error = pdf_lex(&tok, stm, buf, cap, &n);
if (error || tok != PDF_TINT)
{
error = fz_rethrow(error, "corrupt object stream (%d %d R)", num, gen);
goto cleanupstm;
}
numbuf[i] = atoi(buf);
error = pdf_lex(&tok, stm, buf, cap, &n);
if (error || tok != PDF_TINT)
{
error = fz_rethrow(error, "corrupt object stream (%d %d R)", num, gen);
goto cleanupstm;
}
ofsbuf[i] = atoi(buf);
}
fz_seek(stm, first, 0);
for (i = 0; i < count; i++)
{
fz_seek(stm, first + ofsbuf[i], 0);
error = pdf_parsestmobj(&obj, xref, stm, buf, cap);
if (error)
{
error = fz_rethrow(error, "cannot parse object %d in stream (%d %d R)", i, num, gen);
goto cleanupstm;
}
if (numbuf[i] < 1 || numbuf[i] >= xref->len)
{
fz_dropobj(obj);
error = fz_throw("object id (%d 0 R) out of range (0..%d)", numbuf[i], xref->len - 1);
goto cleanupstm;
}
if (xref->table[numbuf[i]].type == 'o' && xref->table[numbuf[i]].ofs == num)
{
if (xref->table[numbuf[i]].obj)
fz_dropobj(xref->table[numbuf[i]].obj);
xref->table[numbuf[i]].obj = obj;
}
else
{
fz_dropobj(obj);
}
}
fz_close(stm);
fz_free(ofsbuf);
fz_free(numbuf);
fz_dropobj(objstm);
return fz_okay;
cleanupstm:
fz_close(stm);
cleanupbuf:
fz_free(ofsbuf);
fz_free(numbuf);
fz_dropobj(objstm);
return error; /* already rethrown */
}
static fz_error
pdf_readnewxref(fz_obj **trailerp, pdf_xref *xref, char *buf, int cap)
{
fz_error error;
fz_stream *stm;
fz_obj *trailer;
fz_obj *index;
fz_obj *obj;
int num, gen, stmofs;
int size, w0, w1, w2;
int t;
int i;
pdf_logxref("load new xref format\n");
error = pdf_parseindobj(&trailer, xref, xref->file, buf, cap, &num, &gen, &stmofs);
if (error)
return fz_rethrow(error, "cannot parse compressed xref stream object");
obj = fz_dictgets(trailer, "Size");
if (!obj)
{
fz_dropobj(trailer);
return fz_throw("xref stream missing Size entry (%d %d R)", num, gen);
}
size = fz_toint(obj);
if (size >= xref->cap)
{
xref->cap = size + 1; /* for hack to allow broken pdf generators with off-by-one errors */
xref->table = fz_realloc(xref->table, xref->cap * sizeof(pdf_xrefentry));
}
if (size > xref->len)
{
for (i = xref->len; i < xref->cap; i++)
{
xref->table[i].ofs = 0;
xref->table[i].gen = 0;
xref->table[i].stmofs = 0;
xref->table[i].obj = nil;
xref->table[i].type = 0;
}
xref->len = size;
}
if (num < 0 || num >= xref->len)
{
if (num == xref->len && num < xref->cap)
{
/* allow broken pdf files that have off-by-one errors in the xref */
fz_warn("object id (%d %d R) out of range (0..%d)", num, gen, xref->len - 1);
xref->len ++;
}
else
{
fz_dropobj(trailer);
return fz_throw("object id (%d %d R) out of range (0..%d)", num, gen, xref->len - 1);
}
}
pdf_logxref("\tnum=%d gen=%d size=%d\n", num, gen, size);
obj = fz_dictgets(trailer, "W");
if (!obj) {
fz_dropobj(trailer);
return fz_throw("xref stream missing W entry (%d %d R)", num, gen);
}
w0 = fz_toint(fz_arrayget(obj, 0));
w1 = fz_toint(fz_arrayget(obj, 1));
w2 = fz_toint(fz_arrayget(obj, 2));
index = fz_dictgets(trailer, "Index");
error = pdf_openstreamat(&stm, xref, num, gen, trailer, stmofs);
if (error)
{
fz_dropobj(trailer);
return fz_rethrow(error, "cannot open compressed xref stream (%d %d R)", num, gen);
}
if (!index)
{
error = pdf_readnewxrefsection(xref, stm, 0, size, w0, w1, w2);
if (error)
{
fz_close(stm);
fz_dropobj(trailer);
return fz_rethrow(error, "cannot read xref stream (%d %d R)", num, gen);
}
}
else
{
for (t = 0; t < fz_arraylen(index); t += 2)
{
int i0 = fz_toint(fz_arrayget(index, t + 0));
int i1 = fz_toint(fz_arrayget(index, t + 1));
error = pdf_readnewxrefsection(xref, stm, i0, i1, w0, w1, w2);
if (error)
{
fz_close(stm);
fz_dropobj(trailer);
return fz_rethrow(error, "cannot read xref stream section (%d %d R)", num, gen);
}
}
}
fz_close(stm);
*trailerp = trailer;
return fz_okay;
}
static fz_error *
loadindexed(fz_colorspace **csp, pdf_xref *xref, fz_obj *array)
{
fz_error *error;
pdf_indexed *cs;
fz_obj *baseobj = fz_arrayget(array, 1);
fz_obj *highobj = fz_arrayget(array, 2);
fz_obj *lookup = fz_arrayget(array, 3);
fz_colorspace *base;
int n;
pdf_logrsrc("load Indexed {\n");
error = pdf_resolve(&baseobj, xref);
if (error)
return error;
error = pdf_loadcolorspace(&base, xref, baseobj);
fz_dropobj(baseobj);
if (error)
return error;
pdf_logrsrc("base %s\n", base->name);
cs = fz_malloc(sizeof(pdf_indexed));
if (!cs)
{
fz_dropcolorspace(base);
return fz_outofmem;
}
initcs((fz_colorspace*)cs, "Indexed", 1, nil, nil, dropindexed);
cs->base = base;
cs->high = fz_toint(highobj);
n = base->n * (cs->high + 1);
cs->lookup = fz_malloc(n);
if (!cs->lookup)
{
fz_dropcolorspace((fz_colorspace*)cs);
return fz_outofmem;
}
if (fz_isstring(lookup) && fz_tostrlen(lookup) == n)
{
unsigned char *buf;
int i;
pdf_logrsrc("string lookup\n");
buf = fz_tostrbuf(lookup);
for (i = 0; i < n; i++)
cs->lookup[i] = buf[i];
}
if (fz_isindirect(lookup))
{
fz_buffer *buf;
int i;
pdf_logrsrc("stream lookup\n");
error = pdf_loadstream(&buf, xref, fz_tonum(lookup), fz_togen(lookup));
if (error)
{
fz_dropcolorspace((fz_colorspace*)cs);
return error;
}
for (i = 0; i < n && i < (buf->wp - buf->rp); i++)
cs->lookup[i] = buf->rp[i];
fz_dropbuffer(buf);
}
pdf_logrsrc("}\n");
*csp = (fz_colorspace*)cs;
return nil;
}
/*
* Load CMap stream in PDF file
*/
fz_error
pdf_loadembeddedcmap(pdf_cmap **cmapp, pdf_xref *xref, fz_obj *stmref)
{
fz_error error = fz_okay;
fz_obj *stmobj;
fz_stream *file = nil;
pdf_cmap *cmap = nil;
pdf_cmap *usecmap;
fz_obj *wmode;
fz_obj *obj;
if ((*cmapp = pdf_finditem(xref->store, PDF_KCMAP, stmref)))
{
pdf_keepcmap(*cmapp);
return fz_okay;
}
pdf_logfont("load embedded cmap (%d %d R) {\n", fz_tonum(stmref), fz_togen(stmref));
stmobj = fz_resolveindirect(stmref);
error = pdf_openstream(&file, xref, fz_tonum(stmref), fz_togen(stmref));
if (error)
{
error = fz_rethrow(error, "cannot open cmap stream");
goto cleanup;
}
error = pdf_parsecmap(&cmap, file);
if (error)
{
error = fz_rethrow(error, "cannot parse cmap stream");
goto cleanup;
}
fz_dropstream(file);
wmode = fz_dictgets(stmobj, "WMode");
if (fz_isint(wmode))
{
pdf_logfont("wmode %d\n", wmode);
pdf_setwmode(cmap, fz_toint(wmode));
}
obj = fz_dictgets(stmobj, "UseCMap");
if (fz_isname(obj))
{
pdf_logfont("usecmap /%s\n", fz_toname(obj));
error = pdf_loadsystemcmap(&usecmap, fz_toname(obj));
if (error)
{
error = fz_rethrow(error, "cannot load system usecmap '%s'", fz_toname(obj));
goto cleanup;
}
pdf_setusecmap(cmap, usecmap);
pdf_dropcmap(usecmap);
}
else if (fz_isindirect(obj))
{
pdf_logfont("usecmap (%d %d R)\n", fz_tonum(obj), fz_togen(obj));
error = pdf_loadembeddedcmap(&usecmap, xref, obj);
if (error)
{
error = fz_rethrow(error, "cannot load embedded usecmap");
goto cleanup;
}
pdf_setusecmap(cmap, usecmap);
pdf_dropcmap(usecmap);
}
pdf_logfont("}\n");
error = pdf_storeitem(xref->store, PDF_KCMAP, stmref, cmap);
if (error)
{
error = fz_rethrow(error, "cannot store cmap resource");
goto cleanup;
}
*cmapp = cmap;
return fz_okay;
cleanup:
if (file)
fz_dropstream(file);
if (cmap)
pdf_dropcmap(cmap);
return error; /* already rethrown */
}
