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, 235 insertions, 0 deletions

diff --git a/base/gsdevmem.c b/base/gsdevmem.c
new file mode 100644
index 000000000..45590e796
--- /dev/null
+++ b/base/gsdevmem.c
@@ -0,0 +1,235 @@
+/* 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.
+*/
+
+
+/* Memory device creation for Ghostscript library */
+#include "math_.h"		/* for fabs */
+#include "memory_.h"
+#include "gx.h"
+#include "gserrors.h"
+#include "gsdevice.h"		/* for prototypes */
+#include "gxarith.h"
+#include "gxdevice.h"
+#include "gxdevmem.h"
+
+/* Make a memory (image) device. */
+/* If colors_size = -16, -24, or -32, this is a true-color device; */
+/* otherwise, colors_size is the size of the palette in bytes */
+/* (2^N for gray scale, 3*2^N for RGB color). */
+/* We separate device allocation and initialization at customer request. */
+int
+gs_initialize_wordimagedevice(gx_device_memory * new_dev, const gs_matrix * pmat,
+              uint width, uint height, const byte * colors, int colors_size,
+                    bool word_oriented, bool page_device, gs_memory_t * mem)
+{
+    const gx_device_memory *proto_dev;
+    int palette_count = colors_size;
+    int num_components = 1;
+    int pcount;
+    int bits_per_pixel;
+    float x_pixels_per_unit, y_pixels_per_unit;
+    byte palette[256 * 3];
+    bool has_color;
+
+    switch (colors_size) {
+        case 3 * 2:
+            palette_count = 2;
+            num_components = 3;
+        case 2:
+            bits_per_pixel = 1;
+            break;
+        case 3 * 4:
+            palette_count = 4;
+            num_components = 3;
+        case 4:
+            bits_per_pixel = 2;
+            break;
+        case 3 * 16:
+            palette_count = 16;
+            num_components = 3;
+        case 16:
+            bits_per_pixel = 4;
+            break;
+        case 3 * 256:
+            palette_count = 256;
+            num_components = 3;
+        case 256:
+            bits_per_pixel = 8;
+            break;
+        case -16:
+            bits_per_pixel = 16;
+            palette_count = 0;
+            break;
+        case -24:
+            bits_per_pixel = 24;
+            palette_count = 0;
+            break;
+        case -32:
+            bits_per_pixel = 32;
+            palette_count = 0;
+            break;
+        default:
+            return_error(gs_error_rangecheck);
+    }
+    proto_dev = (word_oriented ?
+                 gdev_mem_word_device_for_bits(bits_per_pixel) :
+                 gdev_mem_device_for_bits(bits_per_pixel));
+    if (proto_dev == 0)		/* no suitable device */
+        return_error(gs_error_rangecheck);
+    pcount = palette_count * 3;
+    /* Check to make sure the palette contains white and black, */
+    /* and, if it has any colors, the six primaries. */
+    if (bits_per_pixel <= 8) {
+        const byte *p;
+        byte *q;
+        int primary_mask = 0;
+        int i;
+
+        has_color = false;
+        for (i = 0, p = colors, q = palette;
+             i < palette_count; i++, q += 3
+            ) {
+            int mask = 1;
+
+            switch (num_components) {
+                case 1:	/* gray */
+                    q[0] = q[1] = q[2] = *p++;
+                    break;
+                default /* case 3 */ :		/* RGB */
+                    q[0] = p[0], q[1] = p[1], q[2] = p[2];
+                    p += 3;
+            }
+#define shift_mask(b,n)\
+  switch ( b ) { case 0xff: mask <<= n; case 0: break; default: mask = 0; }
+            shift_mask(q[0], 4);
+            shift_mask(q[1], 2);
+            shift_mask(q[2], 1);
+#undef shift_mask
+            primary_mask |= mask;
+            if (q[0] != q[1] || q[0] != q[2])
+                has_color = true;
+        }
+        switch (primary_mask) {
+            case 129:		/* just black and white */
+                if (has_color)	/* color but no primaries */
+                    return_error(gs_error_rangecheck);
+            case 255:		/* full color */
+                break;
+            default:
+                return_error(gs_error_rangecheck);
+        }
+    } else
+        has_color = true;
+    /*
+     * The initial transformation matrix must map 1 user unit to
+     * 1/72".  Let W and H be the width and height in pixels, and
+     * assume the initial matrix is of the form [A 0 0 B X Y].
+     * Then the size of the image in user units is (W/|A|,H/|B|),
+     * hence the size in inches is ((W/|A|)/72,(H/|B|)/72), so
+     * the number of pixels per inch is
+     * (W/((W/|A|)/72),H/((H/|B|)/72)), or (|A|*72,|B|*72).
+     * Similarly, if the initial matrix is [0 A B 0 X Y] for a 90
+     * or 270 degree rotation, the size of the image in user
+     * units is (W/|B|,H/|A|), so the pixels per inch are
+     * (|B|*72,|A|*72).  We forbid non-orthogonal transformation
+     * matrices.
+     */
+    if (is_fzero2(pmat->xy, pmat->yx))
+        x_pixels_per_unit = pmat->xx, y_pixels_per_unit = pmat->yy;
+    else if (is_fzero2(pmat->xx, pmat->yy))
+        x_pixels_per_unit = pmat->yx, y_pixels_per_unit = pmat->xy;
+    else
+        return_error(gs_error_undefinedresult);
+    /* All checks done, initialize the device. */
+    if (bits_per_pixel == 1) {
+        /* Determine the polarity from the palette. */
+        gs_make_mem_device(new_dev, proto_dev, mem,
+                           (page_device ? 1 : -1), 0);
+        /* This is somewhat bogus, but does the right thing */
+        /* in the only cases we care about. */
+        gdev_mem_mono_set_inverted(new_dev,
+                               (palette[0] | palette[1] | palette[2]) != 0);
+    } else {
+        byte *dev_palette = gs_alloc_string(mem, pcount,
+                                            "gs_makeimagedevice(palette)");
+
+        if (dev_palette == 0)
+            return_error(gs_error_VMerror);
+        gs_make_mem_device(new_dev, proto_dev, mem,
+                           (page_device ? 1 : -1), 0);
+        new_dev->palette.size = pcount;
+        new_dev->palette.data = dev_palette;
+        memcpy(dev_palette, palette, pcount);
+        if (!has_color) {
+            new_dev->color_info.num_components = 1;
+            new_dev->color_info.max_color = 0;
+            new_dev->color_info.dither_colors = 0;
+            new_dev->color_info.gray_index = 0;
+        }
+    }
+    /* Memory defice is always initialised as an internal device but */
+    /* this is an external device */
+    new_dev->retained = true;
+    rc_init(new_dev, new_dev->memory, 1);
+
+    new_dev->initial_matrix = *pmat;
+    new_dev->MarginsHWResolution[0] = new_dev->HWResolution[0] =
+        fabs(x_pixels_per_unit) * 72;
+    new_dev->MarginsHWResolution[1] = new_dev->HWResolution[1] =
+        fabs(y_pixels_per_unit) * 72;
+    gx_device_set_width_height((gx_device *) new_dev, width, height);
+    /* Set the ImagingBBox so we get a correct clipping region. */
+    {
+        gs_rect bbox;
+
+        bbox.p.x = 0;
+        bbox.p.y = 0;
+        bbox.q.x = width;
+        bbox.q.y = height;
+        gs_bbox_transform_inverse(&bbox, pmat, &bbox);
+        new_dev->ImagingBBox[0] = bbox.p.x;
+        new_dev->ImagingBBox[1] = bbox.p.y;
+        new_dev->ImagingBBox[2] = bbox.q.x;
+        new_dev->ImagingBBox[3] = bbox.q.y;
+        new_dev->ImagingBBox_set = true;
+    }
+    /* The bitmap will be allocated when the device is opened. */
+    new_dev->is_open = false;
+    new_dev->bitmap_memory = mem;
+    return 0;
+}
+
+int
+gs_makewordimagedevice(gx_device ** pnew_dev, const gs_matrix * pmat,
+               uint width, uint height, const byte * colors, int num_colors,
+                    bool word_oriented, bool page_device, gs_memory_t * mem)
+{
+    int code;
+    gx_device_memory *pnew =
+    gs_alloc_struct(mem, gx_device_memory, &st_device_memory,
+                    "gs_makeimagedevice(device)");
+
+    if (pnew == 0)
+        return_error(gs_error_VMerror);
+    code = gs_initialize_wordimagedevice(pnew, pmat, width, height,
+                                         colors, num_colors, word_oriented,
+                                         page_device, mem);
+    if (code < 0) {
+        gs_free_object(mem, pnew, "gs_makeimagedevice(device)");
+        return code;
+    }
+    *pnew_dev = (gx_device *) pnew;
+    return 0;
+}