/* Finish building a FunctionType 2 (ExponentialInterpolation) function. */
int
gs_build_function_2(i_ctx_t *i_ctx_p, const ref *op, const gs_function_params_t * mnDR,
int depth, gs_function_t ** ppfn, gs_memory_t *mem)
{
gs_function_ElIn_params_t params;
int code, n0, n1;
*(gs_function_params_t *)¶ms = *mnDR;
params.C0 = 0;
params.C1 = 0;
if ((code = dict_float_param(op, "N", 0.0, ¶ms.N)) != 0 ||
(code = n0 = fn_build_float_array_forced(op, "C0", false, ¶ms.C0, mem)) < 0 ||
(code = n1 = fn_build_float_array_forced(op, "C1", false, ¶ms.C1, mem)) < 0
)
goto fail;
if (params.C0 == 0)
n0 = 1; /* C0 defaulted */
if (params.C1 == 0)
n1 = 1; /* C1 defaulted */
if (params.Range == 0)
params.n = n0; /* either one will do */
if (n0 != n1 || n0 != params.n)
goto fail;
code = gs_function_ElIn_init(ppfn, ¶ms, mem);
if (code >= 0)
return 0;
fail:
gs_function_ElIn_free_params(¶ms, mem);
return (code < 0 ? code : gs_note_error(e_rangecheck));
}
/* The caller guarantees that *op is a dictionary. */
int
build_gs_outline_font(i_ctx_t *i_ctx_p, os_ptr op, gs_font_base ** ppfont,
font_type ftype, gs_memory_type_ptr_t pstype,
const build_proc_refs * pbuild,
build_font_options_t options,
build_base_font_proc_t build_base_font)
{
int painttype;
float strokewidth;
gs_font_base *pfont;
int code = dict_int_param(op, "PaintType", 0, 3, 0, &painttype);
if (code < 0)
return code;
code = dict_float_param(op, "StrokeWidth", 0.0, &strokewidth);
if (code < 0)
return code;
code = build_base_font(i_ctx_p, op, ppfont, ftype, pstype, pbuild,
options);
if (code != 0)
return code;
pfont = *ppfont;
pfont->PaintType = painttype;
pfont->StrokeWidth = strokewidth;
return 0;
}
/*
* Get the additional parameters for a Type 2 font (or FontType 2 FDArray
* entry in a CIDFontType 0 font), beyond those common to Type 1 and Type 2
* fonts.
*/
int
type2_font_params(const_os_ptr op, charstring_font_refs_t *pfr,
gs_type1_data *pdata1)
{
int code;
float dwx, nwx;
ref *temp;
pdata1->interpret = gs_type2_interpret;
pdata1->lenIV = DEFAULT_LENIV_2;
pdata1->subroutineNumberBias = subr_bias(pfr->Subrs);
/* Get information specific to Type 2 fonts. */
if (dict_find_string(pfr->Private, "GlobalSubrs", &temp) > 0) {
if (!r_is_array(temp))
return_error(e_typecheck);
pfr->GlobalSubrs = temp;
}
pdata1->gsubrNumberBias = subr_bias(pfr->GlobalSubrs);
if ((code = dict_uint_param(pfr->Private, "gsubrNumberBias",
0, max_uint, pdata1->gsubrNumberBias,
&pdata1->gsubrNumberBias)) < 0 ||
(code = dict_float_param(pfr->Private, "defaultWidthX", 0.0,
&dwx)) < 0 ||
(code = dict_float_param(pfr->Private, "nominalWidthX", 0.0,
&nwx)) < 0
)
return code;
pdata1->defaultWidthX = float2fixed(dwx);
pdata1->nominalWidthX = float2fixed(nwx);
{
ref *pirs;
if (dict_find_string(pfr->Private, "initialRandomSeed", &pirs) <= 0)
pdata1->initialRandomSeed = 0;
else if (!r_has_type(pirs, t_integer))
return_error(e_typecheck);
else
pdata1->initialRandomSeed = pirs->value.intval;
}
return 0;
}
/* from a dictionary. */
static int
dict_spot_params(const ref * pdict, gs_spot_halftone * psp,
ref * psproc, ref * ptproc)
{
int code;
check_dict_read(*pdict);
if ((code = dict_float_param(pdict, "Frequency", 0.0,
&psp->screen.frequency)) != 0 ||
(code = dict_float_param(pdict, "Angle", 0.0,
&psp->screen.angle)) != 0 ||
(code = dict_proc_param(pdict, "SpotFunction", psproc, false)) != 0 ||
(code = dict_bool_param(pdict, "AccurateScreens",
gs_currentaccuratescreens(),
&psp->accurate_screens)) < 0 ||
(code = dict_proc_param(pdict, "TransferFunction", ptproc, false)) < 0
)
return (code < 0 ? code : e_undefined);
psp->transfer = (code > 0 ? (gs_mapping_proc) 0 : gs_mapped_transfer);
psp->transfer_closure.proc = 0;
psp->transfer_closure.data = 0;
return 0;
}
/*
* Similar to fn_build_float_array() except
* - numeric parameter is accepted and converted to 1-element array
* - number of elements is not checked for even/odd
*/
int
fn_build_float_array_forced(const ref * op, const char *kstr, bool required,
const float **pparray, gs_memory_t *mem)
{
ref *par;
int code;
uint size;
float *ptr;
*pparray = 0;
if (dict_find_string(op, kstr, &par) <= 0)
return (required ? gs_note_error(gs_error_rangecheck) : 0);
if( r_is_array(par) )
size = r_size(par);
else if(r_type(par) == t_integer || r_type(par) == t_real)
size = 1;
else
return_error(gs_error_typecheck);
ptr = (float *)gs_alloc_byte_array(mem, size, sizeof(float), kstr);
if (ptr == 0)
return_error(gs_error_VMerror);
if(r_is_array(par) )
code = dict_float_array_check_param(mem, op, kstr,
size, ptr, NULL,
0, gs_error_rangecheck);
else {
code = dict_float_param(op, kstr, 0., ptr); /* defailt cannot happen */
if( code == 0 )
code = 1;
}
if (code < 0 ) {
gs_free_object(mem, ptr, kstr);
return code;
}
*pparray = ptr;
return code;
}
