@libgs/linux-arm64 0.0.0-stage → 0.17.0

package/README.md

@@ -1,3 +1,5 @@
-# Temporary Holding Version
+# libgs
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Ghostscript library (libgs) for linux arm64.
+
+See the [libgs repository](https://github.com/NickNaso/libgs#readme) for how to use it.

package/include/gdevdsp.h

@@ -0,0 +1,417 @@
+/* Copyright (C) 2001-2023 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.,  39 Mesa Street, Suite 108A, San Francisco,
+   CA 94129, USA, for further information.
+*/
+
+/* gdevdsp.h - callback structure for DLL based display device */
+
+#ifndef gdevdsp_INCLUDED
+#  define gdevdsp_INCLUDED
+
+/*
+ * There are 2 mechanisms to provide the callback structure to
+ * Ghostscript. A legacy one, and a modern one. The legacy one is
+ * deprecated and should not be used in new code - at some point it may
+ * be removed.
+ *
+ * Modern method: Call the Ghostscript APIs in the following order:
+ *  gsapi_new_instance(&minst);
+ *  gsapi_register_callout(minst, callout, callout_handle);
+ *  gsapi_init_with_args(minst, argc, argv);
+ *
+ * The callout handler should look for a callout from the 'display'
+ * device, with id=DISPLAY_CALLOUT_GET_CALLBACK and respond by filling
+ * in the supplied gs_display_get_callback_t structure.
+ *
+ * Supported parameters and default values are:
+ * -dDisplayFormat=0                      long
+ *    Color format specified using bitfields below.
+ *    Included as argument of display_size() and display_presize()
+ * These can only be changed when the device is closed.
+ *
+ * Legacy method: Call the Ghostscript APIs in the following order:
+ *  gsapi_new_instance(&minst);
+ *  gsapi_set_display_callback(minst, callback);
+ *  gsapi_init_with_args(minst, argc, argv);
+ *
+ * An additional parameter is supported, with default value NULL:
+ * -sDisplayHandle=16#04d2 or 1234        string
+ *    Caller supplied handle as a decimal or hexadecimal number
+ *    in a string.  On 32-bit platforms, it may be set
+ *    using -dDisplayHandle=1234 for backward compatibility.
+ *    Included as first parameter of all callback functions.
+ *
+ * The second parameter of all callback functions "void *device"
+ * is the address of the Ghostscript display device instance.
+ * The arguments "void *handle" and "void *device" together
+ * uniquely identify an instance of the display device.
+ *
+ * A typical sequence of callbacks (when running without a
+ * display_choose_mode) would be:
+ *  open, presize, memalloc, size, sync, page
+ *  presize, memfree, memalloc, size, sync, page
+ *  preclose, memfree, close
+ * The caller should not access the image buffer:
+ *  - before the first sync
+ *  - between presize and size
+ *  - after preclose
+ * If opening the device fails, you might see the following:
+ *  open, presize, memalloc, memfree, close
+ *
+ * A typical sequence of callbacks (when running with a
+ * display_choose_mode) will depend upon whether display_choose_mode
+ * selects pagemode or request-rectangle mode:
+ *
+ * In the pagemode case:
+ *  open, presize, display_choose_mode, memalloc, size, sync, page
+ *  presize, display_choose_mode, memfree, memalloc, size, sync, page
+ *  preclose, memfree, close
+ * The caller should not access the image buffer:
+ *  - before the first sync
+ *  - between presize and size
+ *  - after preclose
+ * If opening the device fails, you might see the following:
+ *  open, presize, memalloc, memfree, close
+ *
+ * In the request-rectangle mode:
+ *  open, presize, display_choose_mode, {rectangle_request}*
+ *  presize, display_choose_mode, {rectangle_request}*
+ *  preclose, close
+ *
+ * In a run that mixed request-rectangle and pagemode:
+ *  open, presize, display_choose_mode, memalloc, size, sync, page
+ *  presize, display_choose_mode, memfree, {rectangle_request}*
+ *  presize, display_choose_mode, {rectangle_request}*
+ *  presize, display_choose_mode, memalloc, size, sync, page
+ *  preclose, memfree, close
+ */
+
+#define DISPLAY_VERSION_MAJOR 3
+#define DISPLAY_VERSION_MINOR 0
+
+#define DISPLAY_VERSION_MAJOR_V1 1 /* before separation format was added */
+#define DISPLAY_VERSION_MINOR_V1 0
+
+#define DISPLAY_VERSION_MAJOR_V2 2 /* before planar and banding were added */
+#define DISPLAY_VERSION_MINOR_V2 0
+
+/* The display format is set by a combination of the following bitfields */
+
+/* Define the color space alternatives */
+typedef enum {
+    DISPLAY_COLORS_NATIVE	 = (1<<0),
+    DISPLAY_COLORS_GRAY  	 = (1<<1),
+    DISPLAY_COLORS_RGB   	 = (1<<2),
+    DISPLAY_COLORS_CMYK  	 = (1<<3),
+    DISPLAY_COLORS_SEPARATION    = (1<<19)
+} DISPLAY_FORMAT_COLOR;
+#define DISPLAY_COLORS_MASK 0x8000fL
+
+/* Define whether alpha information, or an extra unused bytes is included */
+/* DISPLAY_ALPHA_FIRST and DISPLAY_ALPHA_LAST are not implemented */
+typedef enum {
+    DISPLAY_ALPHA_NONE   = (0<<4),
+    DISPLAY_ALPHA_FIRST  = (1<<4),
+    DISPLAY_ALPHA_LAST   = (1<<5),
+    DISPLAY_UNUSED_FIRST = (1<<6),	/* e.g. Mac xRGB */
+    DISPLAY_UNUSED_LAST  = (1<<7)	/* e.g. Windows BGRx */
+} DISPLAY_FORMAT_ALPHA;
+#define DISPLAY_ALPHA_MASK 0x00f0L
+
+/* Define the depth per component for DISPLAY_COLORS_GRAY,
+ * DISPLAY_COLORS_RGB and DISPLAY_COLORS_CMYK,
+ * or the depth per pixel for DISPLAY_COLORS_NATIVE
+ * DISPLAY_DEPTH_2 and DISPLAY_DEPTH_12 have not been tested.
+ */
+typedef enum {
+    DISPLAY_DEPTH_1   = (1<<8),
+    DISPLAY_DEPTH_2   = (1<<9),
+    DISPLAY_DEPTH_4   = (1<<10),
+    DISPLAY_DEPTH_8   = (1<<11),
+    DISPLAY_DEPTH_12  = (1<<12),
+    DISPLAY_DEPTH_16  = (1<<13)
+    /* unused (1<<14) */
+    /* unused (1<<15) */
+} DISPLAY_FORMAT_DEPTH;
+#define DISPLAY_DEPTH_MASK 0xff00L
+
+/* Define whether Red/Cyan should come first,
+ * or whether Blue/Black should come first
+ */
+typedef enum {
+    DISPLAY_BIGENDIAN    = (0<<16),	/* Red/Cyan first */
+    DISPLAY_LITTLEENDIAN = (1<<16)	/* Blue/Black first */
+} DISPLAY_FORMAT_ENDIAN;
+#define DISPLAY_ENDIAN_MASK 0x00010000L
+
+/* Define whether the raster starts at the top or bottom of the bitmap */
+typedef enum {
+    DISPLAY_TOPFIRST    = (0<<17),	/* Unix, Mac */
+    DISPLAY_BOTTOMFIRST = (1<<17)	/* Windows */
+} DISPLAY_FORMAT_FIRSTROW;
+#define DISPLAY_FIRSTROW_MASK 0x00020000L
+
+/* Define whether packing RGB in 16-bits should use 555
+ * or 565 (extra bit for green)
+ */
+typedef enum {
+    DISPLAY_NATIVE_555 = (0<<18),
+    DISPLAY_NATIVE_565 = (1<<18)
+} DISPLAY_FORMAT_555;
+#define DISPLAY_555_MASK 0x00040000L
+
+/* Define the row alignment, which must be equal to or greater than
+ * the size of a pointer.
+ * The default (DISPLAY_ROW_ALIGN_DEFAULT) is the size of a pointer,
+ * 4 bytes (DISPLAY_ROW_ALIGN_4) on 32-bit systems or 8 bytes
+ * (DISPLAY_ROW_ALIGN_8) on 64-bit systems.
+ */
+typedef enum {
+    DISPLAY_ROW_ALIGN_DEFAULT = (0<<20),
+    /* DISPLAY_ROW_ALIGN_1 = (1<<20), */ /* not currently possible */
+    /* DISPLAY_ROW_ALIGN_2 = (2<<20), */ /* not currently possible */
+    DISPLAY_ROW_ALIGN_4 = (3<<20),
+    DISPLAY_ROW_ALIGN_8 = (4<<20),
+    DISPLAY_ROW_ALIGN_16 = (5<<20),
+    DISPLAY_ROW_ALIGN_32 = (6<<20),
+    DISPLAY_ROW_ALIGN_64 = (7<<20)
+} DISPLAY_FORMAT_ROW_ALIGN;
+#define DISPLAY_ROW_ALIGN_MASK 0x00700000L
+
+/* Define whether we are using chunky, planar or planar interleaved
+ * representation. */
+typedef enum {
+    DISPLAY_CHUNKY             = (0<<23),
+    DISPLAY_PLANAR             = (1<<23),
+    DISPLAY_PLANAR_INTERLEAVED = (2<<23),
+} DISPLAY_FORMAT_PLANARNESS;
+
+#ifndef display_callback_DEFINED
+#define display_callback_DEFINED
+typedef struct display_callback_s display_callback;
+#endif
+
+/*
+ * Note that for Windows, the display callback functions are
+ * cdecl, not stdcall.  This differs from those in iapi.h.
+ */
+
+struct display_callback_s {
+    /* Size of this structure */
+    /* Used for checking if we have been handed a valid structure */
+    int size;
+
+    /* Major version of this structure  */
+    /* The major version number will change if this structure changes. */
+    int version_major;
+
+    /* Minor version of this structure */
+    /* The minor version number will change if new features are added
+     * without changes to this structure.  For example, a new color
+     * format.
+     */
+    int version_minor;
+
+    /* New device has been opened */
+    /* This is the first event from this device. */
+    int (*display_open)(void *handle, void *device);
+
+    /* Device is about to be closed. */
+    /* Device will not be closed until this function returns. */
+    int (*display_preclose)(void *handle, void *device);
+
+    /* Device has been closed. */
+    /* This is the last event from this device. */
+    int (*display_close)(void *handle, void *device);
+
+    /* Device is about to be resized. */
+    /* Resize will only occur if this function returns 0. */
+    /* raster is byte count of a row. */
+    int (*display_presize)(void *handle, void *device,
+        int width, int height, int raster, unsigned int format);
+
+    /* Device has been resized. */
+    /* New pointer to raster returned in pimage */
+    int (*display_size)(void *handle, void *device, int width, int height,
+        int raster, unsigned int format, unsigned char *pimage);
+
+    /* flushpage */
+    int (*display_sync)(void *handle, void *device);
+
+    /* showpage */
+    /* If you want to pause on showpage, then don't return immediately */
+    int (*display_page)(void *handle, void *device, int copies, int flush);
+
+    /* Notify the caller whenever a portion of the raster is updated. */
+    /* This can be used for cooperative multitasking or for
+     * progressive update of the display.
+     * This function pointer may be set to NULL if not required.
+     * NOTE: This is actually a really bad thing to work on. It may well
+     * end up not being called back at all during the rendering process,
+     * in particular if transparency is in use, or if rectangle request
+     * mode is used.
+     */
+    int (*display_update)(void *handle, void *device, int x, int y,
+        int w, int h);
+
+    /* Allocate memory for bitmap */
+    /* This is provided in case you need to create memory in a special
+     * way, e.g. shared.  If this is NULL, the Ghostscript memory device
+     * allocates the bitmap. This will only called to allocate the
+     * image buffer. The first row will be placed at the address
+     * returned by display_memalloc.
+     *
+     * In the event of this callback returning NULL, Ghostscript will
+     * look for a display_rectangle_request callback. If one is not
+     * supplied, then this will be reported as memory exhaustion. If
+     * one is supplied, then Ghostscript will switch to working in
+     * rectangle request mode.
+     */
+    void *(*display_memalloc)(void *handle, void *device, size_t size);
+
+    /* Free memory for bitmap */
+    /* If this is NULL, the Ghostscript memory device will free the bitmap */
+    int (*display_memfree)(void *handle, void *device, void *mem);
+
+    /* Added in V2 */
+    /* When using separation color space (DISPLAY_COLORS_SEPARATION),
+     * give a mapping for one separation component.
+     * This is called for each new component found.
+     * It may be called multiple times for each component.
+     * It may be called at any time between display_size
+     * and display_close.
+     * The client uses this to map from the separations to CMYK
+     * and hence to RGB for display.
+     * GS must only use this callback if version_major >= 2.
+     * The unsigned short c,m,y,k values are 65535 = 1.0.
+     * This function pointer may be set to NULL if not required.
+     */
+    int (*display_separation)(void *handle, void *device,
+        int component, const char *component_name,
+        unsigned short c, unsigned short m,
+        unsigned short y, unsigned short k);
+
+    /* Added in V3 */
+    /* If non NULL, then this gives the callback provider a chance to
+     * a) be informed of and b) control the bandheight used by the
+     * display device. If a call to allocate the page mode bitmap fails
+     * (either an internal allocation or a display_memalloc call), then
+     * Ghostscript will look for the presence of a
+     * display_rectangle_request callback. If it exists, then it will
+     * attempt to use retangle request mode.
+     *
+     * As part of this, it will pick an appropriate bandheight. If
+     * this callback exists, it will be called so the callback provider
+     * can know (and, optionally, tweak) the bandheight to be used.
+     * This is purely for performance. The callback should only ever
+     * *reduce* the bandheight given here.
+     *
+     * Return the adjusted bandheight (or 0 for no change).
+     */
+    int (*display_adjust_band_height)(void *handle, void *device,
+                                      int bandheight);
+
+    /* Ask the callback for a rectangle to render (and a block to render
+     * it in). Each subsequent call tells the caller that any previous
+     * call has finished. To signal 'no more rectangles' return with
+     * *w or *h = 0.
+     *
+     * On entry: *raster and *plane_raster are set to the standard
+     *   values. All other values are undefined.
+     * On return: *memory should point to a block of memory to use.
+     *   Pixel (*ox,*oy) is the first pixel represented in that block.
+     *   *raster = the number of bytes difference between the address of
+     *   component 0 of Pixel(*ox,*oy) and the address of component 0 of
+     *   Pixel(*ox,1+*oy).
+     *   *plane_raster = the number of bytes difference between the
+     *   address of component 0 of Pixel(*ox,*oy) and the address of
+     *   component 1 of Pixel(*ox,*oy), if in planar mode, 0 otherwise.
+     *   *x, *y, *w, *h = rectangle requested within that memory block.
+     *
+     */
+    int (*display_rectangle_request)(void *handle, void *device,
+                                     void **memory, int *ox, int *oy,
+                                     int *raster, int *plane_raster,
+                                     int *x, int *y, int *w, int *h);
+};
+
+/* This is the V2 structure, before banding and planar support was added */
+struct display_callback_v2_s {
+    int size; /* sizeof(struct display_callback_v2) */
+    int version_major; /* DISPLAY_VERSION_MAJOR_V2 */
+    int version_minor; /* DISPLAY_VERSION_MINOR_V2 */
+    int (*display_open)(void *handle, void *device);
+    int (*display_preclose)(void *handle, void *device);
+    int (*display_close)(void *handle, void *device);
+    int (*display_presize)(void *handle, void *device,
+        int width, int height, int raster, unsigned int format);
+    int (*display_size)(void *handle, void *device, int width, int height,
+        int raster, unsigned int format, unsigned char *pimage);
+    int (*display_sync)(void *handle, void *device);
+    int (*display_page)(void *handle, void *device, int copies, int flush);
+    int (*display_update)(void *handle, void *device, int x, int y,
+        int w, int h);
+    void *(*display_memalloc)(void *handle, void *device, unsigned long size);
+    int (*display_memfree)(void *handle, void *device, void *mem);
+    int (*display_separation)(void *handle, void *device,
+        int component, const char *component_name,
+        unsigned short c, unsigned short m,
+        unsigned short y, unsigned short k);
+};
+
+/* This is the V1 structure, before separation format was added */
+struct display_callback_v1_s {
+    int size; /* sizeof(struct display_callback_v1) */
+    int version_major; /* DISPLAY_VERSION_MAJOR_V1 */
+    int version_minor; /* DISPLAY_VERSION_MINOR_V1 */
+    int (*display_open)(void *handle, void *device);
+    int (*display_preclose)(void *handle, void *device);
+    int (*display_close)(void *handle, void *device);
+    int (*display_presize)(void *handle, void *device,
+        int width, int height, int raster, unsigned int format);
+    int (*display_size)(void *handle, void *device, int width, int height,
+        int raster, unsigned int format, unsigned char *pimage);
+    int (*display_sync)(void *handle, void *device);
+    int (*display_page)(void *handle, void *device, int copies, int flush);
+    int (*display_update)(void *handle, void *device, int x, int y,
+        int w, int h);
+    void *(*display_memalloc)(void *handle, void *device, unsigned long size);
+    int (*display_memfree)(void *handle, void *device, void *mem);
+};
+
+#define DISPLAY_CALLBACK_V1_SIZEOF sizeof(struct display_callback_v1_s)
+
+#define DISPLAY_CALLOUT_GET_CALLBACK 0
+#define DISPLAY_CALLOUT_GET_CALLBACK_LEGACY 1
+
+typedef struct {
+    display_callback *callback;
+    void *caller_handle;
+} gs_display_get_callback_t;
+
+/* The display device calls a callout to find the callback structure
+ * and caller_handle from the environment (the DLL caller/user of the
+ * API).
+ * It passes:
+ *   id = DISPLAY_CALLOUT_GET_CALLBACK.
+ *   size = sizeof(gs_display_get_callback_t) (or larger);
+ *   data = pointer to gs_display_get_callback_t instance for callout
+ *          handler to fill in.
+ *
+ * In order to support the old gsapi_set_display_callback we have a
+ * related callout, DISPLAY_CALLOUT_GET_CALLBACK_LEGACY. Do not use
+ * this!
+ */
+
+
+#endif /* gdevdsp_INCLUDED */