/*
* Do the generic work for makepattern: allocate the instance and the
* saved graphics state, and fill in the common members.
*/
int
gs_make_pattern_common(gs_client_color *pcc,
const gs_pattern_template_t *ptemp,
const gs_matrix *pmat, gs_state *pgs, gs_memory_t *mem,
gs_memory_type_ptr_t pstype)
{
gs_pattern_instance_t *pinst;
gs_state *saved;
if (mem == 0)
mem = gs_state_memory(pgs);
rc_alloc_struct_1(pinst, gs_pattern_instance_t, pstype, mem,
return_error(gs_error_VMerror),
"gs_make_pattern_common");
pinst->rc.free = rc_free_pattern_instance;
pinst->type = ptemp->type;
saved = gs_state_copy(pgs, mem);
if (saved == 0) {
gs_free_object(mem, pinst, "gs_make_pattern_common");
return_error(gs_error_VMerror);
}
gs_concat(saved, pmat);
gs_newpath(saved);
pinst->saved = saved;
pcc->pattern = pinst;
pcc->pattern->pattern_id = gs_next_ids(mem, 1);
return 0;
}
/*
* DeviceN and NChannel color spaces can have an attributes dict. In the
* attribute dict can be a Colorants dict which contains Separation color
* spaces. If the Colorant dict is present, the PS logic will build each of
* the Separation color spaces in a temp gstate and then call this procedure
* to attach the Separation color space to the DeviceN color space.
* The parameter to this procedure is a colorant name. The Separation
* color space is in the current (temp) gstate. The DeviceN color space is
* in the next gstate down in the gstate list (pgs->saved).
*/
int
gs_attachattributecolorspace(gs_separation_name sep_name, gs_state * pgs)
{
gs_color_space * pdevncs;
gs_device_n_attributes * patt;
/* Verify that we have a DeviceN color space */
if (!pgs->saved)
return_error(gs_error_rangecheck);
pdevncs = gs_currentcolorspace_inline(pgs->saved);
if (pdevncs->type != &gs_color_space_type_DeviceN)
return_error(gs_error_rangecheck);
/* Allocate an attribute list element for our linked list of attributes */
rc_alloc_struct_1(patt, gs_device_n_attributes, &st_device_n_attributes,
pgs->memory, return_error(gs_error_VMerror),
"gs_attachattributrescolorspace");
/* Point our attribute list entry to the attribute color space */
patt->colorant_name = sep_name;
patt->cspace = gs_currentcolorspace_inline(pgs);
rc_increment_cs(patt->cspace);
/* Link our new attribute color space to the DeviceN color space */
patt->next = pdevncs->params.device_n.colorants;
pdevncs->params.device_n.colorants = patt;
return 0;
}
/*
* Initialize a path contained in an already-heap-allocated object,
* optionally allocating its segments.
*/
static int
path_alloc_segments(gx_path_segments ** ppsegs, gs_memory_t * mem,
client_name_t cname)
{
mem = gs_memory_stable(mem);
rc_alloc_struct_1(*ppsegs, gx_path_segments, &st_path_segments,
mem, return_error(gs_error_VMerror), cname);
(*ppsegs)->rc.free = rc_free_path_segments;
return 0;
}
/* Allocate and initialize a DeviceN map. */
int
alloc_device_n_map(gs_device_n_map ** ppmap, gs_memory_t * mem,
client_name_t cname)
{
gs_device_n_map *pimap;
rc_alloc_struct_1(pimap, gs_device_n_map, &st_device_n_map, mem,
return_error(gs_error_VMerror), cname);
pimap->tint_transform = 0;
pimap->tint_transform_data = 0;
pimap->cache_valid = false;
*ppmap = pimap;
return 0;
}
/*
* Reconstruct a transfer function from its serial representation. The
* buffer provided is expected to be large enough to hold the entire
* transfer function.
*
* Returns the number of bytes read, or < 0 in the event of an error.
*/
static int
gx_ht_read_tf(
gx_transfer_map ** ppmap,
const byte * data,
uint size,
gs_memory_t * mem )
{
gx_ht_tf_type_t tf_type;
gx_transfer_map * pmap;
/* read the type byte */
if (size == 0)
return_error(gs_error_rangecheck);
--size;
tf_type = (gx_ht_tf_type_t)*data++;
/* if no transfer function, exit now */
if (tf_type == gx_ht_tf_none) {
*ppmap = 0;
return 1;
}
/* allocate a transfer map */
rc_alloc_struct_1( pmap,
gx_transfer_map,
&st_transfer_map,
mem,
return_error(gs_error_VMerror),
"gx_ht_read_tf" );
pmap->id = gs_next_ids(mem, 1);
pmap->closure.proc = 0;
pmap->closure.data = 0;
if (tf_type == gx_ht_tf_identity) {
gx_set_identity_transfer(pmap);
return 1;
} else if (tf_type == gx_ht_tf_complete && size >= sizeof(pmap->values)) {
memcpy(pmap->values, data, sizeof(pmap->values));
pmap->proc = gs_mapped_transfer;
*ppmap = pmap;
return 1 + sizeof(pmap->values);
} else {
rc_decrement(pmap, "gx_ht_read_tf");
return_error(gs_error_rangecheck);
}
}
/*
* Allocate an indexed map for an Indexed or Separation color space.
*/
int
alloc_indexed_map(gs_indexed_map ** ppmap, int nvals, gs_memory_t * pmem,
client_name_t cname)
{
gs_indexed_map *pimap;
rc_alloc_struct_1(pimap, gs_indexed_map, &st_indexed_map, pmem,
return_error(gs_error_VMerror), cname);
if (nvals > 0) {
pimap->values =
(float *)gs_alloc_byte_array(pmem, nvals, sizeof(float), cname);
if (pimap->values == 0) {
gs_free_object(pmem, pimap, cname);
return_error(gs_error_VMerror);
}
} else
pimap->values = 0;
pimap->rc.free = free_indexed_map;
pimap->proc_data = 0; /* for GC */
pimap->num_values = nvals;
*ppmap = pimap;
return 0;
}