static bool
pl_read_device_CRD(gs_cie_render *pcrd, gs_state *pgs)
{
gx_device * pdev = gs_currentdevice(pgs);
gs_c_param_list list;
gs_param_string dstring;
char nbuff[64]; /* ample size */
int code = 0;
/*get the CRDName parameter from the device */
gs_c_param_list_write(&list, gs_state_memory(pgs));
if (param_request((gs_param_list *)&list, "CRDName") < 0)
return false;
if ((code = gs_getdeviceparams(pdev, (gs_param_list *)&list)) >= 0) {
gs_c_param_list_read(&list);
if ( (code = param_read_string( (gs_param_list *)&list,
"CRDName",
&dstring
)) == 0 ) {
if (dstring.size > sizeof(nbuff) - 1)
code = 1;
else {
strncpy(nbuff, (char *)dstring.data, dstring.size);
nbuff[dstring.size] = '\0';
}
}
}
gs_c_param_list_release(&list);
if (code != 0)
return false;
gs_c_param_list_write(&list, gs_state_memory(pgs));
if (param_request((gs_param_list *)&list, nbuff) < 0)
return false;
if ((code = gs_getdeviceparams(pdev, (gs_param_list *)&list)) >= 0) {
gs_param_dict dict;
gs_c_param_list_read(&list);
if ( (code = param_begin_read_dict( (gs_param_list *)&list,
nbuff,
&dict,
false
)) == 0 ) {
code = param_get_cie_render1(pcrd, dict.list, pdev);
param_end_read_dict((gs_param_list *)&list, nbuff, &dict);
if (code > 0)
code = 0;
}
}
gs_c_param_list_release(&list);
return (code == 0);
}
/* Install a ICC type color space and use the ICC LABLUT profile. */
int
seticc_lab(i_ctx_t * i_ctx_p, float *white, float *black, float *range_buff)
{
int code;
gs_color_space * pcs;
gs_color_space * palt_cs;
gs_imager_state * pis = (gs_imager_state *)igs;
int i;
static const char *const rfs = LAB_ICC;
gs_param_string val, *pval;
val.data = (const byte *)rfs;
val.size = strlen(rfs);
val.persistent = true;
pval = &val;
palt_cs = gs_currentcolorspace(igs);
/* build the color space object */
code = gs_cspace_build_ICC(&pcs, NULL, gs_state_memory(igs));
if (code < 0)
return gs_rethrow(code, "building color space object");
/* record the current space as the alternative color space */
/* pcs->base_space = palt_cs;
rc_increment_cs(palt_cs); */
/* Get the lab profile. It may already be set in the icc manager.
If not then lets populate it. */
if (pis->icc_manager->lab_profile == NULL ) {
/* This can't happen as the profile
should be initialized during the
setting of the user params */
return gs_rethrow(code, "cannot find lab icc profile");
}
/* Assign the LAB to LAB profile to this color space */
code = gsicc_set_gscs_profile(pcs, pis->icc_manager->lab_profile, gs_state_memory(igs));
rc_increment(pis->icc_manager->lab_profile);
if (code < 0)
return gs_rethrow(code, "installing the lab profile");
pcs->cmm_icc_profile_data->Range.ranges[0].rmin = 0.0;
pcs->cmm_icc_profile_data->Range.ranges[0].rmax = 100.0;
for (i = 1; i < 3; i++) {
pcs->cmm_icc_profile_data->Range.ranges[i].rmin =
range_buff[2 * (i-1)];
pcs->cmm_icc_profile_data->Range.ranges[i].rmax =
range_buff[2 * (i-1) + 1];
}
/* Set the color space. We are done. */
code = gs_setcolorspace(igs, pcs);
return code;
}
/* return SRGB color space to the client */
int
pl_cspace_init_SRGB(gs_color_space **ppcs, const gs_state *pgs)
{
int code;
/* make sure we have a crd set up */
#ifdef DEVICE_DOES_COLOR_CONVERSION
*ppcs = gs_cspace_new_DeviceRGB(pgs->memory);
return 0;
#endif
code = pl_build_crd((gs_state *)pgs);
if ( code < 0 )
return code;
code = gs_cspace_build_CIEABC(ppcs, NULL, gs_state_memory(pgs));
if ( code < 0 )
return code;
*(gs_cie_DecodeLMN(*ppcs)) = pl_DecodeLMN;
*(gs_cie_MatrixLMN(*ppcs)) = pl_MatrixLMN;
(gs_cie_WhitePoint(*ppcs)) = pl_WhitePoint;
(gs_cie_BlackPoint(*ppcs)) = pl_BlackPoint;
return 0;
}
/* Allocate, and prepare to load, the index or tint map. */
int
zcs_begin_map(i_ctx_t *i_ctx_p, gs_indexed_map ** pmap, const ref * pproc,
int num_entries, const gs_color_space * base_space,
op_proc_t map1)
{
gs_memory_t *mem = gs_state_memory(igs);
int space = imemory_space((gs_ref_memory_t *)mem);
int num_components = cs_num_components(base_space);
int num_values = num_entries * num_components;
gs_indexed_map *map;
int code = alloc_indexed_map(&map, num_values, mem,
"setcolorspace(mapped)");
es_ptr ep;
if (code < 0)
return code;
*pmap = map;
/* Map the entire set of color indices. Since the */
/* o-stack may not be able to hold N*4096 values, we have */
/* to load them into the cache as they are generated. */
check_estack(num_csme + 1); /* 1 extra for map1 proc */
ep = esp += num_csme;
make_int(ep + csme_num_components, num_components);
make_struct(ep + csme_map, space, map);
ep[csme_proc] = *pproc;
make_int(ep + csme_hival, num_entries - 1);
make_int(ep + csme_index, -1);
push_op_estack(map1);
return o_push_estack;
}
/*
* Do the generic work for makepattern: allocate the instance and the
* saved graphics state, and fill in the common members.
*/
int
gs_make_pattern_common(gs_client_color *pcc,
const gs_pattern_template_t *ptemp,
const gs_matrix *pmat, gs_state *pgs, gs_memory_t *mem,
gs_memory_type_ptr_t pstype)
{
gs_pattern_instance_t *pinst;
gs_state *saved;
if (mem == 0)
mem = gs_state_memory(pgs);
rc_alloc_struct_1(pinst, gs_pattern_instance_t, pstype, mem,
return_error(gs_error_VMerror),
"gs_make_pattern_common");
pinst->rc.free = rc_free_pattern_instance;
pinst->type = ptemp->type;
saved = gs_state_copy(pgs, mem);
if (saved == 0) {
gs_free_object(mem, pinst, "gs_make_pattern_common");
return_error(gs_error_VMerror);
}
gs_concat(saved, pmat);
gs_newpath(saved);
pinst->saved = saved;
pcc->pattern = pinst;
pcc->pattern->pattern_id = gs_next_ids(mem, 1);
return 0;
}
/* <dict> .builddevicecolorrendering1 <crd> */
static int
zbuilddevicecolorrendering1(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
gs_memory_t *mem = gs_state_memory(igs);
dict_param_list list;
gs_cie_render *pcrd = 0;
int code;
check_type(*op, t_dictionary);
code = dict_param_list_read(&list, op, NULL, false, iimemory);
if (code < 0)
return code;
code = gs_cie_render1_build(&pcrd, mem, ".builddevicecolorrendering1");
if (code >= 0) {
code = param_get_cie_render1(pcrd, (gs_param_list *) & list,
gs_currentdevice(igs));
if (code >= 0) {
/****** FIX refct ******/
/*rc_decrement(pcrd, ".builddevicecolorrendering1"); *//* build sets rc = 1 */
}
}
iparam_list_release(&list);
if (code < 0) {
rc_free_struct(pcrd, ".builddevicecolorrendering1");
return code;
}
istate->colorrendering.dict = *op;
make_istruct_new(op, a_readonly, pcrd);
return 0;
}
/* <dict> .buildcolorrendering1 <crd> */
static int
zbuildcolorrendering1(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
gs_memory_t *mem = gs_state_memory(igs);
int code;
es_ptr ep = esp;
gs_cie_render *pcrd;
ref_cie_render_procs procs;
check_read_type(*op, t_dictionary);
check_dict_read(*op);
code = gs_cie_render1_build(&pcrd, mem, ".buildcolorrendering1");
if (code < 0)
return code;
code = zcrd1_params(op, pcrd, &procs, mem);
if (code < 0 ||
(code = cache_colorrendering1(i_ctx_p, pcrd, &procs,
(gs_ref_memory_t *) mem)) < 0
) {
rc_free_struct(pcrd, ".buildcolorrendering1");
esp = ep;
return code;
}
/****** FIX refct ******/
/*rc_decrement(pcrd, ".buildcolorrendering1"); *//* build sets rc = 1 */
istate->colorrendering.dict = *op;
make_istruct_new(op, a_readonly, pcrd);
return (esp == ep ? 0 : o_push_estack);
}
int
pl_begin_image2(gs_image_enum ** ppenum, gs_image_t * pimage, gs_state * pgs)
{
*ppenum = gs_image_enum_alloc(gs_state_memory(pgs), "px_paint_pattern");
if (*ppenum == 0)
return_error(gs_error_VMerror);
return gs_image_init(*ppenum, pimage, 0, pgs);
}
int
cie_cache_joint(i_ctx_t *i_ctx_p, const ref_cie_render_procs * pcrprocs,
const gs_cie_common *pcie, gs_state * pgs)
{
const gs_cie_render *pcrd = gs_currentcolorrendering(pgs);
gx_cie_joint_caches *pjc = gx_unshare_cie_caches(pgs);
gs_ref_memory_t *imem = (gs_ref_memory_t *) gs_state_memory(pgs);
ref pqr_procs;
uint space;
int code;
int i;
if (pcrd == 0) /* cache is not set up yet */
return 0;
if (pjc == 0) /* must already be allocated */
return_error(e_VMerror);
if (r_has_type(&pcrprocs->TransformPQR, t_null)) {
/*
* This CRD came from a driver, not from a PostScript dictionary.
* Resample TransformPQR in C code.
*/
return gs_cie_cs_complete(pgs, true);
}
gs_cie_compute_points_sd(pjc, pcie, pcrd);
code = ialloc_ref_array(&pqr_procs, a_readonly, 3 * (1 + 4 + 4 * 6),
"cie_cache_common");
if (code < 0)
return code;
/* When we're done, deallocate the procs and complete the caches. */
check_estack(3);
cie_cache_push_finish(i_ctx_p, cie_tpqr_finish, imem, pgs);
*++esp = pqr_procs;
space = r_space(&pqr_procs);
for (i = 0; i < 3; i++) {
ref *p = pqr_procs.value.refs + 3 + (4 + 4 * 6) * i;
const float *ppt = (float *)&pjc->points_sd;
int j;
make_array(pqr_procs.value.refs + i, a_readonly | a_executable | space,
4, p);
make_array(p, a_readonly | space, 4 * 6, p + 4);
p[1] = pcrprocs->TransformPQR.value.refs[i];
make_oper(p + 2, 0, cie_exec_tpqr);
make_oper(p + 3, 0, cie_post_exec_tpqr);
for (j = 0, p += 4; j < 4 * 6; j++, p++, ppt++)
make_real(p, *ppt);
}
return cie_prepare_cache3(i_ctx_p, &pcrd->RangePQR,
pqr_procs.value.const_refs,
pjc->TransformPQR.caches,
pjc, imem, "Transform.PQR");
}
static int
pl_build_crd(gs_state *pgs)
{
int code;
/* nothing to do */
if ( pl_pcrd_built == true )
return gs_setcolorrendering(pgs, pl_pcrd);
code = gs_cie_render1_build(&pl_pcrd, gs_state_memory(pgs), "build_crd");
if ( code < 0 )
return code;
pl_pcrd_built = true;
if ( pl_read_device_CRD(pl_pcrd, pgs) ) {
dprintf("CRD initialized from device\n");
return 0;
}
code = gs_cie_render1_initialize(pgs->memory,
pl_pcrd,
NULL,
&pl_WhitePoint,
&pl_BlackPoint,
&pl_MatrixPQR,
&pl_RangePQR,
&pl_TransformPQR,
&pl_MatrixCRDLMN,
NULL, /* EncodeLMN */
NULL, /* RangeLMN */
NULL, /* MatrixABC */
&pl_EncodeABC_procs,
NULL,
NULL);
if ( code < 0 )
return code; /* should not fail */
code = gs_setcolorrendering(pgs, pl_pcrd);
return code;
}
int seticc(i_ctx_t * i_ctx_p, int ncomps, ref *ICCdict, float *range_buff)
{
int code, k;
gs_color_space * pcs;
gs_color_space * palt_cs;
ref * pstrmval;
stream * s = 0L;
cmm_profile_t *picc_profile;
gs_imager_state * pis = (gs_imager_state *)igs;
int i, expected = 0;
ref * pnameval;
static const char *const icc_std_profile_names[] = {
GSICC_STANDARD_PROFILES
};
static const char *const icc_std_profile_keys[] = {
GSICC_STANDARD_PROFILES_KEYS
};
palt_cs = gs_currentcolorspace(igs);
/* verify the DataSource entry */
if (dict_find_string(ICCdict, "DataSource", &pstrmval) <= 0)
return_error(e_undefined);
check_read_file(i_ctx_p, s, pstrmval);
/* build the color space object */
code = gs_cspace_build_ICC(&pcs, NULL, gs_state_memory(igs));
if (code < 0)
return gs_rethrow(code, "building color space object");
/* For now, dump the profile into a buffer
and obtain handle from the buffer when we need it.
We may want to change this later.
This depends to some degree on what the CMS is capable of doing.
I don't want to get bogged down on stream I/O at this point.
Note also, if we are going to be putting these into the clist we will
want to have this buffer. */
/* Check if we have the /Name entry. This is used to associate with
specs that have enumerated types to indicate sRGB sGray etc */
if (dict_find_string(ICCdict, "Name", &pnameval) > 0){
uint size = r_size(pnameval);
char *str = (char *)gs_alloc_bytes(gs_state_memory(igs), size+1, "seticc");
memcpy(str, (const char *)pnameval->value.bytes, size);
str[size] = 0;
/* Compare this to the standard profile names */
picc_profile = NULL;
for (k = 0; k < GSICC_NUMBER_STANDARD_PROFILES; k++) {
if ( strcmp( str, icc_std_profile_keys[k] ) == 0 ) {
picc_profile = gsicc_get_profile_handle_file(icc_std_profile_names[k],
strlen(icc_std_profile_names[k]), gs_state_memory(igs));
break;
}
}
} else {
picc_profile = gsicc_profile_new(s, gs_state_memory(igs), NULL, 0);
}
if (picc_profile == NULL) {
rc_decrement(picc_profile,"seticc");
rc_decrement(pcs,"seticc");
return -1;
}
code = gsicc_set_gscs_profile(pcs, picc_profile, gs_state_memory(igs));
if (code < 0) {
rc_decrement(picc_profile,"seticc");
rc_decrement(pcs,"seticc");
return code;
}
picc_profile->num_comps = ncomps;
/* We have to get the profile handle due to the fact that we need to know
if it has a data space that is CIELAB */
picc_profile->profile_handle =
gsicc_get_profile_handle_buffer(picc_profile->buffer,
picc_profile->buffer_size,
gs_state_memory(igs));
if (picc_profile->profile_handle == NULL) {
/* Free up everything, the profile is not valid. We will end up going
ahead and using a default based upon the number of components */
rc_decrement(picc_profile,"seticc");
rc_decrement(pcs,"seticc");
return -1;
}
picc_profile->data_cs = gscms_get_profile_data_space(picc_profile->profile_handle);
switch( picc_profile->data_cs ) {
case gsCIEXYZ:
case gsCIELAB:
case gsRGB:
expected = 3;
break;
case gsGRAY:
expected = 1;
break;
case gsCMYK:
expected = 4;
break;
case gsNCHANNEL:
case gsNAMED: /* Silence warnings */
case gsUNDEFINED: /* Silence warnings */
break;
}
if (!expected || ncomps != expected) {
rc_decrement(picc_profile,"seticc");
rc_decrement(pcs,"seticc");
return_error(e_rangecheck);
}
/* Lets go ahead and get the hash code and check if we match one of the default spaces */
/* Later we may want to delay this, but for now lets go ahead and do it */
gsicc_init_hash_cs(picc_profile, pis);
/* Set the range according to the data type that is associated with the
ICC input color type. Occasionally, we will run into CIELAB to CIELAB
profiles for spot colors in PDF documents. These spot colors are typically described
as separation colors with tint transforms that go from a tint value
to a linear mapping between the CIELAB white point and the CIELAB tint
color. This results in a CIELAB value that we need to use to fill. We
need to detect this to make sure we do the proper scaling of the data. For
CIELAB images in PDF, the source is always normal 8 or 16 bit encoded data
in the range from 0 to 255 or 0 to 65535. In that case, there should not
be any encoding and decoding to CIELAB. The PDF content will not include
an ICC profile but will set the color space to \Lab. In this case, we use
our seticc_lab operation to install the LAB to LAB profile, but we detect
that we did that through the use of the is_lab flag in the profile descriptor.
When then avoid the CIELAB encode and decode */
if (picc_profile->data_cs == gsCIELAB) {
/* If the input space to this profile is CIELAB, then we need to adjust the limits */
/* See ICC spec ICC.1:2004-10 Section 6.3.4.2 and 6.4. I don't believe we need to
worry about CIEXYZ profiles or any of the other odds ones. Need to check that though
at some point. */
picc_profile->Range.ranges[0].rmin = 0.0;
picc_profile->Range.ranges[0].rmax = 100.0;
picc_profile->Range.ranges[1].rmin = -128.0;
picc_profile->Range.ranges[1].rmax = 127.0;
picc_profile->Range.ranges[2].rmin = -128.0;
picc_profile->Range.ranges[2].rmax = 127.0;
picc_profile->islab = true;
} else {
for (i = 0; i < ncomps; i++) {
picc_profile->Range.ranges[i].rmin = range_buff[2 * i];
picc_profile->Range.ranges[i].rmax = range_buff[2 * i + 1];
}
}
/* Now see if we are in an overide situation. We have to wait until now
in case this is an LAB profile which we will not overide */
if (gs_currentoverrideicc(pis) && picc_profile->data_cs != gsCIELAB) {
/* Free up the profile structure */
switch( picc_profile->data_cs ) {
case gsRGB:
pcs->cmm_icc_profile_data = pis->icc_manager->default_rgb;
break;
case gsGRAY:
pcs->cmm_icc_profile_data = pis->icc_manager->default_gray;
break;
case gsCMYK:
pcs->cmm_icc_profile_data = pis->icc_manager->default_cmyk;
break;
default:
break;
}
/* Have one increment from the color space. Having these tied
together is not really correct. Need to fix that. ToDo. MJV */
rc_adjust(picc_profile, -2, "seticc");
rc_increment(pcs->cmm_icc_profile_data);
}
/* Set the color space. We are done. No joint cache here... */
code = gs_setcolorspace(igs, pcs);
/* The context has taken a reference to the colorspace. We no longer need
* ours, so drop it. */
rc_decrement_only(pcs, "seticc");
/* In this case, we already have a ref count of 2 on the icc profile
one for when it was created and one for when it was set. We really
only want one here so adjust */
rc_decrement(picc_profile,"seticc");
/* Remove the ICC dict from the stack */
pop(1);
return code;
}
/*
* <dict> .set_outputintent -
*
* Set and use the specified output intent.
*
*/
static int
zset_outputintent(i_ctx_t * i_ctx_p)
{
os_ptr op = osp;
int code = 0;
gx_device *dev = gs_currentdevice(igs);
gs_imager_state *pis = (gs_imager_state *)igs;
cmm_dev_profile_t *dev_profile;
stream * s = 0L;
ref * pnval;
ref * pstrmval;
int ncomps, dev_comps;
cmm_profile_t *picc_profile;
int expected = 0;
gs_color_space_index index;
gsicc_manager_t *icc_manager = pis->icc_manager;
cmm_profile_t *source_profile = NULL;
check_type(*op, t_dictionary);
check_dict_read(*op);
if_debug0m(gs_debug_flag_icc, imemory, "[icc] Using OutputIntent\n");
/* Get the device structure */
code = dev_proc(dev, get_profile)(dev, &dev_profile);
if (dev_profile == NULL) {
code = gsicc_init_device_profile_struct(dev, NULL, 0);
code = dev_proc(dev, get_profile)(dev, &dev_profile);
}
if (dev_profile->oi_profile != NULL) {
return 0; /* Allow only one setting of this object */
}
code = dict_find_string(op, "N", &pnval);
if (code < 0)
return code;
ncomps = pnval->value.intval;
/* verify the DataSource entry. Creat profile from stream */
if (dict_find_string(op, "DataSource", &pstrmval) <= 0)
return_error(e_undefined);
check_read_file(i_ctx_p, s, pstrmval);
picc_profile = gsicc_profile_new(s, gs_state_memory(igs), NULL, 0);
picc_profile->num_comps = ncomps;
picc_profile->profile_handle =
gsicc_get_profile_handle_buffer(picc_profile->buffer,
picc_profile->buffer_size,
gs_state_memory(igs));
if (picc_profile->profile_handle == NULL) {
rc_decrement(picc_profile,"zset_outputintent");
return -1;
}
picc_profile->data_cs = gscms_get_profile_data_space(picc_profile->profile_handle);
switch (picc_profile->data_cs) {
case gsCIEXYZ:
case gsCIELAB:
case gsRGB:
expected = 3;
source_profile = icc_manager->default_rgb;
break;
case gsGRAY:
expected = 1;
source_profile = icc_manager->default_gray;
break;
case gsCMYK:
expected = 4;
source_profile = icc_manager->default_cmyk;
break;
case gsNCHANNEL:
expected = 0;
break;
case gsNAMED:
case gsUNDEFINED:
break;
}
if (expected && ncomps != expected) {
rc_decrement(picc_profile,"zset_outputintent");
return_error(e_rangecheck);
}
gsicc_init_hash_cs(picc_profile, pis);
/* All is well with the profile. Lets set the stuff that needs to be set */
dev_profile->oi_profile = picc_profile;
picc_profile->name = (char *) gs_alloc_bytes(picc_profile->memory,
MAX_DEFAULT_ICC_LENGTH,
"zset_outputintent");
strncpy(picc_profile->name, OI_PROFILE, strlen(OI_PROFILE));
picc_profile->name[strlen(OI_PROFILE)] = 0;
picc_profile->name_length = strlen(OI_PROFILE);
/* Set the range of the profile */
gscms_set_icc_range(&picc_profile);
/* If the output device has a different number of componenets, then we are
going to set the output intent as the proofing profile, unless the
proofing profile has already been set.
If the device has the same number of components (and color model) then as
the profile we will use this as the output profile, unless someone has
explicitly set the output profile.
Finally, we will use the output intent profile for the default profile
of the proper Device profile in the icc manager, again, unless someone
has explicitly set this default profile. */
dev_comps = dev_profile->device_profile[0]->num_comps;
index = gsicc_get_default_type(dev_profile->device_profile[0]);
if (ncomps == dev_comps && index < gs_color_space_index_DevicePixel) {
/* The OI profile is the same type as the profile for the device and a
"default" profile for the device was not externally set. So we go
ahead and use the OI profile as the device profile. Care needs to be
taken here to keep from screwing up any device parameters. We will
use a keyword of OIProfile for the user/device parameter to indicate
its usage. Also, note conflicts if one is setting object dependent
color management */
rc_assign(dev_profile->device_profile[0], picc_profile,
"zset_outputintent");
if_debug0m(gs_debug_flag_icc, imemory, "[icc] OutputIntent used for device profile\n");
} else {
if (dev_profile->proof_profile == NULL) {
/* This means that we should use the OI profile as the proofing
profile. Note that if someone already has specified a
proofing profile it is unclear what they are trying to do
with the output intent. In this case, we will use it
just for the source data below */
dev_profile->proof_profile = picc_profile;
rc_increment(picc_profile);
if_debug0m(gs_debug_flag_icc, imemory, "[icc] OutputIntent used for proof profile\n");
}
}
/* Now the source colors. See which source color space needs to use the
output intent ICC profile */
index = gsicc_get_default_type(source_profile);
if (index < gs_color_space_index_DevicePixel) {
/* source_profile is currently the default. Set it to the OI profile */
switch (picc_profile->data_cs) {
case gsGRAY:
if_debug0m(gs_debug_flag_icc, imemory, "[icc] OutputIntent used source Gray\n");
rc_assign(icc_manager->default_gray, picc_profile,
"zset_outputintent");
break;
case gsRGB:
if_debug0m(gs_debug_flag_icc, imemory, "[icc] OutputIntent used source RGB\n");
rc_assign(icc_manager->default_rgb, picc_profile,
"zset_outputintent");
break;
case gsCMYK:
if_debug0m(gs_debug_flag_icc, imemory, "[icc] OutputIntent used source CMYK\n");
rc_assign(icc_manager->default_cmyk, picc_profile,
"zset_outputintent");
break;
default:
break;
}
}
/* Remove the output intent dict from the stack */
pop(1);
return code;
}
int seticc(i_ctx_t * i_ctx_p, int ncomps, ref *ICCdict, float *range_buff)
{
os_ptr op = osp;
int edepth = ref_stack_count(&e_stack);
int code, reuse_op = 0;
gs_color_space * pcs;
gs_color_space * palt_cs;
int i;
gs_cie_icc * picc_info;
ref * pstrmval;
stream * s = 0L;
palt_cs = gs_currentcolorspace(igs);
/* verify the DataSource entry */
if (dict_find_string(ICCdict, "DataSource", &pstrmval) <= 0)
return_error(e_undefined);
check_read_file(s, pstrmval);
/* build the color space object */
code = gs_cspace_build_CIEICC(&pcs, NULL, gs_state_memory(igs));
if (code < 0)
return code;
picc_info = pcs->params.icc.picc_info;
picc_info->num_components = ncomps;
picc_info->instrp = s;
picc_info->file_id = (s->read_id | s->write_id);
for (i = 0; i < ncomps; i++) {
picc_info->Range.ranges[i].rmin = range_buff[2 * i];
picc_info->Range.ranges[i].rmax = range_buff[2 * i + 1];
}
/* record the current space as the alternative color space */
pcs->base_space = palt_cs;
rc_increment(palt_cs);
code = gx_load_icc_profile(picc_info);
if (code < 0)
return code;
/* If the input space to this profile is CIELAB, then we need to adjust the limits */
/* See ICC spec ICC.1:2004-10 Section 6.3.4.2 and 6.4 */
if(picc_info->plu->e_inSpace == icSigLabData)
{
picc_info->Range.ranges[0].rmin = 0.0;
picc_info->Range.ranges[0].rmax = 100.0;
picc_info->Range.ranges[1].rmin = -128.0;
picc_info->Range.ranges[1].rmax = 127.0;
picc_info->Range.ranges[2].rmin = -128.0;
picc_info->Range.ranges[2].rmax = 127.0;
}
/* If the input space is icSigXYZData, then we should do the limits based upon the white point of the profile. */
if(picc_info->plu->e_inSpace == icSigXYZData)
{
for (i = 0; i < 3; i++)
{
picc_info->Range.ranges[i].rmin = 0;
}
picc_info->Range.ranges[0].rmax = picc_info->common.points.WhitePoint.u;
picc_info->Range.ranges[1].rmax = picc_info->common.points.WhitePoint.v;
picc_info->Range.ranges[2].rmax = picc_info->common.points.WhitePoint.w;
}
code = cie_cache_joint(i_ctx_p, &istate->colorrendering.procs,
(gs_cie_common *)picc_info, igs);
if (code < 0)
return code;
return cie_set_finish( i_ctx_p,
pcs,
&istate->colorspace.procs.cie,
edepth,
code );
}
