/* Finalize contents of a DeviceN color space. */
static void
gx_final_DeviceN(const gs_color_space * pcs)
{
gs_device_n_attributes * pnextatt, * patt = pcs->params.device_n.colorants;
rc_decrement_only(pcs->params.device_n.map, "gx_adjust_DeviceN");
while (patt != NULL) {
pnextatt = patt->next;
rc_decrement(patt->cspace, "gx_final_DeviceN");
rc_decrement(patt, "gx_adjust_DeviceN");
patt = pnextatt;
}
}
/* Close the output file and stream. */
int
gdev_vector_close_file(gx_device_vector * vdev)
{
FILE *f = vdev->file;
int err;
if (vdev->dash_pattern) {
gs_free_object(vdev->memory->stable_memory, vdev->dash_pattern, "vector free dash pattern");
vdev->dash_pattern = 0;
}
if (vdev->bbox_device) {
rc_decrement(vdev->bbox_device->icc_struct, "vector_close(bbox_device->icc_struct");
vdev->bbox_device->icc_struct = NULL;
gs_free_object(vdev->v_memory, vdev->bbox_device,
"vector_close(bbox_device)");
vdev->bbox_device = 0;
}
if (vdev->strm) {
sclose(vdev->strm);
gs_free_object(vdev->v_memory, vdev->strm, "vector_close(strm)");
vdev->strm = 0;
gs_free_object(vdev->v_memory, vdev->strmbuf, "vector_close(strmbuf)");
vdev->strmbuf = 0;
}
vdev->file = 0;
if (f) {
err = ferror(f);
/* We prevented sclose from closing the file. */
if (gx_device_close_output_file((gx_device *)vdev, vdev->fname, f) != 0
|| err != 0)
return_error(gs_error_ioerror);
}
return 0;
}
/*
* Free a path by releasing its segments if they have no more references.
* This also frees the path object iff it was allocated by gx_path_alloc.
*/
void
gx_path_free(gx_path * ppath, client_name_t cname)
{
rc_decrement(ppath->segments, cname);
/* Clean up pointers for GC. */
ppath->box_last = 0;
ppath->segments = 0; /* Nota bene */
if (ppath->allocation == path_allocated_on_heap)
gs_free_object(ppath->memory, ppath, cname);
}
static int
gx_output_saved_page(gx_device_printer *pdev, gx_saved_page *page)
{
int code;
/* Note that banding_type is NOT a device parameter handled in the paramlist */
gdev_banding_type save_banding_type = pdev->space_params.banding_type;
gx_device_clist_reader *crdev = (gx_device_clist_reader *)pdev;
pdev->space_params.banding_type = BandingAlways;
if ((code = gx_saved_page_load(pdev, page)) < 0)
goto out;
/* don't want the band files touched after printing */
crdev->do_not_open_or_close_bandfiles = true;
/* load the color_usage_array */
if ((code = clist_read_color_usage_array(crdev)) < 0)
goto out;
if ((code = clist_read_icctable(crdev)) < 0)
goto out;
code = (crdev->icc_cache_cl = gsicc_cache_new(crdev->memory)) == NULL ?
gs_error_VMerror : code;
if (code < 0)
goto out;
/* After setting params, make sure bg_printing is off */
pdev->bg_print_requested = false;
/* Note: we never flush pages allowing for re-printing from the list */
/* data (files) will be deleted when the list is flushed or freed. */
code = (*dev_proc(pdev, output_page)) ((gx_device *) pdev,
(pdev->IgnoreNumCopies || pdev->NumCopies_set <= 0) ? 1 : pdev->NumCopies, false);
clist_free_icc_table(crdev->icc_table, crdev->memory);
crdev->icc_table = NULL;
rc_decrement(crdev->icc_cache_cl,"clist_finish_page");
crdev->icc_cache_cl = NULL;
/* Close the clist files */
code = crdev->page_info.io_procs->fclose(crdev->page_info.cfile, crdev->page_info.cfname, false);
if (code >= 0) {
crdev->page_info.cfile = NULL;
code = crdev->page_info.io_procs->fclose(crdev->page_info.bfile, crdev->page_info.bfname, false);
}
if (code < 0)
goto out;
crdev->page_info.bfile = NULL;
out:
pdev->space_params.banding_type = save_banding_type;
return code;
}
/* set the srgb color space */
static int
pl_setSRGB(gs_state *pgs)
{
gs_color_space *pcs;
int code;
code = pl_cspace_init_SRGB(&pcs, pgs);
if ( code < 0 )
return code;
code = gs_setcolorspace(pgs, pcs);
rc_decrement(pcs, "ps_setSRGB");
return code;
}
/* This is also exported for teardown after background printing */
void
teardown_device_and_mem_for_thread(gx_device *dev, gp_thread_id thread_id, bool bg_print)
{
gx_device_clist_common *thread_cdev = (gx_device_clist_common *)dev;
gx_device_clist_reader *thread_crdev = (gx_device_clist_reader *)dev;
gs_memory_t *thread_memory = dev->memory;
/* First finish the thread */
gp_thread_finish(thread_id);
if (bg_print) {
/* we are cleaning up a background printing thread, so we clean up similarly to */
/* what is done by clist_finish_page, but without re-opening the clist files. */
clist_teardown_render_threads(dev); /* we may have used multiple threads */
/* free the thread's icc_table since this was not done by clist_finish_page */
clist_free_icc_table(thread_crdev->icc_table, thread_memory);
thread_crdev->icc_table = NULL;
/* NB: gdev_prn_free_memory below will free the color_usage_array */
} else {
/* make sure this doesn't get freed by gdev_prn_free_memory below */
((gx_device_clist_reader *)thread_cdev)->color_usage_array = NULL;
}
rc_decrement(thread_crdev->icc_cache_cl, "teardown_render_thread");
thread_crdev->icc_cache_cl = NULL;
/*
* Free the BufferSpace, close the band files, optionally unlinking them.
* We unlink the files if this call is cleaning up from bg printing.
* Note that the BufferSpace is freed using 'ppdev->buf' so the 'data'
* pointer doesn't need to be the one that the thread started with
*/
/* If this thread was being used for background printing and NumRenderingThreads > 0 */
/* the clist_setup_render_threads may have already closed these files */
if (thread_cdev->page_info.cfile != NULL)
thread_cdev->page_info.io_procs->fclose(thread_cdev->page_info.bfile, thread_cdev->page_info.bfname, bg_print);
if (thread_cdev->page_info.bfile != NULL)
thread_cdev->page_info.io_procs->fclose(thread_cdev->page_info.cfile, thread_cdev->page_info.cfname, bg_print);
thread_cdev->do_not_open_or_close_bandfiles = true; /* we already closed the files */
gdev_prn_free_memory((gx_device *)thread_cdev);
/* Free the device copy this thread used. Note that the
deviceN stuff if was allocated and copied earlier for the device
will be freed with this call and the icc_struct ref count will be decremented. */
gs_free_object(thread_memory, thread_cdev, "clist_teardown_render_threads");
#ifdef DEBUG
dmprintf(thread_memory, "rendering thread ending memory state...\n");
gs_memory_chunk_dump_memory(thread_memory);
dmprintf(thread_memory, " memory dump done.\n");
#endif
gs_memory_chunk_release(thread_memory);
}
/*
* Assign one path to another, adjusting reference counts appropriately.
* Note that this requires that segments of the two paths (but not the path
* objects themselves) were allocated with the same allocator. Note also
* that since it does the equivalent of a gx_path_new(ppto), it may allocate
* a new segments object for ppto.
*/
int
gx_path_assign_preserve(gx_path * ppto, gx_path * ppfrom)
{
gx_path_segments *fromsegs = ppfrom->segments;
gx_path_segments *tosegs = ppto->segments;
gs_memory_t *mem = ppto->memory;
gx_path_allocation_t allocation = ppto->allocation;
if (fromsegs == &ppfrom->local_segments) {
/* We can't use ppfrom's segments object. */
if (tosegs == &ppto->local_segments || gx_path_is_shared(ppto)) {
/* We can't use ppto's segments either. Allocate a new one. */
int code = path_alloc_segments(&tosegs, ppto->memory,
"gx_path_assign");
if (code < 0)
return code;
rc_decrement(ppto->segments, "gx_path_assign");
} else {
/* Use ppto's segments object. */
rc_free_path_segments_local(tosegs->rc.memory, tosegs,
"gx_path_assign");
}
tosegs->contents = fromsegs->contents;
ppfrom->segments = tosegs;
rc_increment(tosegs); /* for reference from ppfrom */
} else {
/* We can use ppfrom's segments object. */
rc_increment(fromsegs);
rc_decrement(tosegs, "gx_path_assign");
}
*ppto = *ppfrom;
ppto->memory = mem;
ppto->allocation = allocation;
return 0;
}
/*
* Finalization for devices: do any special finalization first, then
* close the device if it is open, and finally free the structure
* descriptor if it is dynamic.
*/
void
gx_device_finalize(const gs_memory_t *cmem, void *vptr)
{
gx_device * const dev = (gx_device *)vptr;
(void)cmem; /* unused */
if (dev->icc_struct != NULL) {
rc_decrement(dev->icc_struct, "gx_device_finalize(icc_profile)");
}
if (dev->finalize)
dev->finalize(dev);
discard(gs_closedevice(dev));
if (dev->stype_is_dynamic)
gs_free_const_object(dev->memory->non_gc_memory, dev->stype,
"gx_device_finalize");
}
/* 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;
}
/*
* Reconstruct a transfer function from its serial representation. The
* buffer provided is expected to be large enough to hold the entire
* transfer function.
*
* Returns the number of bytes read, or < 0 in the event of an error.
*/
static int
gx_ht_read_tf(
gx_transfer_map ** ppmap,
const byte * data,
uint size,
gs_memory_t * mem )
{
gx_ht_tf_type_t tf_type;
gx_transfer_map * pmap;
/* read the type byte */
if (size == 0)
return_error(gs_error_rangecheck);
--size;
tf_type = (gx_ht_tf_type_t)*data++;
/* if no transfer function, exit now */
if (tf_type == gx_ht_tf_none) {
*ppmap = 0;
return 1;
}
/* allocate a transfer map */
rc_alloc_struct_1( pmap,
gx_transfer_map,
&st_transfer_map,
mem,
return_error(gs_error_VMerror),
"gx_ht_read_tf" );
pmap->id = gs_next_ids(mem, 1);
pmap->closure.proc = 0;
pmap->closure.data = 0;
if (tf_type == gx_ht_tf_identity) {
gx_set_identity_transfer(pmap);
return 1;
} else if (tf_type == gx_ht_tf_complete && size >= sizeof(pmap->values)) {
memcpy(pmap->values, data, sizeof(pmap->values));
pmap->proc = gs_mapped_transfer;
*ppmap = pmap;
return 1 + sizeof(pmap->values);
} else {
rc_decrement(pmap, "gx_ht_read_tf");
return_error(gs_error_rangecheck);
}
}
void
gx_san__release(gx_device_spot_analyzer **ppadev)
{
gx_device_spot_analyzer *padev = *ppadev;
if (padev == NULL) {
eprintf("Extra call to gx_san__release.");
return;
}
if(--padev->lock < 0) {
eprintf("Wrong lock to gx_san__release.");
return;
}
if (padev->lock == 0) {
*ppadev = NULL;
rc_decrement(padev, "gx_san__release");
}
}
/* Make a new path (newpath). */
int
gx_path_new(gx_path * ppath)
{
gx_path_segments *psegs = ppath->segments;
if (gx_path_is_shared(ppath)) {
int code = path_alloc_segments(&ppath->segments, ppath->memory,
"gx_path_new");
if (code < 0)
return code;
rc_decrement(psegs, "gx_path_new");
} else {
rc_free_path_segments_local(psegs->rc.memory, psegs, "gx_path_new");
}
gx_path_init_contents(ppath);
return 0;
}
int
gs_begin_transparency_mask(gs_state * pgs,
const gs_transparency_mask_params_t * ptmp,
const gs_rect * pbbox, bool mask_is_image)
{
gs_pdf14trans_params_t params = { 0 };
gs_pdf14trans_params_t params_color = { 0 };
const int l = sizeof(params.Background[0]) * ptmp->Background_components;
int i, code;
gs_color_space *blend_color_space;
gsicc_manager_t *icc_manager = pgs->icc_manager;
if (check_for_nontrans_pattern(pgs,
(unsigned char *)"gs_pop_transparency_state")) {
return(0);
}
params.pdf14_op = PDF14_BEGIN_TRANS_MASK;
params.bbox = *pbbox;
params.subtype = ptmp->subtype;
params.Background_components = ptmp->Background_components;
memcpy(params.Background, ptmp->Background, l);
params.GrayBackground = ptmp->GrayBackground;
params.transfer_function = ptmp->TransferFunction_data;
params.function_is_identity =
(ptmp->TransferFunction == mask_transfer_identity);
params.mask_is_image = mask_is_image;
params.replacing = ptmp->replacing;
/* The eventual state that we want this smask to be moved to
is always gray. This should provide us with a significant
speed improvement over the old code. This does not keep us
from having groups within the softmask getting blended in different
color spaces, it just makes the final space be gray, which is what
we will need to get to eventually anyway. In this way we avoid a
final color conversion on a potentially large buffer. */
/* Also check if we have loaded in the transparency icc profiles. If not
go ahead and take care of that now */
if (icc_manager->smask_profiles == NULL) {
code = gsicc_initialize_iccsmask(icc_manager);
if (code < 0)
return(code);
}
/* A new soft mask group, make sure the profiles are set */
if_debug0m('v', pgs->memory, "[v]pushing soft mask color sending\n");
if (params.subtype != TRANSPARENCY_MASK_None) {
params_color.pdf14_op = PDF14_PUSH_SMASK_COLOR;
code = gs_state_update_pdf14trans(pgs, ¶ms_color);
if (code < 0)
return(code);
blend_color_space = gs_cspace_new_DeviceGray(pgs->memory);
blend_color_space->cmm_icc_profile_data = pgs->icc_manager->default_gray;
rc_increment(blend_color_space->cmm_icc_profile_data);
if_debug8m('v', pgs->memory, "[v](0x%lx)gs_begin_transparency_mask [%g %g %g %g]\n\
subtype = %d Background_components = %d %s\n",
(ulong)pgs, pbbox->p.x, pbbox->p.y, pbbox->q.x, pbbox->q.y,
(int)ptmp->subtype, ptmp->Background_components,
(ptmp->TransferFunction == mask_transfer_identity ? "no TR" :
"has TR"));
/* Sample the transfer function */
for (i = 0; i < MASK_TRANSFER_FUNCTION_SIZE; i++) {
float in = (float)(i * (1.0 / (MASK_TRANSFER_FUNCTION_SIZE - 1)));
float out;
ptmp->TransferFunction(in, &out, ptmp->TransferFunction_data);
params.transfer_fn[i] = (byte)floor((double)(out * 255 + 0.5));
}
/* Note: This function is called during the c-list writer side. */
if ( blend_color_space->cmm_icc_profile_data != NULL ) {
/* Blending space is ICC based. If we are doing c-list rendering we will
need to write this color space into the clist. */
params.group_color = ICC;
params.group_color_numcomps =
blend_color_space->cmm_icc_profile_data->num_comps;
/* Get the ICC profile */
/* We don't reference count this - see comment in
* pdf14_update_device_color_procs_pop_c()
*/
params.iccprofile = blend_color_space->cmm_icc_profile_data;
params.icc_hash = blend_color_space->cmm_icc_profile_data->hashcode;
} else {
params.group_color = GRAY_SCALE;
params.group_color_numcomps = 1; /* Need to check */
}
/* Explicitly decrement the profile data since blend_color_space may not
* be an ICC color space object.
*/
rc_decrement(blend_color_space->cmm_icc_profile_data, "gs_begin_transparency_mask");
rc_decrement_only_cs(blend_color_space, "gs_begin_transparency_mask");
}
/*
* Implement get_params for a sample device CRD. A useful convention,
* for devices that can provide more than one CRD, is to have a settable
* parameter CRDName, which gives the name of the CRD in use. This sample
* code provides a constant CRDName: making it settable is left as an
* exercise to the reader.
*/
int
sample_device_crd_get_params(gx_device *pdev, gs_param_list *plist,
const char *crd_param_name)
{
int ecode = 0;
if (param_requested(plist, "CRDName") > 0) {
gs_param_string cns;
int code;
cns.data = (const byte *)crd_param_name;
cns.size = strlen(crd_param_name);
cns.persistent = true;
code = param_write_string(plist, "CRDName", &cns);
if (code < 0)
ecode = code;
}
if (param_requested(plist, crd_param_name) > 0) {
gs_cie_render *pcrd;
int code = gs_cie_render1_build(&pcrd, pdev->memory,
"sample_device_crd_get_params");
if (code >= 0) {
gs_cie_transform_proc3 tpqr;
tpqr = bit_TransformPQR;
tpqr.driver_name = pdev->dname;
code = gs_cie_render1_initialize(pdev->memory, pcrd, NULL,
&bit_WhitePoint, NULL /*BlackPoint*/,
NULL /*MatrixPQR*/, &bit_RangePQR, &tpqr,
NULL /*MatrixLMN*/, &bit_EncodeLMN, &bit_RangeLMN,
&bit_MatrixABC, &bit_EncodeABC, NULL /*RangeABC*/,
&bit_RenderTable);
if (code >= 0) {
code = param_write_cie_render1(plist, crd_param_name, pcrd,
pdev->memory);
}
rc_decrement(pcrd, "sample_device_crd_get_params"); /* release */
}
if (code < 0)
ecode = code;
}
if (param_requested(plist, bit_TransformPQR.proc_name) > 0) {
/*
* We definitely do not recommend the following use of a static
* to hold the address: this is a shortcut.
*/
gs_cie_transform_proc my_proc = bit_TransformPQR_proc;
byte *my_addr = gs_alloc_string(pdev->memory, sizeof(my_proc),
"sd_crd_get_params(proc)");
int code;
if (my_addr == 0)
code = gs_note_error(gs_error_VMerror);
else {
gs_param_string as;
memcpy(my_addr, &my_proc, sizeof(my_proc));
as.data = my_addr;
as.size = sizeof(my_proc);
as.persistent = true;
code = param_write_string(plist, bit_TransformPQR.proc_name, &as);
}
if (code < 0)
ecode = code;
}
return ecode;
}
/* 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));
}
/*
* <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;
}
/* The current color space is the alternate space for the DeviceN space. */
static int
zsetdevicenspace(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
const ref *pcsa;
gs_separation_name *names;
gs_device_n_map *pmap;
uint num_components;
gs_color_space *pcs;
gs_color_space *pacs;
ref_colorspace cspace_old;
gs_function_t *pfn;
int code;
/* Verify that we have an array as our input parameter */
check_read_type(*op, t_array);
if (r_size(op) < 4 || r_size(op) > 5)
return_error(e_rangecheck);
/* pcsa is a pointer to the color names array (element 1 in input array) */
pcsa = op->value.const_refs + 1;
if (!r_is_array(pcsa))
return_error(e_typecheck);
num_components = r_size(pcsa);
if (num_components == 0)
return_error(e_rangecheck);
if (num_components > GS_CLIENT_COLOR_MAX_COMPONENTS)
return_error(e_limitcheck);
/* Check tint transform procedure. Note: Cheap trick to get pointer to it.
The tint transform procedure is element 3 in the input array */
check_proc(pcsa[2]);
/* The alternate color space has been selected as the current color space */
pacs = gs_currentcolorspace(igs);
code = gs_cspace_new_DeviceN(&pcs, num_components, pacs, imemory);
if (code < 0)
return code;
names = pcs->params.device_n.names;
pmap = pcs->params.device_n.map;
pcs->params.device_n.get_colorname_string = gs_get_colorname_string;
/* Pick up the names of the components */
{
uint i;
ref sname;
for (i = 0; i < num_components; ++i) {
array_get(imemory, pcsa, (long)i, &sname);
switch (r_type(&sname)) {
case t_string:
code = name_from_string(imemory, &sname, &sname);
if (code < 0) {
rc_decrement(pcs, ".setdevicenspace");
return code;
}
/* falls through */
case t_name:
names[i] = name_index(imemory, &sname);
break;
default:
rc_decrement(pcs, ".setdevicenspace");
return_error(e_typecheck);
}
}
}
/* Now set the current color space as DeviceN */
cspace_old = istate->colorspace;
/*
* pcsa is a pointer to element 1 (2nd element) in the DeviceN
* description array. Thus pcsa[2] is element #3 (4th element)
* which is the tint transform.
*/
istate->colorspace.procs.special.device_n.layer_names = pcsa[0];
istate->colorspace.procs.special.device_n.tint_transform = pcsa[2];
pfn = ref_function(pcsa + 2); /* See comment above */
if (!pfn)
code = gs_note_error(e_rangecheck);
if (code < 0) {
istate->colorspace = cspace_old;
rc_decrement_only(pcs, "zsetdevicenspace");
return code;
}
gs_cspace_set_devn_function(pcs, pfn);
code = gs_setcolorspace(igs, pcs);
/* release reference from construction */
rc_decrement_only(pcs, "zsetdevicenspace");
if (code < 0) {
istate->colorspace = cspace_old;
return code;
}
pop(1);
return 0;
}
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;
}
/* Set up the color space information for a bitmap image or pattern. */
int
px_image_color_space(gs_image_t *pim,
const px_bitmap_params_t *params, const gs_string *palette,
const gs_state *pgs)
{
int depth = params->depth;
gs_color_space *pbase_pcs = NULL;
gs_color_space *pcs = NULL;
bool cie_space = false;
int code = 0;
switch ( params->color_space ) {
case eGray:
pbase_pcs = gs_cspace_new_DeviceGray(pgs->memory);
pbase_pcs->cmm_icc_profile_data = pgs->icc_manager->default_gray;
pbase_pcs->type = &gs_color_space_type_ICC;
rc_increment(pbase_pcs->cmm_icc_profile_data);
break;
case eRGB:
pbase_pcs = gs_cspace_new_DeviceRGB(pgs->memory);
pbase_pcs->cmm_icc_profile_data = pgs->icc_manager->default_rgb;
pbase_pcs->type = &gs_color_space_type_ICC;
rc_increment(pbase_pcs->cmm_icc_profile_data);
break;
case eSRGB:
case eCRGB:
if ( pl_cspace_init_SRGB(&pbase_pcs, pgs) < 0 )
/* should not happen */
return_error(errorInsufficientMemory);
cie_space = true;
pbase_pcs->cmm_icc_profile_data = pgs->icc_manager->default_rgb;
pbase_pcs->type = &gs_color_space_type_ICC;
rc_increment(pbase_pcs->cmm_icc_profile_data);
break;
default:
return_error(errorIllegalAttributeValue);
}
if (pbase_pcs == NULL)
return_error(errorInsufficientMemory);
if ( params->indexed ) {
pcs = gs_cspace_alloc(pgs->memory, &gs_color_space_type_Indexed);
if ( pcs == NULL ) {
/* free the base space also */
rc_decrement(pbase_pcs, "px_image_color_space");
return_error(errorInsufficientMemory);
}
pcs->base_space = pbase_pcs;
pcs->params.indexed.hival = (1 << depth) - 1;
pcs->params.indexed.lookup.table.size = palette->size;
{
uint n = palette->size;
byte *p = gs_alloc_string(pgs->memory, n,
"px_image_color_space(palette)");
if ( p == 0 ) {
rc_decrement(pbase_pcs, "px_image_color_space");
return_error(errorInsufficientMemory);
}
memcpy(p, palette->data, n);
pcs->params.indexed.lookup.table.data = p;
}
pcs->params.indexed.use_proc = 0;
} else {
pcs = pbase_pcs;
}
gs_image_t_init(pim, pcs);
pim->ColorSpace = pcs;
pim->BitsPerComponent = depth;
if ( params->indexed )
pim->Decode[1] = (1 << depth) - 1;
/* NB - this needs investigation */
if (cie_space && !px_is_currentcolor_pattern(pgs)) {
code = pl_setSRGBcolor((gs_state *)pgs, 0.0, 0.0, 0.0);
}
return code;
}
