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;
}
/* Make a scaled copy of a 1-Input Stitching function. */
static int
fn_1ItSg_make_scaled(const gs_function_1ItSg_t *pfn,
gs_function_1ItSg_t **ppsfn,
const gs_range_t *pranges, gs_memory_t *mem)
{
gs_function_1ItSg_t *psfn =
gs_alloc_struct(mem, gs_function_1ItSg_t, &st_function_1ItSg,
"fn_1ItSg_make_scaled");
int code;
if (psfn == 0)
return_error(gs_error_VMerror);
psfn->params = pfn->params;
psfn->params.Functions = 0; /* in case of failure */
psfn->params.Bounds =
fn_copy_values(pfn->params.Bounds, pfn->params.k - 1, sizeof(float),
mem);
psfn->params.Encode =
fn_copy_values(pfn->params.Encode, 2 * pfn->params.k, sizeof(float),
mem);
if ((code = (psfn->params.Bounds == 0 || psfn->params.Encode == 0 ?
gs_note_error(gs_error_VMerror) : 0)) < 0 ||
(code = fn_common_scale((gs_function_t *)psfn,
(const gs_function_t *)pfn,
pranges, mem)) < 0 ||
(code = fn_scale_functions((gs_function_t ***)&psfn->params.Functions,
pfn->params.Functions,
pfn->params.n, pranges, false, mem)) < 0) {
gs_function_free((gs_function_t *)psfn, true, mem);
return code;
}
*ppsfn = psfn;
return 0;
}
/*
* Allocate a data block for holding our data for the client specific
* data for a color space. In our demo, we are only supporting the
* Separation and DeviceN color spaces. We use a single data structure
* to make the code simpler. We also provide sample hooks for a client
* that wants to convert ALL CIEBased color spaces to XYZ (or Lab).
*/
static demo_color_space_data_t *
allocate_client_data_block(int initial_ref_count, gs_memory_t *mem)
{
/*
* We allocate this with normal GC structure declarations since
* we need this to be able to allocate the gs_imager_state for XYZ
* conversion.
* Since this is in stable memory, we use a simple reference count.
* See client_adjust_cspace_count.
*/
demo_color_space_data_t * pdata =
(demo_color_space_data_t *)gs_alloc_struct(mem, demo_color_space_data_t,
&st_demo_color_space_data, "allocate_client_data_block(pdata)");
if (pdata != NULL) {
memset(pdata, 0, sizeof(demo_color_space_data_t));
/*
* All client color space data blocks must have a pointer to a
* reference count adjust routine as their first field.
*/
pdata->client_adjust_cspace_count = client_adjust_cspace_count;
pdata->ref_count = 1;
pdata->memory = mem;
}
return pdata;
}
/* Define the default implementation of ImageType 3 processing. */
static IMAGE3_MAKE_MID_PROC(make_mid_default); /* check prototype */
static int
make_mid_default(gx_device **pmidev, gx_device *dev, int width, int height,
gs_memory_t *mem)
{
gx_device_memory *midev =
gs_alloc_struct(mem, gx_device_memory, &st_device_memory,
"make_mid_default");
int code;
if (midev == 0)
return_error(gs_error_VMerror);
gs_make_mem_mono_device(midev, mem, NULL);
midev->bitmap_memory = mem;
midev->width = width;
midev->height = height;
check_device_separable((gx_device *)midev);
gx_device_fill_in_procs((gx_device *)midev);
code = dev_proc(midev, open_device)((gx_device *)midev);
if (code < 0) {
gs_free_object(mem, midev, "make_mid_default");
return code;
}
midev->is_open = true;
dev_proc(midev, fill_rectangle)
((gx_device *)midev, 0, 0, width, height, (gx_color_index)0);
*pmidev = (gx_device *)midev;
return 0;
}
/*
* Allocate a path on the heap, and initialize it. If shared is NULL,
* allocate a segments object; if shared is an existing path, share its
* segments.
*/
gx_path *
gx_path_alloc_shared(const gx_path * shared, gs_memory_t * mem,
client_name_t cname)
{
gx_path *ppath = gs_alloc_struct(mem, gx_path, &st_path, cname);
if (ppath == 0)
return 0;
ppath->procs = &default_path_procs;
if (shared) {
if (shared->segments == &shared->local_segments) {
lprintf1("Attempt to share (local) segments of path 0x%lx!\n",
(ulong) shared);
gs_free_object(mem, ppath, cname);
return 0;
}
*ppath = *shared;
rc_increment(ppath->segments);
} else {
int code = path_alloc_segments(&ppath->segments, mem, cname);
if (code < 0) {
gs_free_object(mem, ppath, cname);
return 0;
}
gx_path_init_contents(ppath);
}
ppath->memory = mem;
ppath->allocation = path_allocated_on_heap;
return ppath;
}
int
gs_font_cid2_from_type42(gs_font_cid2 **ppfcid, gs_font_type42 *pfont42,
int wmode, gs_memory_t *mem)
{
gs_font_cid2 *pfcid =
gs_alloc_struct(mem, gs_font_cid2, &st_gs_font_cid2,
"gs_font_cid2_from_type42");
if (pfcid == 0)
return_error(gs_error_VMerror);
/* CIDFontType 2 is a subclass (extension) of FontType 42. */
memcpy(pfcid, pfont42, sizeof(*pfont42));
pfcid->memory = mem;
pfcid->next = pfcid->prev = 0; /* probably not necessary */
pfcid->is_resource = 0;
gs_font_notify_init((gs_font *)pfcid);
pfcid->id = gs_next_ids(mem, 1);
pfcid->base = (gs_font *)pfcid;
pfcid->FontType = ft_CID_TrueType;
/* Fill in the rest of the CIDFont data. */
cid_system_info_set_null(&pfcid->cidata.common.CIDSystemInfo);
pfcid->cidata.common.CIDCount = pfont42->data.numGlyphs;
pfcid->cidata.common.GDBytes = 2; /* not used */
pfcid->cidata.MetricsCount = 0;
pfcid->cidata.CIDMap_proc = identity_CIDMap_proc;
/* Since MetricsCount == 0, don't need orig_procs. */
*ppfcid = pfcid;
return 0;
}
/* Obtain a spot analyzer device. */
int
gx_san__obtain(gs_memory_t *mem, gx_device_spot_analyzer **ppadev)
{
gx_device_spot_analyzer *padev;
int code;
if (*ppadev != 0) {
(*ppadev)->lock++;
return 0;
}
padev = gs_alloc_struct(mem, gx_device_spot_analyzer,
&st_device_spot_analyzer, "gx_san__obtain");
if (padev == 0)
return_error(gs_error_VMerror);
gx_device_init((gx_device *)padev, (const gx_device *)&gx_spot_analyzer_device,
mem, false);
code = gs_opendevice((gx_device *)padev);
if (code < 0) {
gs_free_object(mem, padev, "gx_san__obtain");
return code;
}
padev->lock = 1;
*ppadev = padev;
return 0;
}
gsicc_link_cache_t *
gsicc_cache_new(gs_memory_t *memory)
{
gsicc_link_cache_t *result;
/* We want this to be maintained in stable_memory. It should be be effected by the
save and restores */
result = gs_alloc_struct(memory->stable_memory, gsicc_link_cache_t, &st_icc_linkcache,
"gsicc_cache_new");
if ( result == NULL )
return(NULL);
result->lock = gx_monitor_alloc(memory->stable_memory);
result->wait = gx_semaphore_alloc(memory->stable_memory);
if (result->lock == NULL || result->wait == NULL) {
gs_free_object(memory->stable_memory, result, "gsicc_cache_new");
return(NULL);
}
result->num_waiting = 0;
rc_init_free(result, memory->stable_memory, 1, rc_gsicc_link_cache_free);
result->head = NULL;
result->num_links = 0;
result->memory = memory->stable_memory;
if_debug2(gs_debug_flag_icc,"[icc] Allocating link cache = 0x%x memory = 0x%x\n", result,
result->memory);
return(result);
}
int
gs_push_device_filter(gs_memory_t *mem, gs_state *pgs, gs_device_filter_t *df)
{
gs_device_filter_stack_t *dfs;
gx_device *new_dev = NULL;
int code;
dfs = gs_alloc_struct(mem, gs_device_filter_stack_t,
&st_gs_device_filter_stack, "gs_push_device_filter");
if (dfs == NULL)
return_error(gs_error_VMerror);
rc_increment(pgs->device);
dfs->next_device = pgs->device;
code = df->push(df, mem, pgs, &new_dev, pgs->device);
if (code < 0) {
gs_free_object(mem, dfs, "gs_push_device_filter");
return code;
}
dfs->next = pgs->dfilter_stack;
pgs->dfilter_stack = dfs;
dfs->df = df;
rc_init(dfs, mem, 1);
gs_setdevice_no_init(pgs, new_dev);
rc_decrement_only(new_dev, "gs_push_device_filter");
return code;
}
static gsicc_link_t *
gsicc_alloc_link(gs_memory_t *memory, gsicc_hashlink_t hashcode)
{
gsicc_link_t *result;
gx_semaphore_t *wait;
/* The link has to be added in stable memory. We want them
to be maintained across the gsave and grestore process */
result = gs_alloc_struct(memory->stable_memory, gsicc_link_t, &st_icc_link,
"gsicc_alloc_link");
wait = gx_semaphore_alloc(memory->stable_memory);
if (wait == NULL) {
gs_free_object(memory, result, "gsicc_alloc_link(wait)");
result = NULL;
}
if (result != NULL) {
/* set up placeholder values */
result->next = NULL;
result->contextptr = NULL;
result->link_handle = NULL;
result->hashcode.link_hashcode = hashcode.link_hashcode;
result->hashcode.des_hash = 0;
result->hashcode.src_hash = 0;
result->hashcode.rend_hash = 0;
result->ref_count = 1; /* prevent it from being freed */
result->includes_softproof = 0;
result->is_identity = false;
result->valid = false; /* not yet complete */
result->num_waiting = 0;
result->wait = wait;
}
return(result);
}
/*
* make a new dictionary entry.
*/
static int
pl_dict_build_new_entry(pl_dict_t * pdict, const byte * kdata, uint ksize,
void *value, pl_dict_entry_t * link)
{ /* Make a new entry. */
byte *kstr;
gs_memory_t *mem = pdict->memory;
pl_dict_entry_t *pde;
pde = gs_alloc_struct(mem, pl_dict_entry_t, &st_pl_dict_entry,
"pl_dict_put(entry)");
kstr = (ksize <= pl_dict_max_short_key ? pde->short_key :
gs_alloc_string(mem, ksize, "pl_dict_put(key)"));
if (pde == 0 || kstr == 0) {
if (kstr && kstr != pde->short_key)
gs_free_string(mem, kstr, ksize, "pl_dict_put(key)");
gs_free_object(mem, pde, "pl_dict_put(entry)");
return -1;
}
memcpy(kstr, kdata, ksize);
pde->key.data = (ksize <= pl_dict_max_short_key ? 0 : kstr);
pde->key.size = ksize;
pde->link = link;
pde->value = value;
pde->next = pdict->entries;
pdict->entries = pde;
pdict->entry_count++;
return 0;
}
/* Make a scaled copy of an Arrayed Output function. */
static int
fn_AdOt_make_scaled(const gs_function_AdOt_t *pfn, gs_function_AdOt_t **ppsfn,
const gs_range_t *pranges, gs_memory_t *mem)
{
gs_function_AdOt_t *psfn =
gs_alloc_struct(mem, gs_function_AdOt_t, &st_function_AdOt,
"fn_AdOt_make_scaled");
int code;
if (psfn == 0)
return_error(gs_error_VMerror);
psfn->params = pfn->params;
psfn->params.Functions = 0; /* in case of failure */
if ((code = fn_common_scale((gs_function_t *)psfn,
(const gs_function_t *)pfn,
pranges, mem)) < 0 ||
(code = fn_scale_functions((gs_function_t ***)&psfn->params.Functions,
pfn->params.Functions,
pfn->params.n, pranges, true, mem)) < 0) {
gs_function_free((gs_function_t *)psfn, true, mem);
return code;
}
*ppsfn = psfn;
return 0;
}
void
gs_gscolor1_init(gs_memory_t *mem)
{ gs_color_space *pcs =
gs_alloc_struct(mem, gs_color_space, &st_color_space,
"gs_cs_static_DeviceCMYK");
pcs->type = &gs_color_space_type_DeviceCMYK;
gs_cs_static_DeviceCMYK = pcs;
}
/* Create a RasterOp source device. */
int
gx_alloc_rop_texture_device(gx_device_rop_texture ** prsdev, gs_memory_t * mem,
client_name_t cname)
{
*prsdev = gs_alloc_struct(mem, gx_device_rop_texture,
&st_device_rop_texture, cname);
return (*prsdev == 0 ? gs_note_error(gs_error_VMerror) : 0);
}
/* -------------------- public routines below ----------------- */
int
pxJR3BeginImage(px_args_t * par, px_state_t * pxs)
{
int code = 0;
if (!par->source.available) {
px_vendor_state_t *v_state =
gs_alloc_struct(pxs->memory, px_vendor_state_t,
&st_px_vendor_state,
"pxJR3BeginImage(vendor_state)");
byte *row;
UINT16 *qvalues;
if (v_state == 0)
return_error(errorInsufficientMemory);
if (par->pv[8]) { /* SourceWidth */
v_state->SourceWidth = par->pv[8]->value.i;
v_state->data_per_row = par->pv[8]->value.i;
v_state->color_space = pxs->pxgs->color_space;
if (v_state->color_space != eGraySub)
v_state->data_per_row *= 3;
}
v_state->state = vu_blank;
v_state->rowwritten = 0;
row = gs_alloc_byte_array(pxs->memory, 1, v_state->data_per_row,
"pxJR3BeginImage(row)");
if (row == 0)
return_error(errorInsufficientMemory);
qvalues =
(UINT16 *) gs_alloc_byte_array(pxs->memory, 192, sizeof(UINT16),
"pxJR3BeginImage(qvalues)");
if (qvalues == 0)
return_error(errorInsufficientMemory);
pxs->vendor_state = v_state;
pxs->vendor_state->row = row;
pxs->vendor_state->qvalues = qvalues;
pxs->vendor_state->qcount = 0;
}
if (par->pv[1]) {
ulong len = par->pv[1]->value.i;
/* zero or two payloads */
if (len) {
code = vu_tag_dispatch(par, pxs);
/* Multiple payloads, reset to read 2nd */
if (code == 0 && par->source.position < len)
code = vu_tag_dispatch(par, pxs);
}
}
return code;
}
/* Note that all lines have the same notes. */
int
gx_path_add_lines_notes(gx_path *ppath, const gs_fixed_point *ppts, int count,
segment_notes notes)
{
subpath *psub;
segment *prev;
line_segment *lp = 0;
int i;
int code = 0;
if (count <= 0)
return 0;
path_unshare(ppath);
path_open();
psub = ppath->current_subpath;
prev = psub->last;
/*
* We could do better than the following, but this is a start.
* Note that we don't make any attempt to undo partial additions
* if we fail partway through; this is equivalent to what would
* happen with multiple calls on gx_path_add_line.
*/
for (i = 0; i < count; i++) {
fixed x = ppts[i].x;
fixed y = ppts[i].y;
line_segment *next;
if (ppath->bbox_set && outside_bbox(ppath, x, y)) {
code = gs_note_error(gs_error_rangecheck);
break;
}
if (!(next = gs_alloc_struct(gs_memory_stable(ppath->memory),
line_segment, &st_line,
"gx_path_add_lines"))
) {
code = gs_note_error(gs_error_VMerror);
break;
}
lp = next;
lp->type = s_line;
lp->notes = notes;
prev->next = (segment *) lp;
lp->prev = prev;
lp->pt.x = x;
lp->pt.y = y;
prev = (segment *) lp;
trace_segment("[P]", (segment *) lp);
}
if (lp != 0)
ppath->position.x = lp->pt.x,
ppath->position.y = lp->pt.y,
psub->last = (segment *) lp,
lp->next = 0,
path_update_draw(ppath);
return code;
}
/* Allocate and initialize a 1-Input Stitching function. */
int
gs_function_1ItSg_init(gs_function_t ** ppfn,
const gs_function_1ItSg_params_t * params, gs_memory_t * mem)
{
static const gs_function_head_t function_1ItSg_head = {
function_type_1InputStitching,
{
(fn_evaluate_proc_t) fn_1ItSg_evaluate,
(fn_is_monotonic_proc_t) fn_1ItSg_is_monotonic,
(fn_get_info_proc_t) fn_1ItSg_get_info,
(fn_get_params_proc_t) fn_1ItSg_get_params,
(fn_make_scaled_proc_t) fn_1ItSg_make_scaled,
(fn_free_params_proc_t) gs_function_1ItSg_free_params,
fn_common_free,
(fn_serialize_proc_t) gs_function_1ItSg_serialize,
}
};
int n = (params->Range == 0 ? 0 : params->n);
float prev = params->Domain[0];
int i;
*ppfn = 0; /* in case of error */
for (i = 0; i < params->k; ++i) {
const gs_function_t *psubfn = params->Functions[i];
if (psubfn->params.m != 1)
return_error(gs_error_rangecheck);
if (n == 0)
n = psubfn->params.n;
else if (psubfn->params.n != n)
return_error(gs_error_rangecheck);
/* There are only k - 1 Bounds, not k. */
if (i < params->k - 1) {
if (params->Bounds[i] < prev)
return_error(gs_error_rangecheck);
prev = params->Bounds[i];
}
}
if (params->Domain[1] < prev)
return_error(gs_error_rangecheck);
fn_check_mnDR((const gs_function_params_t *)params, 1, n);
{
gs_function_1ItSg_t *pfn =
gs_alloc_struct(mem, gs_function_1ItSg_t, &st_function_1ItSg,
"gs_function_1ItSg_init");
if (pfn == 0)
return_error(gs_error_VMerror);
pfn->params = *params;
pfn->params.m = 1;
pfn->params.n = n;
pfn->head = function_1ItSg_head;
*ppfn = (gs_function_t *) pfn;
}
return 0;
}
/* Initialize the graphics stack. */
gs_state *
int_gstate_alloc(const gs_dual_memory_t * dmem)
{
int_gstate *iigs;
ref proc0;
int_remap_color_info_t *prci;
gs_ref_memory_t *lmem = dmem->space_local;
gs_ref_memory_t *gmem = dmem->space_global;
gs_state *pgs = gs_state_alloc((gs_memory_t *)lmem);
iigs = gs_alloc_struct((gs_memory_t *)lmem, int_gstate, &st_int_gstate,
"int_gstate_alloc(int_gstate)");
int_gstate_map_refs(iigs, make_null);
make_empty_array(&iigs->dash_pattern_array, a_all);
gs_alloc_ref_array(lmem, &proc0, a_readonly + a_executable, 2,
"int_gstate_alloc(proc0)");
make_oper(proc0.value.refs, 0, zpop);
make_real(proc0.value.refs + 1, 0.0);
iigs->black_generation = proc0;
iigs->undercolor_removal = proc0;
make_false(&iigs->use_cie_color);
/*
* Even though the gstate itself is allocated in local VM, the
* container for the color remapping procedure must be allocated in
* global VM so that the gstate can be copied into global VM.
*/
prci = gs_alloc_struct((gs_memory_t *)gmem, int_remap_color_info_t,
&st_int_remap_color_info,
"int_gstate_alloc(remap color info)");
make_struct(&iigs->remap_color_info, imemory_space(gmem), prci);
clear_pagedevice(iigs);
gs_state_set_client(pgs, iigs, &istate_procs, true);
/* PostScript code wants limit clamping enabled. */
gs_setlimitclamp(pgs, true);
/*
* gsave and grestore only work properly
* if there are always at least 2 entries on the stack.
* We count on the PostScript initialization code to do a gsave.
*/
return pgs;
}
/* Create an interpreter pattern structure. */
int
int_pattern_alloc(int_pattern **ppdata, const ref *op, gs_memory_t *mem)
{
int_pattern *pdata =
gs_alloc_struct(mem, int_pattern, &st_int_pattern, "int_pattern");
if (pdata == 0)
return_error(e_VMerror);
pdata->dict = *op;
*ppdata = pdata;
return 0;
}
gs_image_enum *
gs_image_enum_alloc(gs_memory_t * mem, client_name_t cname)
{
gs_image_enum *penum =
gs_alloc_struct(mem, gs_image_enum, &st_gs_image_enum, cname);
if (penum != 0) {
penum->memory = mem;
image_enum_init(penum);
}
return penum;
}
/*
* Allocate and initialize text state bookkeeping.
*/
pdf_text_state_t *
pdf_text_state_alloc(gs_memory_t *mem)
{
pdf_text_state_t *pts =
gs_alloc_struct(mem, pdf_text_state_t, &st_pdf_text_state,
"pdf_text_state_alloc");
if (pts == 0)
return 0;
*pts = ts_default;
return pts;
}
/* Create a system or user name table (in the stable memory of mem). */
int
create_names_array(ref **ppnames, gs_memory_t *mem, client_name_t cname)
{
ref *pnames = (ref *)
gs_alloc_struct(gs_memory_stable(mem), names_array_ref_t,
&st_names_array_ref, cname);
if (pnames == 0)
return_error(gs_error_VMerror);
make_empty_array(pnames, a_readonly);
*ppnames = pnames;
return 0;
}
static int
alpha_buffer_init(gs_state * pgs, fixed extra_x, fixed extra_y, int alpha_bits,
bool devn)
{
gx_device *dev = gs_currentdevice_inline(pgs);
int log2_alpha_bits = ilog2(alpha_bits);
gs_fixed_rect bbox;
gs_int_rect ibox;
uint width, raster, band_space;
uint height;
gs_log2_scale_point log2_scale;
gs_memory_t *mem;
gx_device_memory *mdev;
log2_scale.x = log2_scale.y = log2_alpha_bits;
gx_path_bbox(pgs->path, &bbox);
ibox.p.x = fixed2int(bbox.p.x - extra_x) - 1;
ibox.p.y = fixed2int(bbox.p.y - extra_y) - 1;
ibox.q.x = fixed2int_ceiling(bbox.q.x + extra_x) + 1;
ibox.q.y = fixed2int_ceiling(bbox.q.y + extra_y) + 1;
width = (ibox.q.x - ibox.p.x) << log2_scale.x;
raster = bitmap_raster(width);
band_space = raster << log2_scale.y;
height = (abuf_nominal / band_space) << log2_scale.y;
if (height == 0)
height = 1 << log2_scale.y;
mem = pgs->memory;
mdev = gs_alloc_struct(mem, gx_device_memory, &st_device_memory,
"alpha_buffer_init");
if (mdev == 0)
return 0; /* if no room, don't buffer */
/* We may have to update the marking parameters if we have a pdf14 device
as our target. Need to do while dev is still active in pgs */
if (dev_proc(dev, dev_spec_op)(dev, gxdso_is_pdf14_device, NULL, 0) > 0) {
gs_update_trans_marking_params(pgs);
}
gs_make_mem_abuf_device(mdev, mem, dev, &log2_scale,
alpha_bits, ibox.p.x << log2_scale.x, devn);
mdev->width = width;
mdev->height = height;
mdev->bitmap_memory = mem;
if ((*dev_proc(mdev, open_device)) ((gx_device *) mdev) < 0) {
/* No room for bits, punt. */
gs_free_object(mem, mdev, "alpha_buffer_init");
return 0;
}
gx_set_device_only(pgs, (gx_device *) mdev);
scale_paths(pgs, log2_scale.x, log2_scale.y, true);
return 1;
}
/* Allocate and initialize an Exponential Interpolation function. */
int
gs_function_ElIn_init(gs_function_t ** ppfn,
const gs_function_ElIn_params_t * params,
gs_memory_t * mem)
{
static const gs_function_head_t function_ElIn_head = {
function_type_ExponentialInterpolation,
{
(fn_evaluate_proc_t) fn_ElIn_evaluate,
(fn_is_monotonic_proc_t) fn_ElIn_is_monotonic,
gs_function_get_info_default,
(fn_get_params_proc_t) fn_ElIn_get_params,
(fn_make_scaled_proc_t) fn_ElIn_make_scaled,
(fn_free_params_proc_t) gs_function_ElIn_free_params,
fn_common_free,
(fn_serialize_proc_t) gs_function_ElIn_serialize,
}
};
int code;
*ppfn = 0; /* in case of error */
code = fn_check_mnDR((const gs_function_params_t *)params, 1, params->n);
if (code < 0)
return code;
if ((params->C0 == 0 || params->C1 == 0) && params->n != 1)
return_error(gs_error_rangecheck);
if (params->N != floor(params->N)) {
/* Non-integral exponent, all inputs must be non-negative. */
if (params->Domain[0] < 0)
return_error(gs_error_rangecheck);
}
if (params->N < 0) {
/* Negative exponent, input must not be zero. */
if (params->Domain[0] <= 0 && params->Domain[1] >= 0)
return_error(gs_error_rangecheck);
} {
gs_function_ElIn_t *pfn =
gs_alloc_struct(mem, gs_function_ElIn_t, &st_function_ElIn,
"gs_function_ElIn_init");
if (pfn == 0)
return_error(gs_error_VMerror);
pfn->params = *params;
pfn->params.m = 1;
pfn->head = function_ElIn_head;
*ppfn = (gs_function_t *) pfn;
}
return 0;
}
/* Allocate & init a gx_page_queue_entry */
gx_page_queue_entry_t * /* rets ptr to allocated object, 0 if VM error */
gx_page_queue_entry_alloc(
gx_page_queue_t * queue /* queue that entry is being alloc'd for */
)
{
gx_page_queue_entry_t *entry
= gs_alloc_struct(queue->memory, gx_page_queue_entry_t,
&st_gx_page_queue_entry, "gx_page_queue_entry_alloc");
if (entry != 0) {
entry->next = 0;
entry->queue = queue;
}
return entry;
}
static int
push_transparency_stack(gs_state *pgs, gs_transparency_state_type_t type,
client_name_t cname)
{
gs_transparency_state_t *pts =
gs_alloc_struct(pgs->memory, gs_transparency_state_t,
&st_transparency_state, cname);
if (pts == 0)
return_error(gs_error_VMerror);
pts->saved = pgs->transparency_stack;
pts->type = type;
pgs->transparency_stack = pts;
return 0;
}
static margin * alloc_margin(line_list * ll)
{ margin *m;
if (ll->free_margin_list != 0) {
m = ll->free_margin_list;
ll->free_margin_list = ll->free_margin_list->next;
} else if (ll->local_margin_alloc_count < MAX_LOCAL_ACTIVE) {
m = ll->local_margins + ll->local_margin_alloc_count;
++ ll->local_margin_alloc_count;
} else {
m = gs_alloc_struct(ll->memory, margin, &st_margin, "filling contiguity margin");
/* The allocation happens only if ll->local_margins[MAX_LOCAL_ACTIVE]
is exceeded. We believe it does very seldom. */
}
return m;
}
/* Create an alpha-compositing object. */
int
gs_create_composite_alpha(gs_composite_t ** ppcte,
const gs_composite_alpha_params_t * params, gs_memory_t * mem)
{
gs_composite_alpha_t *pcte;
pcte = gs_alloc_struct(mem, gs_composite_alpha_t, &st_composite_alpha,
"gs_create_composite_alpha");
if (pcte == NULL)
return_error(gs_error_VMerror);
pcte->type = &gs_composite_alpha_type;
pcte->id = gs_next_ids(mem, 1);
pcte->params = *params;
pcte->idle = false;
*ppcte = (gs_composite_t *) pcte;
return 0;
}
int
s_alloc_param_printer(gs_param_list ** pplist,
const param_printer_params_t * ppp, stream * s,
gs_memory_t * mem)
{
printer_param_list_t *prlist =
gs_alloc_struct(mem, printer_param_list_t, &st_printer_param_list,
"s_alloc_param_printer");
int code;
*pplist = (gs_param_list *)prlist;
if (prlist == 0)
return_error(gs_error_VMerror);
code = s_init_param_printer(prlist, ppp, s);
prlist->memory = mem;
return code;
}
/*
* 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;
}
