/*
* Create an imdi memory device for page or band buffering,
* possibly preceded by a plane extraction device.
*/
int
wtsimdi_create_buf_device(gx_device **pbdev, gx_device *target,
const gx_render_plane_t *render_plane, gs_memory_t *mem, bool for_band)
{
int plane_index = (render_plane ? render_plane->index : -1);
int depth;
const gx_device_memory *mdproto;
gx_device_memory *mdev;
if (plane_index >= 0)
depth = render_plane->depth;
else
depth = target->color_info.depth;
mdproto = gdev_mem_device_for_bits(depth);
if (mdproto == 0)
return_error(gs_error_rangecheck);
if (mem) {
mdev = gs_alloc_struct(mem, gx_device_memory, &st_device_memory,
"create_buf_device");
if (mdev == 0)
return_error(gs_error_VMerror);
} else {
mdev = (gx_device_memory *)*pbdev;
}
if (target == (gx_device *)mdev) {
/* The following is a special hack for setting up printer devices. */
assign_dev_procs(mdev, mdproto);
check_device_separable((gx_device *)mdev);
gx_device_fill_in_procs((gx_device *)mdev);
} else
gs_make_mem_device(mdev, mdproto, mem, (for_band ? 1 : 0),
(target == (gx_device *)mdev ? NULL : target));
mdev->width = target->width;
/*
* The matrix in the memory device is irrelevant,
* because all we do with the device is call the device-level
* output procedures, but we may as well set it to
* something halfway reasonable.
*/
gs_deviceinitialmatrix(target, &mdev->initial_matrix);
/****** QUESTIONABLE, BUT BETTER THAN OMITTING ******/
mdev->color_info = target->color_info;
*pbdev = (gx_device *)mdev;
return 0;
}
int
gs_defaultmatrix(const gs_state * pgs, gs_matrix * pmat)
{
gx_device *dev;
if (pgs->ctm_default_set) { /* set after Install */
*pmat = pgs->ctm_default;
return 1;
}
dev = gs_currentdevice_inline(pgs);
gs_deviceinitialmatrix(dev, pmat);
/* Add in the translation for the Margins. */
pmat->tx += dev->Margins[0] *
dev->HWResolution[0] / dev->MarginsHWResolution[0];
pmat->ty += dev->Margins[1] *
dev->HWResolution[1] / dev->MarginsHWResolution[1];
return 0;
}
/* Read back the bounding box in 1/72" units. */
void
gx_device_bbox_bbox(gx_device_bbox * dev, gs_rect * pbbox)
{
gs_fixed_rect bbox;
BBOX_GET_BOX(dev, &bbox);
if (bbox.p.x > bbox.q.x || bbox.p.y > bbox.q.y) {
/* Nothing has been written on this page. */
pbbox->p.x = pbbox->p.y = pbbox->q.x = pbbox->q.y = 0;
} else {
gs_rect dbox;
gs_matrix mat;
dbox.p.x = fixed2float(bbox.p.x);
dbox.p.y = fixed2float(bbox.p.y);
dbox.q.x = fixed2float(bbox.q.x);
dbox.q.y = fixed2float(bbox.q.y);
gs_deviceinitialmatrix((gx_device *)dev, &mat);
gs_bbox_transform_inverse(&dbox, &mat, pbbox);
}
}
int
gs_screen_order_init_memory(gx_ht_order * porder, const gs_state * pgs,
gs_screen_halftone * phsp, bool accurate,
gs_memory_t * mem)
{
gs_matrix imat;
ulong max_size = gx_ht_cache_default_bits_size();
int code;
gs_lib_ctx_t *ctx = gs_lib_ctx_get_interp_instance(mem);
if (phsp->frequency < 0.1)
return_error(gs_error_rangecheck);
gs_deviceinitialmatrix(gs_currentdevice(pgs), &imat);
code = pick_cell_size(phsp, &imat, max_size,
ctx->screen_min_screen_levels, accurate,
&porder->params);
if (code < 0)
return code;
gx_compute_cell_values(&porder->params);
porder->screen_params.matrix = imat;
porder->screen_params.max_size = max_size;
return gs_screen_order_alloc(porder, mem);
}
