static fz_shade *
pdf_load_shading_dict(pdf_document *xref, pdf_obj *dict, const fz_matrix *transform)
{
fz_shade *shade = NULL;
pdf_function *func[FZ_MAX_COLORS] = { NULL };
pdf_obj *obj;
int funcs = 0;
int type = 0;
int i, in, out;
fz_context *ctx = xref->ctx;
fz_var(shade);
fz_var(func);
fz_var(funcs);
fz_var(type);
fz_try(ctx)
{
shade = fz_malloc_struct(ctx, fz_shade);
FZ_INIT_STORABLE(shade, 1, fz_free_shade_imp);
shade->type = FZ_MESH_TYPE4;
shade->use_background = 0;
shade->use_function = 0;
shade->matrix = *transform;
shade->bbox = fz_infinite_rect;
shade->colorspace = NULL;
funcs = 0;
obj = pdf_dict_gets(dict, "ShadingType");
type = pdf_to_int(obj);
obj = pdf_dict_gets(dict, "ColorSpace");
if (!obj)
fz_throw(ctx, "shading colorspace is missing");
shade->colorspace = pdf_load_colorspace(xref, obj);
obj = pdf_dict_gets(dict, "Background");
if (obj)
{
shade->use_background = 1;
for (i = 0; i < shade->colorspace->n; i++)
shade->background[i] = pdf_to_real(pdf_array_get(obj, i));
}
obj = pdf_dict_gets(dict, "BBox");
if (pdf_is_array(obj))
pdf_to_rect(ctx, obj, &shade->bbox);
obj = pdf_dict_gets(dict, "Function");
if (pdf_is_dict(obj))
{
funcs = 1;
if (type == 1)
in = 2;
else
in = 1;
out = shade->colorspace->n;
func[0] = pdf_load_function(xref, obj, in, out);
if (!func[0])
fz_throw(ctx, "cannot load shading function (%d %d R)", pdf_to_num(obj), pdf_to_gen(obj));
}
else if (pdf_is_array(obj))
{
funcs = pdf_array_len(obj);
if (funcs != 1 && funcs != shade->colorspace->n)
{
funcs = 0;
fz_throw(ctx, "incorrect number of shading functions");
}
if (funcs > FZ_MAX_COLORS)
{
funcs = 0;
fz_throw(ctx, "too many shading functions");
}
if (type == 1)
in = 2;
else
in = 1;
out = 1;
for (i = 0; i < funcs; i++)
{
func[i] = pdf_load_function(xref, pdf_array_get(obj, i), in, out);
if (!func[i])
fz_throw(ctx, "cannot load shading function (%d %d R)", pdf_to_num(obj), pdf_to_gen(obj));
}
}
else if (type < 4)
{
/* Functions are compulsory for types 1,2,3 */
fz_throw(ctx, "cannot load shading function (%d %d R)", pdf_to_num(obj), pdf_to_gen(obj));
}
shade->type = type;
switch (type)
{
case 1: pdf_load_function_based_shading(shade, xref, dict, func[0]); break;
case 2: pdf_load_linear_shading(shade, xref, dict, funcs, func); break;
case 3: pdf_load_radial_shading(shade, xref, dict, funcs, func); break;
case 4: pdf_load_type4_shade(shade, xref, dict, funcs, func); break;
case 5: pdf_load_type5_shade(shade, xref, dict, funcs, func); break;
case 6: pdf_load_type6_shade(shade, xref, dict, funcs, func); break;
case 7: pdf_load_type7_shade(shade, xref, dict, funcs, func); break;
default:
fz_throw(ctx, "unknown shading type: %d", type);
}
for (i = 0; i < funcs; i++)
if (func[i])
pdf_drop_function(ctx, func[i]);
}
fz_catch(ctx)
{
for (i = 0; i < funcs; i++)
if (func[i])
pdf_drop_function(ctx, func[i]);
fz_drop_shade(ctx, shade);
fz_throw(ctx, "cannot load shading type %d (%d %d R)", type, pdf_to_num(dict), pdf_to_gen(dict));
}
return shade;
}
pdf_obj *
pdf_new_xobject(pdf_document *doc, const fz_rect *bbox, const fz_matrix *mat)
{
int idict_num;
pdf_obj *idict = NULL;
pdf_obj *dict = NULL;
pdf_xobject *form = NULL;
pdf_obj *obj = NULL;
pdf_obj *res = NULL;
pdf_obj *procset = NULL;
fz_context *ctx = doc->ctx;
fz_var(idict);
fz_var(dict);
fz_var(form);
fz_var(obj);
fz_var(res);
fz_var(procset);
fz_try(ctx)
{
dict = pdf_new_dict(doc, 0);
obj = pdf_new_rect(doc, bbox);
pdf_dict_puts(dict, "BBox", obj);
pdf_drop_obj(obj);
obj = NULL;
obj = pdf_new_int(doc, 1);
pdf_dict_puts(dict, "FormType", obj);
pdf_drop_obj(obj);
obj = NULL;
obj = pdf_new_int(doc, 0);
pdf_dict_puts(dict, "Length", obj);
pdf_drop_obj(obj);
obj = NULL;
obj = pdf_new_matrix(doc, mat);
pdf_dict_puts(dict, "Matrix", obj);
pdf_drop_obj(obj);
obj = NULL;
res = pdf_new_dict(doc, 0);
procset = pdf_new_array(doc, 2);
obj = pdf_new_name(doc, "PDF");
pdf_array_push(procset, obj);
pdf_drop_obj(obj);
obj = NULL;
obj = pdf_new_name(doc, "Text");
pdf_array_push(procset, obj);
pdf_drop_obj(obj);
obj = NULL;
pdf_dict_puts(res, "ProcSet", procset);
pdf_drop_obj(procset);
procset = NULL;
pdf_dict_puts(dict, "Resources", res);
obj = pdf_new_name(doc, "Form");
pdf_dict_puts(dict, "Subtype", obj);
pdf_drop_obj(obj);
obj = NULL;
obj = pdf_new_name(doc, "XObject");
pdf_dict_puts(dict, "Type", obj);
pdf_drop_obj(obj);
obj = NULL;
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;
form->iteration = 0;
form->bbox = *bbox;
form->matrix = *mat;
form->isolated = 0;
form->knockout = 0;
form->transparency = 0;
form->resources = res;
res = NULL;
idict_num = pdf_create_object(doc);
pdf_update_object(doc, idict_num, dict);
idict = pdf_new_indirect(doc, idict_num, 0);
pdf_drop_obj(dict);
dict = NULL;
pdf_store_item(ctx, idict, form, pdf_xobject_size(form));
form->contents = pdf_keep_obj(idict);
form->me = pdf_keep_obj(idict);
pdf_drop_xobject(ctx, form);
form = NULL;
}
fz_catch(ctx)
{
pdf_drop_obj(procset);
pdf_drop_obj(res);
pdf_drop_obj(obj);
pdf_drop_obj(dict);
pdf_drop_obj(idict);
pdf_drop_xobject(ctx, form);
fz_rethrow_message(ctx, "failed to create xobject)");
}
return idict;
}
pdf_xobject *
pdf_load_xobject(pdf_document *doc, pdf_obj *dict)
{
pdf_xobject *form;
pdf_obj *obj;
fz_context *ctx = doc->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;
form->iteration = 0;
/* Store item immediately, to avoid possible recursion if objects refer back to this one */
pdf_store_item(ctx, dict, form, pdf_xobject_size(form));
fz_try(ctx)
{
obj = pdf_dict_gets(dict, "BBox");
pdf_to_rect(ctx, obj, &form->bbox);
obj = pdf_dict_gets(dict, "Matrix");
if (obj)
pdf_to_matrix(ctx, obj, &form->matrix);
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)
{
fz_try(ctx)
{
form->colorspace = pdf_load_colorspace(doc, obj);
}
fz_catch(ctx)
{
fz_warn(ctx, "cannot load xobject colorspace");
}
}
}
form->resources = pdf_dict_gets(dict, "Resources");
if (form->resources)
pdf_keep_obj(form->resources);
form->contents = pdf_keep_obj(dict);
}
fz_catch(ctx)
{
pdf_remove_item(ctx, pdf_free_xobject_imp, dict);
pdf_drop_xobject(ctx, form);
fz_rethrow_message(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;
}
static fz_shade *
pdf_load_shading_dict(fz_context *ctx, pdf_document *doc, pdf_obj *dict, fz_matrix transform)
{
fz_shade *shade = NULL;
pdf_function *func[FZ_MAX_COLORS] = { NULL };
pdf_obj *obj;
int funcs = 0;
int type = 0;
int i, in, out, n;
fz_var(shade);
fz_var(func);
fz_var(funcs);
fz_var(type);
fz_try(ctx)
{
shade = fz_malloc_struct(ctx, fz_shade);
FZ_INIT_STORABLE(shade, 1, fz_drop_shade_imp);
shade->type = FZ_MESH_TYPE4;
shade->use_background = 0;
shade->use_function = 0;
shade->matrix = transform;
shade->bbox = fz_infinite_rect;
shade->colorspace = NULL;
funcs = 0;
obj = pdf_dict_get(ctx, dict, PDF_NAME(ShadingType));
type = pdf_to_int(ctx, obj);
obj = pdf_dict_get(ctx, dict, PDF_NAME(ColorSpace));
if (!obj)
fz_throw(ctx, FZ_ERROR_SYNTAX, "shading colorspace is missing");
shade->colorspace = pdf_load_colorspace(ctx, obj);
n = fz_colorspace_n(ctx, shade->colorspace);
obj = pdf_dict_get(ctx, dict, PDF_NAME(Background));
if (obj)
{
shade->use_background = 1;
for (i = 0; i < n; i++)
shade->background[i] = pdf_array_get_real(ctx, obj, i);
}
obj = pdf_dict_get(ctx, dict, PDF_NAME(BBox));
if (pdf_is_array(ctx, obj))
shade->bbox = pdf_to_rect(ctx, obj);
obj = pdf_dict_get(ctx, dict, PDF_NAME(Function));
if (pdf_is_dict(ctx, obj))
{
funcs = 1;
if (type == 1)
in = 2;
else
in = 1;
out = n;
func[0] = pdf_load_function(ctx, obj, in, out);
if (!func[0])
fz_throw(ctx, FZ_ERROR_SYNTAX, "cannot load shading function (%d 0 R)", pdf_to_num(ctx, obj));
}
else if (pdf_is_array(ctx, obj))
{
funcs = pdf_array_len(ctx, obj);
if (funcs != 1 && funcs != n)
{
funcs = 0;
fz_throw(ctx, FZ_ERROR_SYNTAX, "incorrect number of shading functions");
}
if (funcs > FZ_MAX_COLORS)
{
funcs = 0;
fz_throw(ctx, FZ_ERROR_SYNTAX, "too many shading functions");
}
if (type == 1)
in = 2;
else
in = 1;
out = 1;
for (i = 0; i < funcs; i++)
{
func[i] = pdf_load_function(ctx, pdf_array_get(ctx, obj, i), in, out);
if (!func[i])
fz_throw(ctx, FZ_ERROR_SYNTAX, "cannot load shading function (%d 0 R)", pdf_to_num(ctx, obj));
}
}
else if (type < 4)
{
/* Functions are compulsory for types 1,2,3 */
fz_throw(ctx, FZ_ERROR_SYNTAX, "cannot load shading function (%d 0 R)", pdf_to_num(ctx, obj));
}
shade->type = type;
switch (type)
{
case 1: pdf_load_function_based_shading(ctx, doc, shade, dict, func[0]); break;
case 2: pdf_load_linear_shading(ctx, doc, shade, dict, funcs, func); break;
case 3: pdf_load_radial_shading(ctx, doc, shade, dict, funcs, func); break;
case 4: pdf_load_type4_shade(ctx, doc, shade, dict, funcs, func); break;
case 5: pdf_load_type5_shade(ctx, doc, shade, dict, funcs, func); break;
case 6: pdf_load_type6_shade(ctx, doc, shade, dict, funcs, func); break;
case 7: pdf_load_type7_shade(ctx, doc, shade, dict, funcs, func); break;
default:
fz_throw(ctx, FZ_ERROR_SYNTAX, "unknown shading type: %d", type);
}
}
fz_always(ctx)
{
for (i = 0; i < funcs; i++)
pdf_drop_function(ctx, func[i]);
}
fz_catch(ctx)
{
fz_drop_shade(ctx, shade);
fz_rethrow(ctx);
}
return shade;
}
