ref *
dstack_find_name_by_index(dict_stack_t * pds, uint nidx)
{
ref *pvalue = real_dstack_find_name_by_index(pds, nidx);
dict *pdict = pds->stack.p->value.pdict;
INCR(lookups);
if (dict_is_packed(pdict)) {
uint hash =
dict_hash_mod(dict_name_index_hash(nidx), npairs(pdict)) + 1;
if (pdict->keys.value.packed[hash] ==
pt_tag(pt_literal_name) + nidx
)
INCR(probes[0]);
else if (pdict->keys.value.packed[hash - 1] ==
pt_tag(pt_literal_name) + nidx
)
INCR(probes[1]);
}
if (gs_debug_c('d') && !(stats_dstack.lookups % 1000))
dlprintf3("[d]lookups=%ld probe1=%ld probe2=%ld\n",
stats_dstack.lookups, stats_dstack.probes[0],
stats_dstack.probes[1]);
return pvalue;
}
int
dict_find(const ref * pdref, const ref * pkey, ref ** ppvalue)
{
dict *pdict = pdref->value.pdict;
int code = real_dict_find(pdref, pkey, ppvalue);
stats_dict.lookups++;
if (r_has_type(pkey, t_name) && dict_is_packed(pdict)) {
uint nidx = name_index(dict_mem(pdict), pkey);
uint hash =
dict_hash_mod(dict_name_index_hash(nidx), npairs(pdict)) + 1;
if (pdict->keys.value.packed[hash] ==
pt_tag(pt_literal_name) + nidx
)
stats_dict.probe1++;
else if (pdict->keys.value.packed[hash - 1] ==
pt_tag(pt_literal_name) + nidx
)
stats_dict.probe2++;
}
/* Do the cheap flag test before the expensive remainder test. */
if (gs_debug_c('d') && !(stats_dict.lookups % 1000))
dlprintf3("[d]lookups=%ld probe1=%ld probe2=%ld\n",
stats_dict.lookups, stats_dict.probe1, stats_dict.probe2);
return code;
}
ttfFont *ttfFont__create(gs_font_dir *dir)
{
gs_memory_t *mem = dir->memory->stable_memory;
ttfFont *ttf;
if (dir->ttm == NULL) {
gx_ttfMemory *m = gs_alloc_struct(mem, gx_ttfMemory, &st_gx_ttfMemory, "ttfFont__create(gx_ttfMemory)");
if (!m)
return 0;
m->super.alloc_struct = gx_ttfMemory__alloc_struct;
m->super.alloc_bytes = gx_ttfMemory__alloc_bytes;
m->super.free = gx_ttfMemory__free;
m->memory = mem;
dir->ttm = m;
}
if(ttfInterpreter__obtain(&dir->ttm->super, &dir->tti))
return 0;
if(gx_san__obtain(mem, &dir->san))
return 0;
ttf = gs_alloc_struct(mem, ttfFont, &st_ttfFont, "ttfFont__create");
if (ttf == NULL)
return 0;
#ifdef DEBUG
ttfFont__init(ttf, &dir->ttm->super, DebugRepaint,
(gs_debug_c('Y') ? DebugPrint : NULL), mem);
#else
ttfFont__init(ttf, &dir->ttm->super, DebugRepaint, NULL, mem);
#endif
return ttf;
}
/* Record next halftone sample */
int
gs_screen_next(gs_screen_enum * penum, floatp value)
{
if (penum->order.wse) {
return gs_wts_screen_enum_next (penum->order.wse, value);
} else {
ht_sample_t sample;
int width = penum->order.width;
gx_ht_bit *bits = (gx_ht_bit *)penum->order.bit_data;
if (value < -1.0 || value > 1.0)
return_error(gs_error_rangecheck);
sample = (ht_sample_t) ((value + 1) * max_ht_sample);
#ifdef DEBUG
if (gs_debug_c('H')) {
gs_point pt;
gs_screen_currentpoint(penum, &pt);
dlprintf6("[H]sample x=%d y=%d (%f,%f): %f -> %u\n",
penum->x, penum->y, pt.x, pt.y, value, sample);
}
#endif
bits[penum->y * width + penum->x].mask = sample;
if (++(penum->x) >= width)
penum->x = 0, ++(penum->y);
return 0;
}
}
/* retrieve the current pcl state and initialize pcl */
static int
pxPassthrough_init(px_state_t * pxs)
{
int code;
if (gs_debug_c('i'))
dmprintf(pxs->memory, "passthrough: initializing global pcl state\n");
global_pcs = pcl_get_gstate(pxs->pcls);
/* default to pcl5c */
global_pcs->personality = 0;
/* for now we do not support intepolation in XL passthrough mode. */
global_pcs->interpolate = false;
/* we don't see a nice way to support the following options with
passthrough at this time (NB) */
global_pcs->page_set_on_command_line = false;
global_pcs->res_set_on_command_line = false;
global_pcs->high_level_device = false;
{
char buf[100];
int ret;
stream_cursor_read r;
ret =
gs_sprintf(buf,
"@PJL SET PAPERLENGTH = %d\n@PJL SET PAPERWIDTH = %d\n",
(int)(pxs->media_dims.y * 10 + .5),
(int)(pxs->media_dims.x * 10 + .5));
r.ptr = (byte *) buf - 1;
r.limit = (byte *) buf + ret - 1;
pjl_proc_process(pxs->pjls, &r);
}
/* do an initial reset to set up a permanent reset. The
motivation here is to avoid tracking down a slew of memory
leaks */
global_pcs->xfm_state.paper_size = pcl_get_default_paper(global_pcs);
pcl_do_resets(global_pcs, pcl_reset_initial);
pcl_do_resets(global_pcs, pcl_reset_permanent);
/* initialize pcl and install xl's page device in pcl's state */
pcl_init_state(global_pcs, pxs->memory);
code = gs_setdevice_no_erase(global_pcs->pgs, gs_currentdevice(pxs->pgs));
if (code < 0)
return code;
/* yet another reset with the new page device */
global_pcs->xfm_state.paper_size = pcl_get_default_paper(global_pcs);
pcl_do_resets(global_pcs, pcl_reset_initial);
/* set the parser state and initialize the pcl parser */
global_pcl_parser_state.definitions = global_pcs->pcl_commands;
global_pcl_parser_state.hpgl_parser_state = &global_gl_parser_state;
pcl_process_init(&global_pcl_parser_state);
/* default 600 to match XL allow PCL to override */
global_pcs->uom_cp = 7200L / 600L;
gs_setgray(global_pcs->pgs, 0);
return 0;
}
/* Note that we just set the clipping path (internal). */
static void
note_set_clip_path(const gs_state * pgs)
{
if (gs_debug_c('P')) {
dlprintf("[P]Clipping path:\n");
gx_cpath_print(pgs->clip_path);
}
}
/* 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;
}
/* Clean up the stacks and validate storage. */
static void
ivalidate_clean_spaces(i_ctx_t *i_ctx_p)
{
if (gs_debug_c('?')) {
ref_stack_cleanup(&d_stack);
ref_stack_cleanup(&e_stack);
ref_stack_cleanup(&o_stack);
ivalidate_spaces();
}
}
int
gs_imager_setmatrix(gs_imager_state * pis, const gs_matrix * pmat)
{
update_matrix_fixed(pis->ctm, pmat->tx, pmat->ty);
set_ctm_only(pis, *pmat);
#ifdef DEBUG
if (gs_debug_c('x'))
dlprintf("[x]imager_setmatrix:\n"), trace_ctm(pis);
#endif
return 0;
}
int
gs_setmatrix(gs_state * pgs, const gs_matrix * pmat)
{
update_ctm(pgs, pmat->tx, pmat->ty);
set_ctm_only(pgs, *pmat);
#ifdef DEBUG
if (gs_debug_c('x'))
dlprintf("[x]setmatrix:\n"), trace_ctm(pgs);
#endif
return 0;
}
static void
debug_b_print_decode(const gs_pixel_image_t *pim, int num_decode)
{
if (gs_debug_c('b')) {
const char *str = " Decode=[";
int i;
for (i = 0; i < num_decode; str = " ", ++i)
dprintf2("%s%g", str, pim->Decode[i]);
dputs("]\n");
}
}
int
gs_rotate(gs_state * pgs, floatp ang)
{
int code = gs_matrix_rotate(&ctm_only(pgs), ang,
&ctm_only_writable(pgs));
pgs->ctm_inverse_valid = false, pgs->char_tm_valid = false;
#ifdef DEBUG
if (gs_debug_c('x'))
dlprintf1("[x]rotate: %f\n", ang), trace_ctm(pgs);
#endif
return code;
}
/*
* ESC * v <nbytes> W
*
* This command creates only the basic element of the the palette: the cid_data
* array. Other parts are created as needed.
*/
static int
pcl_configure_image_data(pcl_args_t * pargs, pcl_state_t * pcs)
{
if (pcs->personality == pcl5e || pcs->raster_state.graphics_mode)
return 0;
#ifdef DEBUG
if (gs_debug_c('i')) {
pcl_debug_dump_data(pcs->memory, arg_data(pargs), uint_arg(pargs));
}
#endif
return install_cid_data(uint_arg(pargs),
arg_data(pargs), pcs, false, false);
}
/* Unmarking routine for ref objects. */
static void
refs_clear_marks(const gs_memory_t *cmem,
void /*obj_header_t */ *vptr, uint size,
const gs_memory_struct_type_t * pstype)
{
ref_packed *rp = (ref_packed *) vptr;
ref_packed *end = (ref_packed *) ((byte *) vptr + size);
/* Since the last ref is full-size, we only need to check for */
/* the end of the block when we see one of those. */
for (;;) {
if (r_is_packed(rp)) {
#ifdef DEBUG
if (gs_debug_c('8')) {
dlprintf1(" [8]unmark packed 0x%lx ", (ulong) rp);
debug_print_ref(cmem, (const ref *)rp);
dputs("\n");
}
#endif
r_clear_pmark(rp);
rp++;
} else { /* full-size ref */
ref *const pref = (ref *)rp;
#ifdef DEBUG
if (gs_debug_c('8')) {
dlprintf1(" [8]unmark ref 0x%lx ", (ulong) rp);
debug_print_ref(cmem, pref);
dputs("\n");
}
#endif
r_clear_attrs(pref, l_mark);
rp += packed_per_ref;
if (rp >= (ref_packed *) end)
break;
}
}
}
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;
}
int
gs_initmatrix(gs_state * pgs)
{
gs_matrix imat;
gs_defaultmatrix(pgs, &imat);
update_ctm(pgs, imat.tx, imat.ty);
set_ctm_only(pgs, imat);
#ifdef DEBUG
if (gs_debug_c('x'))
dlprintf("[x]initmatrix:\n"), trace_ctm(pgs);
#endif
return 0;
}
int
gs_scale(gs_state * pgs, floatp sx, floatp sy)
{
pgs->ctm.xx *= sx;
pgs->ctm.xy *= sx;
pgs->ctm.yx *= sy;
pgs->ctm.yy *= sy;
pgs->ctm_inverse_valid = false, pgs->char_tm_valid = false;
#ifdef DEBUG
if (gs_debug_c('x'))
dlprintf2("[x]scale: %f %f\n", sx, sy), trace_ctm(pgs);
#endif
return 0;
}
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");
}
}
static int DebugPrint(ttfFont *ttf, const char *fmt, ...)
{
char buf[500];
va_list args;
int count;
if (gs_debug_c('Y')) {
va_start(args, fmt);
count = vsnprintf(buf, sizeof(buf), fmt, args);
/* NB: moved debug output from stdout to stderr
*/
errwrite(ttf->DebugMem, buf, count);
va_end(args);
}
return 0;
}
int
gs_concat(gs_state * pgs, const gs_matrix * pmat)
{
gs_matrix cmat;
int code = gs_matrix_multiply(pmat, &ctm_only(pgs), &cmat);
if (code < 0)
return code;
update_ctm(pgs, cmat.tx, cmat.ty);
set_ctm_only(pgs, cmat);
#ifdef DEBUG
if (gs_debug_c('x'))
dlprintf("[x]concat:\n"), trace_matrix(pmat), trace_ctm(pgs);
#endif
return code;
}
/* Note that this may be based on a font other than the current font. */
int
gs_setcharmatrix(gs_state * pgs, const gs_matrix * pmat)
{
gs_matrix cmat;
int code = gs_matrix_multiply(pmat, &ctm_only(pgs), &cmat);
if (code < 0)
return code;
update_matrix_fixed(pgs->char_tm, cmat.tx, cmat.ty);
char_tm_only(pgs) = cmat;
#ifdef DEBUG
if (gs_debug_c('x'))
dlprintf("[x]setting char_tm:"), trace_matrix_fixed(&pgs->char_tm);
#endif
pgs->char_tm_valid = true;
return 0;
}
int
gs_translate_untransformed(gs_state * pgs, floatp dx, floatp dy)
{
gs_point pt;
int code;
pt.x = (float)dx + pgs->ctm.tx;
pt.y = (float)dy + pgs->ctm.ty;
update_ctm(pgs, pt.x, pt.y);
#ifdef DEBUG
if (gs_debug_c('x'))
dlprintf4("[x]translate_untransformed: %f %f -> %f %f\n",
dx, dy, pt.x, pt.y),
trace_ctm(pgs);
#endif
return 0;
}
/* Used by gschar.c to prepare for a BuildChar or BuildGlyph procedure. */
int
gx_translate_to_fixed(register gs_state * pgs, fixed px, fixed py)
{
double fpx = fixed2float(px);
double fdx = fpx - pgs->ctm.tx;
double fpy = fixed2float(py);
double fdy = fpy - pgs->ctm.ty;
fixed dx, dy;
int code;
if (pgs->ctm.txy_fixed_valid) {
dx = float2fixed(fdx);
dy = float2fixed(fdy);
code = gx_path_translate(pgs->path, dx, dy);
if (code < 0)
return code;
if (pgs->char_tm_valid && pgs->char_tm.txy_fixed_valid)
pgs->char_tm.tx_fixed += dx,
pgs->char_tm.ty_fixed += dy;
} else {
if (!gx_path_is_null(pgs->path))
return_error(gs_error_limitcheck);
}
pgs->ctm.tx = fpx;
pgs->ctm.tx_fixed = px;
pgs->ctm.ty = fpy;
pgs->ctm.ty_fixed = py;
pgs->ctm.txy_fixed_valid = true;
pgs->ctm_inverse_valid = false;
if (pgs->char_tm_valid) { /* Update char_tm now, leaving it valid. */
pgs->char_tm.tx += fdx;
pgs->char_tm.ty += fdy;
}
#ifdef DEBUG
if (gs_debug_c('x')) {
dlprintf2("[x]translate_to_fixed %g, %g:\n",
fixed2float(px), fixed2float(py));
trace_ctm(pgs);
dlprintf("[x] char_tm:\n");
trace_matrix_fixed(&pgs->char_tm);
}
#endif
gx_setcurrentpoint(pgs, fixed2float(pgs->ctm.tx_fixed), fixed2float(pgs->ctm.ty_fixed));
pgs->current_point_valid = true;
return 0;
}
/* ---------------- Statistics ---------------- */
#ifdef DEBUG
const char *const cmd_op_names[16] =
{cmd_op_name_strings};
static const char *const cmd_misc_op_names[16] =
{cmd_misc_op_name_strings};
static const char *const cmd_misc2_op_names[16] =
{cmd_misc2_op_name_strings};
static const char *const cmd_segment_op_names[16] =
{cmd_segment_op_name_strings};
static const char *const cmd_path_op_names[16] =
{cmd_path_op_name_strings};
const char *const *const cmd_sub_op_names[16] =
{cmd_misc_op_names, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0,
0, cmd_misc2_op_names, cmd_segment_op_names, cmd_path_op_names
};
struct stats_cmd_s {
ulong op_counts[256];
ulong op_sizes[256];
ulong tile_reset, tile_found, tile_added;
ulong same_band, other_band;
} stats_cmd;
extern ulong stats_cmd_diffs[5]; /* in gxclpath.c */
int
cmd_count_op(int op, uint size)
{
stats_cmd.op_counts[op]++;
stats_cmd.op_sizes[op] += size;
if (gs_debug_c('L')) {
const char *const *sub = cmd_sub_op_names[op >> 4];
if (sub)
dlprintf2(", %s(%u)\n", sub[op & 0xf], size);
else
dlprintf3(", %s %d(%u)\n", cmd_op_names[op >> 4], op & 0xf,
size);
dflush();
}
return op;
}
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 };
#ifdef DEBUG
if (gs_debug_c('v')) {
static const char *const cs_names[] = {
GS_COLOR_SPACE_TYPE_NAMES
};
dlprintf5("[v](0x%lx)begin_transparency_group [%g %g %g %g]\n",
(ulong)pgs, pbbox->p.x, pbbox->p.y, pbbox->q.x, pbbox->q.y);
if (ptgp->ColorSpace)
dprintf1(" CS = %s",
cs_names[(int)gs_color_space_get_index(ptgp->ColorSpace)]);
else
dputs(" (no CS)");
dprintf2(" Isolated = %d Knockout = %d\n",
ptgp->Isolated, ptgp->Knockout);
}
#endif
/*
* 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;
/*
* We are currently doing nothing with the colorspace. Currently
* the blending colorspace is based upon the processs color model
* of the output device.
*/
params.bbox = *pbbox;
return gs_state_update_pdf14trans(pgs, ¶ms);
}
int
gs_translate(gs_state * pgs, floatp dx, floatp dy)
{
gs_point pt;
int code;
if ((code = gs_distance_transform(dx, dy, &ctm_only(pgs), &pt)) < 0)
return code;
pt.x = (float)pt.x + pgs->ctm.tx;
pt.y = (float)pt.y + pgs->ctm.ty;
update_ctm(pgs, pt.x, pt.y);
#ifdef DEBUG
if (gs_debug_c('x'))
dlprintf4("[x]translate: %f %f -> %f %f\n",
dx, dy, pt.x, pt.y),
trace_ctm(pgs);
#endif
return 0;
}
int
gs_setblendmode(gs_state *pgs, gs_blend_mode_t mode)
{
#ifdef DEBUG
if (gs_debug_c('v')) {
static const char *const bm_names[] = { GS_BLEND_MODE_NAMES };
dlprintf1("[v](0x%lx)blend_mode = ", (ulong)pgs);
if (mode >= 0 && mode < countof(bm_names))
dprintf1("%s\n", bm_names[mode]);
else
dprintf1("%d??\n", (int)mode);
}
#endif
if (mode < 0 || mode > MAX_BLEND_MODE)
return_error(gs_error_rangecheck);
pgs->blend_mode = mode;
return 0;
}
static void
gslt_free_object(gs_memory_t * mem, void *ptr, client_name_t cname)
{
if ( ptr != NULL ) {
byte *bptr = (byte *)ptr;
uint header_size = round_up_to_align(1) * 2;
#ifdef DEBUG
if ( gs_debug_c('@') )
memset(bptr-header_size, 0xee, header_size + get_size(ptr));
#endif
free(bptr-header_size);
num_free_called ++;
#ifdef DEBUG
/* da for debug allocator - so scripts can parse the trace */
if_debug2('A', "[da]:free:%p:%s\n", ptr, cname );
#endif
}
}
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;
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
};
dlprintf5("[v](0x%lx)gx_begin_transparency_group [%g %g %g %g]\n",
(ulong)pis, bbox.p.x, bbox.p.y, bbox.q.x, bbox.q.y);
if (tgp.ColorSpace)
dprintf1(" CS = %s",
cs_names[(int)gs_color_space_get_index(tgp.ColorSpace)]);
else
dputs(" (no CS)");
dprintf2(" Isolated = %d Knockout = %d\n",
tgp.Isolated, tgp.Knockout);
}
#endif
if (dev_proc(pdev, begin_transparency_group) != 0)
return (*dev_proc(pdev, begin_transparency_group)) (pdev, &tgp,
&bbox, pis, NULL, NULL);
else
return 0;
}
void
trace_copy_rop(const char *cname, gx_device * dev,
const byte * sdata, int sourcex, uint sraster, gx_bitmap_id id,
const gx_color_index * scolors,
const gx_strip_bitmap * textures,
const gx_color_index * tcolors,
int x, int y, int width, int height,
int phase_x, int phase_y, gs_logical_operation_t lop)
{
dlprintf4("%s: dev=0x%lx(%s) depth=%d\n",
cname, (ulong) dev, dev->dname, dev->color_info.depth);
dlprintf4(" source data=0x%lx x=%d raster=%u id=%lu colors=",
(ulong) sdata, sourcex, sraster, (ulong) id);
if (scolors)
dprintf2("(%lu,%lu);\n", scolors[0], scolors[1]);
else
dputs("none;\n");
if (textures)
dlprintf8(" textures=0x%lx size=%dx%d(%dx%d) raster=%u shift=%d(%d)",
(ulong) textures, textures->size.x, textures->size.y,
textures->rep_width, textures->rep_height,
textures->raster, textures->shift, textures->rep_shift);
else
dlputs(" textures=none");
if (tcolors)
dprintf2(" colors=(%lu,%lu)\n", tcolors[0], tcolors[1]);
else
dputs(" colors=none\n");
dlprintf7(" rect=(%d,%d),(%d,%d) phase=(%d,%d) op=0x%x\n",
x, y, x + width, y + height, phase_x, phase_y,
(uint) lop);
if (gs_debug_c('B')) {
if (sdata)
debug_dump_bitmap(sdata, sraster, height, "source bits");
if (textures && textures->data)
debug_dump_bitmap(textures->data, textures->raster,
textures->size.y, "textures bits");
}
}
