summaryrefslogtreecommitdiff
path: root/gs/base/gsfunc3.c
diff options
context:
space:
mode:
Diffstat (limited to 'gs/base/gsfunc3.c')
-rw-r--r--gs/base/gsfunc3.c748
1 files changed, 748 insertions, 0 deletions
diff --git a/gs/base/gsfunc3.c b/gs/base/gsfunc3.c
new file mode 100644
index 000000000..990a6b0df
--- /dev/null
+++ b/gs/base/gsfunc3.c
@@ -0,0 +1,748 @@
+/* Copyright (C) 2001-2006 Artifex Software, Inc.
+ All Rights Reserved.
+
+ This software is provided AS-IS with no warranty, either express or
+ implied.
+
+ This software is distributed under license and may not be copied, modified
+ or distributed except as expressly authorized under the terms of that
+ license. Refer to licensing information at http://www.artifex.com/
+ or contact Artifex Software, Inc., 7 Mt. Lassen Drive - Suite A-134,
+ San Rafael, CA 94903, U.S.A., +1(415)492-9861, for further information.
+*/
+
+/* $Id$ */
+/* Implementation of LL3 Functions */
+#include "math_.h"
+#include "memory_.h"
+#include "gx.h"
+#include "gserrors.h"
+#include "gsfunc3.h"
+#include "gsparam.h"
+#include "gxfunc.h"
+#include "gxarith.h"
+#include "stream.h"
+
+/* ---------------- Utilities ---------------- */
+
+#define MASK1 ((uint)(~0) / 3)
+
+/*
+ * Free an array of subsidiary Functions. Note that this may be called
+ * before the Functions array has been fully initialized. Note also that
+ * its argument conforms to the Functions array in the parameter structure,
+ * but it (necessarily) deconstifies it.
+ */
+static void
+fn_free_functions(const gs_function_t *const * Functions, int count,
+ gs_memory_t * mem)
+{
+ int i;
+
+ for (i = count; --i >= 0;)
+ if (Functions[i])
+ gs_function_free((gs_function_t *)Functions[i], true, mem);
+ gs_free_const_object(mem, Functions, "Functions");
+}
+
+/*
+ * Scale an array of subsidiary functions. Note that the scale may either
+ * be propagated unchanged (step_ranges = false) or divided among the
+ * (1-output) subfunctions (step_ranges = true).
+ */
+static int
+fn_scale_functions(gs_function_t ***ppsfns, const gs_function_t *const *pfns,
+ int count, const gs_range_t *pranges, bool step_ranges,
+ gs_memory_t *mem)
+{
+ gs_function_t **psfns;
+ int code = alloc_function_array(count, &psfns, mem);
+ const gs_range_t *ranges = pranges;
+ int i;
+
+ if (code < 0)
+ return code;
+ for (i = 0; i < count; ++i) {
+ int code = gs_function_make_scaled(pfns[i], &psfns[i], ranges, mem);
+
+ if (code < 0) {
+ fn_free_functions((const gs_function_t *const *)psfns, count, mem);
+ return code;
+ }
+ if (step_ranges)
+ ++ranges;
+ }
+ *ppsfns = psfns;
+ return 0;
+}
+
+/* ---------------- Exponential Interpolation functions ---------------- */
+
+typedef struct gs_function_ElIn_s {
+ gs_function_head_t head;
+ gs_function_ElIn_params_t params;
+} gs_function_ElIn_t;
+
+private_st_function_ElIn();
+
+/* Evaluate an Exponential Interpolation function. */
+static int
+fn_ElIn_evaluate(const gs_function_t * pfn_common, const float *in, float *out)
+{
+ const gs_function_ElIn_t *const pfn =
+ (const gs_function_ElIn_t *)pfn_common;
+ double arg = in[0], raised;
+ int i;
+
+ if (arg < pfn->params.Domain[0])
+ arg = pfn->params.Domain[0];
+ else if (arg > pfn->params.Domain[1])
+ arg = pfn->params.Domain[1];
+ raised = pow(arg, pfn->params.N);
+ for (i = 0; i < pfn->params.n; ++i) {
+ float v0 = (pfn->params.C0 == 0 ? 0.0 : pfn->params.C0[i]);
+ float v1 = (pfn->params.C1 == 0 ? 1.0 : pfn->params.C1[i]);
+ double value = v0 + raised * (v1 - v0);
+
+ if (pfn->params.Range) {
+ float r0 = pfn->params.Range[2 * i],
+ r1 = pfn->params.Range[2 * i + 1];
+
+ if (value < r0)
+ value = r0;
+ else if (value > r1)
+ value = r1;
+ }
+ out[i] = value;
+ if_debug3('~', "[~]ElIn %g => [%d]%g\n", arg, i, out[i]);
+ }
+ return 0;
+}
+
+/* Test whether an Exponential function is monotonic. (They always are.) */
+static int
+fn_ElIn_is_monotonic(const gs_function_t * pfn_common,
+ const float *lower, const float *upper, uint *mask)
+{
+ const gs_function_ElIn_t *const pfn =
+ (const gs_function_ElIn_t *)pfn_common;
+
+ if (lower[0] > pfn->params.Domain[1] ||
+ upper[0] < pfn->params.Domain[0]
+ )
+ return_error(gs_error_rangecheck);
+ *mask = 0;
+ return 1;
+}
+
+/* Write Exponential Interpolation function parameters on a parameter list. */
+static int
+fn_ElIn_get_params(const gs_function_t *pfn_common, gs_param_list *plist)
+{
+ const gs_function_ElIn_t *const pfn =
+ (const gs_function_ElIn_t *)pfn_common;
+ int ecode = fn_common_get_params(pfn_common, plist);
+ int code;
+
+ if (pfn->params.C0) {
+ if ((code = param_write_float_values(plist, "C0", pfn->params.C0,
+ pfn->params.n, false)) < 0)
+ ecode = code;
+ }
+ if (pfn->params.C1) {
+ if ((code = param_write_float_values(plist, "C1", pfn->params.C1,
+ pfn->params.n, false)) < 0)
+ ecode = code;
+ }
+ if ((code = param_write_float(plist, "N", &pfn->params.N)) < 0)
+ ecode = code;
+ return ecode;
+}
+
+/* Make a scaled copy of an Exponential Interpolation function. */
+static int
+fn_ElIn_make_scaled(const gs_function_ElIn_t *pfn,
+ gs_function_ElIn_t **ppsfn,
+ const gs_range_t *pranges, gs_memory_t *mem)
+{
+ gs_function_ElIn_t *psfn =
+ gs_alloc_struct(mem, gs_function_ElIn_t, &st_function_ElIn,
+ "fn_ElIn_make_scaled");
+ float *c0;
+ float *c1;
+ int code, i;
+
+ if (psfn == 0)
+ return_error(gs_error_VMerror);
+ psfn->params = pfn->params;
+ psfn->params.C0 = c0 =
+ fn_copy_values(pfn->params.C0, pfn->params.n, sizeof(float), mem);
+ psfn->params.C1 = c1 =
+ fn_copy_values(pfn->params.C1, pfn->params.n, sizeof(float), mem);
+ if ((code = ((c0 == 0 && pfn->params.C0 != 0) ||
+ (c1 == 0 && pfn->params.C1 != 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) {
+ gs_function_free((gs_function_t *)psfn, true, mem);
+ return code;
+ }
+ for (i = 0; i < pfn->params.n; ++i) {
+ double base = pranges[i].rmin, factor = pranges[i].rmax - base;
+
+ c1[i] = c1[i] * factor + base;
+ c0[i] = c0[i] * factor + base;
+ }
+ *ppsfn = psfn;
+ return 0;
+}
+
+/* Free the parameters of an Exponential Interpolation function. */
+void
+gs_function_ElIn_free_params(gs_function_ElIn_params_t * params,
+ gs_memory_t * mem)
+{
+ gs_free_const_object(mem, params->C1, "C1");
+ gs_free_const_object(mem, params->C0, "C0");
+ fn_common_free_params((gs_function_params_t *) params, mem);
+}
+
+/* Serialize. */
+static int
+gs_function_ElIn_serialize(const gs_function_t * pfn, stream *s)
+{
+ uint n;
+ const gs_function_ElIn_params_t * p = (const gs_function_ElIn_params_t *)&pfn->params;
+ int code = fn_common_serialize(pfn, s);
+
+ if (code < 0)
+ return code;
+ code = sputs(s, (const byte *)&p->C0[0], sizeof(p->C0[0]) * p->n, &n);
+ if (code < 0)
+ return code;
+ code = sputs(s, (const byte *)&p->C1[0], sizeof(p->C1[0]) * p->n, &n);
+ if (code < 0)
+ return code;
+ return sputs(s, (const byte *)&p->N, sizeof(p->N), &n);
+}
+
+/* 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;
+}
+
+/* ---------------- 1-Input Stitching functions ---------------- */
+
+typedef struct gs_function_1ItSg_s {
+ gs_function_head_t head;
+ gs_function_1ItSg_params_t params;
+} gs_function_1ItSg_t;
+
+private_st_function_1ItSg();
+
+/* Evaluate a 1-Input Stitching function. */
+static int
+fn_1ItSg_evaluate(const gs_function_t * pfn_common, const float *in, float *out)
+{
+ const gs_function_1ItSg_t *const pfn =
+ (const gs_function_1ItSg_t *)pfn_common;
+ float arg = in[0], b0, b1, e0, encoded;
+ int k = pfn->params.k;
+ int i;
+
+ if (arg < pfn->params.Domain[0]) {
+ arg = pfn->params.Domain[0];
+ i = 0;
+ } else if (arg > pfn->params.Domain[1]) {
+ arg = pfn->params.Domain[1];
+ i = k - 1;
+ } else {
+ for (i = 0; i < k - 1; ++i)
+ if (arg <= pfn->params.Bounds[i])
+ break;
+ }
+ b0 = (i == 0 ? pfn->params.Domain[0] : pfn->params.Bounds[i - 1]);
+ b1 = (i == k - 1 ? pfn->params.Domain[1] : pfn->params.Bounds[i]);
+ e0 = pfn->params.Encode[2 * i];
+ if (b1 == b0)
+ encoded = e0;
+ else
+ encoded =
+ (arg - b0) * (pfn->params.Encode[2 * i + 1] - e0) / (b1 - b0) + e0;
+ if_debug3('~', "[~]1ItSg %g in %d => %g\n", arg, i, encoded);
+ return gs_function_evaluate(pfn->params.Functions[i], &encoded, out);
+}
+
+/* Test whether a 1-Input Stitching function is monotonic. */
+static int
+fn_1ItSg_is_monotonic(const gs_function_t * pfn_common,
+ const float *lower, const float *upper, uint *mask)
+{
+ const gs_function_1ItSg_t *const pfn =
+ (const gs_function_1ItSg_t *)pfn_common;
+ float v0 = lower[0], v1 = upper[0];
+ float d0 = pfn->params.Domain[0], d1 = pfn->params.Domain[1];
+ int k = pfn->params.k;
+ int i;
+
+ *mask = 0;
+ if (v0 > v1) {
+ v0 = v1; v1 = lower[0];
+ }
+ if (v0 > d1 || v1 < d0)
+ return_error(gs_error_rangecheck);
+ if (v0 < d0)
+ v0 = d0;
+ if (v1 > d1)
+ v1 = d1;
+ for (i = 0; i < pfn->params.k; ++i) {
+ float b0 = (i == 0 ? d0 : pfn->params.Bounds[i - 1]);
+ float b1 = (i == k - 1 ? d1 : pfn->params.Bounds[i]);
+ const float bsmall = (float)1e-6 * (b1 - b0);
+ float esmall;
+ float e0, e1;
+ float w0, w1;
+ float vv0, vv1;
+ double vb0, vb1;
+
+ if (v0 >= b1)
+ continue;
+ if (v0 >= b1 - bsmall)
+ continue; /* Ignore a small noise */
+ vv0 = max(b0, v0);
+ vv1 = v1;
+ if (vv1 > b1 && v1 < b1 + bsmall)
+ vv1 = b1; /* Ignore a small noise */
+ if (vv0 == vv1)
+ return 1;
+ if (vv0 < b1 && vv1 > b1) {
+ *mask = 1;
+ return 0; /* Consider stitches as monotonity breaks. */
+ }
+ e0 = pfn->params.Encode[2 * i];
+ e1 = pfn->params.Encode[2 * i + 1];
+ esmall = (float)1e-6 * any_abs(e1 - e0);
+ vb0 = max(vv0, b0);
+ vb1 = min(vv1, b1);
+ w0 = (float)(vb0 - b0) * (e1 - e0) / (b1 - b0) + e0;
+ w1 = (float)(vb1 - b0) * (e1 - e0) / (b1 - b0) + e0;
+ /* Note that w0 > w1 is now possible if e0 > e1. */
+ if (e0 > e1) {
+ if (w0 > e0 && w0 - esmall <= e0)
+ w0 = e0; /* Suppress a small noise */
+ if (w1 < e1 && w1 + esmall >= e1)
+ w1 = e1; /* Suppress a small noise */
+ } else {
+ if (w0 < e0 && w0 + esmall >= e0)
+ w0 = e0; /* Suppress a small noise */
+ if (w1 > e1 && w1 - esmall <= e1)
+ w1 = e1; /* Suppress a small noise */
+ }
+ if (w0 > w1)
+ return gs_function_is_monotonic(pfn->params.Functions[i],
+ &w1, &w0, mask);
+ else
+ return gs_function_is_monotonic(pfn->params.Functions[i],
+ &w0, &w1, mask);
+ }
+ /* v0 is equal to the range end. */
+ *mask = 0;
+ return 1;
+}
+
+/* Return 1-Input Stitching function information. */
+static void
+fn_1ItSg_get_info(const gs_function_t *pfn_common, gs_function_info_t *pfi)
+{
+ const gs_function_1ItSg_t *const pfn =
+ (const gs_function_1ItSg_t *)pfn_common;
+
+ gs_function_get_info_default(pfn_common, pfi);
+ pfi->Functions = pfn->params.Functions;
+ pfi->num_Functions = pfn->params.k;
+}
+
+/* Write 1-Input Stitching function parameters on a parameter list. */
+static int
+fn_1ItSg_get_params(const gs_function_t *pfn_common, gs_param_list *plist)
+{
+ const gs_function_1ItSg_t *const pfn =
+ (const gs_function_1ItSg_t *)pfn_common;
+ int ecode = fn_common_get_params(pfn_common, plist);
+ int code;
+
+ if ((code = param_write_float_values(plist, "Bounds", pfn->params.Bounds,
+ pfn->params.k - 1, false)) < 0)
+ ecode = code;
+ if ((code = param_write_float_values(plist, "Encode", pfn->params.Encode,
+ 2 * pfn->params.k, false)) < 0)
+ ecode = code;
+ return ecode;
+}
+
+/* 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;
+}
+
+/* Free the parameters of a 1-Input Stitching function. */
+void
+gs_function_1ItSg_free_params(gs_function_1ItSg_params_t * params,
+ gs_memory_t * mem)
+{
+ gs_free_const_object(mem, params->Encode, "Encode");
+ gs_free_const_object(mem, params->Bounds, "Bounds");
+ fn_free_functions(params->Functions, params->k, mem);
+ fn_common_free_params((gs_function_params_t *) params, mem);
+}
+
+/* Serialize. */
+static int
+gs_function_1ItSg_serialize(const gs_function_t * pfn, stream *s)
+{
+ uint n;
+ const gs_function_1ItSg_params_t * p = (const gs_function_1ItSg_params_t *)&pfn->params;
+ int code = fn_common_serialize(pfn, s);
+ int k;
+
+ if (code < 0)
+ return code;
+ code = sputs(s, (const byte *)&p->k, sizeof(p->k), &n);
+ if (code < 0)
+ return code;
+
+ for (k = 0; k < p->k && code >= 0; k++)
+ code = gs_function_serialize(p->Functions[k], s);
+ if (code < 0)
+ return code;
+ code = sputs(s, (const byte *)&p->Bounds[0], sizeof(p->Bounds[0]) * (p->k - 1), &n);
+ if (code < 0)
+ return code;
+ return sputs(s, (const byte *)&p->Encode[0], sizeof(p->Encode[0]) * (p->k * 2), &n);
+}
+
+/* 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;
+}
+
+/* ---------------- Arrayed Output functions ---------------- */
+
+typedef struct gs_function_AdOt_s {
+ gs_function_head_t head;
+ gs_function_AdOt_params_t params;
+} gs_function_AdOt_t;
+
+private_st_function_AdOt();
+
+/* Evaluate an Arrayed Output function. */
+static int
+fn_AdOt_evaluate(const gs_function_t *pfn_common, const float *in0, float *out)
+{
+ const gs_function_AdOt_t *const pfn =
+ (const gs_function_AdOt_t *)pfn_common;
+ const float *in = in0;
+#define MAX_ADOT_IN 16
+ float in_buf[MAX_ADOT_IN];
+ int i;
+
+ /*
+ * We have to take special care to handle the case where in and out
+ * overlap. For the moment, handle it only for a limited number of
+ * input values.
+ */
+ if (in <= out + (pfn->params.n - 1) && out <= in + (pfn->params.m - 1)) {
+ if (pfn->params.m > MAX_ADOT_IN)
+ return_error(gs_error_rangecheck);
+ memcpy(in_buf, in, pfn->params.m * sizeof(*in));
+ in = in_buf;
+ }
+ for (i = 0; i < pfn->params.n; ++i) {
+ int code =
+ gs_function_evaluate(pfn->params.Functions[i], in, out + i);
+
+ if (code < 0)
+ return code;
+ }
+ return 0;
+#undef MAX_ADOT_IN
+}
+
+/* Test whether an Arrayed Output function is monotonic. */
+static int
+fn_AdOt_is_monotonic(const gs_function_t * pfn_common,
+ const float *lower, const float *upper, uint *mask)
+{
+ const gs_function_AdOt_t *const pfn =
+ (const gs_function_AdOt_t *)pfn_common;
+ int i;
+
+ for (i = 0; i < pfn->params.n; ++i) {
+ int code =
+ gs_function_is_monotonic(pfn->params.Functions[i], lower, upper, mask);
+
+ if (code <= 0)
+ return code;
+ }
+ return 1;
+}
+
+/* Return Arrayed Output function information. */
+static void
+fn_AdOt_get_info(const gs_function_t *pfn_common, gs_function_info_t *pfi)
+{
+ const gs_function_AdOt_t *const pfn =
+ (const gs_function_AdOt_t *)pfn_common;
+
+ gs_function_get_info_default(pfn_common, pfi);
+ pfi->Functions = pfn->params.Functions;
+ pfi->num_Functions = pfn->params.n;
+}
+
+/* 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;
+}
+
+/* Free the parameters of an Arrayed Output function. */
+void
+gs_function_AdOt_free_params(gs_function_AdOt_params_t * params,
+ gs_memory_t * mem)
+{
+ fn_free_functions(params->Functions, params->n, mem);
+ fn_common_free_params((gs_function_params_t *) params, mem);
+}
+
+/* Serialize. */
+static int
+gs_function_AdOt_serialize(const gs_function_t * pfn, stream *s)
+{
+ const gs_function_AdOt_params_t * p = (const gs_function_AdOt_params_t *)&pfn->params;
+ int code = fn_common_serialize(pfn, s);
+ int k;
+
+ if (code < 0)
+ return code;
+ for (k = 0; k < p->n && code >= 0; k++)
+ code = gs_function_serialize(p->Functions[k], s);
+ return code;
+}
+
+/* Allocate and initialize an Arrayed Output function. */
+int
+gs_function_AdOt_init(gs_function_t ** ppfn,
+ const gs_function_AdOt_params_t * params, gs_memory_t * mem)
+{
+ static const gs_function_head_t function_AdOt_head = {
+ function_type_ArrayedOutput,
+ {
+ (fn_evaluate_proc_t) fn_AdOt_evaluate,
+ (fn_is_monotonic_proc_t) fn_AdOt_is_monotonic,
+ (fn_get_info_proc_t) fn_AdOt_get_info,
+ fn_common_get_params, /****** WHAT TO DO ABOUT THIS? ******/
+ (fn_make_scaled_proc_t) fn_AdOt_make_scaled,
+ (fn_free_params_proc_t) gs_function_AdOt_free_params,
+ fn_common_free,
+ (fn_serialize_proc_t) gs_function_AdOt_serialize,
+ }
+ };
+ int m = params->m, n = params->n;
+
+ *ppfn = 0; /* in case of error */
+ if (m <= 0 || n <= 0)
+ return_error(gs_error_rangecheck);
+ {
+ gs_function_AdOt_t *pfn =
+ gs_alloc_struct(mem, gs_function_AdOt_t, &st_function_AdOt,
+ "gs_function_AdOt_init");
+ float *domain = (float *)
+ gs_alloc_byte_array(mem, 2 * m, sizeof(float),
+ "gs_function_AdOt_init(Domain)");
+ int i, j;
+
+ if (pfn == 0)
+ return_error(gs_error_VMerror);
+ pfn->params = *params;
+ pfn->params.Domain = domain;
+ pfn->params.Range = 0;
+ pfn->head = function_AdOt_head;
+ if (domain == 0) {
+ gs_function_free((gs_function_t *)pfn, true, mem);
+ return_error(gs_error_VMerror);
+ }
+ /*
+ * We compute the Domain as the intersection of the Domains of
+ * the individual subfunctions. This isn't quite right: some
+ * subfunction might actually make use of a larger domain of
+ * input values. However, the only place that Arrayed Output
+ * functions are used is in Shading and similar dictionaries,
+ * where the input values are clamped to the intersection of
+ * the individual Domains anyway.
+ */
+ memcpy(domain, params->Functions[0]->params.Domain,
+ 2 * sizeof(float) * m);
+ for (i = 1; i < n; ++i) {
+ const float *dom = params->Functions[i]->params.Domain;
+
+ for (j = 0; j < 2 * m; j += 2, dom += 2) {
+ domain[j] = max(domain[j], dom[0]);
+ domain[j + 1] = min(domain[j + 1], dom[1]);
+ }
+ }
+ *ppfn = (gs_function_t *) pfn;
+ }
+ return 0;
+}
View Lorry Controller Status