static fz_jbig2_globals *
pdf_load_jbig2_globals(fz_context *ctx, pdf_document *doc, pdf_obj *dict)
{
fz_jbig2_globals *globals;
fz_buffer *buf = NULL;
fz_var(buf);
if ((globals = pdf_find_item(ctx, fz_drop_jbig2_globals_imp, dict)) != NULL)
{
return globals;
}
fz_try(ctx)
{
buf = pdf_load_stream(ctx, doc, pdf_to_num(ctx, dict), pdf_to_gen(ctx, dict));
globals = fz_load_jbig2_globals(ctx, buf->data, buf->len);
pdf_store_item(ctx, dict, globals, buf->len);
}
fz_always(ctx)
{
fz_drop_buffer(ctx, buf);
}
fz_catch(ctx)
{
fz_rethrow(ctx);
}
return globals;
}
fz_image *
pdf_load_image(fz_context *ctx, pdf_document *doc, pdf_obj *dict)
{
fz_image *image;
if ((image = pdf_find_item(ctx, fz_drop_image_imp, dict)) != NULL)
return image;
image = pdf_load_image_imp(ctx, doc, NULL, dict, NULL, 0);
pdf_store_item(ctx, dict, image, fz_image_size(ctx, image));
return image;
}
fz_error
pdf_load_shading(fz_shade **shadep, pdf_xref *xref, fz_obj *dict)
{
fz_error error;
fz_matrix mat;
fz_obj *obj;
fz_context *ctx = xref->ctx;
if ((*shadep = pdf_find_item(ctx, xref->store, fz_drop_shade, dict)))
{
fz_keep_shade(*shadep);
return fz_okay;
}
/* Type 2 pattern dictionary */
if (fz_dict_gets(ctx, dict, "PatternType"))
{
obj = fz_dict_gets(ctx, dict, "Matrix");
if (obj)
mat = pdf_to_matrix(ctx, obj);
else
mat = fz_identity;
obj = fz_dict_gets(ctx, dict, "ExtGState");
if (obj)
{
if (fz_dict_gets(ctx, obj, "CA") || fz_dict_gets(ctx, obj, "ca"))
{
fz_warn(ctx, "shading with alpha not supported");
}
}
obj = fz_dict_gets(ctx, dict, "Shading");
if (!obj)
return fz_error_make(ctx, "syntaxerror: missing shading dictionary");
error = pdf_load_shading_dict(shadep, xref, obj, mat);
if (error)
return fz_error_note(ctx, error, "cannot load shading dictionary (%d %d R)", fz_to_num(obj), fz_to_gen(obj));
}
/* Naked shading dictionary */
else
{
error = pdf_load_shading_dict(shadep, xref, dict, fz_identity);
if (error)
return fz_error_note(ctx, error, "cannot load shading dictionary (%d %d R)", fz_to_num(dict), fz_to_gen(dict));
}
pdf_store_item(ctx, xref->store, fz_keep_shade, fz_drop_shade, dict, *shadep);
return fz_okay;
}
fz_shade *
pdf_load_shading(pdf_document *xref, pdf_obj *dict)
{
fz_matrix mat;
pdf_obj *obj;
fz_context *ctx = xref->ctx;
fz_shade *shade;
if ((shade = pdf_find_item(ctx, fz_free_shade_imp, dict)))
{
return shade;
}
/* Type 2 pattern dictionary */
if (pdf_dict_gets(dict, "PatternType"))
{
obj = pdf_dict_gets(dict, "Matrix");
if (obj)
mat = pdf_to_matrix(ctx, obj);
else
mat = fz_identity;
obj = pdf_dict_gets(dict, "ExtGState");
if (obj)
{
if (pdf_dict_gets(obj, "CA") || pdf_dict_gets(obj, "ca"))
{
fz_warn(ctx, "shading with alpha not supported");
}
}
obj = pdf_dict_gets(dict, "Shading");
if (!obj)
fz_throw(ctx, "syntaxerror: missing shading dictionary");
shade = pdf_load_shading_dict(xref, obj, mat);
/* RJW: "cannot load shading dictionary (%d %d R)", pdf_to_num(obj), pdf_to_gen(obj) */
}
/* Naked shading dictionary */
else
{
shade = pdf_load_shading_dict(xref, dict, fz_identity);
/* RJW: "cannot load shading dictionary (%d %d R)", pdf_to_num(dict), pdf_to_gen(dict) */
}
pdf_store_item(ctx, dict, shade, fz_shade_size(shade));
return shade;
}
pdf_pattern *
pdf_load_pattern(fz_context *ctx, pdf_document *doc, pdf_obj *dict)
{
pdf_pattern *pat;
pdf_obj *obj;
if ((pat = pdf_find_item(ctx, pdf_drop_pattern_imp, dict)) != NULL)
{
return pat;
}
pat = fz_malloc_struct(ctx, pdf_pattern);
FZ_INIT_STORABLE(pat, 1, pdf_drop_pattern_imp);
pat->document = doc;
pat->resources = NULL;
pat->contents = NULL;
fz_try(ctx)
{
/* Store pattern now, to avoid possible recursion if objects refer back to this one */
pdf_store_item(ctx, dict, pat, pdf_pattern_size(pat));
pat->ismask = pdf_to_int(ctx, pdf_dict_get(ctx, dict, PDF_NAME_PaintType)) == 2;
pat->xstep = pdf_to_real(ctx, pdf_dict_get(ctx, dict, PDF_NAME_XStep));
pat->ystep = pdf_to_real(ctx, pdf_dict_get(ctx, dict, PDF_NAME_YStep));
obj = pdf_dict_gets(ctx, dict, "BBox");
pdf_to_rect(ctx, obj, &pat->bbox);
obj = pdf_dict_gets(ctx, dict, "Matrix");
if (obj)
pdf_to_matrix(ctx, obj, &pat->matrix);
else
pat->matrix = fz_identity;
pat->resources = pdf_dict_get(ctx, dict, PDF_NAME_Resources);
if (pat->resources)
pdf_keep_obj(ctx, pat->resources);
pat->contents = pdf_keep_obj(ctx, dict);
}
fz_catch(ctx)
{
pdf_remove_item(ctx, pdf_drop_pattern_imp, dict);
pdf_drop_pattern(ctx, pat);
fz_rethrow_message(ctx, "cannot load pattern (%d %d R)", pdf_to_num(ctx, dict), pdf_to_gen(ctx, dict));
}
return pat;
}
fz_error
pdf_load_pattern(pdf_pattern **patp, pdf_xref *xref, fz_obj *dict)
{
fz_error error;
pdf_pattern *pat;
fz_obj *obj;
if ((*patp = pdf_find_item(xref->store, pdf_drop_pattern, dict)))
{
pdf_keep_pattern(*patp);
return fz_okay;
}
pat = fz_malloc(sizeof(pdf_pattern));
pat->refs = 1;
pat->resources = NULL;
pat->contents = NULL;
/* Store pattern now, to avoid possible recursion if objects refer back to this one */
pdf_store_item(xref->store, pdf_keep_pattern, pdf_drop_pattern, dict, pat);
pat->ismask = fz_to_int(fz_dict_gets(dict, "PaintType")) == 2;
pat->xstep = fz_to_real(fz_dict_gets(dict, "XStep"));
pat->ystep = fz_to_real(fz_dict_gets(dict, "YStep"));
obj = fz_dict_gets(dict, "BBox");
pat->bbox = pdf_to_rect(obj);
obj = fz_dict_gets(dict, "Matrix");
if (obj)
pat->matrix = pdf_to_matrix(obj);
else
pat->matrix = fz_identity;
pat->resources = fz_dict_gets(dict, "Resources");
if (pat->resources)
fz_keep_obj(pat->resources);
error = pdf_load_stream(&pat->contents, xref, fz_to_num(dict), fz_to_gen(dict));
if (error)
{
pdf_remove_item(xref->store, pdf_drop_pattern, dict);
pdf_drop_pattern(pat);
return fz_rethrow(error, "cannot load pattern stream (%d %d R)", fz_to_num(dict), fz_to_gen(dict));
}
*patp = pat;
return fz_okay;
}
pdf_pattern *
pdf_load_pattern(pdf_document *xref, pdf_obj *dict)
{
pdf_pattern *pat;
pdf_obj *obj;
fz_context *ctx = xref->ctx;
if ((pat = pdf_find_item(ctx, pdf_free_pattern_imp, dict)))
{
return pat;
}
pat = fz_malloc_struct(ctx, pdf_pattern);
FZ_INIT_STORABLE(pat, 1, pdf_free_pattern_imp);
pat->resources = NULL;
pat->contents = NULL;
/* Store pattern now, to avoid possible recursion if objects refer back to this one */
pdf_store_item(ctx, dict, pat, pdf_pattern_size(pat));
pat->ismask = pdf_to_int(pdf_dict_gets(dict, "PaintType")) == 2;
pat->xstep = pdf_to_real(pdf_dict_gets(dict, "XStep"));
pat->ystep = pdf_to_real(pdf_dict_gets(dict, "YStep"));
obj = pdf_dict_gets(dict, "BBox");
pdf_to_rect(ctx, obj, &pat->bbox);
obj = pdf_dict_gets(dict, "Matrix");
if (obj)
pdf_to_matrix(ctx, obj, &pat->matrix);
else
pat->matrix = fz_identity;
pat->resources = pdf_dict_gets(dict, "Resources");
if (pat->resources)
pdf_keep_obj(pat->resources);
fz_try(ctx)
{
pat->contents = pdf_keep_obj(dict);
}
fz_catch(ctx)
{
pdf_remove_item(ctx, pdf_free_pattern_imp, dict);
pdf_drop_pattern(ctx, pat);
fz_throw(ctx, "cannot load pattern stream (%d %d R)", pdf_to_num(dict), pdf_to_gen(dict));
}
return pat;
}
fz_shade *
pdf_load_shading(fz_context *ctx, pdf_document *doc, pdf_obj *dict)
{
fz_matrix mat;
pdf_obj *obj;
fz_shade *shade;
if ((shade = pdf_find_item(ctx, fz_drop_shade_imp, dict)) != NULL)
{
return shade;
}
/* Type 2 pattern dictionary */
if (pdf_dict_get(ctx, dict, PDF_NAME(PatternType)))
{
obj = pdf_dict_get(ctx, dict, PDF_NAME(Matrix));
if (obj)
pdf_to_matrix(ctx, obj, &mat);
else
mat = fz_identity;
obj = pdf_dict_get(ctx, dict, PDF_NAME(ExtGState));
if (obj)
{
if (pdf_dict_get(ctx, obj, PDF_NAME(CA)) || pdf_dict_get(ctx, obj, PDF_NAME(ca)))
{
fz_warn(ctx, "shading with alpha not supported");
}
}
obj = pdf_dict_get(ctx, dict, PDF_NAME(Shading));
if (!obj)
fz_throw(ctx, FZ_ERROR_SYNTAX, "missing shading dictionary");
shade = pdf_load_shading_dict(ctx, doc, obj, &mat);
}
/* Naked shading dictionary */
else
{
shade = pdf_load_shading_dict(ctx, doc, dict, &fz_identity);
}
pdf_store_item(ctx, dict, shade, fz_shade_size(ctx, shade));
return shade;
}
fz_shade *
pdf_load_shading(fz_context *ctx, pdf_document *doc, pdf_obj *dict)
{
fz_matrix mat;
pdf_obj *obj;
fz_shade *shade;
if ((shade = pdf_find_item(ctx, fz_drop_shade_imp, dict)) != NULL)
{
return shade;
}
/* Type 2 pattern dictionary */
if (pdf_dict_gets(ctx, dict, "PatternType"))
{
obj = pdf_dict_gets(ctx, dict, "Matrix");
if (obj)
pdf_to_matrix(ctx, obj, &mat);
else
mat = fz_identity;
obj = pdf_dict_gets(ctx, dict, "ExtGState");
if (obj)
{
if (pdf_dict_gets(ctx, obj, "CA") || pdf_dict_gets(ctx, obj, "ca"))
{
fz_warn(ctx, "shading with alpha not supported");
}
}
obj = pdf_dict_gets(ctx, dict, "Shading");
if (!obj)
fz_throw(ctx, FZ_ERROR_GENERIC, "syntaxerror: missing shading dictionary");
shade = pdf_load_shading_dict(ctx, doc, obj, &mat);
}
/* Naked shading dictionary */
else
{
shade = pdf_load_shading_dict(ctx, doc, dict, &fz_identity);
}
pdf_store_item(ctx, dict, shade, fz_shade_size(shade));
return shade;
}
fz_image *
pdf_load_image(pdf_document *doc, pdf_obj *dict)
{
fz_context *ctx = doc->ctx;
fz_image *image;
if ((image = pdf_find_item(ctx, fz_free_image, dict)) != NULL)
{
return (fz_image *)image;
}
image = pdf_load_image_imp(doc, NULL, dict, NULL, 0);
pdf_store_item(ctx, dict, image, fz_image_size(ctx, image));
return (fz_image *)image;
}
fz_image *
pdf_load_image(pdf_document *xref, pdf_obj *dict)
{
fz_context *ctx = xref->ctx;
pdf_image *image;
if ((image = pdf_find_item(ctx, pdf_free_image, dict)))
{
return (fz_image *)image;
}
image = pdf_load_image_imp(xref, NULL, dict, NULL, 0);
pdf_store_item(ctx, dict, image, pdf_image_size(ctx, image));
return (fz_image *)image;
}
fz_error
pdf_load_colorspace(fz_colorspace **csp, pdf_xref *xref, fz_obj *obj)
{
fz_error error;
if ((*csp = pdf_find_item(xref->store, fz_drop_colorspace, obj)))
{
fz_keep_colorspace(*csp);
return fz_okay;
}
error = pdf_load_colorspace_imp(csp, xref, obj);
if (error)
return fz_rethrow(error, "cannot load colorspace (%d %d R)", fz_to_num(obj), fz_to_gen(obj));
pdf_store_item(xref->store, fz_keep_colorspace, fz_drop_colorspace, obj, *csp);
return fz_okay;
}
fz_error
pdf_load_image(fz_pixmap **pixp, pdf_xref *xref, fz_obj *dict)
{
fz_error error;
if ((*pixp = pdf_find_item(xref->store, fz_drop_pixmap, dict)))
{
fz_keep_pixmap(*pixp);
return fz_okay;
}
error = pdf_load_image_imp(pixp, xref, NULL, dict, NULL, 0);
if (error)
return fz_rethrow(error, "cannot load image (%d 0 R)", fz_to_num(dict));
// EBookDroid: Commented out for saving A LOTS of memory. Caching is not needed for embedded solutions
// pdf_store_item(xref->store, fz_keep_pixmap, fz_drop_pixmap, dict, *pixp);
return fz_okay;
}
pdf_xobject *
pdf_load_xobject(pdf_document *xref, pdf_obj *dict)
{
pdf_xobject *form;
pdf_obj *obj;
fz_context *ctx = xref->ctx;
if ((form = pdf_find_item(ctx, pdf_free_xobject_imp, dict)))
{
return form;
}
form = fz_malloc_struct(ctx, pdf_xobject);
FZ_INIT_STORABLE(form, 1, pdf_free_xobject_imp);
form->resources = NULL;
form->contents = NULL;
form->colorspace = NULL;
form->me = NULL;
/* Store item immediately, to avoid possible recursion if objects refer back to this one */
pdf_store_item(ctx, dict, form, pdf_xobject_size(form));
obj = pdf_dict_gets(dict, "BBox");
form->bbox = pdf_to_rect(ctx, obj);
obj = pdf_dict_gets(dict, "Matrix");
if (obj)
form->matrix = pdf_to_matrix(ctx, obj);
else
form->matrix = fz_identity;
form->isolated = 0;
form->knockout = 0;
form->transparency = 0;
obj = pdf_dict_gets(dict, "Group");
if (obj)
{
pdf_obj *attrs = obj;
form->isolated = pdf_to_bool(pdf_dict_gets(attrs, "I"));
form->knockout = pdf_to_bool(pdf_dict_gets(attrs, "K"));
obj = pdf_dict_gets(attrs, "S");
if (pdf_is_name(obj) && !strcmp(pdf_to_name(obj), "Transparency"))
form->transparency = 1;
obj = pdf_dict_gets(attrs, "CS");
if (obj)
{
form->colorspace = pdf_load_colorspace(xref, obj);
if (!form->colorspace)
fz_throw(ctx, "cannot load xobject colorspace");
}
}
form->resources = pdf_dict_gets(dict, "Resources");
if (form->resources)
pdf_keep_obj(form->resources);
fz_try(ctx)
{
form->contents = pdf_load_stream(xref, pdf_to_num(dict), pdf_to_gen(dict));
}
fz_catch(ctx)
{
pdf_remove_item(ctx, pdf_free_xobject_imp, dict);
pdf_drop_xobject(ctx, form);
fz_throw(ctx, "cannot load xobject content stream (%d %d R)", pdf_to_num(dict), pdf_to_gen(dict));
}
form->me = pdf_keep_obj(dict);
return form;
}
/*
* Load CMap stream in PDF file
*/
fz_error
pdf_load_embedded_cmap(pdf_cmap **cmapp, pdf_xref *xref, fz_obj *stmobj)
{
fz_error error = fz_okay;
fz_stream *file = NULL;
pdf_cmap *cmap = NULL;
pdf_cmap *usecmap;
fz_obj *wmode;
fz_obj *obj;
if ((*cmapp = pdf_find_item(xref->store, pdf_drop_cmap, stmobj)))
{
pdf_keep_cmap(*cmapp);
return fz_okay;
}
error = pdf_open_stream(&file, xref, fz_to_num(stmobj), fz_to_gen(stmobj));
if (error)
{
error = fz_rethrow(error, "cannot open cmap stream (%d %d R)", fz_to_num(stmobj), fz_to_gen(stmobj));
goto cleanup;
}
error = pdf_parse_cmap(&cmap, file);
if (error)
{
error = fz_rethrow(error, "cannot parse cmap stream (%d %d R)", fz_to_num(stmobj), fz_to_gen(stmobj));
goto cleanup;
}
fz_close(file);
wmode = fz_dict_gets(stmobj, "WMode");
if (fz_is_int(wmode))
pdf_set_wmode(cmap, fz_to_int(wmode));
obj = fz_dict_gets(stmobj, "UseCMap");
if (fz_is_name(obj))
{
error = pdf_load_system_cmap(&usecmap, fz_to_name(obj));
if (error)
{
error = fz_rethrow(error, "cannot load system usecmap '%s'", fz_to_name(obj));
goto cleanup;
}
pdf_set_usecmap(cmap, usecmap);
pdf_drop_cmap(usecmap);
}
else if (fz_is_indirect(obj))
{
error = pdf_load_embedded_cmap(&usecmap, xref, obj);
if (error)
{
error = fz_rethrow(error, "cannot load embedded usecmap (%d %d R)", fz_to_num(obj), fz_to_gen(obj));
goto cleanup;
}
pdf_set_usecmap(cmap, usecmap);
pdf_drop_cmap(usecmap);
}
pdf_store_item(xref->store, pdf_keep_cmap, pdf_drop_cmap, stmobj, cmap);
*cmapp = cmap;
return fz_okay;
cleanup:
if (file)
fz_close(file);
if (cmap)
pdf_drop_cmap(cmap);
return error; /* already rethrown */
}
/*
* Load CMap stream in PDF file
*/
pdf_cmap *
pdf_load_embedded_cmap(pdf_document *doc, pdf_obj *stmobj)
{
fz_stream *file = NULL;
pdf_cmap *cmap = NULL;
pdf_cmap *usecmap;
pdf_obj *wmode;
pdf_obj *obj = NULL;
fz_context *ctx = doc->ctx;
int phase = 0;
fz_var(phase);
fz_var(obj);
fz_var(file);
fz_var(cmap);
if (pdf_obj_marked(stmobj))
fz_throw(ctx, FZ_ERROR_GENERIC, "Recursion in embedded cmap");
if ((cmap = pdf_find_item(ctx, pdf_free_cmap_imp, stmobj)) != NULL)
{
return cmap;
}
fz_try(ctx)
{
file = pdf_open_stream(doc, pdf_to_num(stmobj), pdf_to_gen(stmobj));
phase = 1;
cmap = pdf_load_cmap(ctx, file);
phase = 2;
fz_close(file);
file = NULL;
wmode = pdf_dict_gets(stmobj, "WMode");
if (pdf_is_int(wmode))
pdf_set_cmap_wmode(ctx, cmap, pdf_to_int(wmode));
obj = pdf_dict_gets(stmobj, "UseCMap");
if (pdf_is_name(obj))
{
usecmap = pdf_load_system_cmap(ctx, pdf_to_name(obj));
pdf_set_usecmap(ctx, cmap, usecmap);
pdf_drop_cmap(ctx, usecmap);
}
else if (pdf_is_indirect(obj))
{
phase = 3;
pdf_mark_obj(obj);
usecmap = pdf_load_embedded_cmap(doc, obj);
pdf_unmark_obj(obj);
phase = 4;
pdf_set_usecmap(ctx, cmap, usecmap);
pdf_drop_cmap(ctx, usecmap);
}
pdf_store_item(ctx, stmobj, cmap, pdf_cmap_size(ctx, cmap));
}
fz_catch(ctx)
{
if (file)
fz_close(file);
if (cmap)
pdf_drop_cmap(ctx, cmap);
if (phase < 1)
fz_rethrow_message(ctx, "cannot open cmap stream (%d %d R)", pdf_to_num(stmobj), pdf_to_gen(stmobj));
else if (phase < 2)
fz_rethrow_message(ctx, "cannot parse cmap stream (%d %d R)", pdf_to_num(stmobj), pdf_to_gen(stmobj));
else if (phase < 3)
fz_rethrow_message(ctx, "cannot load system usecmap '%s'", pdf_to_name(obj));
else
{
if (phase == 3)
pdf_unmark_obj(obj);
fz_rethrow_message(ctx, "cannot load embedded usecmap (%d %d R)", pdf_to_num(obj), pdf_to_gen(obj));
}
}
return cmap;
}
/*
* Load CMap stream in PDF file
*/
pdf_cmap *
pdf_load_embedded_cmap(fz_context *ctx, pdf_document *doc, pdf_obj *stmobj)
{
fz_stream *file = NULL;
pdf_cmap *cmap = NULL;
pdf_cmap *usecmap = NULL;
pdf_obj *obj;
fz_var(file);
fz_var(cmap);
fz_var(usecmap);
if (pdf_obj_marked(ctx, stmobj))
fz_throw(ctx, FZ_ERROR_GENERIC, "Recursion in embedded cmap");
if ((cmap = pdf_find_item(ctx, pdf_drop_cmap_imp, stmobj)) != NULL)
return cmap;
fz_try(ctx)
{
file = pdf_open_stream(ctx, stmobj);
cmap = pdf_load_cmap(ctx, file);
obj = pdf_dict_get(ctx, stmobj, PDF_NAME_WMode);
if (pdf_is_int(ctx, obj))
pdf_set_cmap_wmode(ctx, cmap, pdf_to_int(ctx, obj));
obj = pdf_dict_get(ctx, stmobj, PDF_NAME_UseCMap);
if (pdf_is_name(ctx, obj))
{
usecmap = pdf_load_system_cmap(ctx, pdf_to_name(ctx, obj));
pdf_set_usecmap(ctx, cmap, usecmap);
}
else if (pdf_is_indirect(ctx, obj))
{
if (pdf_mark_obj(ctx, obj))
fz_throw(ctx, FZ_ERROR_GENERIC, "recursive CMap");
fz_try(ctx)
usecmap = pdf_load_embedded_cmap(ctx, doc, obj);
fz_always(ctx)
pdf_unmark_obj(ctx, obj);
fz_catch(ctx)
fz_rethrow(ctx);
pdf_set_usecmap(ctx, cmap, usecmap);
}
pdf_store_item(ctx, stmobj, cmap, pdf_cmap_size(ctx, cmap));
}
fz_always(ctx)
{
fz_drop_stream(ctx, file);
pdf_drop_cmap(ctx, usecmap);
}
fz_catch(ctx)
{
pdf_drop_cmap(ctx, cmap);
fz_rethrow(ctx);
}
return cmap;
}
