static fz_colorspace *
load_separation(pdf_document *xref, pdf_obj *array)
{
fz_colorspace *cs;
struct separation *sep = NULL;
fz_context *ctx = xref->ctx;
pdf_obj *nameobj = pdf_array_get(array, 1);
pdf_obj *baseobj = pdf_array_get(array, 2);
pdf_obj *tintobj = pdf_array_get(array, 3);
fz_colorspace *base;
pdf_function *tint = NULL;
int n;
fz_var(tint);
fz_var(sep);
if (pdf_is_array(nameobj))
n = pdf_array_len(nameobj);
else
n = 1;
if (n > FZ_MAX_COLORS)
fz_throw(ctx, "too many components in colorspace");
base = pdf_load_colorspace(xref, baseobj);
/* RJW: "cannot load base colorspace (%d %d R)", pdf_to_num(baseobj), pdf_to_gen(baseobj) */
fz_try(ctx)
{
tint = pdf_load_function(xref, tintobj);
/* RJW: fz_drop_colorspace(ctx, base);
* "cannot load tint function (%d %d R)", pdf_to_num(tintobj), pdf_to_gen(tintobj) */
sep = fz_malloc_struct(ctx, struct separation);
sep->base = base;
sep->tint = tint;
cs = fz_new_colorspace(ctx, n == 1 ? "Separation" : "DeviceN", n);
cs->to_rgb = separation_to_rgb;
cs->free_data = free_separation;
cs->data = sep;
cs->size += sizeof(struct separation) + (base ? base->size : 0) + pdf_function_size(tint);
}
fz_catch(ctx)
{
fz_drop_colorspace(ctx, base);
pdf_drop_function(ctx, tint);
fz_free(ctx, sep);
fz_rethrow(ctx);
}
return cs;
}
static fz_error
load_separation(fz_colorspace **csp, pdf_xref *xref, fz_obj *array)
{
fz_error error;
fz_colorspace *cs;
struct separation *sep;
fz_obj *nameobj = fz_array_get(array, 1);
fz_obj *baseobj = fz_array_get(array, 2);
fz_obj *tintobj = fz_array_get(array, 3);
fz_colorspace *base;
pdf_function *tint;
int n;
if (fz_is_array(nameobj))
n = fz_array_len(nameobj);
else
n = 1;
if (n > FZ_MAX_COLORS)
return fz_throw("too many components in colorspace");
error = pdf_load_colorspace(&base, xref, baseobj);
if (error)
return fz_rethrow(error, "cannot load base colorspace (%d %d R)", fz_to_num(baseobj), fz_to_gen(baseobj));
error = pdf_load_function(&tint, xref, tintobj);
if (error)
{
fz_drop_colorspace(base);
return fz_rethrow(error, "cannot load tint function (%d %d R)", fz_to_num(tintobj), fz_to_gen(tintobj));
}
sep = fz_malloc(sizeof(struct separation));
sep->base = base;
sep->tint = tint;
cs = fz_new_colorspace(n == 1 ? "Separation" : "DeviceN", n);
cs->to_rgb = separation_to_rgb;
cs->free_data = free_separation;
cs->data = sep;
*csp = cs;
return fz_okay;
}
static fz_shade *
pdf_load_shading_dict(pdf_document *xref, 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;
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))
{
shade->bbox = pdf_to_rect(ctx, obj);
}
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;
}
static fz_shade *
pdf_load_shading_dict(fz_context *ctx, pdf_document *doc, 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, 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))
pdf_to_rect(ctx, obj, &shade->bbox);
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;
}
static fz_error
pdf_load_shading_dict(fz_shade **shadep, pdf_xref *xref, fz_obj *dict, fz_matrix transform)
{
fz_error error;
fz_shade *shade;
pdf_function *func[FZ_MAX_COLORS] = { NULL };
fz_stream *stream = NULL;
fz_obj *obj;
int funcs;
int type;
int i;
shade = fz_malloc(sizeof(fz_shade));
shade->refs = 1;
shade->type = FZ_MESH;
shade->use_background = 0;
shade->use_function = 0;
shade->matrix = transform;
shade->bbox = fz_infinite_rect;
shade->extend[0] = 0;
shade->extend[1] = 0;
shade->mesh_len = 0;
shade->mesh_cap = 0;
shade->mesh = NULL;
shade->colorspace = NULL;
funcs = 0;
obj = fz_dict_gets(dict, "ShadingType");
type = fz_to_int(obj);
obj = fz_dict_gets(dict, "ColorSpace");
if (!obj)
{
fz_drop_shade(shade);
return fz_throw("shading colorspace is missing");
}
error = pdf_load_colorspace(&shade->colorspace, xref, obj);
if (error)
{
fz_drop_shade(shade);
return fz_rethrow(error, "cannot load colorspace (%d %d R)", fz_to_num(obj), fz_to_gen(obj));
}
obj = fz_dict_gets(dict, "Background");
if (obj)
{
shade->use_background = 1;
for (i = 0; i < shade->colorspace->n; i++)
shade->background[i] = fz_to_real(fz_array_get(obj, i));
}
obj = fz_dict_gets(dict, "BBox");
if (fz_is_array(obj))
{
shade->bbox = pdf_to_rect(obj);
}
obj = fz_dict_gets(dict, "Function");
if (fz_is_dict(obj))
{
funcs = 1;
error = pdf_load_function(&func[0], xref, obj);
if (error)
{
error = fz_rethrow(error, "cannot load shading function (%d %d R)", fz_to_num(obj), fz_to_gen(obj));
goto cleanup;
}
}
else if (fz_is_array(obj))
{
funcs = fz_array_len(obj);
if (funcs != 1 && funcs != shade->colorspace->n)
{
error = fz_throw("incorrect number of shading functions");
goto cleanup;
}
for (i = 0; i < funcs; i++)
{
error = pdf_load_function(&func[i], xref, fz_array_get(obj, i));
if (error)
{
error = fz_rethrow(error, "cannot load shading function (%d %d R)", fz_to_num(obj), fz_to_gen(obj));
goto cleanup;
}
}
}
if (type >= 4 && type <= 7)
{
error = pdf_open_stream(&stream, xref, fz_to_num(dict), fz_to_gen(dict));
if (error)
{
error = fz_rethrow(error, "cannot open shading stream (%d %d R)", fz_to_num(dict), fz_to_gen(dict));
goto cleanup;
}
}
switch (type)
{
case 1: pdf_load_function_based_shading(shade, xref, dict, func[0]); break;
case 2: pdf_load_axial_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, stream); break;
case 5: pdf_load_type5_shade(shade, xref, dict, funcs, func, stream); break;
case 6: pdf_load_type6_shade(shade, xref, dict, funcs, func, stream); break;
case 7: pdf_load_type7_shade(shade, xref, dict, funcs, func, stream); break;
default:
error = fz_throw("unknown shading type: %d", type);
goto cleanup;
}
if (stream)
fz_close(stream);
for (i = 0; i < funcs; i++)
if (func[i])
pdf_drop_function(func[i]);
*shadep = shade;
return fz_okay;
cleanup:
if (stream)
fz_close(stream);
for (i = 0; i < funcs; i++)
if (func[i])
pdf_drop_function(func[i]);
fz_drop_shade(shade);
return fz_rethrow(error, "cannot load shading type %d (%d %d R)", type, fz_to_num(dict), fz_to_gen(dict));
}
