[gs-commits] ghostpdl branch, master, updated. jbig2dec-0.14-1979-g23b4705
[email protected] (Robin Watts) Wed, 27 Nov 2019 17:26:33 +0000 (UTC)
| Newsgroups | gmane.comp.printing.ghostscript.cvs |
|---|---|
| Message-ID | <[email protected]> |
The ghostpdl branch, master has been updated
via 23b4705f975ee0d4288ad47e62ffb8737ced48a8 (commit)
via b772aaf901a3cd37baf5c06eb141c689829bf673 (commit)
from c9ed069d86f291dc3118ee96f76765432ac478e3 (commit)
----------------------------------------------------------------------
commit 23b4705f975ee0d4288ad47e62ffb8737ced48a8
Author: Robin Watts <[email protected]>
Date: Tue Nov 26 14:43:58 2019 +0000
GPDL PNG support
diff --git a/gpdl/gpdl.mak b/gpdl/gpdl.mak
index d99b172..3695415 100644
--- a/gpdl/gpdl.mak
+++ b/gpdl/gpdl.mak
@@ -44,7 +44,11 @@ GPDL_JBIG2_TOP_OBJ=$(GPDLOBJ)/$(GPDL_JBIG2_TOP_OBJ_FILE)
GPDL_JP2K_TOP_OBJ_FILE=jp2ktop.$(OBJ)
GPDL_JP2K_TOP_OBJ=$(GPDLOBJ)/$(GPDL_JP2K_TOP_OBJ_FILE)
+GPDL_PNG_TOP_OBJ_FILE=pngtop.$(OBJ)
+GPDL_PNG_TOP_OBJ=$(GPDLOBJ)/$(GPDL_PNG_TOP_OBJ_FILE)
+
GPDL_PSI_TOP_OBJS=\
+ $(GPDL_PNG_TOP_OBJ)\
$(GPDL_JP2K_TOP_OBJ)\
$(GPDL_JBIG2_TOP_OBJ)\
$(GPDL_TIFF_TOP_OBJ)\
@@ -63,7 +67,8 @@ LANG_CFLAGS=\
$(D_)PWG_INCLUDED$(_D)\
$(ENABLE_TIFF)\
$(D_)JBIG2_INCLUDED$(_D)\
- $(D_)JP2K_INCLUDED$(_D)
+ $(D_)JP2K_INCLUDED$(_D)\
+ $(D_)PNG_INCLUDED$(_D)\
GPDLCC=$(CC_) $(LANG_CFLAGS) $(I_)$(PSSRCDIR)$(_I) $(I_)$(PLSRCDIR)$(_I) $(I_)$(GLSRCDIR)$(_I) $(I_)$(DEVSRCDIR)$(_I) $(I_)$(GLGENDIR)$(_I) $(C_)
@@ -119,3 +124,8 @@ $(GPDL_JP2K_TOP_OBJ): $(GPDLSRC)jp2ktop.c $(AK)\
$(gxdevice_h) $(gserrors_h) $(gsstate_h) $(strimpl_h) $(gscoord_h)\
$(pltop_h) $(gsicc_manage_h) $(gspaint_h) $(plmain_h)
$(GPDLCC) $(I_)$(JPX_OPENJPEG_I_)$(D).. $(I_)$(JPX_OPENJPEG_I_) $(II)$(GLI_)$(_I) $(JPXCF_) $(I_)$(LWF_JPXI_) $(GPDLSRC)jp2ktop.c $(GPDLO_)$(GPDL_JP2K_TOP_OBJ_FILE)
+
+$(GPDL_PNG_TOP_OBJ): $(GPDLSRC)pngtop.c $(AK)\
+ $(gxdevice_h) $(gserrors_h) $(gsstate_h) $(strimpl_h) $(gscoord_h)\
+ $(png__h) $(pltop_h) $(gsicc_manage_h) $(gspaint_h) $(plmain_h)
+ $(GPDLCC) $(II)$(PI_)$(_I) $(PCF_) $(GPDLSRC)pngtop.c $(GPDLO_)$(GPDL_PNG_TOP_OBJ_FILE)
diff --git a/gpdl/jp2ktop.c b/gpdl/jp2ktop.c
index 9c0b398..76e17d9 100644
--- a/gpdl/jp2ktop.c
+++ b/gpdl/jp2ktop.c
@@ -376,7 +376,7 @@ do_process(jp2k_interp_instance_t *jp2k, stream_cursor_read * pr, bool eof)
{
int code = 0;
gs_color_space *cs;
- ii_state ostate = jp2k->state;
+ ii_state ostate;
size_t bytes_in;
int advanced;
@@ -384,6 +384,7 @@ do_process(jp2k_interp_instance_t *jp2k, stream_cursor_read * pr, bool eof)
do
{
advanced = 0;
+ ostate = jp2k->state;
bytes_in = pr->limit - pr->ptr;
switch(jp2k->state)
{
@@ -629,9 +630,7 @@ early_flush:
return flush_to_uel(pr);
}
advanced |= (ostate != jp2k->state);
- ostate = jp2k->state;
advanced |= (bytes_in != pr->limit - pr->ptr);
- bytes_in = pr->limit - pr->ptr;
} while (advanced);
return code;
diff --git a/gpdl/pngtop.c b/gpdl/pngtop.c
new file mode 100644
index 0000000..a7ed8e0
--- /dev/null
+++ b/gpdl/pngtop.c
@@ -0,0 +1,843 @@
+/* Copyright (C) 2019 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., 1305 Grant Avenue - Suite 200, Novato,
+ CA 94945, U.S.A., +1(415)492-9861, for further information.
+*/
+
+/* pngtop.c */
+/* Top-level API implementation of "PNG" Language Interface */
+
+#include "pltop.h"
+#include "gserrors.h"
+#include "gxdevice.h"
+#include "gsstate.h"
+#include "strimpl.h"
+#include "gscoord.h"
+#include "gsicc_manage.h"
+#include "gspaint.h"
+#include "plmain.h"
+#include "png_.h"
+
+/* Forward decls */
+
+/************************************************************/
+/******** Language wrapper implementation (see pltop.h) *****/
+/************************************************************/
+
+typedef enum
+{
+ ii_state_identifying = 0,
+ ii_state_png,
+ ii_state_png_decode,
+ ii_state_flush
+} ii_state;
+
+/*
+ * Png interpreter instance
+ */
+typedef struct png_interp_instance_s {
+ gs_memory_t *memory;
+ gs_memory_t *cmemory;
+ gx_device *dev;
+ gx_device *nulldev;
+
+ gs_color_space *gray;
+ gs_color_space *rgb;
+
+ /* Png parser state machine */
+ ii_state state;
+
+ int pages;
+
+ uint8_t bpp;
+ uint8_t cs;
+ uint32_t width;
+ uint32_t height;
+ uint32_t xresolution;
+ uint32_t yresolution;
+ int interlaced;
+
+ uint32_t num_comps;
+ uint32_t byte_width;
+ uint32_t y;
+ uint32_t passes;
+
+ uint32_t bytes_available_on_entry;
+
+ gs_image_t image;
+ gs_image_enum *penum;
+ gs_gstate *pgs;
+
+ png_structp png;
+ png_infop png_info;
+ size_t buffer_full;
+ size_t buffer_max;
+ byte *buffer;
+ size_t file_pos;
+
+ byte *samples;
+
+} png_interp_instance_t;
+
+static int
+png_detect_language(const char *s, int len)
+{
+ const byte *hdr = (const byte *)s;
+ if (len >= 8) {
+ if (hdr[0] == 137 &&
+ hdr[1] == 80 &&
+ hdr[2] == 78 &&
+ hdr[3] == 71 &&
+ hdr[4] == 13 &&
+ hdr[5] == 10 &&
+ hdr[6] == 26 &&
+ hdr[7] == 10)
+ return 100;
+ }
+
+ return 0;
+}
+
+static const pl_interp_characteristics_t png_characteristics = {
+ "PNG",
+ png_detect_language,
+ "Artifex",
+ "0.01",
+ "11 Nov 2019",
+ 1 /* minimum input size */
+};
+
+/* GS's fakakta png integration insists on putting a
+ * memory structure pointer in the decompress structs client data.
+ * This is no good to find our instance from. We therefore find
+ * it by offsetting back from the address of the cinfo. This is
+ * a nasty bit of casting, so wrap it in a macro. */
+#define JPG_FROM_CINFO(CINFO) \
+ (png_interp_instance_t *)(((char *)(CINFO))-offsetof(png_interp_instance_t,cinfo))
+
+
+/* Get implementation's characteristics */
+static const pl_interp_characteristics_t * /* always returns a descriptor */
+png_impl_characteristics(const pl_interp_implementation_t *impl) /* implementation of interpreter to alloc */
+{
+ return &png_characteristics;
+}
+
+static void
+png_deallocate(png_interp_instance_t *png)
+{
+ if (png == NULL)
+ return;
+
+ rc_decrement_cs(png->gray, "png_deallocate");
+ rc_decrement_cs(png->rgb, "png_deallocate");
+
+ if (png->pgs != NULL)
+ gs_gstate_free_chain(png->pgs);
+ gs_free_object(png->memory, png, "png_impl_allocate_interp_instance");
+}
+
+/* Deallocate a interpreter instance */
+static int
+png_impl_deallocate_interp_instance(pl_interp_implementation_t *impl)
+{
+ png_interp_instance_t *png = (png_interp_instance_t *)impl->interp_client_data;
+
+ png_deallocate(png);
+ impl->interp_client_data = NULL;
+
+ return 0;
+}
+
+/* Do per-instance interpreter allocation/init. */
+static int
+png_impl_allocate_interp_instance(pl_interp_implementation_t *impl, gs_memory_t *mem)
+{
+ int code;
+ png_interp_instance_t *png
+ = (png_interp_instance_t *)gs_alloc_bytes(mem,
+ sizeof(png_interp_instance_t),
+ "png_impl_allocate_interp_instance");
+ if (!png)
+ return_error(gs_error_VMerror);
+ memset(png, 0, sizeof(*png));
+
+ png->memory = mem;
+ png->pgs = gs_gstate_alloc(mem);
+ if (png->pgs == NULL)
+ goto failVM;
+
+ /* Push one save level onto the stack to assuage the memory handling */
+ code = gs_gsave(png->pgs);
+ if (code < 0)
+ goto fail;
+
+ code = gsicc_init_iccmanager(png->pgs);
+ if (code < 0)
+ goto fail;
+
+ png->gray = gs_cspace_new_ICC(mem, png->pgs, 1);
+ png->rgb = gs_cspace_new_ICC(mem, png->pgs, 3);
+
+ impl->interp_client_data = png;
+
+ return 0;
+
+failVM:
+ code = gs_note_error(gs_error_VMerror);
+fail:
+ (void)png_deallocate(png);
+ return code;
+}
+
+/*
+ * Get the allocator with which to allocate a device
+ */
+static gs_memory_t *
+png_impl_get_device_memory(pl_interp_implementation_t *impl)
+{
+ png_interp_instance_t *png = (png_interp_instance_t *)impl->interp_client_data;
+
+ return png->dev ? png->dev->memory : NULL;
+}
+
+#if 0 /* UNUSED */
+static int
+png_impl_set_param(pl_interp_implementation_t *impl,
+ pl_set_param_type type,
+ const char *param,
+ const void *val)
+{
+ png_interp_instance_t *png = (png_interp_instance_t *)impl->interp_client_data;
+
+ /* No params set here */
+ return 0;
+}
+
+static int
+png_impl_add_path(pl_interp_implementation_t *impl,
+ const char *path)
+{
+ png_interp_instance_t *png = (png_interp_instance_t *)impl->interp_client_data;
+
+ /* No paths to add */
+ return 0;
+}
+
+static int
+png_impl_post_args_init(pl_interp_implementation_t *impl)
+{
+ png_interp_instance_t *png = (png_interp_instance_t *)impl->interp_client_data;
+
+ /* No post args processing */
+ return 0;
+}
+#endif
+
+/* Prepare interp instance for the next "job" */
+static int
+png_impl_init_job(pl_interp_implementation_t *impl,
+ gx_device *device)
+{
+ png_interp_instance_t *png = (png_interp_instance_t *)impl->interp_client_data;
+
+ png->dev = device;
+ png->state = ii_state_identifying;
+
+ return 0;
+}
+
+#if 0 /* UNUSED */
+static int
+png_impl_run_prefix_commands(pl_interp_implementation_t *impl,
+ const char *prefix)
+{
+ png_interp_instance_t *png = (png_interp_instance_t *)impl->interp_client_data;
+
+ return 0;
+}
+
+static int
+png_impl_process_file(pl_interp_implementation_t *impl, const char *filename)
+{
+ png_interp_instance_t *png = (png_interp_instance_t *)impl->interp_client_data;
+
+ return 0;
+}
+#endif
+
+/* Do any setup for parser per-cursor */
+static int /* ret 0 or +ve if ok, else -ve error code */
+png_impl_process_begin(pl_interp_implementation_t * impl)
+{
+ return 0;
+}
+
+/* Ensure we have 'required' bytes to read, and further ensure
+ * that we have no UEL's within those bytes. */
+static int
+ensure_bytes(png_interp_instance_t *png, stream_cursor_read *pr, int required)
+{
+ int n;
+ const uint8_t *p = pr->ptr+1;
+ const uint8_t *q;
+ int avail;
+
+ /* Find out how many bytes we need to check */
+ n = pr->limit - pr->ptr;
+ if (n > required)
+ n = required;
+
+ /* Make sure there are no UELs in that block */
+ q = p + n;
+ while (p != q) {
+ while (p != q && *p != '\033')
+ p++;
+ if (p == q)
+ break;
+ avail = pr->limit - pr->ptr;
+ if (memcmp(p, "\033%-12345X", min(avail, 9)) == 0) {
+ /* At least a partial match to a UEL */
+ return avail < 9 ? gs_error_NeedInput : gs_error_InterpreterExit;
+ }
+ p++;
+ }
+
+ /* If we have enough bytes, great, if not, get some more */
+ return (n < required) ? gs_error_NeedInput : 0;
+}
+
+static int
+flush_to_uel(stream_cursor_read *pr)
+{
+ const uint8_t *p = pr->ptr+1;
+ const uint8_t *q = pr->limit+1;
+ int avail;
+
+ while (p != q) {
+ while (p != q && *p != '\033')
+ p++;
+ if (p == q)
+ break;
+ avail = pr->limit - pr->ptr;
+ if (memcmp(p, "\033%-12345X", min(avail, 9)) == 0) {
+ /* At least a partial match to a UEL. Bin everything to
+ * the start of the match. */
+ pr->ptr = p-1;
+ if (avail == 9) /* Complete match. Exit! */
+ return gs_error_InterpreterExit;
+ /* Partial match. Get more data. */
+ return gs_error_NeedInput;
+ }
+ p++;
+ }
+
+ pr->ptr = pr->limit;
+
+ return 0;
+}
+
+static int
+bytes_until_uel(const stream_cursor_read *pr)
+{
+ const uint8_t *p = pr->ptr+1;
+ const uint8_t *q = pr->limit+1;
+ int avail;
+
+ while (p != q) {
+ while (p != q && *p != '\033')
+ p++;
+ if (p == q)
+ break;
+ avail = pr->limit - pr->ptr;
+ if (memcmp(p, "\033%-12345X", min(avail, 9)) == 0) {
+ /* At least a partial match to a UEL. Everything up to
+ * the start of the match is up for grabs. */
+ return p - (pr->ptr+1);
+ }
+ p++;
+ }
+
+ return pr->limit - pr->ptr;
+}
+
+static void
+my_png_error(png_structp png_ptr, png_const_charp error_msg)
+{
+ /* png_interp_instance_t *png = (png_interp_instance_t *)png_get_error_ptr(png_ptr); */
+
+ png_longjmp(png_ptr, 1);
+}
+
+static void
+my_png_warning(png_structp png_ptr, png_const_charp warning_msg)
+{
+ /* png_interp_instance_t *png = (png_interp_instance_t *)png_get_error_ptr(png_ptr); */
+}
+
+static png_voidp
+my_png_malloc(png_structp png_ptr, png_alloc_size_t size)
+{
+ png_interp_instance_t *png = (png_interp_instance_t *)png_get_mem_ptr(png_ptr);
+
+ return gs_alloc_bytes(png->memory, size, "my_png_malloc");
+}
+
+static void
+my_png_free(png_structp png_ptr, png_voidp ptr)
+{
+ png_interp_instance_t *png = (png_interp_instance_t *)png_get_mem_ptr(png_ptr);
+
+ gs_free_object(png->memory, ptr, "my_png_free");
+}
+
+static void
+my_png_read(png_structp png_ptr, png_bytep data, png_size_t length)
+{
+ png_interp_instance_t *png = (png_interp_instance_t *)png_get_io_ptr(png_ptr);
+ if (length + png->file_pos > png->buffer_full)
+ png_error(png_ptr, "Overread!");
+
+ memcpy(data, &png->buffer[png->file_pos], length);
+ png->file_pos += length;
+}
+
+static int
+do_impl_process(png_interp_instance_t *png, stream_cursor_read * pr, bool eof)
+{
+ int code = 0;
+ ii_state ostate;
+ size_t bytes_in;
+ int advanced;
+
+ /* Loop until we stop 'advancing'. */
+ do
+ {
+ ostate = png->state;
+ bytes_in = pr->limit - pr->ptr;
+ advanced = 0;
+ switch(png->state)
+ {
+ case ii_state_identifying:
+ {
+ const byte *hdr;
+ /* Try and get us 8 bytes */
+ code = ensure_bytes(png, pr, 8);
+ if (code < 0)
+ return code;
+ hdr = pr->ptr+1;
+ if (hdr[0] == 137 &&
+ hdr[1] == 80 &&
+ hdr[2] == 78 &&
+ hdr[3] == 71 &&
+ hdr[4] == 13 &&
+ hdr[5] == 10 &&
+ hdr[6] == 26 &&
+ hdr[7] == 10) {
+ png->state = ii_state_png;
+ break;
+ }
+ png->state = ii_state_flush;
+ break;
+ }
+ case ii_state_png:
+ {
+ /* Gather data into a buffer */
+ int bytes = bytes_until_uel(pr);
+
+ if (bytes == 0 && pr->limit - pr->ptr > 9) {
+ /* No bytes until UEL, and there is space for a UEL in the buffer */
+ png->state = ii_state_png_decode;
+ png->file_pos = 0;
+ break;
+ }
+ if (bytes == 0 && eof) {
+ /* No bytes until UEL, and we are at eof */
+ png->state = ii_state_png_decode;
+ png->file_pos = 0;
+ break;
+ }
+
+ if (png->buffer_full + bytes > png->buffer_max) {
+ /* Need to expand our buffer */
+ size_t proposed = png->buffer_full*2;
+ if (proposed == 0)
+ proposed = 32768;
+ while (proposed < png->buffer_full + bytes)
+ proposed *= 2;
+
+ if (png->buffer == NULL) {
+ png->buffer = gs_alloc_bytes(png->memory, proposed, "png_buffer");
+ if (png->buffer == NULL) {
+ png->state = ii_state_flush;
+ break;
+ }
+ } else {
+ void *new_buf = gs_resize_object(png->memory, png->buffer, proposed, "png_buffer");
+ if (new_buf == NULL) {
+ png->state = ii_state_flush;
+ break;
+ }
+ png->buffer = new_buf;
+ }
+ png->buffer_max = proposed;
+ }
+
+ memcpy(&png->buffer[png->buffer_full], pr->ptr+1, bytes);
+ png->buffer_full += bytes;
+ pr->ptr += bytes;
+ break;
+ }
+ case ii_state_png_decode:
+ {
+ gs_color_space *cs;
+ float scale, xext, yext, xoffset, yoffset;
+
+ png->png = png_create_read_struct_2(
+ PNG_LIBPNG_VER_STRING,
+ (png_voidp)png,
+ my_png_error,
+ my_png_warning,
+ (png_voidp)png,
+ my_png_malloc,
+ my_png_free);
+ if (png->png == NULL) {
+ png->state = ii_state_flush;
+ break;
+ }
+
+ png->png_info = png_create_info_struct(png->png);
+ if (!png->png_info) {
+ png->state = ii_state_flush;
+ break;
+ }
+
+ png_set_read_fn(png->png, png, my_png_read);
+ png_set_alpha_mode(png->png, PNG_ALPHA_PNG, PNG_DEFAULT_sRGB);
+
+ if (setjmp(png_jmpbuf(png->png))) {
+ png->state = ii_state_flush;
+ break;
+ }
+
+ /* We use the "low level" interface to libpng to allow us to
+ * optimise memory usage. Any errors will longjmp. */
+ png_read_info(png->png, png->png_info);
+
+ png_set_expand_16(png->png);
+ png_set_alpha_mode(png->png, PNG_ALPHA_OPTIMIZED, PNG_DEFAULT_sRGB);
+ {
+ int bpc, color;
+ static const png_color_16 bg = { 0, 65535, 65535, 65535, 65535 };
+ png_get_IHDR(png->png, png->png_info,
+ &png->width,
+ &png->height,
+ &bpc,
+ &color,
+ &png->interlaced,
+ NULL /* compression */,
+ NULL /* filter */);
+ switch (color) {
+ case PNG_COLOR_TYPE_GRAY_ALPHA:
+ case PNG_COLOR_TYPE_GRAY:
+ png->num_comps = 1;
+ break;
+ case PNG_COLOR_TYPE_PALETTE:
+ png_set_palette_to_rgb(png->png);
+ png->num_comps = 3;
+ break;
+ case PNG_COLOR_TYPE_RGB:
+ case PNG_COLOR_TYPE_RGB_ALPHA:
+ png->num_comps = 3;
+ break;
+ default:
+ png->state = ii_state_flush;
+ png_longjmp(png->png, 1);
+ break;
+ }
+ png->passes = png_set_interlace_handling(png->png);
+ png_set_background(png->png, &bg, PNG_BACKGROUND_GAMMA_SCREEN, 0, 1);
+ }
+
+ png->xresolution = png_get_x_pixels_per_inch(png->png, png->png_info);
+ png->yresolution = png_get_y_pixels_per_inch(png->png, png->png_info);
+ if (png->xresolution == 0)
+ png->xresolution = png->yresolution;
+ if (png->yresolution == 0)
+ png->yresolution = png->xresolution;
+ if (png->xresolution == 0)
+ png->xresolution = png->yresolution = 72;
+
+ cs = (png->num_comps == 1 ? png->gray : png->rgb);
+
+ /* Read the updated info */
+ png_read_update_info(png->png, png->png_info);
+ png->bpp = png_get_bit_depth(png->png, png->png_info) * png->num_comps;
+
+ /* Scale to fit, if too large. */
+ scale = 1.0f;
+ if (png->width * png->dev->HWResolution[0] > png->dev->width * png->xresolution)
+ scale = ((float)png->dev->width * png->xresolution) / (png->width * png->dev->HWResolution[0]);
+ if (scale * png->height * png->dev->HWResolution[1] > png->dev->height * png->yresolution)
+ scale = ((float)png->dev->height * png->yresolution) / (png->height * png->dev->HWResolution[1]);
+
+ /* Centre - Extents and offsets are all calculated in points (1/72 of an inch) */
+ xext = ((float)png->width * 72 * scale / png->xresolution);
+ xoffset = (png->dev->width * 72 / png->dev->HWResolution[0] - xext)/2;
+ yext = ((float)png->height * 72 * scale / png->yresolution);
+ yoffset = (png->dev->height * 72 / png->dev->HWResolution[1] - yext)/2;
+
+ /* Now we've got the data from the image header, we can
+ * make the gs image instance */
+ png->byte_width = png_get_rowbytes(png->png, png->png_info);
+
+ png->nulldev = gs_currentdevice(png->pgs);
+ rc_increment(png->nulldev);
+ code = gs_setdevice_no_erase(png->pgs, png->dev);
+ if (code < 0) {
+ png->state = ii_state_flush;
+ break;
+ }
+ gs_initmatrix(png->pgs);
+
+ /* By default the ctm is set to:
+ * xres/72 0
+ * 0 -yres/72
+ * 0 dev->height * yres/72
+ * i.e. it moves the origin from being top right to being bottom left.
+ * We want to move it back, as without this, the image will be displayed
+ * upside down.
+ */
+ code = gs_translate(png->pgs, 0.0, png->dev->height * 72 / png->dev->HWResolution[1]);
+ if (code >= 0)
+ code = gs_translate(png->pgs, xoffset, -yoffset);
+ if (code >= 0)
+ code = gs_scale(png->pgs, scale, -scale);
+ /* At this point, the ctm is set to:
+ * xres/72 0
+ * 0 yres/72
+ * 0 0
+ */
+ if (code >= 0)
+ code = gs_erasepage(png->pgs);
+ if (code < 0) {
+ png->state = ii_state_flush;
+ break;
+ }
+
+ png->samples = gs_alloc_bytes(png->memory, png->byte_width * (png->interlaced ? png->height : 1), "png_impl_process(samples)");
+ if (png->samples == NULL) {
+ png->state = ii_state_flush;
+ break;
+ }
+
+ memset(&png->image, 0, sizeof(png->image));
+ gs_image_t_init(&png->image, cs);
+ png->image.BitsPerComponent = png->bpp/png->num_comps;
+ png->image.Width = png->width;
+ png->image.Height = png->height;
+
+ png->image.ImageMatrix.xx = png->xresolution / 72.0f;
+ png->image.ImageMatrix.yy = png->yresolution / 72.0f;
+
+ png->penum = gs_image_enum_alloc(png->memory, "png_impl_process(penum)");
+ if (png->penum == NULL) {
+ code = gs_note_error(gs_error_VMerror);
+ png->state = ii_state_flush;
+ return code;
+ }
+
+ code = gs_image_init(png->penum,
+ &png->image,
+ false,
+ false,
+ png->pgs);
+ if (code < 0) {
+ png->state = ii_state_flush;
+ return code;
+ }
+
+ {
+ int i, j;
+
+ if (png->interlaced) {
+ /* Collect the results from all but the last pass */
+ for (j = png->passes-1; j > 0; j--)
+ for (i = 0; i < png->height; i++)
+ png_read_row(png->png, &png->samples[i*png->byte_width], NULL);
+
+ /* And actually process the last pass */
+ for (i = 0; i < png->height; i++) {
+ uint used;
+
+ png_read_row(png->png, &png->samples[i*png->byte_width], NULL);
+
+ code = gs_image_next(png->penum, &png->samples[i*png->byte_width], png->byte_width, &used);
+ if (code < 0) {
+ png->state = ii_state_flush;
+ break;
+ }
+ }
+ } else {
+ for (i = 0; i < png->height; i++) {
+ uint used;
+
+ png_read_row(png->png, png->samples, NULL);
+
+ code = gs_image_next(png->penum, png->samples, png->byte_width, &used);
+ if (code < 0) {
+ png->state = ii_state_flush;
+ break;
+ }
+ }
+ }
+ }
+
+ code = gs_image_cleanup_and_free_enum(png->penum, png->pgs);
+ png->penum = NULL;
+ if (code < 0) {
+ png->state = ii_state_flush;
+ break;
+ }
+ code = pl_finish_page(png->memory->gs_lib_ctx->top_of_system,
+ png->pgs, 1, true);
+ if (code < 0) {
+ png->state = ii_state_flush;
+ break;
+ }
+
+ /* FIXME */
+ png->state = ii_state_flush;
+ break;
+ }
+ default:
+ case ii_state_flush:
+ //png_destroy_decompress(&png->cinfo);
+
+ //gs_png_mem_term((j_common_ptr)&png->cinfo);
+
+ if (png->penum) {
+ (void)gs_image_cleanup_and_free_enum(png->penum, png->pgs);
+ png->penum = NULL;
+ }
+
+ gs_free_object(png->memory, png->samples, "png_impl_process(samples)");
+ png->samples = NULL;
+ /* We want to bin any data we get up to, but not including
+ * a UEL. */
+ return flush_to_uel(pr);
+ }
+ advanced |= (ostate != png->state);
+ advanced |= (bytes_in != pr->limit - pr->ptr);
+ } while (advanced);
+
+ return code;
+}
+
+static int
+png_impl_process(pl_interp_implementation_t * impl, stream_cursor_read * pr)
+{
+ png_interp_instance_t *png = (png_interp_instance_t *)impl->interp_client_data;
+
+ return do_impl_process(png, pr, 0);
+}
+
+static int
+png_impl_process_end(pl_interp_implementation_t * impl)
+{
+ return 0;
+}
+
+/* Not implemented */
+static int
+png_impl_flush_to_eoj(pl_interp_implementation_t *impl, stream_cursor_read *cursor)
+{
+ const byte *p = cursor->ptr;
+ const byte *rlimit = cursor->limit;
+
+ /* Skip to, but leave UEL in buffer for PJL to find later */
+ for (; p < rlimit; ++p)
+ if (p[1] == '\033') {
+ uint avail = rlimit - p;
+
+ if (memcmp(p + 1, "\033%-12345X", min(avail, 9)))
+ continue;
+ if (avail < 9)
+ break;
+ cursor->ptr = p;
+ return 1; /* found eoj */
+ }
+ cursor->ptr = p;
+ return 0; /* need more */
+}
+
+/* Parser action for end-of-file */
+static int
+png_impl_process_eof(pl_interp_implementation_t *impl)
+{
+ png_interp_instance_t *png = (png_interp_instance_t *)impl->interp_client_data;
+ stream_cursor_read cursor;
+
+ cursor.ptr = NULL;
+ cursor.limit = NULL;
+
+ return do_impl_process(png, &cursor, 1);
+}
+
+/* Report any errors after running a job */
+static int
+png_impl_report_errors(pl_interp_implementation_t *impl, /* interp instance to wrap up job in */
+ int code, /* prev termination status */
+ long file_position, /* file position of error, -1 if unknown */
+ bool force_to_cout /* force errors to cout */
+)
+{
+ return 0;
+}
+
+/* Wrap up interp instance after a "job" */
+static int
+png_impl_dnit_job(pl_interp_implementation_t *impl)
+{
+ png_interp_instance_t *png = (png_interp_instance_t *)impl->interp_client_data;
+
+ if (png->nulldev) {
+ int code = gs_setdevice(png->pgs, png->nulldev);
+ png->dev = NULL;
+ rc_decrement(png->nulldev, "png_impl_dnit_job(nulldevice)");
+ png->nulldev = NULL;
+ return code;
+ }
+ return 0;
+}
+
+/* Parser implementation descriptor */
+const pl_interp_implementation_t png_implementation = {
+ png_impl_characteristics,
+ png_impl_allocate_interp_instance,
+ png_impl_get_device_memory,
+ NULL, /* png_impl_set_param */
+ NULL, /* png_impl_add_path */
+ NULL, /* png_impl_post_args_init */
+ png_impl_init_job,
+ NULL, /* png_impl_run_prefix_commands */
+ NULL, /* png_impl_process_file */
+ png_impl_process_begin,
+ png_impl_process,
+ png_impl_process_end,
+ png_impl_flush_to_eoj,
+ png_impl_process_eof,
+ png_impl_report_errors,
+ png_impl_dnit_job,
+ png_impl_deallocate_interp_instance,
+ NULL
+};
diff --git a/pcl/pl/plimpl.c b/pcl/pl/plimpl.c
index 71d806c..a95d38c 100644
--- a/pcl/pl/plimpl.c
+++ b/pcl/pl/plimpl.c
@@ -47,6 +47,8 @@ extern pl_interp_implementation_t jbig2_implementation;
extern pl_interp_implementation_t jp2k_implementation;
+extern pl_interp_implementation_t png_implementation;
+
/* Zero-terminated list of pointers to implementations */
pl_interp_implementation_t *pdl_implementations[] = {
&pjl_implementation,
@@ -78,6 +80,9 @@ pl_interp_implementation_t *pdl_implementations[] = {
#ifdef JP2K_INCLUDED
&jp2k_implementation,
#endif
+#ifdef PNG_INCLUDED
+ &png_implementation,
+#endif
0
};
diff --git a/windows/ghostpdl.vcproj b/windows/ghostpdl.vcproj
index 3e884e0..908db31 100644
--- a/windows/ghostpdl.vcproj
+++ b/windows/ghostpdl.vcproj
@@ -318,6 +318,10 @@
>
</File>
<File
+ RelativePath="..\gpdl\pngtop.c"
+ >
+ </File>
+ <File
RelativePath="..\gpdl\psitop.c"
>
</File>
----------------------------------------------------------------------
commit b772aaf901a3cd37baf5c06eb141c689829bf673
Author: Robin Watts <[email protected]>
Date: Tue Nov 26 14:35:05 2019 +0000
Bug 701949: Add 'omitEOD' flag to RLE compressor and use for PXL.
It turns out that some printers (Samsung ML-2250 and Canon
ImageRunner iRC2380i at least) object to the EOD byte appearing
in RLE data in PXL streams.
Ken kindly checked the PXL spec for me, and found that: "The PXL
spec does say a control code of -128 is ignored and not included
in the decompressed data and the byte following a control byte
of 128 (I assume they mean -128 here) is treated as the next
control byte. And PCL only uses RLE data for images, so they do
know how much data they expect."
Thus, the conclusion we reached is that PCL/PXL don't need
(indeed, really does not want) the EOD byte.
The Postscript spec clearly defines the EOD byte though. Rather
than break the streams for postscript, we introduce a flag
'omitEOD' that can be set for the encoder when we want to produce
a stream for use with PCL/PXL.
diff --git a/base/srle.c b/base/srle.c
index 0c0186e..21b729f 100644
--- a/base/srle.c
+++ b/base/srle.c
@@ -329,11 +329,13 @@ run_len_0_n0_read:
*++q = n0;
}
case state_eod_unmarked:
- if (wlimit - q < 1) {
- ss->state = state_eod_unmarked;
- goto no_output_room;
+ if (!ss->omitEOD) {
+ if (wlimit - q < 1) {
+ ss->state = state_eod_unmarked;
+ goto no_output_room;
+ }
+ *++q = 128; /* EOD */
}
- *++q = 128; /* EOD */
case state_eod:
ss->run_len = 0;
ss->state = state_0;
diff --git a/base/srlx.h b/base/srlx.h
index ebf1720..98309db 100644
--- a/base/srlx.h
+++ b/base/srlx.h
@@ -32,6 +32,7 @@ typedef struct stream_RLE_state_s {
stream_RL_state_common;
/* The following parameters are set by the client. */
ulong record_size;
+ bool omitEOD;
/* The following change dynamically. */
ulong record_left; /* bytes left in current record */
byte n0;
@@ -47,7 +48,7 @@ typedef struct stream_RLE_state_s {
/* We define the initialization procedure here, so that clients */
/* can avoid a procedure call. */
#define s_RLE_set_defaults_inline(ss)\
- ((ss)->EndOfData = true, (ss)->record_size = 0)
+ ((ss)->EndOfData = true, (ss)->omitEOD = false, (ss)->record_size = 0)
#define s_RLE_init_inline(ss)\
((ss)->record_left =\
((ss)->record_size == 0 ? ((ss)->record_size = max_uint) :\
diff --git a/devices/vector/gdevpx.c b/devices/vector/gdevpx.c
index 5d2d0ed..a1fce1b 100644
--- a/devices/vector/gdevpx.c
+++ b/devices/vector/gdevpx.c
@@ -741,6 +741,7 @@ pclxl_write_image_data_RLE(gx_device_pclxl * xdev, const byte * base,
goto nc;
s_RLE_set_defaults_inline(&rlstate);
rlstate.EndOfData = false;
+ rlstate.omitEOD = true;
s_RLE_init_inline(&rlstate);
w.ptr = buf - 1;
w.limit = w.ptr + num_bytes;
diff --git a/psi/zfilter.c b/psi/zfilter.c
index dfe3a1d..3ce7652 100644
--- a/psi/zfilter.c
+++ b/psi/zfilter.c
@@ -109,6 +109,7 @@ zRLE(i_ctx_t *i_ctx_p)
stream_RLE_state state;
int code;
+ s_RLE_template.set_defaults((stream_state *)&state);
check_op(2);
code = rl_setup(op - 1, &state.EndOfData);
if (code < 0)
Summary of changes:
base/srle.c | 10 +-
base/srlx.h | 3 +-
devices/vector/gdevpx.c | 1 +
gpdl/gpdl.mak | 12 +-
gpdl/jp2ktop.c | 5 +-
gpdl/pngtop.c | 843 ++++++++++++++++++++++++++++++++++++++++++++++++
pcl/pl/plimpl.c | 5 +
psi/zfilter.c | 1 +
windows/ghostpdl.vcproj | 4 +
9 files changed, 875 insertions(+), 9 deletions(-)
create mode 100644 gpdl/pngtop.c