/*
* Force the enumerator to be a gs_show_enum *, which the current
* implementation code requires.
*/
static int
show_n_begin(gs_show_enum *penum, gs_state *pgs, int code, gs_text_enum_t *pte)
{
if (code < 0)
return code;
if (gs_object_type(pgs->memory, pte) != &st_gs_show_enum) {
/* Use the default implementation. */
gx_device *dev = pgs->device;
gs_text_params_t text;
gs_memory_t *mem = pte->memory;
dev_proc_text_begin((*text_begin)) = dev_proc(dev, text_begin);
text = pte->text;
gs_text_release(pte, "show_n_begin");
/* Temporarily reset the text_begin procedure to the default. */
set_dev_proc(dev, text_begin, gx_default_text_begin);
code = gs_text_begin(pgs, &text, mem, &pte);
set_dev_proc(dev, text_begin, text_begin);
if (code < 0)
return code;
}
/* Now we know pte points to a gs_show_enum. */
*penum = *(gs_show_enum *)pte;
gs_free_object(pgs->memory, pte, "show_n_begin");
return code;
}
/* (Re)set renderer device fields which get trampled by gdevprn_open & put_params */
static void
reinit_printer_into_renderer(
gx_device_printer * const pdev /* printer to convert */
)
{
set_dev_proc(pdev, put_params, gdev_prn_async_render_put_params);
}
/* Close the device and free its storage. */
static int
dca_close(gx_device * dev)
{ /*
* Finalization will call close again: avoid a recursion loop.
*/
set_dev_proc(dev, close_device, gx_default_close_device);
gs_free_object(dev->memory, dev, "dca_close");
return 0;
}
/* Forward the color mapping procedures from a device to its target. */
void
gx_device_forward_color_procs(gx_device_forward * dev)
{
set_dev_proc(dev, map_rgb_color, gx_forward_map_rgb_color);
set_dev_proc(dev, map_color_rgb, gx_forward_map_color_rgb);
set_dev_proc(dev, map_cmyk_color, gx_forward_map_cmyk_color);
set_dev_proc(dev, map_rgb_alpha_color, gx_forward_map_rgb_alpha_color);
set_dev_proc(dev, get_color_mapping_procs, gx_forward_get_color_mapping_procs);
set_dev_proc(dev, get_color_comp_index, gx_forward_get_color_comp_index);
set_dev_proc(dev, encode_color, gx_forward_encode_color);
set_dev_proc(dev, decode_color, gx_forward_decode_color);
}
/* Forward the color mapping procedures from a device to its target. */
void
gx_device_forward_color_procs(gx_device_forward * dev)
{
set_dev_proc(dev, map_rgb_color, gx_forward_map_rgb_color);
set_dev_proc(dev, map_color_rgb, gx_forward_map_color_rgb);
set_dev_proc(dev, map_cmyk_color, gx_forward_map_cmyk_color);
set_dev_proc(dev, map_rgb_alpha_color, gx_forward_map_rgb_alpha_color);
set_dev_proc(dev, get_color_mapping_procs, gx_forward_get_color_mapping_procs);
set_dev_proc(dev, get_color_comp_index, gx_forward_get_color_comp_index);
set_dev_proc(dev, encode_color, gx_forward_encode_color);
set_dev_proc(dev, decode_color, gx_forward_decode_color);
set_dev_proc(dev, get_profile, gx_forward_get_profile);
/* Not strictly a color proc, but may affect color encoding */
fill_dev_proc(dev, set_graphics_type_tag, gx_forward_set_graphics_type_tag);
fill_dev_proc(dev, dev_spec_op, gx_forward_dev_spec_op);
}
int
clist_enable_multi_thread_render(gx_device *dev)
{
int code = -1;
gp_thread_id thread;
if (dev->procs.get_bits_rectangle == clist_get_bits_rect_mt)
return 1; /* no need to test again */
/* We need to test gp_thread_start since we may be on a platform */
/* built without working threads, i.e., using gp_nsync.c dummy */
/* routines. The nosync gp_thread_start returns a -ve error code. */
if ((code = gp_thread_start(test_threads, NULL, &thread)) < 0 ) {
return code; /* Threads don't work */
}
gp_thread_finish(thread);
set_dev_proc(dev, get_bits_rectangle, clist_get_bits_rect_mt);
set_dev_proc(dev, process_page, clist_process_page_mt);
return 1;
}
static int
pngalpha_create_buf_device(gx_device **pbdev, gx_device *target, int y,
const gx_render_plane_t *render_plane, gs_memory_t *mem,
gx_band_complexity_t *band_complexity)
{
gx_device_printer *ptarget = (gx_device_printer *)target;
int code = gx_default_create_buf_device(pbdev, target, y,
render_plane, mem, band_complexity);
/* Now set copy_alpha to one that handles RGBA */
set_dev_proc(*pbdev, copy_alpha, ptarget->orig_procs.copy_alpha);
return code;
}
/*
* Note: The color space (pcs) has already been modified to use the
* alternate color space.
*/
void
capture_spot_equivalent_cmyk_colors(gx_device * pdev, const gs_state * pgs,
const gs_client_color * pcc, const gs_color_space * pcs,
int sep_num, equivalent_cmyk_color_params * pparams)
{
gs_imager_state temp_state = *((const gs_imager_state *)pgs);
color_capture_device temp_device = { 0 };
gx_device_color dev_color;
gsicc_rendering_intents_t rendering_intent;
int code;
cmm_dev_profile_t *dev_profile;
cmm_profile_t *curr_output_profile;
cmm_dev_profile_t temp_profile;
code = dev_proc(pdev, get_profile)(pdev, &dev_profile);
gsicc_extract_profile(pdev->graphics_type_tag,
dev_profile, &(curr_output_profile),
&rendering_intent);
/*
* Create a temp device. The primary purpose of this device is pass the
* separation number and a pointer to the original device's equivalent
* color parameters. Since we only using this device for a very specific
* purpose, we only set up the color_info structure and our data.
*/
temp_device.color_info = pdev->color_info;
temp_device.sep_num = sep_num;
temp_device.pequiv_cmyk_colors = pparams;
temp_device.memory = pgs->memory;
temp_profile.usefastcolor = false; /* This avoids a few headaches */
temp_profile.device_profile[0] = curr_output_profile;
temp_profile.device_profile[1] = NULL;
temp_profile.device_profile[2] = NULL;
temp_profile.device_profile[2] = NULL;
temp_profile.link_profile = NULL;
temp_profile.proof_profile = NULL;
temp_device.icc_struct = &temp_profile;
set_dev_proc(&temp_device, get_profile, gx_default_get_profile);
/*
* Create a temp copy of the imager state. We do this so that we
* can modify the color space mapping (cmap) procs. We use our
* replacment procs to capture the color. The installation of a
* Separation or DeviceN color space also sets a use_alt_cspace flag
* in the state. We also need to set this to use the alternate space.
*/
temp_state.cmap_procs = &cmap_capture_cmyk_color;
temp_state.color_component_map.use_alt_cspace = true;
/* Now capture the color */
pcs->type->remap_color (pcc, pcs, &dev_color, &temp_state,
(gx_device *)&temp_device, gs_color_select_texture);
}
/* Set the buf_procs in a printer device to planar mode. */
int
gdev_prn_set_procs_planar(gx_device *dev)
{
gx_device_printer * const pdev = (gx_device_printer *)dev;
pdev->printer_procs.buf_procs.create_buf_device =
gdev_prn_create_buf_planar;
pdev->printer_procs.buf_procs.size_buf_device =
gdev_prn_size_buf_planar;
if (dev_proc(pdev, dev_spec_op) == gx_default_dev_spec_op)
set_dev_proc(pdev, dev_spec_op, prn_planar_dev_spec_op);
return 0;
}
int
clist_enable_multi_thread_render(gx_device *dev)
{
int code = -1;
/* We need to test gp_create_thread since we may be on a platform */
/* built without working threads, i.e., using gp_nsync.c dummy */
/* routines. The nosync gp_create_thread returns a -ve error code */
if ((code = gp_create_thread(test_threads, NULL)) < 0 ) {
return code; /* Threads don't work */
}
set_dev_proc(dev, get_bits_rectangle, clist_get_bits_rect_mt);
return 1;
}
/* (Re)set printer device fields which get trampled by gdevprn_open & put_params */
static void
reinit_printer_into_printera(
gx_device_printer * const pdev /* printer to convert */
)
{
/* Change some of the procedure vector to point at async procedures */
/* Originals were already saved by gdev_prn_open */
if (dev_proc(pdev, close_device) == gdev_prn_close)
set_dev_proc(pdev, close_device, gdev_prn_async_write_close_device);
set_dev_proc(pdev, output_page, gdev_prn_async_write_output_page);
set_dev_proc(pdev, put_params, gdev_prn_async_write_put_params);
set_dev_proc(pdev, get_xfont_procs, gx_default_get_xfont_procs);
set_dev_proc(pdev, get_xfont_device, gx_default_get_xfont_device);
set_dev_proc(pdev, get_hardware_params, gdev_prn_async_write_get_hardware_params);
/* clist writer calls this if it runs out of memory & wants to retry */
pdev->free_up_bandlist_memory = &gdev_prn_async_write_free_up_bandlist_memory;
}
/*
* Set up a planar memory device, after calling gs_make_mem_device but
* before opening the device. The pre-existing device provides the color
* mapping procedures, but not the drawing procedures. Requires: num_planes
* > 0, plane_depths[0 .. num_planes - 1] > 0, sum of plane depths =
* mdev->color_info.depth.
*
* Note that this is the only public procedure in this file, and the only
* sanctioned way to set up a planar memory device.
*/
int
gdev_mem_set_planar(gx_device_memory * mdev, int num_planes,
const gx_render_plane_t *planes /*[num_planes]*/)
{
int total_depth;
int same_depth = planes[0].depth;
gx_color_index covered = 0;
int pi;
const gx_device_memory *mdproto = gdev_mem_device_for_bits(mdev->color_info.depth);
if (num_planes < 1 || num_planes > GX_DEVICE_COLOR_MAX_COMPONENTS)
return_error(gs_error_rangecheck);
for (pi = 0, total_depth = 0; pi < num_planes; ++pi) {
int shift = planes[pi].shift;
int plane_depth = planes[pi].depth;
gx_color_index mask;
if (shift < 0 || plane_depth > 16 ||
!gdev_mem_device_for_bits(plane_depth))
return_error(gs_error_rangecheck);
mask = (((gx_color_index)1 << plane_depth) - 1) << shift;
if (covered & mask)
return_error(gs_error_rangecheck);
covered |= mask;
if (plane_depth != same_depth)
same_depth = 0;
total_depth += plane_depth;
}
if (total_depth > mdev->color_info.depth)
return_error(gs_error_rangecheck);
mdev->num_planes = num_planes;
memcpy(mdev->planes, planes, num_planes * sizeof(planes[0]));
mdev->plane_depth = same_depth;
/* Change the drawing procedures. */
set_dev_proc(mdev, open_device, mem_planar_open);
if (num_planes == 1) {
/* For 1 plane, just use a normal device */
set_dev_proc(mdev, fill_rectangle, dev_proc(mdproto, fill_rectangle));
set_dev_proc(mdev, copy_mono, dev_proc(mdproto, copy_mono));
set_dev_proc(mdev, copy_color, dev_proc(mdproto, copy_color));
set_dev_proc(mdev, copy_alpha, dev_proc(mdproto, copy_alpha));
set_dev_proc(mdev, strip_tile_rectangle, dev_proc(mdproto, strip_tile_rectangle));
set_dev_proc(mdev, strip_copy_rop, dev_proc(mdproto, strip_copy_rop));
set_dev_proc(mdev, get_bits_rectangle, dev_proc(mdproto, get_bits_rectangle));
} else {
set_dev_proc(mdev, fill_rectangle, mem_planar_fill_rectangle);
set_dev_proc(mdev, copy_mono, mem_planar_copy_mono);
if ((mdev->color_info.depth == 24) &&
(mdev->num_planes == 3) &&
(mdev->planes[0].depth == 8) && (mdev->planes[0].shift == 16) &&
(mdev->planes[1].depth == 8) && (mdev->planes[1].shift == 8) &&
(mdev->planes[2].depth == 8) && (mdev->planes[2].shift == 0))
set_dev_proc(mdev, copy_color, mem_planar_copy_color_24to8);
else if ((mdev->color_info.depth == 4) &&
(mdev->num_planes == 4) &&
(mdev->planes[0].depth == 1) && (mdev->planes[0].shift == 3) &&
(mdev->planes[1].depth == 1) && (mdev->planes[1].shift == 2) &&
(mdev->planes[2].depth == 1) && (mdev->planes[2].shift == 1) &&
(mdev->planes[3].depth == 1) && (mdev->planes[3].shift == 0))
set_dev_proc(mdev, copy_color, mem_planar_copy_color_4to1);
else
set_dev_proc(mdev, copy_color, mem_planar_copy_color);
set_dev_proc(mdev, copy_alpha, gx_default_copy_alpha);
set_dev_proc(mdev, copy_plane, mem_planar_copy_plane);
set_dev_proc(mdev, strip_tile_rectangle, mem_planar_strip_tile_rectangle);
set_dev_proc(mdev, strip_copy_rop, mem_planar_strip_copy_rop);
set_dev_proc(mdev, get_bits_rectangle, mem_planar_get_bits_rectangle);
set_dev_proc(mdev, dev_spec_op, mem_planar_dev_spec_op);
}
return 0;
}
int eprn_open_device(gx_device *device)
{
eprn_Eprn *eprn = &((eprn_Device *)device)->eprn;
const char *epref = eprn->CUPS_messages? CUPS_ERRPREF: "";
int rc;
#ifdef EPRN_TRACE
if_debug0(EPRN_TRACE_CHAR, "! eprn_open_device()...\n");
#endif
/* Checks on page size and determination of derived values */
if (eprn_set_page_layout((eprn_Device *)device) != 0)
return_error(gs_error_rangecheck);
/* Check the rendering parameters */
if (eprn_check_colour_info(eprn->cap->colour_info, &eprn->colour_model,
&device->HWResolution[0], &device->HWResolution[1],
&eprn->black_levels, &eprn->non_black_levels) != 0) {
gs_param_string str;
eprintf1("%s" ERRPREF "The requested combination of colour model (",
epref);
str.size = 0;
if (eprn_get_string(eprn->colour_model, eprn_colour_model_list, &str) != 0)
assert(0); /* Bug. No harm on NDEBUG because I've just set the size. */
errwrite(device->memory, (const char *)str.data, str.size * sizeof(str.data[0]));
eprintf7("),\n"
"%s resolution (%gx%g ppi) and intensity levels (%d, %d) is\n"
"%s not supported by the %s.\n",
epref, device->HWResolution[0], device->HWResolution[1],
eprn->black_levels, eprn->non_black_levels, epref, eprn->cap->name);
return_error(gs_error_rangecheck);
}
/* Initialization for colour rendering */
if (device->color_info.num_components == 4) {
/* Native colour space is 'DeviceCMYK' */
set_dev_proc(device, map_rgb_color, NULL);
if (eprn->intensity_rendering == eprn_IR_FloydSteinberg)
set_dev_proc(device, map_cmyk_color, &eprn_map_cmyk_color_max);
else if (device->color_info.max_gray > 1 || device->color_info.max_color > 1)
set_dev_proc(device, map_cmyk_color, &eprn_map_cmyk_color_flex);
else
set_dev_proc(device, map_cmyk_color, &eprn_map_cmyk_color);
if (eprn->intensity_rendering == eprn_IR_FloydSteinberg)
set_dev_proc(device, map_rgb_color, &eprn_map_rgb_color_for_CMY_or_K_max);
else if (device->color_info.max_gray > 1 || device->color_info.max_color > 1)
set_dev_proc(device, map_rgb_color, &eprn_map_rgb_color_for_CMY_or_K_flex);
else
set_dev_proc(device, map_rgb_color, &eprn_map_rgb_color_for_CMY_or_K);
}
else {
set_dev_proc(device, map_cmyk_color, NULL);
if (eprn->colour_model == eprn_DeviceRGB) {
if (eprn->intensity_rendering == eprn_IR_FloydSteinberg)
set_dev_proc(device, map_rgb_color, &eprn_map_rgb_color_for_RGB_max);
else if (device->color_info.max_color > 1)
set_dev_proc(device, map_rgb_color, &eprn_map_rgb_color_for_RGB_flex);
else
set_dev_proc(device, map_rgb_color, &eprn_map_rgb_color_for_RGB);
} else {
if (eprn->intensity_rendering == eprn_IR_FloydSteinberg)
set_dev_proc(device, map_rgb_color, &eprn_map_rgb_color_for_CMY_or_K_max);
else if (device->color_info.max_gray > 1 || device->color_info.max_color > 1)
set_dev_proc(device, map_rgb_color, &eprn_map_rgb_color_for_CMY_or_K_flex);
else
set_dev_proc(device, map_rgb_color, &eprn_map_rgb_color_for_CMY_or_K);
}
}
eprn->output_planes = eprn_bits_for_levels(eprn->black_levels) +
3 * eprn_bits_for_levels(eprn->non_black_levels);
#if !defined(GS_REVISION) || GS_REVISION >= 600
/* According to my understanding, the following call should be superfluous
(because the colour mapping functions may not be called while the device
is closed) and I am also not aware of any situation where it does make a
difference. It shouldn't do any harm, though, and I feel safer with it :-)
*/
gx_device_decache_colors(device);
#endif
#ifndef EPRN_NO_PAGECOUNTFILE
/* Read the page count value */
if (eprn->pagecount_file != NULL) {
unsigned long count;
if (pcf_getcount(eprn->pagecount_file, &count) == 0)
device->PageCount = count;
/* unsigned to signed. The C standard permits
an implementation to generate an overflow indication if the value is
too large. I consider this to mean that the type of 'PageCount' is
inappropriate :-). Note that eprn does not use 'PageCount' for
updating the file. */
else {
/* pcf_getcount() has issued an error message. */
eprintf(
" No further attempts will be made to access the page count file.\n");
gs_free(device->memory->non_gc_memory, eprn->pagecount_file, strlen(eprn->pagecount_file) + 1,
sizeof(char), "eprn_open_device");
eprn->pagecount_file = NULL;
}
}
#endif /* !EPRN_NO_PAGECOUNTFILE */
/* Open the "prn" device part */
if ((rc = gdev_prn_open(device)) != 0) return rc;
/* Just in case a previous open call failed in a derived device (note that
'octets_per_line' is still the same as then): */
if (eprn->scan_line.str != NULL)
gs_free(device->memory->non_gc_memory, eprn->scan_line.str, eprn->octets_per_line, sizeof(eprn_Octet),
"eprn_open_device");
if (eprn->next_scan_line.str != NULL) {
gs_free(device->memory->non_gc_memory, eprn->next_scan_line.str, eprn->octets_per_line, sizeof(eprn_Octet),
"eprn_open_device");
eprn->next_scan_line.str = NULL;
}
/* Calls which might depend on prn having been initialized */
eprn->octets_per_line = gdev_prn_raster((gx_device_printer *)device);
eprn->scan_line.str = (eprn_Octet *) gs_malloc(device->memory->non_gc_memory, eprn->octets_per_line,
sizeof(eprn_Octet), "eprn_open_device");
if (eprn->intensity_rendering == eprn_IR_FloydSteinberg) {
eprn->next_scan_line.str = (eprn_Octet *) gs_malloc(device->memory->non_gc_memory, eprn->octets_per_line,
sizeof(eprn_Octet), "eprn_open_device");
if (eprn->next_scan_line.str == NULL && eprn->scan_line.str != NULL) {
gs_free(device->memory->non_gc_memory, eprn->scan_line.str, eprn->octets_per_line, sizeof(eprn_Octet),
"eprn_open_device");
eprn->scan_line.str = NULL;
}
}
if (eprn->scan_line.str == NULL) {
eprintf1("%s" ERRPREF
"Memory allocation failure from gs_malloc() in eprn_open_device().\n",
epref);
return_error(gs_error_VMerror);
}
return rc;
}
/* Open the output file and stream. */
int
gdev_vector_open_file_options(gx_device_vector * vdev, uint strmbuf_size,
int open_options)
{
bool binary = !(open_options & VECTOR_OPEN_FILE_ASCII);
int code = -1; /* (only for testing, never returned) */
cmm_dev_profile_t *icc_struct;
/* Open the file as seekable or sequential, as requested. */
if (!(open_options & VECTOR_OPEN_FILE_SEQUENTIAL)) {
/* Try to open as seekable. */
code =
gx_device_open_output_file((gx_device *)vdev, vdev->fname,
binary, true, &vdev->file);
}
if (code < 0 && (open_options & (VECTOR_OPEN_FILE_SEQUENTIAL |
VECTOR_OPEN_FILE_SEQUENTIAL_OK))) {
/* Try to open as sequential. */
code = gx_device_open_output_file((gx_device *)vdev, vdev->fname,
binary, false, &vdev->file);
}
if ((code >= 0) && (dev_proc(vdev, get_profile) != NULL)) {
code = dev_proc(vdev, get_profile)((gx_device *)vdev, &icc_struct);
}
if (code < 0)
return code;
if ((vdev->strmbuf = gs_alloc_bytes(vdev->v_memory, strmbuf_size,
"vector_open(strmbuf)")) == 0 ||
(vdev->strm = s_alloc(vdev->v_memory,
"vector_open(strm)")) == 0 ||
((open_options & VECTOR_OPEN_FILE_BBOX) &&
(vdev->bbox_device =
gs_alloc_struct_immovable(vdev->v_memory,
gx_device_bbox, &st_device_bbox,
"vector_open(bbox_device)")) == 0)
) {
if (vdev->bbox_device)
gs_free_object(vdev->v_memory, vdev->bbox_device,
"vector_open(bbox_device)");
vdev->bbox_device = 0;
if (vdev->strm)
gs_free_object(vdev->v_memory, vdev->strm,
"vector_open(strm)");
vdev->strm = 0;
if (vdev->strmbuf)
gs_free_object(vdev->v_memory, vdev->strmbuf,
"vector_open(strmbuf)");
vdev->strmbuf = 0;
gx_device_close_output_file((gx_device *)vdev, vdev->fname, vdev->file);
vdev->file = 0;
return_error(gs_error_VMerror);
}
vdev->strmbuf_size = strmbuf_size;
swrite_file(vdev->strm, vdev->file, vdev->strmbuf, strmbuf_size);
vdev->open_options = open_options;
/*
* We don't want finalization to close the file, but we do want it
* to flush the stream buffer.
*/
vdev->strm->procs.close = vdev->strm->procs.flush;
if (vdev->bbox_device) {
gx_device_bbox_init(vdev->bbox_device, NULL, vdev->v_memory);
rc_increment(vdev->bbox_device);
vdev->bbox_device->icc_struct = icc_struct;
rc_increment(vdev->bbox_device->icc_struct);
gx_device_set_resolution((gx_device *) vdev->bbox_device,
vdev->HWResolution[0],
vdev->HWResolution[1]);
/* Do the right thing about upright vs. inverted. */
/* (This is dangerous in general, since the procedure */
/* might reference non-standard elements.) */
set_dev_proc(vdev->bbox_device, get_initial_matrix,
dev_proc(vdev, get_initial_matrix));
(*dev_proc(vdev->bbox_device, open_device))
((gx_device *) vdev->bbox_device);
}
return 0;
}
/* Write the page. */
static int
pcx2up_print_page(gx_device_printer * pdev, FILE * file)
{
gx_device_2up *pdev2 = (gx_device_2up *) pdev;
const gx_device_printer *prdev_template =
(const gx_device_printer *)&gs_pcx2up_device;
if (!pdev2->have_odd_page) { /* This is the odd page, just save it. */
pdev2->have_odd_page = true;
return gdev_prn_save_page(pdev, &pdev2->odd_page, 1);
} else { /* This is the even page, do 2-up output. */
gx_saved_page even_page;
gx_placed_page pages[2];
int x_offset = (int)(pdev->HWResolution[0] * 0.5);
int code = gdev_prn_save_page(pdev, &even_page, 1);
int prdev_size = prdev_template->params_size;
gx_device_printer *prdev;
#define rdev ((gx_device *)prdev)
if (code < 0)
return code;
/* Create the placed page list. */
pages[0].page = &pdev2->odd_page;
pages[0].offset.x = x_offset;
pages[0].offset.y = 0 /*y_offset */ ;
pages[1].page = &even_page;
pages[1].offset.x = pdev->width + x_offset * 3;
pages[1].offset.y = 0 /*y_offset */ ;
/* Create and open a device for rendering. */
prdev = (gx_device_printer *)
gs_alloc_bytes(pdev->memory, prdev_size,
"pcx2up_print_page(device)");
if (prdev == 0)
return_error(gs_error_VMerror);
memcpy(prdev, prdev_template, prdev_size);
check_device_separable((gx_device *)rdev);
gx_device_fill_in_procs(rdev);
set_dev_proc(prdev, open_device,
dev_proc(&gs_pcx256_device, open_device));
prdev->printer_procs.print_page =
gs_pcx256_device.printer_procs.print_page;
prdev->space_params.band =
pages[0].page->info.band_params; /* either one will do */
prdev->space_params.MaxBitmap = 0;
prdev->space_params.BufferSpace =
prdev->space_params.band.BandBufferSpace;
prdev->width = prdev->space_params.band.BandWidth;
prdev->OpenOutputFile = false;
code = (*dev_proc(rdev, open_device)) (rdev);
if (code < 0)
return code;
rdev->is_open = true;
prdev->file = pdev->file;
/* Render the pages. */
code = gdev_prn_render_pages(prdev, pages, 2);
/* Clean up. */
if (pdev->file != 0)
prdev->file = 0; /* don't close it */
gs_closedevice(rdev);
pdev2->have_odd_page = false;
return code;
#undef rdev
}
}
// set color info and procedures according to pixeldepth
static int
mac_set_colordepth(gx_device *dev, int depth)
{
gx_device_macos * mdev = (gx_device_macos *)dev;
gx_device_color_info * ci = &mdev->color_info;
if (depth != 1 && depth != 4 && depth != 7 && depth != 8 && depth != 24)
return gs_error_rangecheck;
mdev->color_info.depth = depth;
switch (depth)
{
case 1: // Black/White
ci->num_components = 1;
ci->max_gray = 1; ci->max_color = 0;
ci->dither_grays = 2; ci->dither_colors = 0;
set_dev_proc(dev, map_rgb_color, gx_default_b_w_map_rgb_color);
set_dev_proc(dev, map_color_rgb, gx_default_b_w_map_color_rgb);
break;
case 4: // 4Bit-Gray
ci->num_components = 1;
ci->max_gray = 15; ci->max_color = 0;
ci->dither_grays = 16; ci->dither_colors = 0;
set_dev_proc(dev, map_rgb_color, gx_default_gray_map_rgb_color);
set_dev_proc(dev, map_color_rgb, gx_default_gray_map_color_rgb);
break;
case 7: // 8Bit-Gray
ci->depth = 7;
ci->num_components = 1;
ci->max_gray = 255; ci->max_color = 0;
ci->dither_grays = 256; ci->dither_colors = 0;
set_dev_proc(dev, map_rgb_color, gx_default_gray_map_rgb_color);
set_dev_proc(dev, map_color_rgb, gx_default_gray_map_color_rgb);
break;
case 8: // 8Bit-Color
ci->num_components = 3;
ci->max_gray = 15; ci->max_color = 5;
ci->dither_grays = 16; ci->dither_colors = 6;
set_dev_proc(dev, map_rgb_color, gx_default_rgb_map_rgb_color);
set_dev_proc(dev, map_color_rgb, gx_default_rgb_map_color_rgb);
break;
/* case 16: // 16Bit-Color
ci->num_components = 3;
ci->max_gray = 255; ci->max_color = 65535;
ci->dither_grays = 256; ci->dither_colors = 65536;
set_dev_proc(dev, map_rgb_color, gx_default_rgb_map_rgb_color);
set_dev_proc(dev, map_color_rgb, gx_default_rgb_map_color_rgb);
break;
*/
case 24: // 24Bit-Color
ci->num_components = 3;
ci->max_gray = 255; ci->max_color = 16777215;
ci->dither_grays = 256; ci->dither_colors = 16777216;
set_dev_proc(dev, map_rgb_color, gx_default_rgb_map_rgb_color);
set_dev_proc(dev, map_color_rgb, gx_default_rgb_map_color_rgb);
break;
}
return 0;
}
/* Initialize a bounding box device. */
void
gx_device_bbox_init(gx_device_bbox * dev, gx_device * target, gs_memory_t *mem)
{
gx_device_init((gx_device *) dev, (const gx_device *)&gs_bbox_device,
(target ? target->memory : mem), true);
if (target) {
gx_device_forward_fill_in_procs((gx_device_forward *) dev);
set_dev_proc(dev, get_initial_matrix, gx_forward_get_initial_matrix);
set_dev_proc(dev, map_rgb_color, gx_forward_map_rgb_color);
set_dev_proc(dev, map_color_rgb, gx_forward_map_color_rgb);
set_dev_proc(dev, map_cmyk_color, gx_forward_map_cmyk_color);
set_dev_proc(dev, map_rgb_alpha_color, gx_forward_map_rgb_alpha_color);
set_dev_proc(dev, get_color_mapping_procs, gx_forward_get_color_mapping_procs);
set_dev_proc(dev, get_color_comp_index, gx_forward_get_color_comp_index);
set_dev_proc(dev, encode_color, gx_forward_encode_color);
set_dev_proc(dev, decode_color, gx_forward_decode_color);
set_dev_proc(dev, dev_spec_op, gx_forward_dev_spec_op);
set_dev_proc(dev, fill_rectangle_hl_color, gx_forward_fill_rectangle_hl_color);
set_dev_proc(dev, include_color_space, gx_forward_include_color_space);
set_dev_proc(dev, update_spot_equivalent_colors,
gx_forward_update_spot_equivalent_colors);
set_dev_proc(dev, get_page_device, gx_forward_get_page_device);
set_dev_proc(dev, ret_devn_params, gx_forward_ret_devn_params);
gx_device_set_target((gx_device_forward *)dev, target);
} else {
gx_device_fill_in_procs((gx_device *)dev);
gx_device_forward_fill_in_procs((gx_device_forward *) dev);
}
dev->box_procs = box_procs_default;
dev->box_proc_data = dev;
bbox_copy_params(dev, false);
dev->free_standing = false; /* being used as a component */
}
