Commit of build_consolidation branch

Squashed into one commit (see branch for details of the evolution of the
branch).

This brings gpcl6 and gxps into the Ghostscript build system, and a shared
set of graphics library object files for all the interpreters.

Also, brings the same configuration options to the pcl and xps products as we
have for Ghostscript.

1 files changed, 582 insertions, 0 deletions

diff --git a/base/gshtx.c b/base/gshtx.c
new file mode 100644
index 000000000..1dab7b098
--- /dev/null
+++ b/base/gshtx.c
@@ -0,0 +1,582 @@
+/* Copyright (C) 2001-2012 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 the license contained in the file LICENSE in this distribution.
+
+   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.
+*/
+
+
+/* Stand-alone halftone/transfer function related code */
+#include "memory_.h"
+#include "gx.h"
+#include "gserrors.h"
+#include "gsstruct.h"
+#include "gsutil.h"		/* for gs_next_ids */
+#include "gxfmap.h"
+#include "gzstate.h"
+#include "gzht.h"
+#include "gshtx.h"		/* must come after g*ht.h */
+
+/*
+ * Procedure to free the set of components when a halftone is released.
+ */
+static void
+free_comps(
+              gs_memory_t * pmem,
+              void *pvht,
+              client_name_t cname
+)
+{
+    gs_ht *pht = (gs_ht *) pvht;
+
+    gs_free_object(pmem, pht->params.ht_multiple.components, cname);
+    gs_free_object(pmem, pvht, cname);
+}
+
+/*
+ * Stub transfer function, to be applied to components that are not provided
+ * with a transfer function.
+ */
+static float
+null_closure_transfer(
+                         double val,
+                         const gx_transfer_map * pmap_dummy,	/* NOTUSED */
+                         const void *dummy	/* NOTUSED */
+)
+{
+    return val;
+}
+
+/*
+ * Build a gs_ht halftone structure.
+ */
+int
+gs_ht_build(
+               gs_ht ** ppht,
+               uint num_comps,
+               gs_memory_t * pmem
+)
+{
+    gs_ht *pht;
+    gs_ht_component *phtc;
+    int i;
+
+    /* must have at least one component */
+    *ppht = 0;
+    if (num_comps == 0)
+        return_error(gs_error_rangecheck);
+
+    /* allocate the halftone and the array of components */
+    rc_alloc_struct_1(pht,
+                      gs_ht,
+                      &st_gs_ht,
+                      pmem,
+                      return_error(gs_error_VMerror),
+                      "gs_ht_build"
+        );
+    phtc = gs_alloc_struct_array(pmem,
+                                 num_comps,
+                                 gs_ht_component,
+                                 &st_ht_comp_element,
+                                 "gs_ht_build"
+        );
+    if (phtc == 0) {
+        gs_free_object(pmem, pht, "gs_ht_build");
+        return_error(gs_error_VMerror);
+    }
+    /* initialize the halftone */
+    pht->type = ht_type_multiple;
+    pht->rc.free = free_comps;
+    pht->params.ht_multiple.components = phtc;
+    pht->params.ht_multiple.num_comp = num_comps;
+
+    for (i = 0; i < num_comps; i++) {
+        phtc[i].comp_number = i;
+        phtc[i].cname = 0;
+        phtc[i].type = ht_type_none;
+    }
+
+    *ppht = pht;
+
+    return 0;
+}
+
+/*
+ * Set a spot-function halftone component in a gs_ht halftone.
+ */
+int
+gs_ht_set_spot_comp(
+                       gs_ht * pht,
+                       int comp,
+                       double freq,
+                       double angle,
+                       float (*spot_func) (double, double),
+                       bool accurate,
+                       gs_ht_transfer_proc transfer,
+                       const void *client_data
+)
+{
+    gs_ht_component *phtc = &(pht->params.ht_multiple.components[comp]);
+
+    if (comp >= pht->params.ht_multiple.num_comp)
+        return_error(gs_error_rangecheck);
+    if (phtc->type != ht_type_none)
+        return_error(gs_error_invalidaccess);
+
+    phtc->type = ht_type_spot;
+    phtc->params.ht_spot.screen.frequency = freq;
+    phtc->params.ht_spot.screen.angle = angle;
+    phtc->params.ht_spot.screen.spot_function = spot_func;
+    phtc->params.ht_spot.accurate_screens = accurate;
+    phtc->params.ht_spot.transfer = gs_mapped_transfer;
+
+    phtc->params.ht_spot.transfer_closure.proc =
+        (transfer == 0 ? null_closure_transfer : transfer);
+    phtc->params.ht_spot.transfer_closure.data = client_data;
+
+    return 0;
+}
+
+/*
+ * Set a threshold halftone component in a gs_ht halftone. Note that the
+ * caller is responsible for releasing the threshold data.
+ */
+int
+gs_ht_set_threshold_comp(
+                            gs_ht * pht,
+                            int comp,
+                            int width,
+                            int height,
+                            const gs_const_string * thresholds,
+                            gs_ht_transfer_proc transfer,
+                            const void *client_data
+)
+{
+    gs_ht_component *phtc = &(pht->params.ht_multiple.components[comp]);
+
+    if (comp >= pht->params.ht_multiple.num_comp)
+        return_error(gs_error_rangecheck);
+    if (phtc->type != ht_type_none)
+        return_error(gs_error_invalidaccess);
+
+    phtc->type = ht_type_threshold;
+    phtc->params.ht_threshold.width = width;
+    phtc->params.ht_threshold.height = height;
+    phtc->params.ht_threshold.thresholds = *thresholds;
+    phtc->params.ht_threshold.transfer = gs_mapped_transfer;
+
+    phtc->params.ht_threshold.transfer_closure.proc =
+        (transfer == 0 ? null_closure_transfer : transfer);
+    phtc->params.ht_threshold.transfer_closure.data = client_data;
+
+    return 0;
+}
+
+/*
+ * Increase the reference count of a gs_ht structure by 1.
+ */
+void
+gs_ht_reference(
+                   gs_ht * pht
+)
+{
+    rc_increment(pht);
+}
+
+/*
+ * Decrement the reference count of a gs_ht structure by 1. Free the
+ * structure if the reference count reaches 0.
+ */
+void
+gs_ht_release(
+                 gs_ht * pht
+)
+{
+    rc_decrement_only(pht, "gs_ht_release");
+}
+
+/*
+ *  Verify that a gs_ht halftone is legitimate.
+ */
+static int
+check_ht(
+            gs_ht * pht
+)
+{
+    int i;
+    int num_comps = pht->params.ht_multiple.num_comp;
+
+    if (pht->type != ht_type_multiple)
+        return_error(gs_error_unregistered);
+    for (i = 0; i < num_comps; i++) {
+        gs_ht_component *phtc = &(pht->params.ht_multiple.components[i]);
+        if ((phtc->type != ht_type_spot) && (phtc->type != ht_type_threshold))
+            return_error(gs_error_unregistered);
+    }
+    return 0;
+}
+
+/*
+ *  Load a transfer map from a gs_ht_transfer_proc function.
+ */
+static void
+build_transfer_map(
+                      gs_ht_component * phtc,
+                      gx_transfer_map * pmap
+)
+{
+    gs_ht_transfer_proc proc;
+    const void *client_info;
+    int i;
+    frac *values = pmap->values;
+
+    if (phtc->type == ht_type_spot) {
+        proc = phtc->params.ht_spot.transfer_closure.proc;
+        client_info = phtc->params.ht_spot.transfer_closure.data;
+    } else {
+        proc = phtc->params.ht_threshold.transfer_closure.proc;
+        client_info = phtc->params.ht_threshold.transfer_closure.data;
+    }
+
+    for (i = 0; i < transfer_map_size; i++) {
+        float fval =
+            proc(i * (1 / (double)(transfer_map_size - 1)), pmap, client_info);
+
+        values[i] =
+            (fval <= 0.0 ? frac_0 : fval >= 1.0 ? frac_1 :
+             float2frac(fval));
+    }
+}
+
+/*
+ *  Allocate the order and transfer maps required by a halftone, and perform
+ *  some elementary initialization. This will also build the component index
+ *  to order index map.
+ */
+static gx_ht_order_component *
+alloc_ht_order(
+                  const gs_ht * pht,
+                  gs_memory_t * pmem,
+                  byte * comp2order
+)
+{
+    int num_comps = pht->params.ht_multiple.num_comp;
+    gx_ht_order_component *pocs = gs_alloc_struct_array(
+                                                           pmem,
+                                           pht->params.ht_multiple.num_comp,
+                                                      gx_ht_order_component,
+                                             &st_ht_order_component_element,
+                                                           "alloc_ht_order"
+    );
+    int inext = 0;
+    int i;
+
+    if (pocs == 0)
+        return 0;
+    pocs->corder.transfer = 0;
+
+    for (i = 0; i < num_comps; i++) {
+        gs_ht_component *phtc = &(pht->params.ht_multiple.components[i]);
+        gx_transfer_map *pmap = gs_alloc_struct(pmem,
+                                                gx_transfer_map,
+                                                &st_transfer_map,
+                                                "alloc_ht_order"
+        );
+
+        if (pmap == 0) {
+            int j;
+
+            for (j = 0; j < inext; j++)
+                gs_free_object(pmem, pocs[j].corder.transfer, "alloc_ht_order");
+            gs_free_object(pmem, pocs, "alloc_ht_order");
+            return 0;
+        }
+        pmap->proc = gs_mapped_transfer;
+        pmap->id = gs_next_ids(pmem, 1);
+        pocs[inext].corder.levels = 0;
+        pocs[inext].corder.bit_data = 0;
+        pocs[inext].corder.cache = 0;
+        pocs[inext].corder.transfer = pmap;
+        pocs[inext].cname = phtc->cname;
+        pocs[inext].comp_number = phtc->comp_number;
+        comp2order[i] = inext++;
+    }
+
+    return pocs;
+}
+
+/*
+ *  Build the halftone order for one component.
+ */
+static int
+build_component(
+                   gs_ht_component * phtc,
+                   gx_ht_order * porder,
+                   gs_state * pgs,
+                   gs_memory_t * pmem
+)
+{
+    if (phtc->type == ht_type_spot) {
+        gs_screen_enum senum;
+        int code;
+
+        code = gx_ht_process_screen_memory(&senum,
+                                           pgs,
+                                           &phtc->params.ht_spot.screen,
+                                      phtc->params.ht_spot.accurate_screens,
+                                           pmem
+            );
+        if (code < 0)
+            return code;
+
+        /* avoid wiping out the transfer structure pointer */
+        senum.order.transfer = porder->transfer;
+        *porder = senum.order;
+
+    } else {			/* ht_type_threshold */
+        int code;
+        gx_transfer_map *transfer = porder->transfer;
+
+        porder->params.M = phtc->params.ht_threshold.width;
+        porder->params.N = 0;
+        porder->params.R = 1;
+        porder->params.M1 = phtc->params.ht_threshold.height;
+        porder->params.N1 = 0;
+        porder->params.R1 = 1;
+        code = gx_ht_alloc_threshold_order(porder,
+                                           phtc->params.ht_threshold.width,
+                                           phtc->params.ht_threshold.height,
+                                           256,
+                                           pmem
+            );
+        if (code < 0)
+            return code;
+        gx_ht_construct_threshold_order(
+                                porder,
+                                phtc->params.ht_threshold.thresholds.data
+            );
+        /*
+         * gx_ht_construct_threshold_order wipes out transfer map pointer,
+         * restore it here.
+         */
+        porder->transfer = transfer;
+    }
+
+    build_transfer_map(phtc, porder->transfer);
+    return 0;
+}
+
+/*
+ * Free an order array and all elements it points to.
+ */
+static void
+free_order_array(
+                    gx_ht_order_component * pocs,
+                    int num_comps,
+                    gs_memory_t * pmem
+)
+{
+    int i;
+
+    for (i = 0; i < num_comps; i++)
+        gx_ht_order_release(&(pocs[i].corder), pmem, true);
+    gs_free_object(pmem, pocs, "gs_ht_install");
+}
+
+/*
+ *  Install a gs_ht halftone as the current halftone in the graphic state.
+ */
+int
+gs_ht_install(
+                 gs_state * pgs,
+                 gs_ht * pht
+)
+{
+    int code = 0;
+    gs_memory_t *pmem = pht->rc.memory;
+    gx_device_halftone dev_ht;
+    gx_ht_order_component *pocs;
+    byte comp2order[32];	/* ample component to order map */
+    int num_comps = pht->params.ht_multiple.num_comp;
+    int i;
+
+    /* perform so sanity checks (must have one default component) */
+    if ((code = check_ht(pht)) != 0)
+        return code;
+
+    /* allocate the halftone order structure and transfer maps */
+    if ((pocs = alloc_ht_order(pht, pmem, comp2order)) == 0)
+        return_error(gs_error_VMerror);
+
+    /* build all of the order for each component */
+    for (i = 0; i < num_comps; i++) {
+        int j = comp2order[i];
+
+        code = build_component(&(pht->params.ht_multiple.components[i]),
+                               &(pocs[j].corder),
+                               pgs,
+                               pmem
+            );
+
+        if ((code >= 0) && (j != 0)) {
+            gx_ht_cache *pcache;
+
+            pcache = gx_ht_alloc_cache(pmem,
+                                       4,
+                                       pocs[j].corder.raster *
+                                       (pocs[j].corder.num_bits /
+                                        pocs[j].corder.width) * 4
+                );
+
+            if (pcache == 0)
+                code = gs_note_error(gs_error_VMerror);
+            else {
+                pocs[j].corder.cache = pcache;
+                gx_ht_init_cache(pmem, pcache, &(pocs[j].corder));
+            }
+        }
+        if (code < 0)
+            break;
+    }
+
+    if (code < 0) {
+        free_order_array(pocs, num_comps, pmem);
+        return code;
+    }
+    /* initialize the device halftone structure */
+    dev_ht.rc.memory = pmem;
+    dev_ht.order = pocs[0].corder;	/* Default */
+    if (num_comps == 1) {
+        /* we have only a Default; we don't need components. */
+        gs_free_object(pmem, pocs, "gs_ht_install");
+        dev_ht.components = 0;
+    } else {
+        dev_ht.components = pocs;
+        dev_ht.num_comp = num_comps;
+    }
+
+    /* at last, actually install the halftone in the graphic state */
+    if ((code = gx_ht_install(pgs, (gs_halftone *) pht, &dev_ht)) < 0)
+        gx_device_halftone_release(&dev_ht, pmem);
+    return code;
+}
+
+/* ---------------- Mask-defined halftones ---------------- */
+
+/*
+ * Create a halftone order from an array of explicit masks.  This is
+ * silly, because the rendering machinery actually wants masks, but doing
+ * it right seems to require too many changes in existing code.
+ */
+static int
+create_mask_bits(const byte * mask1, const byte * mask2,
+                 int width, int height, gx_ht_bit * bits)
+{
+    /*
+     * We do this with the slowest, simplest possible algorithm....
+     */
+    int width_bytes = (width + 7) >> 3;
+    int x, y;
+    int count = 0;
+
+    for (y = 0; y < height; ++y)
+        for (x = 0; x < width; ++x) {
+            int offset = y * width_bytes + (x >> 3);
+            byte bit_mask = 0x80 >> (x & 7);
+
+            if ((mask1[offset] ^ mask2[offset]) & bit_mask) {
+                if (bits)
+                    gx_ht_construct_bit(&bits[count], width, y * width + x);
+                ++count;
+            }
+        }
+    return count;
+}
+static int
+create_mask_order(gx_ht_order * porder, gs_state * pgs,
+                  const gs_client_order_halftone * phcop,
+                  gs_memory_t * mem)
+{
+    int width_bytes = (phcop->width + 7) >> 3;
+    const byte *masks = (const byte *)phcop->client_data;
+    int bytes_per_mask = width_bytes * phcop->height;
+    const byte *prev_mask;
+    int num_levels = phcop->num_levels;
+    int num_bits = 0;
+    int i;
+    int code;
+
+    /* Do a first pass to compute how many bits entries will be needed. */
+    for (prev_mask = masks, num_bits = 0, i = 0;
+         i < num_levels - 1;
+         ++i, prev_mask += bytes_per_mask
+        )
+        num_bits += create_mask_bits(prev_mask, prev_mask + bytes_per_mask,
+                                     phcop->width, phcop->height, NULL);
+    code = gx_ht_alloc_client_order(porder, phcop->width, phcop->height,
+                                    num_levels, num_bits, mem);
+    if (code < 0)
+        return code;
+    /* Fill in the bits and levels entries. */
+    for (prev_mask = masks, num_bits = 0, i = 0;
+         i < num_levels - 1;
+         ++i, prev_mask += bytes_per_mask
+        ) {
+        porder->levels[i] = num_bits;
+        num_bits += create_mask_bits(prev_mask, prev_mask + bytes_per_mask,
+                                     phcop->width, phcop->height,
+                                     ((gx_ht_bit *)porder->bit_data) +
+                                      num_bits);
+    }
+    porder->levels[num_levels - 1] = num_bits;
+    return 0;
+}
+
+/* Define the client-order halftone procedure structure. */
+static const gs_client_order_ht_procs_t mask_order_procs =
+{
+    create_mask_order
+};
+
+/*
+ * Define a halftone by an explicit set of masks.  We translate these
+ * internally into a threshold array, since that's what the halftone
+ * rendering machinery knows how to deal with.
+ */
+int
+gs_ht_set_mask_comp(gs_ht * pht,
+                    int component_index,
+                    int width, int height, int num_levels,
+                    const byte * masks,		/* width x height x num_levels bits */
+                    gs_ht_transfer_proc transfer,
+                    const void *client_data)
+{
+    gs_ht_component *phtc =
+    &(pht->params.ht_multiple.components[component_index]);
+
+    if (component_index >= pht->params.ht_multiple.num_comp)
+        return_error(gs_error_rangecheck);
+    if (phtc->type != ht_type_none)
+        return_error(gs_error_invalidaccess);
+
+    phtc->type = ht_type_client_order;
+    phtc->params.client_order.width = width;
+    phtc->params.client_order.height = height;
+    phtc->params.client_order.num_levels = num_levels;
+    phtc->params.client_order.procs = &mask_order_procs;
+    phtc->params.client_order.client_data = masks;
+    phtc->params.client_order.transfer_closure.proc =
+        (transfer == 0 ? null_closure_transfer : transfer);
+    phtc->params.client_order.transfer_closure.data = client_data;
+
+    return 0;
+
+}