void
pdf_storeitem(pdf_store *store, pdf_itemkind kind, fz_obj *key, void *val)
{
pdf_item *item;
item = fz_malloc(sizeof(pdf_item));
item->kind = kind;
item->key = fz_keepobj(key);
item->val = val;
item->age = 0;
item->next = nil;
if (fz_isindirect(key))
{
struct refkey refkey;
pdf_logrsrc("store item %s (%d %d R) ptr=%p\n", kindstr(kind), fz_tonum(key), fz_togen(key), val);
refkey.kind = kind;
refkey.oid = fz_tonum(key);
refkey.gen = fz_togen(key);
fz_hashinsert(store->hash, &refkey, item);
}
else
{
pdf_logrsrc("store item %s: ... = %p\n", kindstr(kind), val);
item->next = store->root;
store->root = item;
}
keepitem(kind, val);
}
static fz_error *
loadseparation(fz_colorspace **csp, pdf_xref *xref, fz_obj *array)
{
fz_error *error;
struct separation *cs;
fz_obj *nameobj = fz_arrayget(array, 1);
fz_obj *baseobj = fz_arrayget(array, 2);
fz_obj *tintobj = fz_arrayget(array, 3);
fz_colorspace *base;
pdf_function *tint;
int n;
pdf_logrsrc("load Separation {\n");
if (fz_isarray(nameobj))
n = fz_arraylen(nameobj);
else
n = 1;
pdf_logrsrc("n = %d\n", n);
error = pdf_resolve(&baseobj, xref);
if (error)
return error;
error = pdf_loadcolorspace(&base, xref, baseobj);
fz_dropobj(baseobj);
if (error)
return error;
error = pdf_loadfunction(&tint, xref, tintobj);
if (error)
{
fz_dropcolorspace(base);
return error;
}
cs = fz_malloc(sizeof(struct separation));
if (!cs)
{
pdf_dropfunction(tint);
fz_dropcolorspace(base);
return fz_outofmem;
}
initcs((fz_colorspace*)cs,
n == 1 ? "Separation" : "DeviceN", n,
separationtoxyz, nil, dropseparation);
cs->base = base;
cs->tint = tint;
pdf_logrsrc("}\n");
*csp = (fz_colorspace*)cs;
return nil;
}
fz_error *
pdf_storeitem(pdf_store *store, pdf_itemkind kind, fz_obj *key, void *val)
{
fz_error *error;
switch (kind)
{
case PDF_KCOLORSPACE: fz_keepcolorspace(val); break;
case PDF_KFUNCTION: pdf_keepfunction(val); break;
case PDF_KXOBJECT: pdf_keepxobject(val); break;
case PDF_KIMAGE: fz_keepimage(val); break;
case PDF_KPATTERN: pdf_keeppattern(val); break;
case PDF_KSHADE: fz_keepshade(val); break;
case PDF_KCMAP: pdf_keepcmap(val); break;
case PDF_KFONT: fz_keepfont(val); break;
}
if (fz_isindirect(key))
{
struct refkey item;
pdf_logrsrc("store item %d: %d %d R = %p\n", kind, fz_tonum(key), fz_togen(key), val);
item.kind = kind;
item.oid = fz_tonum(key);
item.gen = fz_togen(key);
error = fz_hashinsert(store->hash, &item, val);
if (error)
return error;
}
else
{
pdf_item *item;
item = fz_malloc(sizeof(pdf_item));
if (!item)
return fz_outofmem;
pdf_logrsrc("store item %d: ... = %p\n", kind, val);
item->kind = kind;
item->key = fz_keepobj(key);
item->val = val;
item->next = store->root;
store->root = item;
}
return nil;
}
static fz_error
loadseparation(fz_colorspace **csp, pdf_xref *xref, fz_obj *array)
{
fz_error error;
struct separation *cs;
fz_obj *nameobj = fz_arrayget(array, 1);
fz_obj *baseobj = fz_arrayget(array, 2);
fz_obj *tintobj = fz_arrayget(array, 3);
fz_colorspace *base;
pdf_function *tint;
int n;
pdf_logrsrc("load Separation {\n");
if (fz_isarray(nameobj))
n = fz_arraylen(nameobj);
else
n = 1;
if (n > FZ_MAXCOLORS)
return fz_throw("too many components in colorspace");
pdf_logrsrc("n = %d\n", n);
error = pdf_loadcolorspace(&base, xref, baseobj);
if (error)
return fz_rethrow(error, "cannot load base colorspace");
error = pdf_loadfunction(&tint, xref, tintobj);
if (error)
{
fz_dropcolorspace(base);
return fz_rethrow(error, "cannot load tint function");
}
cs = fz_malloc(sizeof(struct separation));
initcs((fz_colorspace*)cs,
n == 1 ? "Separation" : "DeviceN", n,
separationtoxyz, nil, freeseparation);
cs->base = fz_keepcolorspace(base);
cs->tint = pdf_keepfunction(tint);
fz_dropcolorspace(base);
pdf_dropfunction(tint);
pdf_logrsrc("}\n");
*csp = (fz_colorspace*)cs;
return fz_okay;
}
static fz_error
loadpostscriptfunc(pdf_function *func, pdf_xref *xref, fz_obj *dict, int oid, int gen)
{
fz_error error;
fz_stream *stream;
int codeptr;
pdf_logrsrc("load postscript function (%d %d R)\n", oid, gen);
error = pdf_openstream(&stream, xref, oid, gen);
if (error)
return fz_rethrow(error, "cannot open calculator function stream");
if (fz_readbyte(stream) != '{')
{
fz_dropstream(stream);
return fz_throw("stream is not a calculator function");
}
func->u.p.code = nil;
func->u.p.cap = 0;
codeptr = 0;
error = parsecode(func, stream, &codeptr);
if (error)
{
fz_dropstream(stream);
return fz_rethrow(error, "cannot parse calculator function");
}
fz_dropstream(stream);
return fz_okay;
}
static void evictitem(pdf_item *item)
{
pdf_logrsrc("evicting item %s (%d %d R) at age %d\n", kindstr(item->kind), fz_tonum(item->key), fz_togen(item->key), item->age);
fz_dropobj(item->key);
dropitem(item->kind, item->val);
fz_free(item);
}
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");
}
static fz_error *
loadcalgray(fz_colorspace **csp, pdf_xref *xref, fz_obj *dict)
{
fz_error *error;
struct calgray *cs;
fz_obj *tmp;
error = pdf_resolve(&dict, xref);
if (error)
return error;
cs = fz_malloc(sizeof(struct calgray));
if (!cs)
return fz_outofmem;
pdf_logrsrc("load CalGray\n");
initcs((fz_colorspace*)cs, "CalGray", 1, graytoxyz, xyztogray, nil);
cs->white[0] = 1.0;
cs->white[1] = 1.0;
cs->white[2] = 1.0;
cs->black[0] = 0.0;
cs->black[1] = 0.0;
cs->black[2] = 0.0;
cs->gamma = 1.0;
tmp = fz_dictgets(dict, "WhitePoint");
if (fz_isarray(tmp))
{
cs->white[0] = fz_toreal(fz_arrayget(tmp, 0));
cs->white[1] = fz_toreal(fz_arrayget(tmp, 1));
cs->white[2] = fz_toreal(fz_arrayget(tmp, 2));
}
tmp = fz_dictgets(dict, "BlackPoint");
if (fz_isarray(tmp))
{
cs->black[0] = fz_toreal(fz_arrayget(tmp, 0));
cs->black[1] = fz_toreal(fz_arrayget(tmp, 1));
cs->black[2] = fz_toreal(fz_arrayget(tmp, 2));
}
tmp = fz_dictgets(dict, "Gamma");
if (fz_isreal(tmp))
cs->gamma = fz_toreal(tmp);
fz_dropobj(dict);
*csp = (fz_colorspace*) cs;
return nil;
}
static fz_colorspace *
loadlab(pdf_xref *xref, fz_obj *dict)
{
struct cielab *cs;
fz_obj *tmp;
cs = fz_malloc(sizeof(struct cielab));
pdf_logrsrc("load Lab\n");
initcs((fz_colorspace*)cs, "Lab", 3, labtoxyz, xyztolab, nil);
cs->white[0] = 1.0;
cs->white[1] = 1.0;
cs->white[2] = 1.0;
cs->black[0] = 0.0;
cs->black[1] = 0.0;
cs->black[2] = 0.0;
cs->range[0] = -100;
cs->range[1] = 100;
cs->range[2] = -100;
cs->range[3] = 100;
tmp = fz_dictgets(dict, "WhitePoint");
if (fz_isarray(tmp))
{
cs->white[0] = fz_toreal(fz_arrayget(tmp, 0));
cs->white[1] = fz_toreal(fz_arrayget(tmp, 1));
cs->white[2] = fz_toreal(fz_arrayget(tmp, 2));
}
tmp = fz_dictgets(dict, "BlackPoint");
if (fz_isarray(tmp))
{
cs->black[0] = fz_toreal(fz_arrayget(tmp, 0));
cs->black[1] = fz_toreal(fz_arrayget(tmp, 1));
cs->black[2] = fz_toreal(fz_arrayget(tmp, 2));
}
tmp = fz_dictgets(dict, "Range");
if (fz_isarray(tmp))
{
cs->range[0] = fz_toreal(fz_arrayget(tmp, 0));
cs->range[1] = fz_toreal(fz_arrayget(tmp, 1));
cs->range[2] = fz_toreal(fz_arrayget(tmp, 2));
cs->range[3] = fz_toreal(fz_arrayget(tmp, 3));
}
return (fz_colorspace*) cs;
}
void
pdf_removeitem(pdf_store *store, pdf_itemkind kind, fz_obj *key)
{
pdf_item *item, *prev;
struct refkey refkey;
if (key == nil)
return;
if (fz_isindirect(key))
{
refkey.kind = kind;
refkey.oid = fz_tonum(key);
refkey.gen = fz_togen(key);
item = fz_hashfind(store->hash, &refkey);
if (!item)
return;
fz_hashremove(store->hash, &refkey);
pdf_logrsrc("remove item %s (%d %d R) ptr=%p\n", kindstr(kind), fz_tonum(key), fz_togen(key), item->val);
dropitem(kind, item->val);
fz_dropobj(item->key);
fz_free(item);
}
else
{
prev = nil;
for (item = store->root; item; item = item->next)
{
if (item->kind == kind && !fz_objcmp(item->key, key))
{
if (!prev)
store->root = item->next;
else
prev->next = item->next;
dropitem(kind, item->val);
fz_dropobj(item->key);
fz_free(item);
break;
}
prev = item;
}
}
}
static fz_colorspace *
loadcalgray(pdf_xref *xref, fz_obj *dict)
{
struct calgray *cs;
fz_obj *tmp;
cs = fz_malloc(sizeof(struct calgray));
pdf_logrsrc("load CalGray\n");
initcs((fz_colorspace*)cs, "CalGray", 1, graytoxyz, xyztogray, nil);
cs->white[0] = 1.0;
cs->white[1] = 1.0;
cs->white[2] = 1.0;
cs->black[0] = 0.0;
cs->black[1] = 0.0;
cs->black[2] = 0.0;
cs->gamma = 1.0;
tmp = fz_dictgets(dict, "WhitePoint");
if (fz_isarray(tmp))
{
cs->white[0] = fz_toreal(fz_arrayget(tmp, 0));
cs->white[1] = fz_toreal(fz_arrayget(tmp, 1));
cs->white[2] = fz_toreal(fz_arrayget(tmp, 2));
}
tmp = fz_dictgets(dict, "BlackPoint");
if (fz_isarray(tmp))
{
cs->black[0] = fz_toreal(fz_arrayget(tmp, 0));
cs->black[1] = fz_toreal(fz_arrayget(tmp, 1));
cs->black[2] = fz_toreal(fz_arrayget(tmp, 2));
}
tmp = fz_dictgets(dict, "Gamma");
if (fz_isreal(tmp))
cs->gamma = fz_toreal(tmp);
return (fz_colorspace*) cs;
}
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 fz_colorspace *
loadcalrgb(pdf_xref *xref, fz_obj *dict)
{
struct calrgb *cs;
fz_obj *tmp;
int i;
cs = fz_malloc(sizeof(struct calrgb));
pdf_logrsrc("load CalRGB\n");
initcs((fz_colorspace*)cs, "CalRGB", 3, rgbtoxyz, xyztorgb, nil);
cs->white[0] = 1.0;
cs->white[1] = 1.0;
cs->white[2] = 1.0;
cs->black[0] = 0.0;
cs->black[1] = 0.0;
cs->black[2] = 0.0;
cs->gamma[0] = 1.0;
cs->gamma[1] = 1.0;
cs->gamma[2] = 1.0;
cs->matrix[0] = 1.0; cs->matrix[1] = 0.0; cs->matrix[2] = 0.0;
cs->matrix[3] = 0.0; cs->matrix[4] = 1.0; cs->matrix[5] = 0.0;
cs->matrix[6] = 0.0; cs->matrix[7] = 0.0; cs->matrix[8] = 1.0;
tmp = fz_dictgets(dict, "WhitePoint");
if (fz_isarray(tmp))
{
cs->white[0] = fz_toreal(fz_arrayget(tmp, 0));
cs->white[1] = fz_toreal(fz_arrayget(tmp, 1));
cs->white[2] = fz_toreal(fz_arrayget(tmp, 2));
}
tmp = fz_dictgets(dict, "BlackPoint");
if (fz_isarray(tmp))
{
cs->black[0] = fz_toreal(fz_arrayget(tmp, 0));
cs->black[1] = fz_toreal(fz_arrayget(tmp, 1));
cs->black[2] = fz_toreal(fz_arrayget(tmp, 2));
}
tmp = fz_dictgets(dict, "Gamma");
if (fz_isarray(tmp))
{
cs->gamma[0] = fz_toreal(fz_arrayget(tmp, 0));
cs->gamma[1] = fz_toreal(fz_arrayget(tmp, 1));
cs->gamma[2] = fz_toreal(fz_arrayget(tmp, 2));
}
tmp = fz_dictgets(dict, "Matrix");
if (fz_isarray(tmp))
{
for (i = 0; i < 9; i++)
cs->matrix[i] = fz_toreal(fz_arrayget(tmp, i));
}
fz_invert3x3(cs->invmat, cs->matrix);
return (fz_colorspace*) cs;
}
fz_error
pdf_loadxobject(pdf_xobject **formp, pdf_xref *xref, fz_obj *dict)
{
fz_error error;
pdf_xobject *form;
fz_obj *obj;
if ((*formp = pdf_finditem(xref->store, PDF_KXOBJECT, dict)))
{
pdf_keepxobject(*formp);
return fz_okay;
}
form = fz_malloc(sizeof(pdf_xobject));
form->refs = 1;
form->resources = nil;
form->contents = nil;
/* Store item immediately, to avoid possible recursion if objects refer back to this one */
pdf_storeitem(xref->store, PDF_KXOBJECT, dict, form);
pdf_logrsrc("load xobject (%d %d R) ptr=%p {\n", fz_tonum(dict), fz_togen(dict), form);
obj = fz_dictgets(dict, "BBox");
form->bbox = pdf_torect(obj);
pdf_logrsrc("bbox [%g %g %g %g]\n",
form->bbox.x0, form->bbox.y0,
form->bbox.x1, form->bbox.y1);
obj = fz_dictgets(dict, "Matrix");
if (obj)
form->matrix = pdf_tomatrix(obj);
else
form->matrix = fz_identity();
pdf_logrsrc("matrix [%g %g %g %g %g %g]\n",
form->matrix.a, form->matrix.b,
form->matrix.c, form->matrix.d,
form->matrix.e, form->matrix.f);
form->isolated = 0;
form->knockout = 0;
form->transparency = 0;
obj = fz_dictgets(dict, "Group");
if (obj)
{
fz_obj *attrs = obj;
form->isolated = fz_tobool(fz_dictgets(attrs, "I"));
form->knockout = fz_tobool(fz_dictgets(attrs, "K"));
obj = fz_dictgets(attrs, "S");
if (fz_isname(obj) && !strcmp(fz_toname(obj), "Transparency"))
form->transparency = 1;
}
pdf_logrsrc("isolated %d\n", form->isolated);
pdf_logrsrc("knockout %d\n", form->knockout);
pdf_logrsrc("transparency %d\n", form->transparency);
form->resources = fz_dictgets(dict, "Resources");
if (form->resources)
fz_keepobj(form->resources);
error = pdf_loadstream(&form->contents, xref, fz_tonum(dict), fz_togen(dict));
if (error)
{
pdf_removeitem(xref->store, PDF_KXOBJECT, dict);
pdf_dropxobject(form);
return fz_rethrow(error, "cannot load xobject content stream (%d %d R)", fz_tonum(dict), fz_togen(dict));
}
pdf_logrsrc("stream %d bytes\n", form->contents->wp - form->contents->rp);
pdf_logrsrc("}\n");
*formp = form;
return fz_okay;
}
static fz_error *
loadlab(fz_colorspace **csp, pdf_xref *xref, fz_obj *dict)
{
fz_error *error;
struct cielab *cs;
fz_obj *tmp;
error = pdf_resolve(&dict, xref);
if (error)
return error;
cs = fz_malloc(sizeof(struct cielab));
if (!cs)
return fz_outofmem;
pdf_logrsrc("load Lab\n");
initcs((fz_colorspace*)cs, "Lab", 3, labtoxyz, xyztolab, nil);
cs->white[0] = 1.0;
cs->white[1] = 1.0;
cs->white[2] = 1.0;
cs->black[0] = 0.0;
cs->black[1] = 0.0;
cs->black[2] = 0.0;
cs->range[0] = -100;
cs->range[1] = 100;
cs->range[2] = -100;
cs->range[3] = 100;
tmp = fz_dictgets(dict, "WhitePoint");
if (fz_isarray(tmp))
{
cs->white[0] = fz_toreal(fz_arrayget(tmp, 0));
cs->white[1] = fz_toreal(fz_arrayget(tmp, 1));
cs->white[2] = fz_toreal(fz_arrayget(tmp, 2));
}
tmp = fz_dictgets(dict, "BlackPoint");
if (fz_isarray(tmp))
{
cs->black[0] = fz_toreal(fz_arrayget(tmp, 0));
cs->black[1] = fz_toreal(fz_arrayget(tmp, 1));
cs->black[2] = fz_toreal(fz_arrayget(tmp, 2));
}
tmp = fz_dictgets(dict, "Range");
if (fz_isarray(tmp))
{
cs->range[0] = fz_toreal(fz_arrayget(tmp, 0));
cs->range[1] = fz_toreal(fz_arrayget(tmp, 1));
cs->range[2] = fz_toreal(fz_arrayget(tmp, 2));
cs->range[3] = fz_toreal(fz_arrayget(tmp, 3));
}
fz_dropobj(dict);
*csp = (fz_colorspace*) cs;
return nil;
}
static fz_error *
loadcalrgb(fz_colorspace **csp, pdf_xref *xref, fz_obj *dict)
{
fz_error *error;
struct calrgb *cs;
fz_obj *tmp;
int i;
error = pdf_resolve(&dict, xref);
if (error)
return error;
cs = fz_malloc(sizeof(struct calrgb));
if (!cs)
return fz_outofmem;
pdf_logrsrc("load CalRGB\n");
initcs((fz_colorspace*)cs, "CalRGB", 3, rgbtoxyz, xyztorgb, nil);
cs->white[0] = 1.0;
cs->white[1] = 1.0;
cs->white[2] = 1.0;
cs->black[0] = 0.0;
cs->black[1] = 0.0;
cs->black[2] = 0.0;
cs->gamma[0] = 1.0;
cs->gamma[1] = 1.0;
cs->gamma[2] = 1.0;
cs->matrix[0] = 1.0; cs->matrix[1] = 0.0; cs->matrix[2] = 0.0;
cs->matrix[3] = 0.0; cs->matrix[4] = 1.0; cs->matrix[5] = 0.0;
cs->matrix[6] = 0.0; cs->matrix[7] = 0.0; cs->matrix[8] = 1.0;
tmp = fz_dictgets(dict, "WhitePoint");
if (fz_isarray(tmp))
{
cs->white[0] = fz_toreal(fz_arrayget(tmp, 0));
cs->white[1] = fz_toreal(fz_arrayget(tmp, 1));
cs->white[2] = fz_toreal(fz_arrayget(tmp, 2));
}
tmp = fz_dictgets(dict, "BlackPoint");
if (fz_isarray(tmp))
{
cs->black[0] = fz_toreal(fz_arrayget(tmp, 0));
cs->black[1] = fz_toreal(fz_arrayget(tmp, 1));
cs->black[2] = fz_toreal(fz_arrayget(tmp, 2));
}
tmp = fz_dictgets(dict, "Gamma");
if (fz_isarray(tmp))
{
cs->gamma[0] = fz_toreal(fz_arrayget(tmp, 0));
cs->gamma[1] = fz_toreal(fz_arrayget(tmp, 1));
cs->gamma[2] = fz_toreal(fz_arrayget(tmp, 2));
}
tmp = fz_dictgets(dict, "Matrix");
if (fz_isarray(tmp))
{
for (i = 0; i < 9; i++)
cs->matrix[i] = fz_toreal(fz_arrayget(tmp, i));
}
fz_invert3x3(cs->invmat, cs->matrix);
fz_dropobj(dict);
*csp = (fz_colorspace*) cs;
return nil;
}
fz_error *
pdf_loadxobject(pdf_xobject **formp, pdf_xref *xref, fz_obj *dict, fz_obj *ref)
{
fz_error *error;
pdf_xobject *form;
fz_obj *obj;
if ((*formp = pdf_finditem(xref->store, PDF_KXOBJECT, ref)))
{
pdf_keepxobject(*formp);
return fz_okay;
}
form = fz_malloc(sizeof(pdf_xobject));
if (!form)
return fz_throw("outofmem: xobject struct");
form->refs = 1;
form->resources = nil;
form->contents = nil;
/* Store item immediately, to avoid infinite recursion if contained
objects refer again to this xobject */
error = pdf_storeitem(xref->store, PDF_KXOBJECT, ref, form);
if (error)
{
pdf_dropxobject(form);
return fz_rethrow(error, "cannot store xobject resource");
}
pdf_logrsrc("load xobject %d %d (%p) {\n", fz_tonum(ref), fz_togen(ref), form);
obj = fz_dictgets(dict, "BBox");
form->bbox = pdf_torect(obj);
pdf_logrsrc("bbox [%g %g %g %g]\n",
form->bbox.x0, form->bbox.y0,
form->bbox.x1, form->bbox.y1);
obj = fz_dictgets(dict, "Matrix");
if (obj)
form->matrix = pdf_tomatrix(obj);
else
form->matrix = fz_identity();
pdf_logrsrc("matrix [%g %g %g %g %g %g]\n",
form->matrix.a, form->matrix.b,
form->matrix.c, form->matrix.d,
form->matrix.e, form->matrix.f);
obj = fz_dictgets(dict, "I");
form->isolated = fz_tobool(obj);
obj = fz_dictgets(dict, "K");
form->knockout = fz_tobool(obj);
pdf_logrsrc("isolated %d\n", form->isolated);
pdf_logrsrc("knockout %d\n", form->knockout);
obj = fz_dictgets(dict, "Resources");
if (obj)
{
error = pdf_resolve(&obj, xref);
if (error)
{
fz_dropobj(obj);
error = fz_rethrow(error, "cannot resolve xobject resources");
goto cleanup;
}
error = pdf_loadresources(&form->resources, xref, obj);
fz_dropobj(obj);
if (error)
{
error = fz_rethrow(error, "cannot load xobject resources");
goto cleanup;
}
}
error = pdf_loadstream(&form->contents, xref, fz_tonum(ref), fz_togen(ref));
if (error)
{
error = fz_rethrow(error, "cannot load xobject content stream");
goto cleanup;
}
pdf_logrsrc("stream %d bytes\n", form->contents->wp - form->contents->rp);
pdf_logrsrc("}\n");
*formp = form;
return fz_okay;
cleanup:
pdf_removeitem(xref->store, PDF_KXOBJECT, ref);
pdf_dropxobject(form);
return error;
}
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;
}
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 *
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;
}
