/* Common code shared between remap and concretize */
static int
gx_ciea_to_icc(gs_color_space **ppcs_icc, gs_color_space *pcs, gs_memory_t *memory)
{
int code = 0;
gs_color_space *palt_cs = pcs->base_space;
gx_cie_vector_cache *a_cache = &(pcs->params.a->caches.DecodeA);
gx_cie_scalar_cache *lmn_caches = &(pcs->params.a->common.caches.DecodeLMN[0]);
if_debug0(gs_debug_flag_icc,"[icc] Creating ICC profile from CIEA object");
/* build the ICC color space object */
code = gs_cspace_build_ICC(ppcs_icc, NULL, memory);
/* record the cie alt space as the icc alternative color space */
(*ppcs_icc)->base_space = palt_cs;
rc_increment_cs(palt_cs);
(*ppcs_icc)->cmm_icc_profile_data = gsicc_profile_new(NULL, memory, NULL, 0);
code = gsicc_create_froma(pcs, &((*ppcs_icc)->cmm_icc_profile_data->buffer),
&((*ppcs_icc)->cmm_icc_profile_data->buffer_size), memory,
a_cache, lmn_caches);
gsicc_init_profile_info((*ppcs_icc)->cmm_icc_profile_data);
(*ppcs_icc)->cmm_icc_profile_data->default_match = CIE_A;
/* Assign to the icc_equivalent member variable */
pcs->icc_equivalent = *ppcs_icc;
pcs->icc_equivalent->cmm_icc_profile_data->data_cs = gsGRAY;
return(code);
}
/* Common code shared between remap and concretize */
static int
gx_cieabc_to_icc(gs_color_space **ppcs_icc, gs_color_space *pcs, bool *islab,
gs_memory_t *memory)
{
int code;
gs_color_space *palt_cs = pcs->base_space;
gx_cie_vector_cache *abc_caches = &(pcs->params.abc->caches.DecodeABC.caches[0]);
gx_cie_scalar_cache *lmn_caches = &(pcs->params.abc->common.caches.DecodeLMN[0]);
if_debug0m(gs_debug_flag_icc, memory, "[icc] Creating ICC profile from abc object");
/* build the ICC color space object */
code = gs_cspace_build_ICC(ppcs_icc, NULL, memory);
if (code < 0)
return gs_rethrow(code, "Failed to create ICC profile");
/* record the cie alt space as the icc alternative color space */
(*ppcs_icc)->base_space = palt_cs;
rc_increment_cs(palt_cs);
(*ppcs_icc)->cmm_icc_profile_data = gsicc_profile_new(NULL, memory, NULL, 0);
if ((*ppcs_icc)->cmm_icc_profile_data == NULL)
gs_throw(gs_error_VMerror, "Failed to create ICC profile");
code = gsicc_create_fromabc(pcs, &((*ppcs_icc)->cmm_icc_profile_data->buffer),
&((*ppcs_icc)->cmm_icc_profile_data->buffer_size), memory,
abc_caches, lmn_caches, islab);
if (code < 0)
return gs_rethrow(code, "Failed to build ICC profile from CIEABC");
code = gsicc_init_profile_info((*ppcs_icc)->cmm_icc_profile_data);
if (code < 0)
return gs_rethrow(code, "Failed to build ICC profile from CIEDEF");
(*ppcs_icc)->cmm_icc_profile_data->default_match = CIE_ABC;
/* Assign to the icc_equivalent member variable */
pcs->icc_equivalent = *ppcs_icc;
pcs->icc_equivalent->cmm_icc_profile_data->data_cs = gsRGB;
return 0;
}
/* Common code shared between remap and concretize for defg */
static int
gx_ciedefg_to_icc(gs_color_space **ppcs_icc, gs_color_space *pcs, gs_memory_t *memory)
{
int code = 0;
gs_color_space *palt_cs = pcs->base_space;
gx_cie_vector_cache *abc_caches = &(pcs->params.abc->caches.DecodeABC.caches[0]);
gx_cie_scalar_cache *lmn_caches = &(pcs->params.abc->common.caches.DecodeLMN[0]);
gx_cie_scalar_cache *defg_caches = &(pcs->params.defg->caches_defg.DecodeDEFG[0]);
if_debug0(gs_debug_flag_icc,"[icc] Creating ICC profile from defg object");
/* build the ICC color space object */
code = gs_cspace_build_ICC(ppcs_icc, NULL, memory->stable_memory);
/* record the cie alt space as the icc alternative color space */
(*ppcs_icc)->base_space = palt_cs;
rc_increment_cs(palt_cs);
(*ppcs_icc)->cmm_icc_profile_data = gsicc_profile_new(NULL, memory, NULL, 0);
code = gsicc_create_fromdefg(pcs, &((*ppcs_icc)->cmm_icc_profile_data->buffer),
&((*ppcs_icc)->cmm_icc_profile_data->buffer_size), memory,
abc_caches, lmn_caches, defg_caches);
gsicc_init_profile_info((*ppcs_icc)->cmm_icc_profile_data);
(*ppcs_icc)->cmm_icc_profile_data->default_match = CIE_DEFG;
pcs->icc_equivalent = *ppcs_icc;
pcs->icc_equivalent->cmm_icc_profile_data->data_cs = gsCMYK;
return(0);
}
/*
* Construct a new separation color space.
*/
int
gs_cspace_new_Separation(
gs_color_space **ppcs,
gs_color_space * palt_cspace,
gs_memory_t * pmem
)
{
gs_color_space *pcs;
int code;
if (palt_cspace == 0 || !palt_cspace->type->can_be_alt_space)
return_error(gs_error_rangecheck);
pcs = gs_cspace_alloc(pmem, &gs_color_space_type_Separation);
if (pcs == NULL)
return_error(gs_error_VMerror);
pcs->params.separation.map = NULL;
code = alloc_device_n_map(&pcs->params.separation.map, pmem,
"gs_cspace_build_Separation");
if (code < 0) {
gs_free_object(pmem, pcs, "gs_cspace_build_Separation");
return_error(code);
}
pcs->base_space = palt_cspace;
rc_increment_cs(palt_cspace);
*ppcs = pcs;
return 0;
}
/*
* DeviceN and NChannel color spaces can have an attributes dict. In the
* attribute dict can be a Colorants dict which contains Separation color
* spaces. If the Colorant dict is present, the PS logic will build each of
* the Separation color spaces in a temp gstate and then call this procedure
* to attach the Separation color space to the DeviceN color space.
* The parameter to this procedure is a colorant name. The Separation
* color space is in the current (temp) gstate. The DeviceN color space is
* in the next gstate down in the gstate list (pgs->saved).
*/
int
gs_attachattributecolorspace(gs_separation_name sep_name, gs_state * pgs)
{
gs_color_space * pdevncs;
gs_device_n_attributes * patt;
/* Verify that we have a DeviceN color space */
if (!pgs->saved)
return_error(gs_error_rangecheck);
pdevncs = gs_currentcolorspace_inline(pgs->saved);
if (pdevncs->type != &gs_color_space_type_DeviceN)
return_error(gs_error_rangecheck);
/* Allocate an attribute list element for our linked list of attributes */
rc_alloc_struct_1(patt, gs_device_n_attributes, &st_device_n_attributes,
pgs->memory, return_error(gs_error_VMerror),
"gs_attachattributrescolorspace");
/* Point our attribute list entry to the attribute color space */
patt->colorant_name = sep_name;
patt->cspace = gs_currentcolorspace_inline(pgs);
rc_increment_cs(patt->cspace);
/* Link our new attribute color space to the DeviceN color space */
patt->next = pdevncs->params.device_n.colorants;
pdevncs->params.device_n.colorants = patt;
return 0;
}
RELOC_PTRS_END
/* ------ Public procedures ------ */
/*
* Create a new DeviceN colorspace.
*/
int
gs_cspace_new_DeviceN(
gs_color_space **ppcs,
uint num_components,
gs_color_space *palt_cspace,
gs_memory_t *pmem
)
{
gs_color_space *pcs;
gs_device_n_params *pcsdevn;
gs_separation_name *pnames;
int code;
if (palt_cspace == 0 || !palt_cspace->type->can_be_alt_space)
return_error(gs_error_rangecheck);
pcs = gs_cspace_alloc(pmem, &gs_color_space_type_DeviceN);
if (pcs == NULL)
return_error(gs_error_VMerror);
pcsdevn = &pcs->params.device_n;
pcsdevn->names = NULL;
pcsdevn->map = NULL;
pcsdevn->colorants = NULL;
/* Allocate space for color names list. */
code = alloc_device_n_map(&pcsdevn->map, pmem, "gs_cspace_build_DeviceN");
if (code < 0) {
gs_free_object(pmem, pcs, "gs_cspace_new_DeviceN");
return code;
}
/* Allocate space for color names list. */
pnames = (gs_separation_name *)
gs_alloc_byte_array(pmem, num_components, sizeof(gs_separation_name),
".gs_cspace_build_DeviceN(names)");
if (pnames == 0) {
gs_free_object(pmem, pcsdevn->map, ".gs_cspace_build_DeviceN(map)");
gs_free_object(pmem, pcs, "gs_cspace_new_DeviceN");
return_error(gs_error_VMerror);
}
pcs->base_space = palt_cspace;
rc_increment_cs(palt_cspace);
pcsdevn->names = pnames;
pcsdevn->num_components = num_components;
*ppcs = pcs;
return 0;
}
/* Install a DeviceN color space. */
static int
gx_install_DeviceN(gs_color_space * pcs, gs_state * pgs)
{
int code;
code = check_DeviceN_component_names(pcs, pgs);
if (code < 0)
return code;
/* See if we have an ICC profile that we can associate with
this DeviceN color space */
if (pgs->icc_manager->device_n != NULL) {
/* An nclr profile is in the manager. Grab one that matches. */
cmm_profile_t *profdata = gsicc_finddevicen(pcs, pgs->icc_manager);
if (profdata != NULL)
rc_increment(profdata);
if (pcs->cmm_icc_profile_data != NULL)
rc_decrement(pcs->cmm_icc_profile_data, "gx_install_DeviceN");
pcs->cmm_icc_profile_data = profdata;
}
/* {csrc} was pgs->color_space->params.device_n.use_alt_cspace */
((gs_color_space *)pcs)->params.device_n.use_alt_cspace =
using_alt_color_space(pgs);
if (pcs->params.device_n.use_alt_cspace && pcs->cmm_icc_profile_data == NULL ) {
/* No nclr ICC profile */
code = (pcs->base_space->type->install_cspace)
(pcs->base_space, pgs);
} else if (pcs->params.device_n.use_alt_cspace) {
gs_color_space *nclr_pcs;
/* Need to install the nclr cspace */
code = gs_cspace_build_ICC(&nclr_pcs, NULL, pgs->memory);
nclr_pcs->cmm_icc_profile_data = pcs->cmm_icc_profile_data;
rc_increment(pcs->cmm_icc_profile_data);
rc_increment_cs(nclr_pcs); /* Suspicious - RJW */
rc_decrement_cs(pcs->base_space, "gx_install_DeviceN");
pcs->base_space = nclr_pcs;
}
/*
* Give the device an opportunity to capture equivalent colors for any
* spot colors which might be present in the color space.
*/
if (code >= 0) {
if (dev_proc(pgs->device, update_spot_equivalent_colors))
code = dev_proc(pgs->device, update_spot_equivalent_colors)
(pgs->device, pgs);
}
return code;
}
/* ---------------- General colors and color spaces ---------------- */
int
gs_setcolorspace_only(gs_state * pgs, gs_color_space * pcs)
{
int code = 0;
gs_color_space *cs_old = pgs->color[0].color_space;
gs_client_color cc_old = *pgs->color[0].ccolor;
if (pgs->in_cachedevice)
return_error(gs_error_undefined);
if (pcs->id != cs_old->id) {
rc_increment_cs(pcs);
pgs->color[0].color_space = pcs;
if ( (code = pcs->type->install_cspace(pcs, pgs)) < 0 ||
(pgs->overprint && (code = gs_do_set_overprint(pgs)) < 0) ) {
pgs->color[0].color_space = cs_old;
rc_decrement_only_cs(pcs, "gs_setcolorspace");
} else {
cs_old->type->adjust_color_count(&cc_old, cs_old, -1);
rc_decrement_only_cs(cs_old, "gs_setcolorspace");
}
}
return(code);
}
/* Common framework for building shadings. */
static int
build_shading(i_ctx_t *i_ctx_p, build_shading_proc_t proc)
{
os_ptr op = osp;
int code;
float box[4];
gs_shading_params_t params;
gs_shading_t *psh;
ref *pvalue;
check_type(*op, t_dictionary);
params.ColorSpace = 0;
params.cie_joint_caches = 0;
params.Background = 0;
/* Collect parameters common to all shading types. */
{
gs_color_space *pcs = gs_currentcolorspace(igs);
int num_comp = gs_color_space_num_components(pcs);
if (num_comp < 0) { /* Pattern color space */
gs_errorinfo_put_pair_from_dict(i_ctx_p, op, "ColorSpace");
return_error(gs_error_typecheck);
}
params.ColorSpace = pcs;
rc_increment_cs(pcs);
if (dict_find_string(op, "Background", &pvalue) > 0) {
gs_client_color *pcc =
ialloc_struct(gs_client_color, &st_client_color,
"build_shading");
if (pcc == 0) {
code = gs_note_error(gs_error_VMerror);
goto fail;
}
pcc->pattern = 0;
params.Background = pcc;
code = dict_floats_param(imemory, op, "Background",
gs_color_space_num_components(pcs),
pcc->paint.values, NULL);
if (code < 0) {
gs_errorinfo_put_pair_from_dict(i_ctx_p, op, "Background");
goto fail;
}
}
}
if (dict_find_string(op, "BBox", &pvalue) <= 0)
params.have_BBox = false;
else if ((code = dict_floats_param(imemory, op, "BBox",
4, box, NULL)) == 4) {
/* Adobe Interpreters accept denormalised BBox - bug 688937 */
if (box[0] <= box[2]) {
params.BBox.p.x = box[0];
params.BBox.q.x = box[2];
} else {
params.BBox.p.x = box[2];
params.BBox.q.x = box[0];
}
if (box[1] <= box[3]) {
params.BBox.p.y = box[1];
params.BBox.q.y = box[3];
} else {
params.BBox.p.y = box[3];
params.BBox.q.y = box[1];
}
params.have_BBox = true;
} else {
gs_errorinfo_put_pair_from_dict(i_ctx_p, op, "BBox");
goto fail;
}
code = dict_bool_param(op, "AntiAlias", false, ¶ms.AntiAlias);
if (code < 0) {
gs_errorinfo_put_pair_from_dict(i_ctx_p, op, "AntiAlias");
goto fail;
}
/* Finish building the shading. */
code = (*proc)(i_ctx_p, op, ¶ms, &psh, imemory);
if (code < 0)
goto fail;
if (gx_color_space_needs_cie_caches(psh->params.ColorSpace)) {
rc_decrement(psh->params.cie_joint_caches, "build_shading");
psh->params.cie_joint_caches = gx_currentciecaches(igs);
rc_increment(psh->params.cie_joint_caches);
}
make_istruct_new(op, 0, psh);
return code;
fail:
gs_free_object(imemory, params.Background, "Background");
if (params.ColorSpace) {
rc_decrement_only_cs(params.ColorSpace, "build_shading");
}
return (code < 0 ? code : gs_note_error(gs_error_rangecheck));
}