int
gx_begin_transparency_group(gs_imager_state * pis, gx_device * pdev,
const gs_pdf14trans_params_t * pparams)
{
gs_transparency_group_params_t tgp = {0};
gs_rect bbox;
if (pparams->Background_components != 0 &&
pparams->Background_components != pdev->color_info.num_components)
return_error(gs_error_rangecheck);
tgp.Isolated = pparams->Isolated;
tgp.Knockout = pparams->Knockout;
tgp.idle = pparams->idle;
tgp.mask_id = pparams->mask_id;
/* Needed so that we do proper blending */
tgp.group_color = pparams->group_color;
tgp.group_color_numcomps = pparams->group_color_numcomps;
tgp.iccprofile = pparams->iccprofile;
tgp.icc_hashcode = pparams->icc_hash;
pis->opacity.alpha = pparams->opacity.alpha;
pis->shape.alpha = pparams->shape.alpha;
pis->blend_mode = pparams->blend_mode;
bbox = pparams->bbox;
#ifdef DEBUG
if (gs_debug_c('v')) {
static const char *const cs_names[] = {
GS_COLOR_SPACE_TYPE_NAMES
};
dmlprintf6(pdev->memory, "[v](0x%lx)gx_begin_transparency_group [%g %g %g %g] Num_grp_clr_comp = %d\n",
(ulong)pis, bbox.p.x, bbox.p.y, bbox.q.x, bbox.q.y,
pparams->group_color_numcomps);
if (tgp.ColorSpace)
dmprintf1(pdev->memory, " CS = %s",
cs_names[(int)gs_color_space_get_index(tgp.ColorSpace)]);
else
dmputs(pdev->memory, " (no CS)");
dmprintf2(pdev->memory, " Isolated = %d Knockout = %d\n",
tgp.Isolated, tgp.Knockout);
if (tgp.iccprofile)
dmprintf(pdev->memory, " Have ICC Profile for blending\n");
}
#endif
if (dev_proc(pdev, begin_transparency_group) != 0)
return (*dev_proc(pdev, begin_transparency_group)) (pdev, &tgp, &bbox, pis,
NULL);
else
return 0;
}
/* set variables other than setting the page device that do not
default to pcl reset values */
void
pxPassthrough_pcl_state_nonpage_exceptions(px_state_t * pxs)
{
/* xl cursor -> pcl cursor position */
gs_point xlcp, pclcp, dp;
/* make the pcl ctm active, after resets the hpgl/2 ctm is
active. */
pcl_set_graphics_state(global_pcs);
/* xl current point -> device point -> pcl current
point. If anything fails we assume the current
point is not valid and use the cap from the pcl
state initialization - pcl's origin */
if (gs_currentpoint(pxs->pgs, &xlcp) ||
gs_transform(pxs->pgs, xlcp.x, xlcp.y, &dp) ||
gs_itransform(global_pcs->pgs, dp.x, dp.y, &pclcp)) {
global_pcs->cap.x = 0;
global_pcs->cap.y = inch2coord(2.0 / 6.0); /* 1/6" off by 2x in resolution. */
if (gs_debug_c('i'))
dmprintf2(pxs->memory,
"passthrough: changing cap NO currentpoint (%d, %d) \n",
global_pcs->cap.x, global_pcs->cap.y);
} else {
if (gs_debug_c('i'))
dmprintf8(pxs->memory,
"passthrough: changing cap from (%d,%d) (%d,%d) (%d, %d) (%d, %d) \n",
global_pcs->cap.x, global_pcs->cap.y, (coord) xlcp.x,
(coord) xlcp.y, (coord) dp.x, (coord) dp.y,
(coord) pclcp.x, (coord) pclcp.y);
global_pcs->cap.x = (coord) pclcp.x;
global_pcs->cap.y = (coord) pclcp.y;
}
if (global_pcs->underline_enabled)
global_pcs->underline_start = global_pcs->cap;
global_char_angle = pxs->pxgs->char_angle;
global_char_shear.x = pxs->pxgs->char_shear.x;
global_char_shear.y = pxs->pxgs->char_shear.y;
global_char_scale.x = pxs->pxgs->char_scale.x;
global_char_scale.y = pxs->pxgs->char_scale.y;
global_char_bold_value = pxs->pxgs->char_bold_value;
}
static void
pxPassthrough_setpagestate(px_state_t * pxs)
{
/* by definition we are in "snippet mode" if pxl has dirtied
the page */
if (pxs->have_page) {
if (gs_debug_c('i'))
dmprintf(pxs->memory, "passthrough: snippet mode\n");
/* disable an end page in pcl, also used to flag in snippet mode */
global_pcs->end_page = pcl_end_page_noop;
/* set the page size and orientation. Really just sets
the page tranformation does not feed a page (see noop
above) */
pcl_new_logical_page_for_passthrough(global_pcs,
(int)pxs->orientation,
&pxs->media_dims);
if (gs_debug_c('i'))
dmprintf2(pxs->memory,
"passthrough: snippet mode changing orientation from %d to %d\n",
global_pcs->xfm_state.lp_orient, (int)pxs->orientation);
} else { /* not snippet mode - full page mode */
/* pcl can feed the page and presumedely pcl commands will
be used to set pcl's state. */
global_pcs->end_page = pcl_end_page_top;
/* clean the pcl page if it was marked by a previous snippet
and set to full page mode. */
global_pcs->page_marked = 0;
pcl_new_logical_page_for_passthrough(global_pcs,
(int)pxs->orientation,
&pxs->media_dims);
if (gs_debug_c('i'))
dmprintf(pxs->memory, "passthrough: full page mode\n");
}
}
int
gs_begin_transparency_group(gs_state *pgs,
const gs_transparency_group_params_t *ptgp,
const gs_rect *pbbox)
{
gs_pdf14trans_params_t params = { 0 };
const gs_color_space *blend_color_space;
gs_imager_state * pis = (gs_imager_state *)pgs;
cmm_profile_t *profile;
if (check_for_nontrans_pattern(pgs,
(unsigned char *)"gs_begin_transparency_group")) {
return(0);
}
/*
* Put parameters into a compositor parameter and then call the
* create_compositor. This will pass the data to the PDF 1.4
* transparency device.
*/
params.pdf14_op = PDF14_BEGIN_TRANS_GROUP;
params.Isolated = ptgp->Isolated;
params.Knockout = ptgp->Knockout;
params.image_with_SMask = ptgp->image_with_SMask;
params.opacity = pgs->opacity;
params.shape = pgs->shape;
params.blend_mode = pgs->blend_mode;
/* This function is called during the c-list writer side.
Store some information so that we know what the color space is
so that we can adjust according later during the clist reader.
We currently will use the concrete space for any space other than a
device space. However, if the device is a sep device it will blend
in DeviceN color space as required. */
blend_color_space = gs_currentcolorspace_inline(pgs);
if (gs_color_space_get_index(blend_color_space) > gs_color_space_index_DeviceCMYK) {
/* ICC and PS CIE based case. Note that unidirectional PS CIE color
spaces should not be allowed but end up occuring when processing
PDF files with -dUseCIEColor. We will end up using the appropriate
ICC default color space in these cases. */
blend_color_space = gs_currentcolorspace_inline(pgs);
} else {
blend_color_space = cs_concrete_space(blend_color_space, pis);
}
/* Note that if the /CS parameter was NOT present in the push
of the transparency group, then we must actually inherent
the previous group color space, or the color space of the
target device (process color model). Here we just want
to set it as a unknown type for clist writing, as we will take care
of using the parent group color space later during clist reading.
Also, if the group was not isolated we MUST use the parent group
color space regardless of what the group color space is specified to be
*/
if (ptgp->ColorSpace == NULL || params.Isolated != true) {
params.group_color = UNKNOWN;
params.group_color_numcomps = 0;
} else {
/* The /CS parameter was present. Use what was set. Currently
all our Device spaces are actually ICC based. The other options
are if -dUseCIEColor is set, in which case it could be
coming in as a PS CIE color space, which should not be allowed
but should default to one of the default ICC color spaces. Note
that CalRGB and CalGray, which are valid bidirectional color spaces
are converted to ICC profiles during installation. PS CIE building
to ICC is delayed. */
if ( gs_color_space_is_ICC(blend_color_space) ) {
/* 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 */
params.iccprofile = blend_color_space->cmm_icc_profile_data;
params.icc_hash = blend_color_space->cmm_icc_profile_data->hashcode;
} else {
/* Color space was NOT ICC based. PS CIE space and DeviceN are the only
other option. Use the ICC default based upon the component count. */
switch (cs_num_components(blend_color_space)) {
case 1:
profile = pgs->icc_manager->default_gray;
break;
case 3:
profile = pgs->icc_manager->default_rgb;
break;
case 4:
profile = pgs->icc_manager->default_cmyk;
break;
default:
/* We can end up here if we are in a deviceN color space and
we have a sep output device */
profile = NULL;
params.group_color = DEVICEN;
params.group_color_numcomps = cs_num_components(blend_color_space);
break;
}
if (profile != NULL) {
params.group_color = ICC;
params.group_color_numcomps = profile->num_comps;
params.iccprofile = profile;
params.icc_hash = profile->hashcode;
}
}
}
#ifdef DEBUG
if (gs_debug_c('v')) {
static const char *const cs_names[] = {
GS_COLOR_SPACE_TYPE_NAMES
};
dmlprintf6(pgs->memory, "[v](0x%lx)begin_transparency_group [%g %g %g %g] Num_grp_clr_comp = %d\n",
(ulong)pgs, pbbox->p.x, pbbox->p.y, pbbox->q.x, pbbox->q.y,params.group_color_numcomps);
if (ptgp->ColorSpace)
dmprintf1(pgs->memory, " CS = %s",
cs_names[(int)gs_color_space_get_index(ptgp->ColorSpace)]);
else
dmputs(pgs->memory, " (no CS)");
dmprintf2(pgs->memory, " Isolated = %d Knockout = %d\n",
ptgp->Isolated, ptgp->Knockout);
}
#endif
params.bbox = *pbbox;
return gs_state_update_pdf14trans(pgs, ¶ms);
}
void
clist_teardown_render_threads(gx_device *dev)
{
gx_device_clist *cldev = (gx_device_clist *)dev;
gx_device_clist_common *cdev = (gx_device_clist_common *)dev;
gx_device_clist_reader *crdev = &cldev->reader;
gs_memory_t *mem = cdev->bandlist_memory;
int i;
if (crdev->render_threads != NULL) {
/* Wait for each thread to finish then free its memory */
for (i = (crdev->num_render_threads - 1); i >= 0; i--) {
clist_render_thread_control_t *thread = &(crdev->render_threads[i]);
gx_device_clist_common *thread_cdev = (gx_device_clist_common *)thread->cdev;
if (thread->status == THREAD_BUSY)
gx_semaphore_wait(thread->sema_this);
/* Free control semaphores */
gx_semaphore_free(thread->sema_group);
gx_semaphore_free(thread->sema_this);
/* destroy the thread's buffer device */
thread_cdev->buf_procs.destroy_buf_device(thread->bdev);
if (thread->options) {
if (thread->options->free_buffer_fn && thread->buffer) {
thread->options->free_buffer_fn(thread->options->arg, dev, thread->memory, thread->buffer);
thread->buffer = NULL;
}
thread->options = NULL;
}
/* before freeing this device's memory, swap with cdev if it was the main_thread_data */
if (thread_cdev->data == crdev->main_thread_data) {
thread_cdev->data = cdev->data;
cdev->data = crdev->main_thread_data;
}
#ifdef DEBUG
if (gs_debug[':'])
dmprintf2(thread->memory, "%% Thread %d total usertime=%ld msec\n", i, thread->cputime);
dmprintf1(thread->memory, "\nThread %d ", i);
#endif
teardown_device_and_mem_for_thread((gx_device *)thread_cdev, thread->thread, false);
}
gs_free_object(mem, crdev->render_threads, "clist_teardown_render_threads");
crdev->render_threads = NULL;
/* Now re-open the clist temp files so we can write to them */
if (cdev->page_info.cfile == NULL) {
char fmode[4];
strcpy(fmode, "a+"); /* file already exists and we want to re-use it */
strncat(fmode, gp_fmode_binary_suffix, 1);
cdev->page_info.io_procs->fopen(cdev->page_info.cfname, fmode, &cdev->page_info.cfile,
mem, cdev->bandlist_memory, true);
cdev->page_info.io_procs->fseek(cdev->page_info.cfile, 0, SEEK_SET, cdev->page_info.cfname);
cdev->page_info.io_procs->fopen(cdev->page_info.bfname, fmode, &cdev->page_info.bfile,
mem, cdev->bandlist_memory, false);
cdev->page_info.io_procs->fseek(cdev->page_info.bfile, 0, SEEK_SET, cdev->page_info.bfname);
}
}
}
