int
pdf_cs_Pattern_uncolored_hl(gx_device_pdf *pdev,
const gs_color_space *pcs, cos_value_t *pvalue)
{
/* Only for high level colors. */
return pdf_color_space_named(pdev, pvalue, NULL, pcs, &pdf_color_space_names, true, NULL, 0);
}
int
pdf_color_space(gx_device_pdf *pdev, cos_value_t *pvalue,
const gs_range_t **ppranges,
const gs_color_space *pcs,
const pdf_color_space_names_t *pcsn,
bool by_name)
{
return pdf_color_space_named(pdev, pvalue, ppranges, pcs, pcsn, by_name, NULL, 0);
}
static int
pdf_make_group_dict(gx_device_pdf * pdev, const gs_pdf14trans_params_t * pparams,
const gs_imager_state * pis, cos_dict_t **pdict)
{
pdf_resource_t *pres_group;
cos_dict_t *group_dict;
int code;
const gs_state *gstate = gx_hld_get_gstate_ptr(pis);
cos_value_t cs_value;
code = pdf_alloc_resource(pdev, resourceGroup, gs_no_id, &pres_group, -1);
if (code < 0)
return code;
cos_become(pres_group->object, cos_type_dict);
group_dict = (cos_dict_t *)pres_group->object;
code = cos_dict_put_c_key_string(group_dict, "/Type", (const byte *)"/Group", 6);
if (code < 0)
return code;
code = cos_dict_put_c_key_string(group_dict, "/S", (const byte *)"/Transparency", 13);
if (code < 0)
return code;
if (pparams->Isolated) {
code = cos_dict_put_c_key_bool(group_dict, "/I", true);
if (code < 0)
return code;
}
if (pparams->Knockout) {
code = cos_dict_put_c_key_bool(group_dict, "/K", true);
if (code < 0)
return code;
}
if (gstate != NULL) {
const gs_color_space *cs = gstate->color_space;
code = pdf_color_space_named(pdev, &cs_value, NULL, cs,
&pdf_color_space_names, false, NULL, 0);
if (code < 0)
return code;
code = cos_dict_put_c_key(group_dict, "/CS", &cs_value);
if (code < 0)
return code;
}
group_dict = NULL; /* The next line invalidates it. */
code = pdf_substitute_resource(pdev, &pres_group, resourceGroup, NULL, false);
if (code < 0)
return code;
*pdict = (cos_dict_t *)pres_group->object;
return 0;
}
/*
* Create a PDF color space corresponding to a PostScript color space.
* For parameterless color spaces, set *pvalue to a (literal) string with
* the color space name; for other color spaces, create a cos_array_t if
* necessary and set *pvalue to refer to it. In the latter case, if
* by_name is true, return a string /Rxxxx rather than a reference to
* the actual object.
*
* If ppranges is not NULL, then if the domain of the color space had
* to be scaled (to convert a CIEBased space to ICCBased), store a pointer
* to the ranges in *ppranges, otherwise set *ppranges to 0.
*/
int
pdf_color_space_named(gx_device_pdf *pdev, cos_value_t *pvalue,
const gs_range_t **ppranges,
const gs_color_space *pcs_in,
const pdf_color_space_names_t *pcsn,
bool by_name, const byte *res_name, int name_length)
{
const gs_color_space *pcs;
gs_color_space_index csi;
cos_array_t *pca;
cos_dict_t *pcd;
cos_value_t v;
const gs_cie_common *pciec;
gs_function_t *pfn;
const gs_range_t *ranges = 0;
uint serialized_size;
byte *serialized = NULL, serialized0[100];
pdf_resource_t *pres = NULL;
int code;
#if 0
bool islab = false;
#endif
/* If color space is CIE based and we have compatibility then go ahead and use the ICC alternative */
if ((pdev->CompatibilityLevel < 1.3) || !gs_color_space_is_PSCIE(pcs_in) ) {
pcs = pcs_in;
} else {
pcs = pcs_in;
/* The snippet below creates an ICC equivalent profile for the PS
color space. This is disabled until I add the capability to
specify the profile version to ensure compatability with
the PDF versions */
#if 0
if (pcs_in->icc_equivalent != NULL) {
pcs = pcs_in->icc_equivalent;
} else {
/* Need to create the equivalent object */
gs_colorspace_set_icc_equivalent((gs_color_space *)pcs_in, &islab, pdev->memory);
pcs = pcs_in->icc_equivalent;
}
#endif
}
csi = gs_color_space_get_index(pcs);
/* Note that if csi is ICC, check to see if this was one of
the default substitutes that we introduced for DeviceGray,
DeviceRGB or DeviceCMYK. If it is, then just write
the default color. Depending upon the flavor of PDF,
or other options, we may want to actually have all
the colors defined by ICC profiles and not do the following
substituion of the Device space. */
if (csi == gs_color_space_index_ICC) {
csi = gsicc_get_default_type(pcs->cmm_icc_profile_data);
}
if (ppranges)
*ppranges = 0; /* default */
switch (csi) {
case gs_color_space_index_DeviceGray:
cos_c_string_value(pvalue, pcsn->DeviceGray);
return 0;
case gs_color_space_index_DeviceRGB:
cos_c_string_value(pvalue, pcsn->DeviceRGB);
return 0;
case gs_color_space_index_DeviceCMYK:
cos_c_string_value(pvalue, pcsn->DeviceCMYK);
return 0;
case gs_color_space_index_Pattern:
if (!pcs->params.pattern.has_base_space) {
cos_c_string_value(pvalue, "/Pattern");
return 0;
}
break;
case gs_color_space_index_ICC:
/*
* Take a special early exit for unrecognized ICCBased color spaces,
* or for PDF 1.2 output (ICCBased color spaces date from PDF 1.3).
*/
if (pcs->cmm_icc_profile_data == NULL ||
pdev->CompatibilityLevel < 1.3
) {
if (res_name != NULL)
return 0; /* Ignore .includecolorspace */
if (pcs->base_space != NULL) {
return pdf_color_space_named( pdev, pvalue, ppranges,
pcs->base_space,
pcsn, by_name, NULL, 0);
} else {
/* Base space is NULL, use appropriate device space */
switch( cs_num_components(pcs) ) {
case 1:
cos_c_string_value(pvalue, pcsn->DeviceGray);
return 0;
case 3:
cos_c_string_value(pvalue, pcsn->DeviceRGB);
return 0;
case 4:
cos_c_string_value(pvalue, pcsn->DeviceCMYK);
return 0;
default:
break;
}
}
}
break;
default:
break;
}
if (pdev->params.ColorConversionStrategy == ccs_CMYK &&
csi != gs_color_space_index_DeviceCMYK &&
csi != gs_color_space_index_DeviceGray &&
csi != gs_color_space_index_Pattern)
return_error(gs_error_rangecheck);
if (pdev->params.ColorConversionStrategy == ccs_sRGB &&
csi != gs_color_space_index_DeviceRGB &&
csi != gs_color_space_index_DeviceGray &&
csi != gs_color_space_index_Pattern)
return_error(gs_error_rangecheck);
if (pdev->params.ColorConversionStrategy == ccs_Gray &&
csi != gs_color_space_index_DeviceGray &&
csi != gs_color_space_index_Pattern)
return_error(gs_error_rangecheck);
/* Check whether we already have a PDF object for this color space. */
if (pcs->id != gs_no_id)
pres = pdf_find_resource_by_gs_id(pdev, resourceColorSpace, pcs->id);
if (pres == NULL) {
stream s;
s_init(&s, pdev->memory);
swrite_position_only(&s);
code = cs_serialize(pcs, &s);
if (code < 0)
return_error(gs_error_unregistered); /* Must not happen. */
serialized_size = stell(&s);
sclose(&s);
if (serialized_size <= sizeof(serialized0))
serialized = serialized0;
else {
serialized = gs_alloc_bytes(pdev->pdf_memory, serialized_size, "pdf_color_space");
if (serialized == NULL)
return_error(gs_error_VMerror);
}
swrite_string(&s, serialized, serialized_size);
code = cs_serialize(pcs, &s);
if (code < 0)
return_error(gs_error_unregistered); /* Must not happen. */
if (stell(&s) != serialized_size)
return_error(gs_error_unregistered); /* Must not happen. */
sclose(&s);
pres = pdf_find_cspace_resource(pdev, serialized, serialized_size);
if (pres != NULL) {
if (serialized != serialized0)
gs_free_object(pdev->pdf_memory, serialized, "pdf_color_space");
serialized = NULL;
}
}
if (pres) {
const pdf_color_space_t *const ppcs =
(const pdf_color_space_t *)pres;
if (ppranges != 0 && ppcs->ranges != 0)
*ppranges = ppcs->ranges;
pca = (cos_array_t *)pres->object;
goto ret;
}
/* Space has parameters -- create an array. */
pca = cos_array_alloc(pdev, "pdf_color_space");
if (pca == 0)
return_error(gs_error_VMerror);
switch (csi) {
case gs_color_space_index_ICC:
code = pdf_iccbased_color_space(pdev, pvalue, pcs, pca);
break;
case gs_color_space_index_CIEA: {
/* Check that we can represent this as a CalGray space. */
const gs_cie_a *pcie = pcs->params.a;
bool unitary = cie_ranges_are_0_1(&pcie->RangeA, 1);
bool identityA = (pcie->MatrixA.u == 1 && pcie->MatrixA.v == 1 &&
pcie->MatrixA.w == 1);
gs_vector3 expts;
pciec = (const gs_cie_common *)pcie;
if (!pcie->common.MatrixLMN.is_identity) {
code = pdf_convert_cie_space(pdev, pca, pcs, "GRAY", pciec,
&pcie->RangeA, ONE_STEP_NOT, NULL,
&ranges);
break;
}
if (unitary && identityA &&
CIE_CACHE_IS_IDENTITY(&pcie->caches.DecodeA) &&
CIE_SCALAR3_CACHE_IS_EXPONENTIAL(pcie->common.caches.DecodeLMN, expts) &&
expts.v == expts.u && expts.w == expts.u
) {
DO_NOTHING;
} else if (unitary && identityA &&
CIE_CACHE3_IS_IDENTITY(pcie->common.caches.DecodeLMN) &&
cie_vector_cache_is_exponential(&pcie->caches.DecodeA, &expts.u)
) {
DO_NOTHING;
} else {
code = pdf_convert_cie_space(pdev, pca, pcs, "GRAY", pciec,
&pcie->RangeA, ONE_STEP_NOT, NULL,
&ranges);
break;
}
code = cos_array_add(pca, cos_c_string_value(&v, "/CalGray"));
if (code < 0)
return code;
pcd = cos_dict_alloc(pdev, "pdf_color_space(dict)");
if (pcd == 0)
return_error(gs_error_VMerror);
if (expts.u != 1) {
code = cos_dict_put_c_key_real(pcd, "/Gamma", expts.u);
if (code < 0)
return code;
}
}
cal:
/* Finish handling a CIE-based color space (Calxxx or Lab). */
if (code < 0)
return code;
code = pdf_finish_cie_space(pca, pcd, pciec);
break;
case gs_color_space_index_CIEABC: {
/* Check that we can represent this as a CalRGB space. */
const gs_cie_abc *pcie = pcs->params.abc;
bool unitary = cie_ranges_are_0_1(pcie->RangeABC.ranges, 3);
gs_vector3 expts;
const gs_matrix3 *pmat = NULL;
cie_cache_one_step_t one_step =
cie_cached_abc_is_one_step(pcie, &pmat);
pciec = (const gs_cie_common *)pcie;
if (unitary) {
switch (one_step) {
case ONE_STEP_ABC:
if (CIE_VECTOR3_CACHE_IS_EXPONENTIAL(pcie->caches.DecodeABC.caches, expts))
goto calrgb;
break;
case ONE_STEP_LMN:
if (CIE_SCALAR3_CACHE_IS_EXPONENTIAL(pcie->common.caches.DecodeLMN, expts))
goto calrgb;
default:
break;
}
}
if (cie_is_lab(pcie)) {
/* Represent this as a Lab space. */
pcd = cos_dict_alloc(pdev, "pdf_color_space(dict)");
if (pcd == 0)
return_error(gs_error_VMerror);
code = pdf_put_lab_color_space(pca, pcd, pcie->RangeABC.ranges);
goto cal;
} else {
code = pdf_convert_cie_space(pdev, pca, pcs, "RGB ", pciec,
pcie->RangeABC.ranges,
one_step, pmat, &ranges);
break;
}
calrgb:
code = cos_array_add(pca, cos_c_string_value(&v, "/CalRGB"));
if (code < 0)
return code;
pcd = cos_dict_alloc(pdev, "pdf_color_space(dict)");
if (pcd == 0)
return_error(gs_error_VMerror);
if (expts.u != 1 || expts.v != 1 || expts.w != 1) {
code = cos_dict_put_c_key_vector3(pcd, "/Gamma", &expts);
if (code < 0)
return code;
}
if (!pmat->is_identity) {
cos_array_t *pcma =
cos_array_alloc(pdev, "pdf_color_space(Matrix)");
if (pcma == 0)
return_error(gs_error_VMerror);
if ((code = cos_array_add_vector3(pcma, &pmat->cu)) < 0 ||
(code = cos_array_add_vector3(pcma, &pmat->cv)) < 0 ||
(code = cos_array_add_vector3(pcma, &pmat->cw)) < 0 ||
(code = cos_dict_put(pcd, (const byte *)"/Matrix", 7,
COS_OBJECT_VALUE(&v, pcma))) < 0
)
return code;
}
}
goto cal;
case gs_color_space_index_CIEDEF:
code = pdf_convert_cie_space(pdev, pca, pcs, "RGB ",
(const gs_cie_common *)pcs->params.def,
pcs->params.def->RangeDEF.ranges,
ONE_STEP_NOT, NULL, &ranges);
break;
case gs_color_space_index_CIEDEFG:
code = pdf_convert_cie_space(pdev, pca, pcs, "CMYK",
(const gs_cie_common *)pcs->params.defg,
pcs->params.defg->RangeDEFG.ranges,
ONE_STEP_NOT, NULL, &ranges);
break;
case gs_color_space_index_Indexed:
code = pdf_indexed_color_space(pdev, pvalue, pcs, pca);
break;
case gs_color_space_index_DeviceN:
if (!pdev->PreserveDeviceN)
return_error(gs_error_rangecheck);
if (pdev->CompatibilityLevel < 1.3)
return_error(gs_error_rangecheck);
pfn = gs_cspace_get_devn_function(pcs);
/****** CURRENTLY WE ONLY HANDLE Functions ******/
if (pfn == 0)
return_error(gs_error_rangecheck);
{
cos_array_t *psna =
cos_array_alloc(pdev, "pdf_color_space(DeviceN)");
int i;
byte *name_string;
uint name_string_length;
cos_value_t v_attriburtes, *va = NULL;
if (psna == 0)
return_error(gs_error_VMerror);
for (i = 0; i < pcs->params.device_n.num_components; ++i) {
if ((code = pcs->params.device_n.get_colorname_string(
pdev->memory,
pcs->params.device_n.names[i], &name_string,
&name_string_length)) < 0 ||
(code = pdf_string_to_cos_name(pdev, name_string,
name_string_length, &v)) < 0 ||
(code = cos_array_add_no_copy(psna, &v)) < 0)
return code;
}
COS_OBJECT_VALUE(&v, psna);
if (pcs->params.device_n.colorants != NULL) {
cos_dict_t *colorants = cos_dict_alloc(pdev, "pdf_color_space(DeviceN)");
cos_value_t v_colorants, v_separation, v_colorant_name;
const gs_device_n_attributes *csa;
pdf_resource_t *pres_attributes;
if (colorants == NULL)
return_error(gs_error_VMerror);
code = pdf_alloc_resource(pdev, resourceOther, 0, &pres_attributes, -1);
if (code < 0)
return code;
cos_become(pres_attributes->object, cos_type_dict);
COS_OBJECT_VALUE(&v_colorants, colorants);
code = cos_dict_put((cos_dict_t *)pres_attributes->object,
(const byte *)"/Colorants", 10, &v_colorants);
if (code < 0)
return code;
for (csa = pcs->params.device_n.colorants; csa != NULL; csa = csa->next) {
code = pcs->params.device_n.get_colorname_string(pdev->memory,
csa->colorant_name, &name_string, &name_string_length);
if (code < 0)
return code;
code = pdf_color_space_named(pdev, &v_separation, NULL, csa->cspace, pcsn, false, NULL, 0);
if (code < 0)
return code;
code = pdf_string_to_cos_name(pdev, name_string, name_string_length, &v_colorant_name);
if (code < 0)
return code;
code = cos_dict_put(colorants, v_colorant_name.contents.chars.data,
v_colorant_name.contents.chars.size, &v_separation);
if (code < 0)
return code;
}
code = pdf_substitute_resource(pdev, &pres_attributes, resourceOther, NULL, true);
if (code < 0)
return code;
pres_attributes->where_used |= pdev->used_mask;
va = &v_attriburtes;
COS_OBJECT_VALUE(va, pres_attributes->object);
}
if ((code = pdf_separation_color_space(pdev, pca, "/DeviceN", &v,
pcs->base_space,
pfn, &pdf_color_space_names, va)) < 0)
return code;
}
break;
case gs_color_space_index_Separation:
if (!pdev->PreserveSeparation)
return_error(gs_error_rangecheck);
pfn = gs_cspace_get_sepr_function(pcs);
/****** CURRENTLY WE ONLY HANDLE Functions ******/
if (pfn == 0)
return_error(gs_error_rangecheck);
{
byte *name_string;
uint name_string_length;
if ((code = pcs->params.separation.get_colorname_string(
pdev->memory,
pcs->params.separation.sep_name, &name_string,
&name_string_length)) < 0 ||
(code = pdf_string_to_cos_name(pdev, name_string,
name_string_length, &v)) < 0 ||
(code = pdf_separation_color_space(pdev, pca, "/Separation", &v,
pcs->base_space,
pfn, &pdf_color_space_names, NULL)) < 0)
return code;
}
break;
case gs_color_space_index_Pattern:
if ((code = pdf_color_space_named(pdev, pvalue, ppranges,
pcs->base_space,
&pdf_color_space_names, false, NULL, 0)) < 0 ||
(code = cos_array_add(pca,
cos_c_string_value(&v, "/Pattern"))) < 0 ||
(code = cos_array_add(pca, pvalue)) < 0
)
return code;
break;
default:
return_error(gs_error_rangecheck);
}
/*
* Register the color space as a resource, since it must be referenced
* by name rather than directly.
*/
{
pdf_color_space_t *ppcs;
if (code < 0 ||
(code = pdf_alloc_resource(pdev, resourceColorSpace, pcs->id,
&pres, -1)) < 0
) {
COS_FREE(pca, "pdf_color_space");
return code;
}
pdf_reserve_object_id(pdev, pres, 0);
if (res_name != NULL) {
int l = min(name_length, sizeof(pres->rname) - 1);
memcpy(pres->rname, res_name, l);
pres->rname[l] = 0;
}
ppcs = (pdf_color_space_t *)pres;
if (serialized == serialized0) {
serialized = gs_alloc_bytes(pdev->pdf_memory, serialized_size, "pdf_color_space");
if (serialized == NULL)
return_error(gs_error_VMerror);
memcpy(serialized, serialized0, serialized_size);
}
ppcs->serialized = serialized;
ppcs->serialized_size = serialized_size;
if (ranges) {
int num_comp = gs_color_space_num_components(pcs);
gs_range_t *copy_ranges = (gs_range_t *)
gs_alloc_byte_array(pdev->pdf_memory, num_comp,
sizeof(gs_range_t), "pdf_color_space");
if (copy_ranges == 0) {
COS_FREE(pca, "pdf_color_space");
return_error(gs_error_VMerror);
}
memcpy(copy_ranges, ranges, num_comp * sizeof(gs_range_t));
ppcs->ranges = copy_ranges;
if (ppranges)
*ppranges = copy_ranges;
} else
ppcs->ranges = 0;
pca->id = pres->object->id;
COS_FREE(pres->object, "pdf_color_space");
pres->object = (cos_object_t *)pca;
cos_write_object(COS_OBJECT(pca), pdev, resourceColorSpace);
}
ret:
if (by_name) {
/* Return a resource name rather than an object reference. */
discard(COS_RESOURCE_VALUE(pvalue, pca));
} else
discard(COS_OBJECT_VALUE(pvalue, pca));
if (pres != NULL) {
pres->where_used |= pdev->used_mask;
code = pdf_add_resource(pdev, pdev->substream_Resources, "/ColorSpace", pres);
if (code < 0)
return code;
}
return 0;
}
/*
* Create an Indexed color space. This is a single-use procedure,
* broken out only for readability.
*/
static int
pdf_indexed_color_space(gx_device_pdf *pdev, cos_value_t *pvalue,
const gs_color_space *pcs, cos_array_t *pca)
{
const gs_indexed_params *pip = &pcs->params.indexed;
const gs_color_space *base_space = pcs->base_space;
int num_entries = pip->hival + 1;
int num_components = gs_color_space_num_components(base_space);
uint table_size = num_entries * num_components;
/* Guess at the extra space needed for PS string encoding. */
uint string_size = 2 + table_size * 4;
uint string_used;
byte buf[100]; /* arbitrary */
stream_AXE_state st;
stream s, es;
gs_memory_t *mem = pdev->pdf_memory;
byte *table;
byte *palette;
cos_value_t v;
int code;
/* PDF doesn't support Indexed color spaces with more than 256 entries. */
if (num_entries > 256)
return_error(gs_error_rangecheck);
if (pdev->CompatibilityLevel < 1.3 && !pdev->ForOPDFRead) {
switch (gs_color_space_get_index(pcs)) {
case gs_color_space_index_Pattern:
case gs_color_space_index_Separation:
case gs_color_space_index_Indexed:
case gs_color_space_index_DeviceN:
return_error(gs_error_rangecheck);
default:
DO_NOTHING;
}
}
table = gs_alloc_string(mem, string_size, "pdf_color_space(table)");
palette = gs_alloc_string(mem, table_size, "pdf_color_space(palette)");
if (table == 0 || palette == 0) {
gs_free_string(mem, palette, table_size,
"pdf_color_space(palette)");
gs_free_string(mem, table, string_size,
"pdf_color_space(table)");
return_error(gs_error_VMerror);
}
s_init(&s, mem);
swrite_string(&s, table, string_size);
s_init(&es, mem);
s_init_state((stream_state *)&st, &s_PSSE_template, NULL);
s_init_filter(&es, (stream_state *)&st, buf, sizeof(buf), &s);
sputc(&s, '(');
if (pcs->params.indexed.use_proc) {
gs_client_color cmin, cmax;
byte *pnext = palette;
int i, j;
/* Find the legal range for the color components. */
for (j = 0; j < num_components; ++j)
cmin.paint.values[j] = (float)min_long,
cmax.paint.values[j] = (float)max_long;
gs_color_space_restrict_color(&cmin, base_space);
gs_color_space_restrict_color(&cmax, base_space);
/*
* Compute the palette values, with the legal range for each
* one mapped to [0 .. 255].
*/
for (i = 0; i < num_entries; ++i) {
gs_client_color cc;
gs_cspace_indexed_lookup(pcs, i, &cc);
for (j = 0; j < num_components; ++j) {
float v = (cc.paint.values[j] - cmin.paint.values[j])
* 255 / (cmax.paint.values[j] - cmin.paint.values[j]);
*pnext++ = (v <= 0 ? 0 : v >= 255 ? 255 : (byte)v);
}
}
} else
memcpy(palette, pip->lookup.table.data, table_size);
if (gs_color_space_get_index(base_space) ==
gs_color_space_index_DeviceRGB
) {
/* Check for an all-gray palette3. */
int i;
for (i = table_size; (i -= 3) >= 0; )
if (palette[i] != palette[i + 1] ||
palette[i] != palette[i + 2]
)
break;
if (i < 0) {
/* Change the color space to DeviceGray. */
for (i = 0; i < num_entries; ++i)
palette[i] = palette[i * 3];
table_size = num_entries;
base_space = gs_cspace_new_DeviceGray(mem);
}
}
stream_write(&es, palette, table_size);
gs_free_string(mem, palette, table_size, "pdf_color_space(palette)");
sclose(&es);
sflush(&s);
string_used = (uint)stell(&s);
table = gs_resize_string(mem, table, string_size, string_used,
"pdf_color_space(table)");
/*
* Since the array is always referenced by name as a resource
* rather than being written as a value, even for in-line images,
* always use the full name for the color space.
*
* We don't have to worry about the range of the base space:
* in PDF, unlike PostScript, the values from the lookup table are
* scaled automatically.
*/
if ((code = pdf_color_space_named(pdev, pvalue, NULL, base_space,
&pdf_color_space_names, false, NULL, 0)) < 0 ||
(code = cos_array_add(pca,
cos_c_string_value(&v,
pdf_color_space_names.Indexed
/*pcsn->Indexed*/))) < 0 ||
(code = cos_array_add(pca, pvalue)) < 0 ||
(code = cos_array_add_int(pca, pip->hival)) < 0 ||
(code = cos_array_add_no_copy(pca,
cos_string_value(&v, table,
string_used))) < 0
)
return code;
return 0;
}
/* Create a Separation or DeviceN color space (internal). */
static int
pdf_separation_color_space(gx_device_pdf *pdev,
cos_array_t *pca, const char *csname,
const cos_value_t *snames,
const gs_color_space *alt_space,
const gs_function_t *pfn,
const pdf_color_space_names_t *pcsn,
const cos_value_t *v_attributes)
{
cos_value_t v;
const gs_range_t *ranges;
int code, csi;
/* We need to think about the alternate space. If we are producing
* PDF/X or PDF/A we can't produce some device spaces, and the code in
* pdf_color_space_named always allows device spaces. We could alter
* that code, but by then we don't know its an Alternate space, and have
* lost the tin transform procedure. So instead we check here.
*/
csi = gs_color_space_get_index(alt_space);
/* Note that if csi is ICC, check to see if this was one of
the default substitutes that we introduced for DeviceGray,
DeviceRGB or DeviceCMYK. If it is, then just write
the default color. Depending upon the flavor of PDF,
or other options, we may want to actually have all
the colors defined by ICC profiles and not do the following
substituion of the Device space. */
if (csi == gs_color_space_index_ICC) {
csi = gsicc_get_default_type(alt_space->cmm_icc_profile_data);
}
if (csi == gs_color_space_index_DeviceRGB && (pdev->PDFX ||
(pdev->PDFA && (pdev->pcm_color_info_index == gs_color_space_index_DeviceCMYK)))) {
/* We have a DeviceRGB alternate, but are producing either PDF/X or
* PDF/A with a DeviceCMYK process color model. So we need to convert
* the alternate space into CMYK. We do this by evaluating the function
* at each end of the Separation space (0 and 1), convert the resulting
* RGB colours into CMYK and create a new function which linearly
* interpolates between these points.
*/
gs_function_t *new_pfn = 0;
float in[1] = {0.0f};
float out_low[4];
float out_high[4];
code = gs_function_evaluate(pfn, in, out_low);
if (code < 0)
return code;
pdf_SepRGB_ConvertToCMYK((float *)&out_low, (float *)&out_low);
in[0] = 1.0f;
code = gs_function_evaluate(pfn, in, out_high);
if (code < 0)
return code;
pdf_SepRGB_ConvertToCMYK((float *)&out_high, (float *)&out_high);
code = pdf_make_base_space_function(pdev, &new_pfn, 4, out_low, out_high);
if (code < 0)
return code;
if ((code = cos_array_add(pca, cos_c_string_value(&v, csname))) < 0 ||
(code = cos_array_add_no_copy(pca, snames)) < 0 ||
(code = (int)cos_c_string_value(&v, (const char *)pcsn->DeviceCMYK)) < 0 ||
(code = cos_array_add(pca, &v)) < 0 ||
(code = pdf_function_scaled(pdev, new_pfn, 0x00, &v)) < 0 ||
(code = cos_array_add(pca, &v)) < 0 ||
(v_attributes != NULL ? code = cos_array_add(pca, v_attributes) : 0) < 0
) {}
pdf_delete_base_space_function(pdev, new_pfn);
return code;
}
if (csi == gs_color_space_index_DeviceCMYK &&
(pdev->PDFA && (pdev->pcm_color_info_index == gs_color_space_index_DeviceRGB))) {
/* We have a DeviceCMYK alternate, but are producingPDF/A with a
* DeviceRGB process color model. See comment above re DviceRGB.
*/
gs_function_t *new_pfn = 0;
float in[1] = {0.0f};
float out_low[4];
float out_high[4];
code = gs_function_evaluate(pfn, in, out_low);
if (code < 0)
return code;
pdf_SepCMYK_ConvertToRGB((float *)&out_low, (float *)&out_low);
in[0] = 1.0f;
code = gs_function_evaluate(pfn, in, out_high);
if (code < 0)
return code;
pdf_SepCMYK_ConvertToRGB((float *)&out_high, (float *)&out_high);
code = pdf_make_base_space_function(pdev, &new_pfn, 3, out_low, out_high);
if (code < 0)
return code;
if ((code = cos_array_add(pca, cos_c_string_value(&v, csname))) < 0 ||
(code = cos_array_add_no_copy(pca, snames)) < 0 ||
(code = (int)cos_c_string_value(&v, pcsn->DeviceRGB)) < 0 ||
(code = cos_array_add(pca, &v)) < 0 ||
(code = pdf_function_scaled(pdev, new_pfn, 0x00, &v)) < 0 ||
(code = cos_array_add(pca, &v)) < 0 ||
(v_attributes != NULL ? code = cos_array_add(pca, v_attributes) : 0) < 0
) {}
pdf_delete_base_space_function(pdev, new_pfn);
return code;
}
if ((code = cos_array_add(pca, cos_c_string_value(&v, csname))) < 0 ||
(code = cos_array_add_no_copy(pca, snames)) < 0 ||
(code = pdf_color_space_named(pdev, &v, &ranges, alt_space, pcsn, false, NULL, 0)) < 0 ||
(code = cos_array_add(pca, &v)) < 0 ||
(code = pdf_function_scaled(pdev, pfn, ranges, &v)) < 0 ||
(code = cos_array_add(pca, &v)) < 0 ||
(v_attributes != NULL ? code = cos_array_add(pca, v_attributes) : 0) < 0
)
return code;
return 0;
}
