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"); } }