/* Get the device parameters. */
int
gs_get_device_or_hw_params(gx_device * orig_dev, gs_param_list * plist,
bool is_hardware)
{
/*
* We must be prepared to copy the device if it is the read-only
* prototype.
*/
gx_device *dev;
int code;
if (orig_dev->memory)
dev = orig_dev;
else {
code = gs_copydevice(&dev, orig_dev, plist->memory);
if (code < 0)
return code;
}
gx_device_set_procs(dev);
fill_dev_proc(dev, get_params, gx_default_get_params);
fill_dev_proc(dev, get_page_device, gx_default_get_page_device);
fill_dev_proc(dev, get_alpha_bits, gx_default_get_alpha_bits);
code = (is_hardware ?
(*dev_proc(dev, get_hardware_params)) (dev, plist) :
(*dev_proc(dev, get_params)) (dev, plist));
if (dev != orig_dev)
gx_device_retain(dev, false); /* frees the copy */
return code;
}
/* <device> copydevice <newdevice> */
private int
zcopydevice(register os_ptr op)
{ gx_device *new_dev;
int code;
check_read_type(*op, t_device);
code = gs_copydevice(&new_dev, op->value.pdevice, imemory);
if ( code < 0 )
return code;
new_dev->memory = imemory;
make_tav(op, t_device, icurrent_space | a_all, pdevice, new_dev);
return 0;
}
/* Set up and start the render threads */
static int
clist_setup_render_threads(gx_device *dev, int y)
{
gx_device_printer *pdev = (gx_device_printer *)dev;
gx_device_clist *cldev = (gx_device_clist *)dev;
gx_device_clist_common *cdev = (gx_device_clist_common *)cldev;
gx_device_clist_reader *crdev = &cldev->reader;
gs_memory_t *mem = cdev->bandlist_memory;
gx_device *protodev;
gs_c_param_list paramlist;
int i, code, band;
int band_count = cdev->nbands;
char fmode[4];
crdev->num_render_threads = pdev->num_render_threads_requested;
if(gs_debug[':'] != 0)
dprintf1("%% %d rendering threads requested.\n", pdev->num_render_threads_requested);
if (crdev->num_render_threads > band_count)
crdev->num_render_threads = band_count; /* don't bother starting more threads than bands */
/* Allocate and initialize an array of thread control structures */
crdev->render_threads = (clist_render_thread_control_t *)
gs_alloc_byte_array(mem, crdev->num_render_threads,
sizeof(clist_render_thread_control_t), "clist_setup_render_threads" );
/* fallback to non-threaded if allocation fails */
if (crdev->render_threads == NULL) {
eprintf(" VMerror prevented threads from starting.\n");
return_error(gs_error_VMerror);
}
memset(crdev->render_threads, 0, crdev->num_render_threads *
sizeof(clist_render_thread_control_t));
crdev->main_thread_data = cdev->data; /* save data area */
/* Based on the line number requested, decide the order of band rendering */
/* Almost all devices go in increasing line order (except the bmp* devices ) */
crdev->thread_lookahead_direction = (y < (cdev->height - 1)) ? 1 : -1;
band = y / crdev->page_info.band_params.BandHeight;
/* Close the files so we can open them in multiple threads */
if ((code = cdev->page_info.io_procs->fclose(cdev->page_cfile, cdev->page_cfname, false)) < 0 ||
(code = cdev->page_info.io_procs->fclose(cdev->page_bfile, cdev->page_bfname, false)) < 0) {
gs_free_object(mem, crdev->render_threads, "clist_setup_render_threads");
crdev->render_threads = NULL;
eprintf("Closing clist files prevented threads from starting.\n");
return_error(gs_error_unknownerror); /* shouldn't happen */
}
cdev->page_cfile = cdev->page_bfile = NULL;
strcpy(fmode, "r"); /* read access for threads */
strncat(fmode, gp_fmode_binary_suffix, 1);
/* Find the prototype for this device (needed so we can copy from it) */
for (i=0; (protodev = (gx_device *)gs_getdevice(i)) != NULL; i++)
if (strcmp(protodev->dname, dev->dname) == 0)
break;
if (protodev == NULL) {
eprintf("Could not find prototype device. Rendering threads not started.\n");
return gs_error_rangecheck;
}
gs_c_param_list_write(¶mlist, mem);
if ((code = gs_getdeviceparams(dev, (gs_param_list *)¶mlist)) < 0) {
eprintf1("Error getting device params, code=%d. Rendering threads not started.\n", code);
return code;
}
/* Loop creating the devices and semaphores for each thread, then start them */
for (i=0; (i < crdev->num_render_threads) && (band >= 0) && (band < band_count);
i++, band += crdev->thread_lookahead_direction) {
gx_device *ndev;
gx_device_clist *ncldev;
gx_device_clist_common *ncdev;
clist_render_thread_control_t *thread = &(crdev->render_threads[i]);
/* Every thread will have a 'chunk allocator' to reduce the interaction
* with the 'base' allocator which has 'mutex' (locking) protection.
* This improves performance of the threads.
*/
if ((code = gs_memory_chunk_wrap(&(thread->memory), mem )) < 0) {
eprintf1("chunk_wrap returned error code: %d\n", code);
break;
}
thread->band = -1; /* a value that won't match any valid band */
if ((code = gs_copydevice((gx_device **) &ndev, protodev, thread->memory)) < 0) {
code = 0; /* even though we failed, no cleanup needed */
break;
}
ncldev = (gx_device_clist *)ndev;
ncdev = (gx_device_clist_common *)ndev;
gx_device_fill_in_procs(ndev);
((gx_device_printer *)ncdev)->buffer_memory = ncdev->memory =
ncdev->bandlist_memory = thread->memory;
gs_c_param_list_read(¶mlist);
ndev->PageCount = dev->PageCount; /* copy to prevent mismatch error */
if ((code = gs_putdeviceparams(ndev, (gs_param_list *)¶mlist)) < 0)
break;
ncdev->page_uses_transparency = cdev->page_uses_transparency;
/* gdev_prn_allocate_memory sets the clist for writing, creating new files.
* We need to unlink those files and open the main thread's files, then
* reset the clist state for reading/rendering
*/
if ((code = gdev_prn_allocate_memory(ndev, NULL, ndev->width, ndev->height)) < 0)
break;
thread->cdev = ndev;
/* close and unlink the temp files just created */
cdev->page_info.io_procs->fclose(ncdev->page_cfile, ncdev->page_cfname, true);
cdev->page_info.io_procs->fclose(ncdev->page_bfile, ncdev->page_bfname, true);
/* open the main thread's files for this thread */
if ((code=cdev->page_info.io_procs->fopen(cdev->page_cfname, fmode, &ncdev->page_cfile,
thread->memory, thread->memory, true)) < 0 ||
(code=cdev->page_info.io_procs->fopen(cdev->page_bfname, fmode, &ncdev->page_bfile,
thread->memory, thread->memory, false)) < 0)
break;
clist_render_init(ncldev); /* Initialize clist device for reading */
ncdev->page_bfile_end_pos = cdev->page_bfile_end_pos;
/* create the buf device for this thread, and allocate the semaphores */
if ((code = gdev_create_buf_device(cdev->buf_procs.create_buf_device,
&(thread->bdev), cdev->target,
band*crdev->page_band_height, NULL,
thread->memory, clist_get_band_complexity(dev,y)) < 0))
break;
if ((thread->sema_this = gx_semaphore_alloc(thread->memory)) == NULL ||
(thread->sema_group = gx_semaphore_alloc(thread->memory)) == NULL) {
code = gs_error_VMerror;
break;
}
/* Start thread 'i' to do band */
if ((code = clist_start_render_thread(dev, i, band)) < 0)
break;
}
gs_c_param_list_release(¶mlist);
/* If the code < 0, the last thread creation failed -- clean it up */
if (code < 0) {
/* the following relies on 'free' ignoring NULL pointers */
gx_semaphore_free(crdev->render_threads[i].sema_group);
gx_semaphore_free(crdev->render_threads[i].sema_this);
if (crdev->render_threads[i].bdev != NULL)
cdev->buf_procs.destroy_buf_device(crdev->render_threads[i].bdev);
if (crdev->render_threads[i].cdev != NULL) {
gx_device_clist_common *thread_cdev = (gx_device_clist_common *)crdev->render_threads[i].cdev;
/* Close the file handles, but don't delete (unlink) the files */
thread_cdev->page_info.io_procs->fclose(thread_cdev->page_bfile, thread_cdev->page_bfname, false);
thread_cdev->page_info.io_procs->fclose(thread_cdev->page_cfile, thread_cdev->page_cfname, false);
thread_cdev->do_not_open_or_close_bandfiles = true; /* we already closed the files */
gdev_prn_free_memory((gx_device *)thread_cdev);
gs_free_object(crdev->render_threads[i].memory, thread_cdev,
"clist_setup_render_threads");
}
if (crdev->render_threads[i].memory != NULL)
gs_memory_chunk_release(crdev->render_threads[i].memory);
}
/* If we weren't able to create at least one thread, punt */
/* Although a single thread isn't any more efficient, the */
/* machinery still works, so that's OK. */
if (i == 0) {
if (crdev->render_threads[0].memory != NULL)
gs_memory_chunk_release(crdev->render_threads[0].memory);
gs_free_object(mem, crdev->render_threads, "clist_setup_render_threads");
crdev->render_threads = NULL;
/* restore the file pointers */
if (cdev->page_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_cfname, fmode, &cdev->page_cfile,
mem, cdev->bandlist_memory, true);
cdev->page_info.io_procs->fseek(cdev->page_cfile, 0, SEEK_SET, cdev->page_cfname);
cdev->page_info.io_procs->fopen(cdev->page_bfname, fmode, &cdev->page_bfile,
mem, cdev->bandlist_memory, false);
cdev->page_info.io_procs->fseek(cdev->page_bfile, 0, SEEK_SET, cdev->page_bfname);
}
eprintf1("Rendering threads not started, code=%d.\n", code);
return_error(code);
}
crdev->num_render_threads = i;
crdev->curr_render_thread = 0;
if(gs_debug[':'] != 0)
dprintf1("%% Using %d rendering threads\n", i);
return 0;
}
int
main(int argc, const char *argv[])
{
char achar = '0';
gs_memory_t *mem;
gs_state *pgs;
const gx_device *const *list;
gx_device *dev;
gx_device_bbox *bbdev;
int code;
gp_init();
mem = gs_malloc_init();
gs_lib_init1(mem);
if (argc < 2 || (achar = argv[1][0]) < '1' ||
achar > '0' + countof(tests) - 1
) {
lprintf1("Usage: gslib 1..%c\n", '0' + (char)countof(tests) - 1);
gs_abort(mem);
}
gs_debug['@'] = 1;
gs_debug['?'] = 1;
/*gs_debug['B'] = 1; *//****** PATCH ******/
/*gs_debug['L'] = 1; *//****** PATCH ******/
/*
* gs_iodev_init must be called after the rest of the inits, for
* obscure reasons that really should be documented!
*/
gs_iodev_init(mem);
/****** WRONG ******/
gs_lib_device_list(&list, NULL);
gs_copydevice(&dev, list[0], mem);
check_device_separable(dev);
gx_device_fill_in_procs(dev);
bbdev =
gs_alloc_struct_immovable(mem, gx_device_bbox, &st_device_bbox,
"bbox");
gx_device_bbox_init(bbdev, dev, mem);
code = dev_proc(dev, get_profile)(dev, &bbdev->icc_struct);
rc_increment(bbdev->icc_struct);
/* Print out the device name just to test the gsparam.c API. */
{
gs_c_param_list list;
gs_param_string nstr;
gs_c_param_list_write(&list, mem);
code = gs_getdeviceparams(dev, (gs_param_list *) & list);
if (code < 0) {
lprintf1("getdeviceparams failed! code = %d\n", code);
gs_abort(mem);
}
gs_c_param_list_read(&list);
code = param_read_string((gs_param_list *) & list, "Name", &nstr);
if (code < 0) {
lprintf1("reading Name failed! code = %d\n", code);
gs_abort(mem);
}
dputs("Device name = ");
debug_print_string(nstr.data, nstr.size);
dputs("\n");
gs_c_param_list_release(&list);
}
/*
* If this is a device that takes an OutputFile, set the OutputFile
* to "-" in the copy.
*/
{
gs_c_param_list list;
gs_param_string nstr;
gs_c_param_list_write(&list, mem);
param_string_from_string(nstr, "-");
code = param_write_string((gs_param_list *)&list, "OutputFile", &nstr);
if (code < 0) {
lprintf1("writing OutputFile failed! code = %d\n", code);
gs_abort(mem);
}
gs_c_param_list_read(&list);
code = gs_putdeviceparams(dev, (gs_param_list *)&list);
gs_c_param_list_release(&list);
if (code < 0 && code != gs_error_undefined) {
lprintf1("putdeviceparams failed! code = %d\n", code);
gs_abort(mem);
}
}
dev = (gx_device *) bbdev;
pgs = gs_state_alloc(mem);
gs_setdevice_no_erase(pgs, dev); /* can't erase yet */
{
gs_point dpi;
gs_screen_halftone ht;
gs_dtransform(pgs, 72.0, 72.0, &dpi);
ht.frequency = min(fabs(dpi.x), fabs(dpi.y)) / 16.001;
ht.angle = 0;
ht.spot_function = odsf;
gs_setscreen(pgs, &ht);
}
/* gsave and grestore (among other places) assume that */
/* there are at least 2 gstates on the graphics stack. */
/* Ensure that now. */
gs_gsave(pgs);
gs_erasepage(pgs);
code = (*tests[achar - '1']) (pgs, mem);
gs_output_page(pgs, 1, 1);
{
gs_rect bbox;
gx_device_bbox_bbox(bbdev, &bbox);
dprintf4("Bounding box: [%g %g %g %g]\n",
bbox.p.x, bbox.p.y, bbox.q.x, bbox.q.y);
}
if (code)
dprintf1("**** Test returned code = %d.\n", code);
dputs("Done. Press <enter> to exit.");
fgetc(mem->gs_lib_ctx->fstdin);
gs_lib_finit(0, 0, mem);
return 0;
#undef mem
}
/*
* Open this printer device in ASYNC (overlapped) mode.
* This routine must always called by the concrete device's xx_open routine
* in lieu of gdev_prn_open.
*/
int
gdev_prn_async_write_open(gx_device_printer * pwdev, int max_raster,
int min_band_height, int max_src_image_row)
{
gx_device *const pdev = (gx_device *) pwdev;
int code;
bool writer_is_open = false;
gx_device_clist_writer *const pcwdev =
&((gx_device_clist *) pwdev)->writer;
gx_device_clist_reader *pcrdev = 0;
gx_device_printer *prdev = 0;
gs_memory_t *render_memory = 0; /* renderer's mem allocator */
pwdev->page_queue = 0;
pwdev->bandlist_memory = 0;
pwdev->async_renderer = 0;
/* allocate & init render memory */
/* The big memory consumers are: */
/* - the buffer used to read images from the command list */
/* - buffer used by gx_real_default_strip_copy_rop() */
/* - line pointer tables for memory devices used in plane extraction */
/* - the halftone cache */
/* - the band rendering buffer */
/* The * 2's in the next statement are a ****** HACK ****** to deal with */
/* sandbars in the memory manager. */
if ((code = alloc_render_memory(&render_memory,
pwdev->memory->non_gc_memory, RendererAllocationOverheadBytes + max_raster
/* the first * 2 is not a hack */
+ (max_raster + sizeof(void *) * 2) * min_band_height
+ max_src_image_row + gx_ht_cache_default_bits_size() * 2)) < 0)
goto open_err;
/* Alloc & init bandlist allocators */
/* Bandlist mem is threadsafe & common to rdr/wtr, so it's used */
/* for page queue & cmd list buffers. */
if ((code = alloc_bandlist_memory
(&pwdev->bandlist_memory, pwdev->memory->non_gc_memory)) < 0)
goto open_err;
/* Dictate banding parameters for both renderer & writer */
/* Protect from user change, since user changing these won't be */
/* detected, ergo the necessary close/reallocate/open wouldn't happen. */
pwdev->space_params.banding_type = BandingAlways;
pwdev->space_params.params_are_read_only = true;
/* Make a copy of device for use as rendering device b4 opening writer */
code = gs_copydevice((gx_device **) & prdev, pdev, render_memory);
pcrdev = &((gx_device_clist *) prdev)->reader;
if (code < 0)
goto open_err;
/* -------------- Open cmd list WRITER instance of device ------- */
/* --------------------------------------------------------------- */
/* This is wrong, because it causes the same thing in the renderer */
pwdev->OpenOutputFile = 0; /* Don't open output file in writer */
/* Hack: set this vector to tell gdev_prn_open to allocate for async rendering */
pwdev->free_up_bandlist_memory = &gdev_prn_async_write_free_up_bandlist_memory;
/* prevent clist writer from queuing path graphics & force it to split images */
pwdev->clist_disable_mask |= clist_disable_fill_path |
clist_disable_stroke_path | clist_disable_complex_clip |
clist_disable_nonrect_hl_image | clist_disable_pass_thru_params;
if ((code = gdev_prn_open(pdev)) >= 0) {
writer_is_open = true;
/* set up constant async-specific fields in device */
reinit_printer_into_printera(pwdev);
/* keep ptr to renderer device */
pwdev->async_renderer = prdev;
/* Allocate the page queue, then initialize it */
/* Use bandlist memory since it's shared between rdr & wtr */
if ((pwdev->page_queue = gx_page_queue_alloc(pwdev->bandlist_memory)) == 0)
code = gs_note_error(gs_error_VMerror);
else
/* Allocate from clist allocator since it is thread-safe */
code = gx_page_queue_init(pwdev->page_queue, pwdev->bandlist_memory);
}
/* ------------ Open cmd list RENDERER instance of device ------- */
/* --------------------------------------------------------------- */
if (code >= 0) {
gx_semaphore_t *open_semaphore;
/* Force writer's actual band params into reader's requested params */
prdev->space_params.band = pcwdev->page_info.band_params;
/* copydevice has already set up prdev->memory = render_memory */
/* prdev->bandlist_memory = pwdev->bandlist_memory; */
prdev->buffer_memory = prdev->memory;
/* enable renderer to accept changes to params computed by writer */
prdev->space_params.params_are_read_only = false;
/* page queue is common to both devices */
prdev->page_queue = pwdev->page_queue;
/* Start renderer thread & wait for its successful open of device */
if (!(open_semaphore = gx_semaphore_alloc(prdev->memory)))
code = gs_note_error(gs_error_VMerror);
else {
gdev_prn_start_render_params thread_params;
thread_params.writer_device = pwdev;
thread_params.open_semaphore = open_semaphore;
thread_params.open_code = 0;
code = (*pwdev->printer_procs.start_render_thread)
(&thread_params);
if (code >= 0)
gx_semaphore_wait(open_semaphore);
code = thread_params.open_code;
gx_semaphore_free(open_semaphore);
}
}
/* ----- Set the recovery procedure for the mem allocator ----- */
if (code >= 0) {
gs_memory_retrying_set_recover(
(gs_memory_retrying_t *)pwdev->memory->non_gc_memory,
prna_mem_recover,
(void *)pcwdev
);
}
/* --------------------- Wrap up --------------------------------- */
/* --------------------------------------------------------------- */
if (code < 0) {
open_err:
/* error mop-up */
if (render_memory && !prdev)
free_render_memory(render_memory);
gdev_prn_dealloc(pwdev);
if (writer_is_open) {
gdev_prn_close(pdev);
pwdev->free_up_bandlist_memory = 0;
}
}
return code;
}
/* Exported for use by background printing. */
gx_device *
setup_device_and_mem_for_thread(gs_memory_t *chunk_base_mem, gx_device *dev, bool bg_print, gsicc_link_cache_t **cachep)
{
int i, code;
char fmode[4];
gs_memory_t *thread_mem;
gx_device_clist *cldev = (gx_device_clist *)dev;
gx_device_printer *pdev = (gx_device_printer *)dev;
gx_device_clist_common *cdev = (gx_device_clist_common *)cldev;
gx_device *ndev;
gx_device_clist *ncldev;
gx_device_clist_common *ncdev;
gx_device_printer *npdev;
gx_device *protodev;
gs_c_param_list paramlist;
gs_devn_params *pclist_devn_params;
/* Every thread will have a 'chunk allocator' to reduce the interaction
* with the 'base' allocator which has 'mutex' (locking) protection.
* This improves performance of the threads.
*/
if ((code = gs_memory_chunk_wrap(&(thread_mem), chunk_base_mem )) < 0) {
emprintf1(dev->memory, "chunk_wrap returned error code: %d\n", code);
return NULL;
}
/* Find the prototype for this device (needed so we can copy from it) */
for (i=0; (protodev = (gx_device *)gs_getdevice(i)) != NULL; i++)
if (strcmp(protodev->dname, dev->dname) == 0)
break;
/* Clone the device from the prototype device */
if (protodev == NULL ||
(code = gs_copydevice((gx_device **) &ndev, protodev, thread_mem)) < 0) {
gs_memory_chunk_release(thread_mem);
return NULL;
}
ncldev = (gx_device_clist *)ndev;
ncdev = (gx_device_clist_common *)ndev;
npdev = (gx_device_printer *)ndev;
gx_device_fill_in_procs(ndev);
((gx_device_printer *)ncdev)->buffer_memory =
ncdev->memory =
ncdev->bandlist_memory =
thread_mem;
ndev->PageCount = dev->PageCount; /* copy to prevent mismatch error */
npdev->file = pdev->file; /* For background printing when doing N copies with %d */
strcpy((npdev->fname), (pdev->fname));
ndev->color_info = dev->color_info; /* copy before putdeviceparams */
ndev->pad = dev->pad;
ndev->log2_align_mod = dev->log2_align_mod;
ndev->is_planar = dev->is_planar;
#if CMM_THREAD_SAFE
ndev->icc_struct = dev->icc_struct; /* Set before put params */
rc_increment(ndev->icc_struct);
#endif
/* get the current device parameters to put into the cloned device */
gs_c_param_list_write(¶mlist, dev->memory);
if ((code = gs_getdeviceparams(dev, (gs_param_list *)¶mlist)) < 0) {
emprintf1(dev->memory,
"Error getting device params, code=%d. Rendering threads not started.\n",
code);
goto out_cleanup;
}
gs_c_param_list_read(¶mlist);
if ((code = gs_putdeviceparams(ndev, (gs_param_list *)¶mlist)) < 0)
goto out_cleanup;
gs_c_param_list_release(¶mlist);
/* In the case of a separation device, we need to make sure we get the
devn params copied over */
pclist_devn_params = dev_proc(dev, ret_devn_params)(dev);
if (pclist_devn_params != NULL) {
code = devn_copy_params(dev, ndev);
if (code < 0) {
#ifdef DEBUG /* suppress a warning on a release build */
gs_note_error(gs_error_VMerror);
#endif
goto out_cleanup;
}
}
/* Also make sure supports_devn is set correctly */
ndev->icc_struct->supports_devn = cdev->icc_struct->supports_devn;
ncdev->page_uses_transparency = cdev->page_uses_transparency;
if_debug3m(gs_debug_flag_icc, cdev->memory,
"[icc] MT clist device = 0x%p profile = 0x%p handle = 0x%p\n",
ncdev,
ncdev->icc_struct->device_profile[0],
ncdev->icc_struct->device_profile[0]->profile_handle);
/* If the device is_planar, then set the flag in the new_device and the procs */
if ((ncdev->is_planar = cdev->is_planar))
gdev_prn_set_procs_planar(ndev);
/* gdev_prn_allocate_memory sets the clist for writing, creating new files.
* We need to unlink those files and open the main thread's files, then
* reset the clist state for reading/rendering
*/
if ((code = gdev_prn_allocate_memory(ndev, NULL, ndev->width, ndev->height)) < 0)
goto out_cleanup;
/* close and unlink the temp files just created */
ncdev->page_info.io_procs->fclose(ncdev->page_info.cfile, ncdev->page_info.cfname, true);
ncdev->page_info.io_procs->fclose(ncdev->page_info.bfile, ncdev->page_info.bfname, true);
ncdev->page_info.cfile = ncdev->page_info.bfile = NULL;
/* open the main thread's files for this thread */
strcpy(fmode, "r"); /* read access for threads */
strncat(fmode, gp_fmode_binary_suffix, 1);
if ((code=cdev->page_info.io_procs->fopen(cdev->page_info.cfname, fmode, &ncdev->page_info.cfile,
thread_mem, thread_mem, true)) < 0 ||
(code=cdev->page_info.io_procs->fopen(cdev->page_info.bfname, fmode, &ncdev->page_info.bfile,
thread_mem, thread_mem, false)) < 0)
goto out_cleanup;
strcpy((ncdev->page_info.cfname), (cdev->page_info.cfname));
strcpy((ncdev->page_info.bfname), (cdev->page_info.bfname));
clist_render_init(ncldev); /* Initialize clist device for reading */
ncdev->page_info.bfile_end_pos = cdev->page_info.bfile_end_pos;
/* The threads are maintained until clist_finish_page. At which
point, the threads are torn down, the master clist reader device
is changed to writer, and the icc_table and the icc_cache_cl freed */
#if CMM_THREAD_SAFE
/* safe to share the link cache */
ncdev->icc_cache_cl = cdev->icc_cache_cl;
rc_increment(cdev->icc_cache_cl, "setup_render_thread");
#else
/* each thread needs its own link cache */
if (cachep != NULL) {
if (*cachep == NULL) {
/* We don't have one cached that we can reuse, so make one. */
if ((*cachep = gsicc_cache_new(thread_mem->thread_safe_memory)) == NULL)
goto out_cleanup;
}
rc_increment(*cachep);
ncdev->icc_cache_cl = *cachep;
} else if ((ncdev->icc_cache_cl = gsicc_cache_new(thread_mem)) == NULL)
goto out_cleanup;
#endif
if (bg_print) {
gx_device_clist_reader *ncrdev = (gx_device_clist_reader *)ncdev;
if (cdev->icc_table != NULL) {
/* This is a background printing thread, so it cannot share the icc_table */
/* since this probably was created with a GC'ed allocator and the bg_print */
/* thread can't deal with the relocation. Free the cdev->icc_table and get */
/* a new one from the clist. */
clist_free_icc_table(cdev->icc_table, cdev->memory);
cdev->icc_table = NULL;
if ((code = clist_read_icctable((gx_device_clist_reader *)ncdev)) < 0)
goto out_cleanup;
}
/* Similarly for the color_usage_array, when the foreground device switches to */
/* writer mode, the foreground's array will be freed. */
if ((code = clist_read_color_usage_array(ncrdev)) < 0)
goto out_cleanup;
} else {
/* Use the same profile table and color usage array in each thread */
ncdev->icc_table = cdev->icc_table; /* OK for multiple rendering threads */
((gx_device_clist_reader *)ncdev)->color_usage_array =
((gx_device_clist_reader *)cdev)->color_usage_array;
}
/* Needed for case when the target has cielab profile and pdf14 device
has a RGB profile stored in the profile list of the clist */
ncdev->trans_dev_icc_hash = cdev->trans_dev_icc_hash;
/* success */
return ndev;
out_cleanup:
/* Close the file handles, but don't delete (unlink) the files */
if (ncdev->page_info.bfile != NULL)
ncdev->page_info.io_procs->fclose(ncdev->page_info.bfile, ncdev->page_info.bfname, false);
if (ncdev->page_info.cfile != NULL)
ncdev->page_info.io_procs->fclose(ncdev->page_info.cfile, ncdev->page_info.cfname, false);
ncdev->do_not_open_or_close_bandfiles = true; /* we already closed the files */
if (ndev != NULL) {
gdev_prn_free_memory(ndev);
gs_free_object(thread_mem, ndev, "setup_device_and_mem_for_thread");
}
gs_memory_chunk_release(thread_mem);
return NULL;
}
