summaryrefslogtreecommitdiff
path: root/contrib/opvp
diff options
context:
space:
mode:
authorChris Liddell <chris.liddell@artifex.com>2013-07-23 16:24:19 +0100
committerChris Liddell <chris.liddell@artifex.com>2015-07-20 18:21:17 +0100
commit6948650efd3fb9e2a70b8cf16aca57e9d0b7eb0a (patch)
tree5c2a1c671c1d4521f8a770d1e69e3d4342718030 /contrib/opvp
parent7fd9e0be26e67c36f87733bc89ea07dc26d9f839 (diff)
downloadghostpdl-6948650efd3fb9e2a70b8cf16aca57e9d0b7eb0a.tar.gz
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.
Diffstat (limited to 'contrib/opvp')
-rw-r--r--contrib/opvp/gdevopvp.c5406
-rw-r--r--contrib/opvp/opvp.h299
-rw-r--r--contrib/opvp/opvp_0_2_0.h298
-rw-r--r--contrib/opvp/opvp_common.h53
-rw-r--r--contrib/opvp/opvp_media.def166
5 files changed, 6222 insertions, 0 deletions
diff --git a/contrib/opvp/gdevopvp.c b/contrib/opvp/gdevopvp.c
new file mode 100644
index 000000000..c32e435d5
--- /dev/null
+++ b/contrib/opvp/gdevopvp.c
@@ -0,0 +1,5406 @@
+/* Copyright (c) 2003-2004, AXE, Inc. All rights reserved.
+
+ This program is free software; you can redistribute it and/or modify it
+ under the terms of the GNU General Public License as published by the
+ Free Software Foundation; either version 2 of the License, or (at your
+ option) any later version.
+
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ General Public License for more details.
+
+ You should have received a copy of the GNU General Public License along
+ with this program; if not, write to:
+
+ Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor
+ Boston, MA 02110-1301
+ USA
+
+*/
+
+/* $Id: gdevopvp.c 728 2008-03-03 02:56:05Z sho-otani $ */
+/* gdevopvp.c ver.1.00 rel.1.0 26 Nov 2004 */
+/* OpenPrinting Vector Printer Driver Glue Code */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <locale.h>
+#include <langinfo.h>
+#include <dlfcn.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+
+/* Set compatibility flag just in case we have GNU iconv.h */
+#ifndef USE_LIBICONV_GNU
+# define LIBICONV_PLUG
+#endif
+#include <iconv.h>
+
+#include "string_.h"
+#include "math_.h"
+#include "gx.h"
+
+#include "gscdefs.h"
+#include "gsexit.h"
+#include "gsstruct.h"
+#include "gserrors.h"
+#include "gsmatrix.h"
+#include "gsparam.h"
+#include "gxdevice.h"
+#include "gxdcconv.h"
+#include "gscspace.h"
+#include "gsutil.h"
+#include "gdevprn.h"
+#include "gdevvec.h"
+#include "spprint.h"
+#include "ghost.h"
+#include "gzstate.h"
+
+#include "gspath.h"
+#include "gzpath.h"
+#include "gzcpath.h"
+#include "gsropt.h"
+#include "gsiparam.h"
+#include "gxxfont.h"
+
+/* added for image gamma correction */
+#include "gximage.h"
+#include "gxfmap.h"
+#include "gxfrac.h"
+#include "gxcvalue.h"
+
+#include "opvp_common.h"
+
+#define ENABLE_SIMPLE_MODE 1
+#define ENABLE_SKIP_RASTER 1
+#define ENABLE_AUTO_REVERSE 1
+
+/* ----- data types/macros ----- */
+
+/* for debug */
+#ifdef printf
+#undef printf
+#endif
+#ifdef fprintf
+#undef fprintf
+#endif
+
+/* buffer */
+#define OPVP_BUFF_SIZE 1024
+
+/* ROP */
+#define OPVP_0_2_ROP_S 0xCC
+#define OPVP_0_2_ROP_P 0xF0
+#define OPVP_0_2_ROP_OR 0xB8
+
+/* paper */
+#define PS_DPI 72
+#define MMPI 25.4
+#define TOLERANCE 3.0
+
+typedef struct {
+ const char *region;
+ const char *name;
+ float width;
+ float height;
+} OPVP_Paper;
+
+#define X_DPI 300
+#define Y_DPI 300
+
+#define MAX_PATH_POINTS 1000
+
+/* driver */
+typedef struct gx_device_opvp_s {
+ gx_device_vector_common;
+} gx_device_opvp;
+
+typedef struct gx_device_oprp_s {
+ gx_device_common;
+ gx_prn_device_common;
+} gx_device_oprp;
+
+/* point (internal) */
+typedef struct {
+ double x;
+ double y;
+} _fPoint;
+
+/* ----- private function prototypes ----- */
+
+/* Utilities */
+static int opvp_startpage(gx_device *);
+static int opvp_endpage(void);
+static char *opvp_alloc_string(char **, const char *);
+static char *opvp_cat_string(char **, const char *);
+static char *opvp_adjust_num_string(char *);
+static char **opvp_gen_dynamic_lib_name(void);
+static char *opvp_to_utf8(char *);
+#define opvp_check_in_page(pdev) \
+ ((beginPage) || (inkjet) ? 0 \
+ : (*vdev_proc(pdev, beginpage))((gx_device_vector*)pdev))
+static int opvp_get_papertable_index(gx_device *);
+static char *opvp_get_sizestring(float, float);
+/* not used static const char *opvp_get_papersize_region(gx_device *);*/
+/* not used static const char *opvp_get_papersize_name(gx_device *);*/
+/* not used static char *opvp_get_papersize_inch(gx_device *);*/
+/* not used static const char *opvp_get_papersize(gx_device *);*/
+static char *opvp_get_mediasize(gx_device *);
+static char *opvp_gen_page_info(gx_device *);
+static char *opvp_gen_doc_info(gx_device *);
+static char *opvp_gen_job_info(gx_device *);
+static int opvp_set_brush_color(gx_device_opvp *, gx_color_index,
+ opvp_brush_t *);
+static int opvp_draw_image(gx_device_opvp *, int,
+ int, int, int, int, int, int, const byte *);
+
+/* load/unload vector driver */
+static int opvp_load_vector_driver(void);
+static int opvp_unload_vector_driver(void);
+static int prepare_open(gx_device *);
+
+/* driver procs */
+static int opvp_open(gx_device *);
+static int oprp_open(gx_device *);
+static void opvp_get_initial_matrix(gx_device *, gs_matrix *);
+static int opvp_output_page(gx_device *, int, int);
+static int opvp_close(gx_device *);
+#if GS_VERSION_MAJOR >= 8
+static gx_color_index opvp_map_rgb_color(gx_device *, const gx_color_value *); /* modified for gs 8.15 */
+#else
+static gx_color_index opvp_map_rgb_color(gx_device *, gx_color_value,
+ gx_color_value, gx_color_value);
+#endif
+static int opvp_map_color_rgb(gx_device *, gx_color_index, gx_color_value *);
+static int opvp_copy_mono(gx_device *, const byte *, int, int,
+ gx_bitmap_id, int, int, int, int,
+ gx_color_index, gx_color_index);
+static int opvp_copy_color(gx_device *, const byte *, int, int,
+ gx_bitmap_id, int, int, int, int);
+static int _get_params(gs_param_list *);
+static int opvp_get_params(gx_device *, gs_param_list *);
+static int oprp_get_params(gx_device *, gs_param_list *);
+static int _put_params(gs_param_list *);
+static int opvp_put_params(gx_device *, gs_param_list *);
+static int oprp_put_params(gx_device *, gs_param_list *);
+static int opvp_fill_path(gx_device *, const gs_imager_state *, gx_path *,
+ const gx_fill_params *, const gx_device_color *,
+ const gx_clip_path *);
+static int opvp_stroke_path(gx_device *, const gs_imager_state *, gx_path *,
+ const gx_stroke_params *, const gx_drawing_color *,
+ const gx_clip_path *);
+static int opvp_fill_mask(gx_device *, const byte *, int, int, gx_bitmap_id,
+ int, int, int, int, const gx_drawing_color *,
+ int, gs_logical_operation_t, const gx_clip_path *);
+
+/* available color spaces */
+
+static char cspace_available[] = {
+ 0, /* OPVP_CSPACE_BW */
+ 0, /* OPVP_CSPACE_DEVICEGRAY */
+ 0, /* OPVP_CSPACE_DEVICECMY */
+ 0, /* OPVP_CSPACE_DEVICECMYK */
+ 0, /* OPVP_CSPACE_DEVICERGB */
+ 0, /* OPVP_CSPACE_DEVICEKRGB */
+ 1, /* OPVP_CSPACE_STANDARDRGB */
+ 0 /* OPVP_CSPACE_STANDARDRGB64 */
+};
+
+/* vector driver procs */
+static int opvp_beginpage(gx_device_vector *);
+static int opvp_setlinewidth(gx_device_vector *, double);
+static int opvp_setlinecap(gx_device_vector *, gs_line_cap);
+static int opvp_setlinejoin(gx_device_vector *, gs_line_join);
+static int opvp_setmiterlimit(gx_device_vector *, double);
+static int opvp_setdash(gx_device_vector *, const float *, uint, double);
+static int opvp_setflat(gx_device_vector *, double);
+static int opvp_setlogop(gx_device_vector *, gs_logical_operation_t,
+ gs_logical_operation_t);
+#if GS_VERSION_MAJOR >= 8
+static int opvp_can_handle_hl_color(gx_device_vector *, const gs_imager_state *, const gx_drawing_color *);
+static int opvp_setfillcolor(gx_device_vector *, const gs_imager_state *, const gx_drawing_color *);
+static int opvp_setstrokecolor(gx_device_vector *, const gs_imager_state *,const gx_drawing_color *);
+#else
+static int opvp_setfillcolor(gx_device_vector *, const gx_drawing_color *);
+static int opvp_setstrokecolor(gx_device_vector *, const gx_drawing_color *);
+#endif
+static int opvp_vector_dopath(gx_device_vector *, const gx_path *,
+ gx_path_type_t, const gs_matrix *);
+static int opvp_vector_dorect(gx_device_vector *, fixed, fixed, fixed, fixed,
+ gx_path_type_t);
+static int opvp_beginpath(gx_device_vector *, gx_path_type_t);
+static int opvp_moveto(gx_device_vector *, double, double, double, double,
+ gx_path_type_t);
+static int opvp_lineto(gx_device_vector *, double, double, double, double,
+ gx_path_type_t);
+static int opvp_curveto(gx_device_vector *, double, double, double, double,
+ double, double, double, double, gx_path_type_t);
+static int opvp_closepath(gx_device_vector *, double, double, double, double,
+ gx_path_type_t);
+static int opvp_endpath(gx_device_vector *, gx_path_type_t);
+
+/* ----- Paper definition ----- */
+OPVP_Paper paperTable[] =
+{
+#if 0
+ {"jpn","hagaki",100/MMPI*PS_DPI,148/MMPI*PS_DPI},
+ {"iso","a6" ,105/MMPI*PS_DPI,148/MMPI*PS_DPI},
+ {"jis","b6" ,128/MMPI*PS_DPI,182/MMPI*PS_DPI},
+ {"jpn","oufuku",148/MMPI*PS_DPI,200/MMPI*PS_DPI},
+ {"iso","a5" ,148/MMPI*PS_DPI,210/MMPI*PS_DPI},
+ {"jis","b5" ,182/MMPI*PS_DPI,257/MMPI*PS_DPI},
+ {"iso","a4" ,210/MMPI*PS_DPI,297/MMPI*PS_DPI},
+ {"na" ,"letter", 8.5*PS_DPI, 11*PS_DPI},/* 215.9x279.4 */
+ {"na" ,"legal" , 8.5*PS_DPI, 14*PS_DPI},/* 215.9x355.6 */
+ {"jis","b4" ,257/MMPI*PS_DPI,364/MMPI*PS_DPI},
+ {"iso","a3" ,297/MMPI*PS_DPI,420/MMPI*PS_DPI},
+#else
+#include "opvp_media.def"
+#endif
+ {NULL ,NULL , 0, 0}
+};
+
+/* ----- Driver definition ----- */
+
+/* Driver procedures */
+static dev_proc_open_device(opvp_open);
+static dev_proc_open_device(oprp_open);
+static dev_proc_output_page(opvp_output_page);
+static dev_proc_print_page(oprp_print_page);
+static dev_proc_close_device(opvp_close);
+static dev_proc_get_params(opvp_get_params);
+static dev_proc_get_params(oprp_get_params);
+static dev_proc_put_params(opvp_put_params);
+static dev_proc_put_params(oprp_put_params);
+static dev_proc_fill_rectangle(opvp_fill_rectangle);
+static dev_proc_begin_image(opvp_begin_image);
+static image_enum_proc_plane_data(opvp_image_plane_data);
+static image_enum_proc_end_image(opvp_image_end_image);
+
+gs_public_st_suffix_add0_final(
+ st_device_opvp,
+ gx_device_opvp,
+ "gx_device_opvp",
+ device_opvp_enum_ptrs,
+ device_opvp_reloc_ptrs,
+ gx_device_finalize,
+ st_device_vector
+);
+
+#define opvp_initial_values \
+ NULL, /* *vectorDriver */\
+ NULL, /* *printerModel */\
+ NULL, /* *handle */\
+ NULL, /* (*OpenPrinter)() */\
+ NULL, /* *ErrorNo */\
+ -1, /* outputFD */\
+ 0, /* nApiEntry */\
+ NULL, /* *apiEntry */\
+ -1, /* printerContext */\
+ NULL, /* *jobInfo */\
+ NULL /* *docInfo */
+
+/* device procs */
+#define opvp_procs \
+{\
+ opvp_open,\
+ opvp_get_initial_matrix,\
+ NULL, /* sync_output */\
+ opvp_output_page,\
+ opvp_close,\
+ opvp_map_rgb_color,\
+ opvp_map_color_rgb,\
+ opvp_fill_rectangle, /*gdev_vector_fill_rectangle,*/\
+ NULL, /* tile_rectangle OBSOLETE */\
+ opvp_copy_mono,\
+ opvp_copy_color,\
+ NULL, /* draw_line OBSOLETE */\
+ NULL, /* get_bits */\
+ opvp_get_params,\
+ opvp_put_params,\
+ NULL, /* map_cmyk_color */\
+ NULL, /* get_xfont_procs */\
+ NULL, /* get_xfont_device */\
+ NULL, /* map_rgb_alpha_color */\
+ gx_page_device_get_page_device,\
+ NULL, /* get_alpha_bits OBSOLETE */\
+ NULL, /* copy_alpha */\
+ NULL, /* get_band */\
+ NULL, /* copy_rop */\
+ opvp_fill_path,\
+ opvp_stroke_path,\
+ opvp_fill_mask,\
+ gdev_vector_fill_trapezoid,\
+ gdev_vector_fill_parallelogram,\
+ gdev_vector_fill_triangle,\
+ NULL, /* draw_thin_line */\
+ opvp_begin_image,\
+ NULL, /* image_data */\
+ NULL, /* end_image */\
+ NULL, /* strip_tile_rectangle */\
+ NULL, /* strip_copy_rop */\
+ NULL, /* get_clipping_box */\
+ NULL, /* begin_typed_image */\
+ NULL, /* get_bits_rectangle */\
+ NULL, /* map_color_rgb_alpha */\
+ NULL, /* create_compositor */\
+ NULL, /* get_hardware_params */\
+ NULL, /* text_begin */\
+ NULL, /* finish_copydevice */\
+ NULL, /* begin_transparency_group */\
+ NULL, /* end_transparency_group */\
+ NULL, /* begin_transparency_mask */\
+ NULL, /* end_transparency_mask */\
+ NULL /* discard_transparency_layer */\
+}
+
+/* vector procs */
+static gx_device_vector_procs opvp_vector_procs =
+{
+ /* Page management */
+ opvp_beginpage,
+ /* Imager state */
+ opvp_setlinewidth,
+ opvp_setlinecap,
+ opvp_setlinejoin,
+ opvp_setmiterlimit,
+ opvp_setdash,
+ opvp_setflat,
+ opvp_setlogop,
+ /* Other state */
+#if GS_VERSION_MAJOR >= 8
+ opvp_can_handle_hl_color, /* added for gs 8.15 */
+#endif
+ opvp_setfillcolor,
+ opvp_setstrokecolor,
+ /* Paths */
+ opvp_vector_dopath,
+ opvp_vector_dorect,
+ opvp_beginpath,
+ opvp_moveto,
+ opvp_lineto,
+ opvp_curveto,
+ opvp_closepath,
+ opvp_endpath
+};
+
+const gx_device_opvp gs_opvp_device =
+{
+ std_device_dci_type_body(
+ gx_device_opvp,
+ 0,
+ "opvp",
+ &st_device_opvp,
+ DEFAULT_WIDTH_10THS_A4 * X_DPI / 10,
+ DEFAULT_HEIGHT_10THS_A4 * Y_DPI / 10,
+ X_DPI,
+ Y_DPI,
+ 3,
+ 24,
+ 255,
+ 255,
+ 256,
+ 256
+ ),
+ opvp_procs
+};
+
+/* for inkjet */
+static gx_device_procs prn_oprp_procs =
+ prn_color_params_procs(
+ oprp_open,
+ opvp_output_page,
+ opvp_close,
+ opvp_map_rgb_color,
+ opvp_map_color_rgb,
+ oprp_get_params,
+ oprp_put_params
+ );
+
+const gx_device_oprp gs_oprp_device =
+{
+ prn_device_std_margins_body(
+ gx_device_oprp,
+ prn_oprp_procs,
+ "oprp",
+ DEFAULT_WIDTH_10THS_A4,
+ DEFAULT_HEIGHT_10THS_A4,
+ X_DPI,
+ Y_DPI,
+ 0, 0, 0, 0, 0, 0,
+ 24,
+ oprp_print_page
+ )
+};
+
+/* driver mode */
+static bool vector = true;
+static bool inkjet = false;
+static char *vectorDriver = NULL;
+static char *printerModel = NULL;
+static void *handle = NULL;
+static opvp_dc_t (*OpenPrinter)(opvp_int_t,const opvp_char_t*,
+ const opvp_int_t[2],
+ opvp_api_procs_t**) = NULL;
+static int (*OpenPrinter_0_2)(int,char*,int*,
+ OPVP_api_procs**) = NULL;
+static opvp_int_t *ErrorNo = NULL;
+static opvp_int_t outputFD = -1;
+static opvp_int_t nApiEntry = 0;
+static opvp_api_procs_t *apiEntry = NULL;
+static OPVP_api_procs *apiEntry_0_2 = NULL;
+static opvp_dc_t printerContext = -1;
+static char *jobInfo = NULL;
+static char *docInfo = NULL;
+static opvp_cspace_t colorSpace = OPVP_CSPACE_STANDARDRGB;
+static opvp_cspace_t savedColorSpace;
+static opvp_brush_t *vectorFillColor = NULL;
+static float margins[4] = {0, 0, 0, 0};
+static float zoom[2] = {1, 1};
+static float shift[2] = {0, 0};
+static bool zoomAuto = false;
+static bool zooming = false;
+static bool beginPage = false;
+
+static int
+GetLastError_1_0(void)
+{
+ return *ErrorNo;
+}
+
+static int (*GetLastError)(void) = GetLastError_1_0;
+
+/* Wrapper functions that keep compatible with 0.2 */
+
+/* color space mapping 0.2 to 1.0 */
+static opvp_cspace_t cspace_0_2_to_1_0[] = {
+ OPVP_CSPACE_BW,
+ OPVP_CSPACE_DEVICEGRAY,
+ OPVP_CSPACE_DEVICECMY,
+ OPVP_CSPACE_DEVICECMYK,
+ OPVP_CSPACE_DEVICERGB,
+ OPVP_CSPACE_STANDARDRGB,
+ OPVP_CSPACE_STANDARDRGB64
+};
+
+/* color space mapping 1.0 to 0.2 */
+static opvp_cspace_t cspace_1_0_to_0_2[] = {
+ OPVP_cspaceBW,
+ OPVP_cspaceDeviceGray,
+ OPVP_cspaceDeviceCMY,
+ OPVP_cspaceDeviceCMYK,
+ OPVP_cspaceDeviceRGB,
+ 0, /* 0.2 doesn't have OPVP_CSPACE_DEVICEKRGB */
+ OPVP_cspaceStandardRGB,
+ OPVP_cspaceStandardRGB64,
+};
+
+/* image format mapping 1.0 to 0.2 */
+static opvp_imageformat_t iformat_1_0_to_0_2[] = {
+ OPVP_iformatRaw,
+ OPVP_iformatRaw, /* OPVP_IFORMAT_MASK use iformat raw in 0.2 */
+ OPVP_iformatRLE,
+ OPVP_iformatJPEG,
+ OPVP_iformatPNG,
+};
+/* image colorDepth needed in 0.2 */
+static int colorDepth_0_2[] = {
+ 1, /* OPVP_CSPACE_BW */
+ 8, /* OPVP_CSPACE_DEVICEGRAY */
+ 24, /* OPVP_CSPACE_DEVICECMY */
+ 32, /* OPVP_CSPACE_DEVICECMYK */
+ 24, /* OPVP_CSPACE_DEVICERGB */
+ 32, /* OPVP_CSPACE_DEVICEKRGB */
+ 24, /* OPVP_CSPACE_STANDARDRGB */
+ 64, /* OPVP_CSPACE_STANDARDRGB64 */
+};
+
+/* translate error code */
+static int
+GetLastError_0_2(void)
+{
+ switch(*ErrorNo) {
+ case OPVP_FATALERROR_0_2:
+ return OPVP_FATALERROR;
+ break;
+ case OPVP_BADREQUEST_0_2:
+ return OPVP_BADREQUEST;
+ break;
+ case OPVP_BADCONTEXT_0_2:
+ return OPVP_BADCONTEXT;
+ break;
+ case OPVP_NOTSUPPORTED_0_2:
+ return OPVP_NOTSUPPORTED;
+ break;
+ case OPVP_JOBCANCELED_0_2:
+ return OPVP_JOBCANCELED;
+ break;
+ case OPVP_PARAMERROR_0_2:
+ return OPVP_PARAMERROR;
+ break;
+ default:
+ break;
+ }
+ /* unknown error no */
+ /* return FATALERROR instead */
+ return OPVP_FATALERROR;
+}
+
+static opvp_result_t
+StartPageWrapper(opvp_dc_t printerContext, const opvp_char_t *pageInfo)
+{
+ int r;
+
+ if ((r = apiEntry_0_2->StartPage(printerContext,
+ /* discard const */(char *)pageInfo)) != OPVP_OK) {
+ /* error */
+ return r;
+ }
+ /* initialize ROP */
+ if (apiEntry_0_2->SetROP != NULL) {
+ apiEntry_0_2->SetROP(printerContext,
+ OPVP_0_2_ROP_P);
+ }
+ return OPVP_OK;
+}
+
+static opvp_result_t
+InitGSWrapper(opvp_dc_t printerContext)
+{
+ int r;
+
+ if ((r = apiEntry_0_2->InitGS(printerContext)) != OPVP_OK) {
+ /* error */
+ return r;
+ }
+ /* initialize ROP */
+ if (apiEntry_0_2->SetROP != NULL) {
+ apiEntry_0_2->SetROP(printerContext,
+ OPVP_0_2_ROP_P);
+ }
+ return OPVP_OK;
+}
+
+static opvp_result_t
+QueryColorSpaceWrapper( opvp_dc_t printerContext, opvp_int_t *pnum,
+ opvp_cspace_t *pcspace)
+{
+ int r;
+ int i;
+
+ if ((r = apiEntry_0_2->QueryColorSpace(printerContext,
+ (OPVP_ColorSpace *)pcspace,pnum)) != OPVP_OK) {
+ /* error */
+ return r;
+ }
+ /* translate cspaces */
+ for (i = 0;i < *pnum;i++) {
+ if (pcspace[i]
+ >= sizeof(cspace_0_2_to_1_0)/sizeof(opvp_cspace_t)) {
+ /* unknown color space */
+ /* set DEVICERGB instead */
+ pcspace[i] = OPVP_CSPACE_DEVICERGB;
+ } else {
+ pcspace[i] = cspace_0_2_to_1_0[pcspace[i]];
+ }
+ }
+ return OPVP_OK;
+}
+
+static opvp_result_t
+SetColorSpaceWrapper(opvp_dc_t printerContext, opvp_cspace_t cspace)
+{
+ if (cspace == OPVP_CSPACE_DEVICEKRGB) {
+ /* 0.2 doesn't have OPVP_CSPACE_DEVICEKRGB */
+ *ErrorNo = OPVP_NOTSUPPORTED_0_2;
+ return -1;
+ }
+ if (cspace
+ >= sizeof(cspace_1_0_to_0_2)/sizeof(OPVP_ColorSpace)) {
+ /* unknown color space */
+ *ErrorNo = OPVP_PARAMERROR_0_2;
+ return -1;
+ }
+ return apiEntry_0_2->SetColorSpace(printerContext,
+ cspace_1_0_to_0_2[cspace]);
+}
+
+static opvp_result_t
+GetColorSpaceWrapper(opvp_dc_t printerContext, opvp_cspace_t *pcspace)
+{
+ int r;
+
+ if ((r = apiEntry_0_2->GetColorSpace(printerContext,
+ (OPVP_ColorSpace *)pcspace)) != OPVP_OK) {
+ /* error */
+ return r;
+ }
+ if (*pcspace
+ >= sizeof(cspace_0_2_to_1_0)/sizeof(opvp_cspace_t)) {
+ /* unknown color space */
+ /* set DEVICERGB instead */
+ *pcspace = OPVP_CSPACE_DEVICERGB;
+ } else {
+ *pcspace = cspace_0_2_to_1_0[*pcspace];
+ }
+ return r;
+}
+
+static opvp_result_t
+SetStrokeColorWrapper(opvp_dc_t printerContext, const opvp_brush_t *brush)
+{
+ OPVP_Brush brush_0_2;
+
+ if (brush == NULL) {
+ *ErrorNo = OPVP_PARAMERROR_0_2;
+ return -1;
+ }
+ if (brush->colorSpace == OPVP_CSPACE_DEVICEKRGB) {
+ /* 0.2 doesn't have OPVP_CSPACE_DEVICEKRGB */
+ return OPVP_NOTSUPPORTED;
+ }
+ if (brush->colorSpace
+ >= sizeof(cspace_1_0_to_0_2)/sizeof(OPVP_ColorSpace)) {
+ /* unknown color space */
+ *ErrorNo = OPVP_PARAMERROR_0_2;
+ return -1;
+ }
+ brush_0_2.colorSpace = cspace_1_0_to_0_2[brush->colorSpace];
+ brush_0_2.xorg = brush->xorg;
+ brush_0_2.yorg = brush->yorg;
+ brush_0_2.pbrush = (OPVP_BrushData *)brush->pbrush;
+ memcpy(brush_0_2.color,brush->color,sizeof(brush_0_2.color));
+ return apiEntry_0_2->SetStrokeColor(printerContext,&brush_0_2);
+}
+
+static opvp_result_t
+SetFillColorWrapper(opvp_dc_t printerContext, const opvp_brush_t *brush)
+{
+ OPVP_Brush brush_0_2;
+
+ if (brush == NULL) {
+ *ErrorNo = OPVP_PARAMERROR_0_2;
+ return -1;
+ }
+ if (brush->colorSpace == OPVP_CSPACE_DEVICEKRGB) {
+ /* 0.2 doesn't have OPVP_CSPACE_DEVICEKRGB */
+ return OPVP_NOTSUPPORTED;
+ }
+ if (brush->colorSpace
+ >= sizeof(cspace_1_0_to_0_2)/sizeof(OPVP_ColorSpace)) {
+ /* unknown color space */
+ *ErrorNo = OPVP_PARAMERROR_0_2;
+ return -1;
+ }
+ brush_0_2.colorSpace = cspace_1_0_to_0_2[brush->colorSpace];
+ brush_0_2.xorg = brush->xorg;
+ brush_0_2.yorg = brush->yorg;
+ brush_0_2.pbrush = (OPVP_BrushData *)brush->pbrush;
+ memcpy(brush_0_2.color,brush->color,sizeof(brush_0_2.color));
+ return apiEntry_0_2->SetFillColor(printerContext,&brush_0_2);
+}
+
+static opvp_result_t
+SetBgColorWrapper(opvp_dc_t printerContext, const opvp_brush_t *brush)
+{
+ OPVP_Brush brush_0_2;
+
+ if (brush == NULL) {
+ *ErrorNo = OPVP_PARAMERROR_0_2;
+ return -1;
+ }
+ if (brush->colorSpace == OPVP_CSPACE_DEVICEKRGB) {
+ /* 0.2 doesn't have OPVP_CSPACE_DEVICEKRGB */
+ *ErrorNo = OPVP_NOTSUPPORTED_0_2;
+ return -1;
+ }
+ if (brush->colorSpace
+ >= sizeof(cspace_1_0_to_0_2)/sizeof(OPVP_ColorSpace)) {
+ /* unknown color space */
+ *ErrorNo = OPVP_PARAMERROR_0_2;
+ return -1;
+ }
+ brush_0_2.colorSpace = cspace_1_0_to_0_2[brush->colorSpace];
+ brush_0_2.xorg = brush->xorg;
+ brush_0_2.yorg = brush->yorg;
+ brush_0_2.pbrush = (OPVP_BrushData *)brush->pbrush;
+ memcpy(brush_0_2.color,brush->color,sizeof(brush_0_2.color));
+ return apiEntry_0_2->SetBgColor(printerContext,&brush_0_2);
+}
+
+static opvp_result_t
+DrawImageWrapper(
+ opvp_dc_t printerContext,
+ opvp_int_t sourceWidth,
+ opvp_int_t sourceHeight,
+ opvp_int_t sourcePitch,
+ opvp_imageformat_t imageFormat,
+ opvp_int_t destinationWidth,
+ opvp_int_t destinationHeight,
+ const void *imagedata)
+{
+ int r;
+ OPVP_Rectangle rect;
+ OPVP_ImageFormat iformat_0_2;
+ OPVP_PaintMode paintmode_0_2 = OPVP_paintModeTransparent;
+ int depth;
+
+ if (imageFormat == OPVP_IFORMAT_MASK) {
+ if (apiEntry_0_2->GetPaintMode != NULL) {
+ apiEntry_0_2->GetPaintMode(printerContext,
+ &paintmode_0_2);
+ }
+ if (paintmode_0_2 != OPVP_paintModeTransparent) {
+ if (apiEntry_0_2->SetROP != NULL) {
+ apiEntry_0_2->SetROP(printerContext,
+ OPVP_0_2_ROP_S);
+ }
+ }
+ else {
+ if (apiEntry_0_2->SetROP != NULL) {
+ apiEntry_0_2->SetROP(printerContext,
+ OPVP_0_2_ROP_OR);
+ }
+ }
+ depth = 1;
+ } else {
+ if (apiEntry_0_2->SetROP != NULL) {
+ apiEntry_0_2->SetROP(printerContext,OPVP_0_2_ROP_S);
+ }
+ depth = colorDepth_0_2[colorSpace];
+ }
+
+ OPVP_I2FIX(0,rect.p0.x);
+ OPVP_I2FIX(0,rect.p0.y);
+ OPVP_I2FIX(destinationWidth,rect.p1.x);
+ OPVP_I2FIX(destinationHeight,rect.p1.y);
+ if (imageFormat >= sizeof(iformat_1_0_to_0_2)/sizeof(OPVP_ImageFormat)) {
+ /* illegal image format */
+ *ErrorNo = OPVP_PARAMERROR_0_2;
+ return -1;
+ }
+ iformat_0_2 = iformat_1_0_to_0_2[imageFormat];
+ r = apiEntry_0_2->DrawImage(printerContext,sourceWidth,sourceHeight,
+ depth,iformat_0_2,rect,
+ sourcePitch*sourceHeight,
+ /* remove const */ (void *)imagedata);
+
+ if (apiEntry_0_2->SetROP != NULL) {
+ apiEntry_0_2->SetROP(printerContext,OPVP_0_2_ROP_P);
+ }
+
+ return r;
+}
+
+static opvp_result_t
+StartDrawImageWrapper(
+ opvp_dc_t printerContext,
+ opvp_int_t sourceWidth,
+ opvp_int_t sourceHeight,
+ opvp_int_t sourcePitch,
+ opvp_imageformat_t imageFormat,
+ opvp_int_t destinationWidth,
+ opvp_int_t destinationHeight)
+{
+ int r;
+ OPVP_Rectangle rect;
+ OPVP_ImageFormat iformat_0_2;
+ OPVP_PaintMode paintmode_0_2 = OPVP_paintModeTransparent;
+ int depth;
+
+ if (imageFormat == OPVP_IFORMAT_MASK) {
+ if (apiEntry_0_2->GetPaintMode != NULL) {
+ apiEntry_0_2->GetPaintMode(printerContext,
+ &paintmode_0_2);
+ }
+ if (paintmode_0_2 != OPVP_paintModeTransparent) {
+ if (apiEntry_0_2->SetROP != NULL) {
+ apiEntry_0_2->SetROP(printerContext,OPVP_0_2_ROP_S);
+ }
+ }
+ else {
+ if (apiEntry_0_2->SetROP != NULL) {
+ apiEntry_0_2->SetROP(printerContext,OPVP_0_2_ROP_OR);
+ }
+ }
+ depth = 1;
+ } else {
+ if (apiEntry_0_2->SetROP != NULL) {
+ apiEntry_0_2->SetROP(printerContext,OPVP_0_2_ROP_S);
+ }
+ depth = colorDepth_0_2[colorSpace];
+ }
+
+ OPVP_I2FIX(0,rect.p0.x);
+ OPVP_I2FIX(0,rect.p0.y);
+ OPVP_I2FIX(destinationWidth,rect.p1.x);
+ OPVP_I2FIX(destinationHeight,rect.p1.y);
+ if (imageFormat >= sizeof(iformat_1_0_to_0_2)/sizeof(OPVP_ImageFormat)) {
+ /* illegal image format */
+ *ErrorNo = OPVP_PARAMERROR_0_2;
+ return -1;
+ }
+ iformat_0_2 = iformat_1_0_to_0_2[imageFormat];
+ r = apiEntry_0_2->StartDrawImage(printerContext,
+ sourceWidth,sourceHeight,
+ depth,iformat_0_2,rect);
+
+ return r;
+}
+
+static opvp_result_t
+EndDrawImageWrapper(opvp_dc_t printerContext)
+{
+ int r;
+
+ r = apiEntry_0_2->EndDrawImage(printerContext);
+
+ /* make sure rop is pattern copy */
+ if (apiEntry_0_2->SetROP != NULL) {
+ apiEntry_0_2->SetROP(printerContext,OPVP_0_2_ROP_P);
+ }
+
+ return r;
+}
+
+static opvp_result_t
+QueryDeviceCapabilityWrapper(
+ opvp_dc_t printerContext,
+ opvp_queryinfoflags_t queryflag,
+ opvp_int_t *buflen,
+ opvp_char_t *infoBuf)
+{
+ return apiEntry_0_2->QueryDeviceCapability(printerContext,queryflag,
+ *buflen,(char *)infoBuf);
+}
+
+static opvp_result_t
+QueryDeviceInfoWrapper(
+ opvp_dc_t printerContext,
+ opvp_queryinfoflags_t queryflag,
+ opvp_int_t *buflen,
+ opvp_char_t *infoBuf)
+{
+ if (queryflag & OPVP_QF_MEDIACOPY) {
+ *ErrorNo = OPVP_NOTSUPPORTED;
+ return -1;
+ }
+ if (queryflag & OPVP_QF_PRINTREGION) {
+ queryflag &= ~OPVP_QF_PRINTREGION;
+ queryflag |= 0x0020000;
+ }
+ return apiEntry_0_2->QueryDeviceInfo(printerContext,queryflag,
+ *buflen,(char *)infoBuf);
+}
+
+static opvp_result_t
+SetLineDashWrapper(opvp_dc_t printerContext, opvp_int_t num,
+ const opvp_fix_t *pdash)
+{
+ return apiEntry_0_2->SetLineDash(printerContext,
+ /* remove const */ (OPVP_Fix *)pdash,num);
+}
+
+static opvp_result_t
+GetLineDashWrapper(opvp_dc_t printerContext, opvp_int_t *pnum,
+ opvp_fix_t *pdash)
+{
+ return apiEntry_0_2->GetLineDash(printerContext,
+ pdash,pnum);
+}
+
+static opvp_dc_t
+OpenPrinterWrapper(
+ opvp_int_t outputFD,
+ const opvp_char_t *printerModel,
+ const opvp_int_t apiVersion[2],
+ opvp_api_procs_t **apiProcs)
+{
+ opvp_dc_t dc = -1;
+
+ if (OpenPrinter != NULL) {
+ dc = (*OpenPrinter)(outputFD,printerModel,apiVersion,apiProcs);
+ } else {
+ /* try version 0.2 */
+
+ if (OpenPrinter_0_2 != NULL) {
+ static opvp_api_procs_t tEntry;
+ int nApiEntry;
+
+ dc = (*OpenPrinter_0_2)(outputFD,
+ /* remove const */
+ (char *)printerModel,
+ &nApiEntry,&apiEntry_0_2);
+ /* setting functions */
+ tEntry.opvpClosePrinter
+ = apiEntry_0_2->ClosePrinter;
+ tEntry.opvpStartJob
+ = (opvp_result_t (*)(opvp_int_t,
+ const opvp_char_t*))
+ apiEntry_0_2->StartJob;
+ tEntry.opvpEndJob = apiEntry_0_2->EndJob;
+ tEntry.opvpAbortJob = NULL;
+ tEntry.opvpStartDoc
+ = (opvp_result_t (*)(opvp_dc_t,
+ const opvp_char_t*))
+ apiEntry_0_2->StartDoc;
+ tEntry.opvpEndDoc = apiEntry_0_2->EndDoc;
+ if (apiEntry_0_2->StartPage != NULL) {
+ tEntry.opvpStartPage = StartPageWrapper;
+ } else {
+ tEntry.opvpStartPage = NULL;
+ }
+ tEntry.opvpEndPage = apiEntry_0_2->EndPage;
+
+ if (apiEntry_0_2->QueryDeviceCapability != NULL) {
+ tEntry.opvpQueryDeviceCapability
+ = QueryDeviceCapabilityWrapper;
+ } else {
+ tEntry.opvpQueryDeviceCapability = NULL;
+ }
+
+ if (apiEntry_0_2->QueryDeviceInfo != NULL) {
+ tEntry.opvpQueryDeviceInfo = QueryDeviceInfoWrapper;
+ } else {
+ tEntry.opvpQueryDeviceInfo = NULL;
+ }
+
+ tEntry.opvpResetCTM = apiEntry_0_2->ResetCTM;
+ tEntry.opvpSetCTM = (opvp_result_t (*)(opvp_dc_t,
+ const opvp_ctm_t*))
+ apiEntry_0_2->SetCTM;
+ tEntry.opvpGetCTM = (opvp_result_t (*)(opvp_dc_t,opvp_ctm_t*))
+ apiEntry_0_2->GetCTM;
+ if (apiEntry_0_2->InitGS != NULL) {
+ tEntry.opvpInitGS = InitGSWrapper;
+ } else {
+ tEntry.opvpInitGS = NULL;
+ }
+ tEntry.opvpSaveGS = apiEntry_0_2->SaveGS;
+ tEntry.opvpRestoreGS = apiEntry_0_2->RestoreGS;
+ if (apiEntry_0_2->QueryColorSpace != NULL) {
+ tEntry.opvpQueryColorSpace = QueryColorSpaceWrapper;
+ } else {
+ tEntry.opvpQueryColorSpace = NULL;
+ }
+ if (apiEntry_0_2->SetColorSpace != NULL) {
+ tEntry.opvpSetColorSpace = SetColorSpaceWrapper;
+ } else {
+ tEntry.opvpSetColorSpace = NULL;
+ }
+ if (apiEntry_0_2->GetColorSpace != NULL) {
+ tEntry.opvpGetColorSpace = GetColorSpaceWrapper;
+ } else {
+ tEntry.opvpGetColorSpace = NULL;
+ }
+ tEntry.opvpSetFillMode
+ = (opvp_result_t (*)(opvp_dc_t,opvp_fillmode_t))
+ apiEntry_0_2->SetFillMode;
+ tEntry.opvpGetFillMode
+ = (opvp_result_t (*)(opvp_dc_t,opvp_fillmode_t*))
+ apiEntry_0_2->GetFillMode;
+ tEntry.opvpSetAlphaConstant = apiEntry_0_2->SetAlphaConstant;
+ tEntry.opvpGetAlphaConstant = apiEntry_0_2->GetAlphaConstant;
+ tEntry.opvpSetLineWidth = apiEntry_0_2->SetLineWidth;
+ tEntry.opvpGetLineWidth = apiEntry_0_2->GetLineWidth;
+ if (apiEntry_0_2->SetLineDash != NULL) {
+ tEntry.opvpSetLineDash = SetLineDashWrapper;
+ } else {
+ tEntry.opvpSetLineDash = NULL;
+ }
+ if (apiEntry_0_2->GetLineDash != NULL) {
+ tEntry.opvpGetLineDash = GetLineDashWrapper;
+ } else {
+ tEntry.opvpGetLineDash = NULL;
+ }
+ tEntry.opvpSetLineDashOffset
+ = apiEntry_0_2->SetLineDashOffset;
+ tEntry.opvpGetLineDashOffset
+ = apiEntry_0_2->GetLineDashOffset;
+ tEntry.opvpSetLineStyle
+ = (opvp_result_t (*)(opvp_dc_t,opvp_linestyle_t))
+ apiEntry_0_2->SetLineStyle;
+ tEntry.opvpGetLineStyle
+ = (opvp_result_t (*)(opvp_dc_t,opvp_linestyle_t*))
+ apiEntry_0_2->GetLineStyle;
+ tEntry.opvpSetLineCap
+ = (opvp_result_t (*)(opvp_dc_t,opvp_linecap_t))
+ apiEntry_0_2->SetLineCap;
+ tEntry.opvpGetLineCap
+ = (opvp_result_t (*)(opvp_dc_t,opvp_linecap_t*))
+ apiEntry_0_2->GetLineCap;
+ tEntry.opvpSetLineJoin
+ = (opvp_result_t (*)(opvp_dc_t,opvp_linejoin_t))
+ apiEntry_0_2->SetLineJoin;
+ tEntry.opvpGetLineJoin
+ = (opvp_result_t (*)(opvp_dc_t,opvp_linejoin_t*))
+ apiEntry_0_2->GetLineJoin;
+ tEntry.opvpSetMiterLimit = apiEntry_0_2->SetMiterLimit;
+ tEntry.opvpGetMiterLimit = apiEntry_0_2->GetMiterLimit;
+ tEntry.opvpSetPaintMode
+ = (opvp_result_t (*)(opvp_dc_t,opvp_paintmode_t))
+ apiEntry_0_2->SetPaintMode;
+ tEntry.opvpGetPaintMode
+ = (opvp_result_t (*)(opvp_dc_t,opvp_paintmode_t*))
+ apiEntry_0_2->GetPaintMode;
+ if (apiEntry_0_2->SetStrokeColor != NULL) {
+ tEntry.opvpSetStrokeColor = SetStrokeColorWrapper;
+ } else {
+ tEntry.opvpSetStrokeColor = NULL;
+ }
+ if (apiEntry_0_2->SetFillColor != NULL) {
+ tEntry.opvpSetFillColor = SetFillColorWrapper;
+ } else {
+ tEntry.opvpSetFillColor = NULL;
+ }
+ if (apiEntry_0_2->SetBgColor != NULL) {
+ tEntry.opvpSetBgColor = SetBgColorWrapper;
+ } else {
+ tEntry.opvpSetBgColor = NULL;
+ }
+ tEntry.opvpNewPath = apiEntry_0_2->NewPath;
+ tEntry.opvpEndPath = apiEntry_0_2->EndPath;
+ tEntry.opvpStrokePath = apiEntry_0_2->StrokePath;
+ tEntry.opvpFillPath = apiEntry_0_2->FillPath;
+ tEntry.opvpStrokeFillPath = apiEntry_0_2->StrokeFillPath;
+ tEntry.opvpSetClipPath
+ = (opvp_result_t (*)(opvp_dc_t,opvp_cliprule_t))
+ apiEntry_0_2->SetClipPath;
+ tEntry.opvpResetClipPath = apiEntry_0_2->ResetClipPath;
+ tEntry.opvpSetCurrentPoint = apiEntry_0_2->SetCurrentPoint;
+ tEntry.opvpLinePath
+ = (opvp_result_t (*)(opvp_dc_t,
+ opvp_pathmode_t,opvp_int_t,
+ const opvp_point_t*))
+ apiEntry_0_2->LinePath;
+ tEntry.opvpPolygonPath
+ = (opvp_result_t (*)(opvp_dc_t,opvp_int_t,
+ const opvp_int_t*,
+ const opvp_point_t*))
+ apiEntry_0_2->PolygonPath;
+ tEntry.opvpRectanglePath
+ = (opvp_result_t (*)(opvp_dc_t,opvp_int_t,
+ const opvp_rectangle_t*))
+ apiEntry_0_2->RectanglePath;
+ tEntry.opvpRoundRectanglePath
+ = (opvp_result_t (*)(opvp_dc_t,opvp_int_t,
+ const opvp_roundrectangle_t*))
+ apiEntry_0_2->RoundRectanglePath;
+ tEntry.opvpBezierPath
+ = (opvp_result_t (*)(opvp_dc_t,opvp_int_t,
+ const opvp_point_t*))
+ apiEntry_0_2->BezierPath;
+ tEntry.opvpArcPath
+ = (opvp_result_t (*)(opvp_dc_t,opvp_arcmode_t,
+ opvp_arcdir_t,opvp_fix_t,opvp_fix_t,opvp_fix_t,
+ opvp_fix_t,opvp_fix_t,opvp_fix_t,opvp_fix_t,
+ opvp_fix_t))apiEntry_0_2->ArcPath;
+ if (apiEntry_0_2->DrawImage != NULL) {
+ tEntry.opvpDrawImage = DrawImageWrapper;
+ } else {
+ tEntry.opvpDrawImage = NULL;
+ }
+ if (apiEntry_0_2->StartDrawImage != NULL) {
+ tEntry.opvpStartDrawImage = StartDrawImageWrapper;
+ } else {
+ tEntry.opvpStartDrawImage = NULL;
+ }
+ tEntry.opvpTransferDrawImage =
+ (opvp_result_t (*)(opvp_dc_t,opvp_int_t,const void*))
+ apiEntry_0_2->TransferDrawImage;
+ if (apiEntry_0_2->EndDrawImage != NULL) {
+ tEntry.opvpEndDrawImage = EndDrawImageWrapper;
+ } else {
+ tEntry.opvpEndDrawImage = NULL;
+ }
+ tEntry.opvpStartScanline = apiEntry_0_2->StartScanline;
+ tEntry.opvpScanline
+ = (opvp_result_t (*)(opvp_dc_t,opvp_int_t,
+ const opvp_int_t*))
+ apiEntry_0_2->Scanline;
+ tEntry.opvpEndScanline = apiEntry_0_2->EndScanline;
+ tEntry.opvpStartRaster = apiEntry_0_2->StartRaster;
+ tEntry.opvpTransferRasterData
+ = (opvp_result_t (*)(opvp_dc_t,opvp_int_t,
+ const opvp_byte_t*))
+ apiEntry_0_2->TransferRasterData;
+ tEntry.opvpSkipRaster = apiEntry_0_2->SkipRaster;
+ tEntry.opvpEndRaster = apiEntry_0_2->EndRaster;
+ tEntry.opvpStartStream = apiEntry_0_2->StartStream;
+ tEntry.opvpTransferStreamData
+ = (opvp_result_t (*)(opvp_dc_t,opvp_int_t,
+ const void *))
+ apiEntry_0_2->TransferStreamData;
+ tEntry.opvpEndStream = apiEntry_0_2->EndStream;
+
+ *apiProcs = &tEntry;
+
+ GetLastError = GetLastError_0_2;
+ }
+ }
+ return dc;
+}
+
+/* for image */
+static const
+gx_image_enum_procs_t opvp_image_enum_procs =
+{
+ opvp_image_plane_data,
+ opvp_image_end_image
+};
+typedef enum _FastImageSupportMode {
+ FastImageDisable,
+ FastImageNoCTM,
+ FastImageNoRotate,
+ FastImageRightAngle,
+ FastImageReverseAngle,
+ FastImageAll
+} FastImageSupportMode;
+
+static char *fastImage = NULL;
+static FastImageSupportMode FastImageMode = FastImageDisable;
+static bool begin_image = false;
+static bool change_paint_mode = false;
+static bool change_cspace = false;
+static gs_color_space_index color_index = 0;
+static gs_color_space_index base_color_index = 0;
+static byte palette[3*256];
+static float imageDecode[GS_IMAGE_MAX_COMPONENTS * 2];
+static bool reverse_image = false;
+
+/* added for image gamma correction */
+typedef struct bbox_image_enum_s {
+ gx_image_enum_common;
+/* gs_memory_t *memory; */
+ gs_matrix matrix; /* map from image space to device dpace */
+ const gx_clip_path *pcpath;
+ gx_image_enum_common_t *target_info;
+ bool params_are_const;
+ int x0, x1;
+ int y, height;
+} bbox_image_enum;
+
+/* The following is already defined in stdpre.h */
+/*#define min(a, b) (((a) < (b))? (a) : (b))*/
+
+/* ----- Utilities ----- */
+
+/* initialize Graphic State */
+/* No defaults in OPVP 1.0 */
+static int
+InitGS(void)
+{
+ if (apiEntry->opvpInitGS != NULL) {
+ if (apiEntry->opvpInitGS(printerContext) != OPVP_OK) {
+ return -1;
+ }
+ }
+ if (apiEntry->opvpSetColorSpace != NULL) {
+ if (apiEntry->opvpSetColorSpace(printerContext,colorSpace)
+ != OPVP_OK) {
+ return -1;
+ }
+ }
+ if (apiEntry->opvpSetPaintMode != NULL) {
+ if (apiEntry->opvpSetPaintMode(printerContext,
+ OPVP_PAINTMODE_TRANSPARENT) != OPVP_OK) {
+ return -1;
+ }
+ }
+ if (apiEntry->opvpSetAlphaConstant != NULL) {
+ if (apiEntry->opvpSetAlphaConstant(printerContext,1.0)
+ != OPVP_OK) {
+ return -1;
+ }
+ }
+
+ /* other properties are set by GhostScript */
+ return 0;
+}
+
+static int
+opvp_startpage(gx_device *dev)
+{
+ int ecode = 0;
+ opvp_result_t r = -1;
+ static char *page_info = NULL;
+
+ /* page info */
+ page_info = opvp_alloc_string(&page_info, OPVP_INFO_PREFIX);
+ page_info = opvp_cat_string(&page_info, opvp_gen_page_info(dev));
+
+ /* call StartPage */
+ if (printerContext != -1) {
+ if (apiEntry->opvpStartPage)
+ r = apiEntry->opvpStartPage(printerContext,
+ (opvp_char_t *)opvp_to_utf8(page_info));
+ if (r != OPVP_OK) {
+ ecode = -1;
+ } else {
+ ecode = InitGS();
+ }
+ }
+
+ return ecode;
+}
+
+static int
+opvp_endpage(void)
+{
+ int ecode = 0;
+ opvp_result_t r = -1;
+
+ /* call EndPage */
+ if (printerContext != -1) {
+ if (apiEntry->opvpEndPage)
+ r = apiEntry->opvpEndPage(printerContext);
+ if (r != OPVP_OK) {
+ ecode = -1;
+ }
+ }
+
+ return ecode;
+}
+
+static char *
+opvp_alloc_string(char **destin, const char *source)
+{
+ if (!destin) return NULL;
+
+ if (*destin) {
+ if (source) {
+ *destin = realloc(*destin, strlen(source)+1);
+ } else {
+ free(*destin);
+ *destin = NULL;
+ }
+ } else {
+ if (source) {
+ *destin = malloc(strlen(source)+1);
+ }
+ }
+ if (*destin && source) {
+ if (*destin != source) {
+ strcpy(*destin, source);
+ }
+ }
+
+ return *destin;
+}
+
+static char *
+opvp_cat_string(char **destin, const char *string)
+{
+ if (!destin) return NULL;
+ if (!(*destin)) return opvp_alloc_string(destin, string);
+
+ if (string) {
+ *destin = realloc(*destin, strlen(*destin) +strlen(string)+1);
+ strcat(*destin, string);
+ }
+
+ return *destin;
+}
+
+static char *
+opvp_adjust_num_string(char *num_string)
+{
+ char *pp;
+ char *lp;
+
+ if (!num_string) return NULL;
+
+ if ((pp = strrchr(num_string, '.'))) {
+ for (lp = &(num_string[strlen(num_string)-1]); lp > pp; lp--) {
+ if (*lp == '0') {
+ *lp = '\0';
+ } else {
+ break;
+ }
+ }
+ if (lp == pp) *lp = '\0';
+ }
+
+ return num_string;
+}
+
+static char **
+opvp_gen_dynamic_lib_name(void)
+{
+ static char *buff[5] = {NULL,NULL,NULL,NULL,NULL};
+ char tbuff[OPVP_BUFF_SIZE];
+
+ if (!vectorDriver) {
+ return NULL;
+ }
+
+ memset((void*)tbuff, 0, OPVP_BUFF_SIZE);
+ strncpy(tbuff, vectorDriver, OPVP_BUFF_SIZE - 1);
+ opvp_alloc_string(&(buff[0]), tbuff);
+
+ memset((void*)tbuff, 0, OPVP_BUFF_SIZE);
+ strncpy(tbuff, vectorDriver, OPVP_BUFF_SIZE - 4);
+ strcat(tbuff, ".so");
+ opvp_alloc_string(&(buff[1]), tbuff);
+
+ memset((void*)tbuff, 0, OPVP_BUFF_SIZE);
+ strncpy(tbuff, vectorDriver, OPVP_BUFF_SIZE - 5);
+ strcat(tbuff, ".dll");
+ opvp_alloc_string(&(buff[2]), tbuff);
+
+ memset((void*)tbuff, 0, OPVP_BUFF_SIZE);
+ strcpy(tbuff, "lib");
+ strncat(tbuff, vectorDriver, OPVP_BUFF_SIZE - 7);
+ strcat(tbuff, ".so");
+ opvp_alloc_string(&(buff[3]), tbuff);
+
+ buff[4] = NULL;
+
+ return buff;
+}
+
+static char *
+opvp_to_utf8(char *string)
+{
+ char *locale;
+ iconv_t cd;
+ char *buff = NULL;
+ size_t ib, ob;
+ int complete = false;
+ char *ibuff, *obuff;
+ char *ostring = NULL;
+
+ if (string) {
+ ib = strlen(string);
+ if (ib > 0) {
+ ob = ib * 4;
+ buff = malloc(ob+1);
+ setlocale(LC_CTYPE, "");
+#ifdef CODESET
+ locale = nl_langinfo(CODESET);
+#else
+ locale = "UTF-8";
+#endif /* CODESET */
+ if (locale) {
+ if (strcmp(locale, "C") && buff) {
+ if ((cd = iconv_open("UTF-8", locale)) != (iconv_t)-1) {
+ ibuff = string;
+ obuff = buff;
+ if (iconv(cd, &ibuff, &ib, &obuff, &ob) != -1) {
+ *obuff = 0;
+ complete = true;
+ }
+ iconv_close(cd);
+ }
+ }
+ }
+ }
+ }
+
+ if (complete) {
+ ostring = opvp_alloc_string(&ostring, buff);
+ } else {
+ ostring = string;
+ }
+
+ if (buff) free(buff);
+ return ostring;
+}
+
+static float
+opvp_fabsf(float f)
+{
+ return (float)fabs((double)f);
+}
+
+static int
+opvp_get_papertable_index(gx_device *pdev)
+{
+ int i;
+ float width, height;
+ bool landscape;
+ float paper_w, paper_h;
+ float prev = -1;
+ int paper = -1;
+ int candidate = -1;
+ int smaller = -1;
+ int larger = -1;
+ int s_candi = -1;
+ int l_candi = -1;
+ float h_delta = TOLERANCE;
+ float sw_delta = TOLERANCE;
+ float sh_delta = TOLERANCE;
+ float lw_delta = TOLERANCE;
+ float lh_delta = TOLERANCE;
+ bool match = false;
+ float f;
+
+ /* portrait or landscape */
+ landscape = (pdev->MediaSize[0] < pdev->MediaSize[1] ? false : true);
+
+ /* paper size */
+ width = (landscape ? pdev->MediaSize[1] : pdev->MediaSize[0]);
+ height = (landscape ? pdev->MediaSize[0] : pdev->MediaSize[1]);
+
+ for (i=0; paperTable[i].name != NULL; i++) {
+ paper_w = paperTable[i].width;
+ paper_h = paperTable[i].height;
+ if (width == paper_w) {
+ if (height == paper_h) {
+ paper = i;
+ match = true;
+ break;
+ } else if ((f = opvp_fabsf(height - paper_h)) < TOLERANCE) {
+ if (f < h_delta) {
+ h_delta = f;
+ candidate = i;
+ }
+ }
+ } else if (candidate != -1) {
+ paper = candidate;
+ match = true;
+ break;
+ } else if (prev != paper_w) {
+ prev = paper_w;
+ if (paper_w < width) {
+ if ((f = opvp_fabsf(width - paper_w)) < TOLERANCE) {
+ if (f < sw_delta) {
+ sw_delta = f;
+ smaller = i;
+ }
+ }
+ } else {
+ if ((f = opvp_fabsf(width - paper_w)) < TOLERANCE) {
+ if (f < lw_delta) {
+ lw_delta = f;
+ larger = i;
+ }
+ }
+ }
+ }
+ }
+ if (!match) {
+ paper = i;
+ if (smaller != -1) {
+ paper_w = paperTable[smaller].width;
+ for (i = smaller; paperTable[i].width == paper_w; i++) {
+ paper_h = paperTable[i].height;
+ if (height == paper_h) {
+ sh_delta = 0;
+ s_candi = i;
+ break;
+ } else if ((f = opvp_fabsf(height - paper_h)) < TOLERANCE) {
+ if (f < sh_delta) {
+ sh_delta = f;
+ s_candi = i;
+ }
+ }
+ }
+ }
+ if (larger != -1) {
+ paper_w = paperTable[larger].width;
+ for (i = larger; paperTable[i].width == paper_w; i++) {
+ paper_h = paperTable[i].height;
+ if (height == paper_h) {
+ lh_delta = 0;
+ l_candi = i;
+ break;
+ } else if ((f = opvp_fabsf(height - paper_h)) < TOLERANCE) {
+ if (f < lh_delta) {
+ lh_delta = f;
+ l_candi = i;
+ }
+ }
+ }
+ }
+ if (s_candi != -1) {
+ if (l_candi != -1) {
+ if ((sw_delta + sh_delta)
+ < (lw_delta + lh_delta)) {
+ paper = s_candi;
+ } else {
+ paper = l_candi;
+ }
+ } else {
+ paper = s_candi;
+ }
+ } else {
+ if (l_candi != -1) {
+ paper = l_candi;
+ }
+ }
+ }
+
+ return paper;
+}
+
+static char *
+opvp_get_sizestring(float width, float height)
+{
+ char nbuff[OPVP_BUFF_SIZE];
+ char nbuff1[OPVP_BUFF_SIZE / 2];
+ char nbuff2[OPVP_BUFF_SIZE / 2];
+ static char *buff = NULL;
+
+ memset((void*)nbuff, 0, OPVP_BUFF_SIZE);
+ memset((void*)nbuff1, 0, OPVP_BUFF_SIZE / 2);
+ memset((void*)nbuff2, 0, OPVP_BUFF_SIZE / 2);
+
+ snprintf(nbuff1, OPVP_BUFF_SIZE / 2 - 1, "%.3f", width);
+ snprintf(nbuff2, OPVP_BUFF_SIZE / 2 - 1, "%.3f", height);
+ snprintf(nbuff, OPVP_BUFF_SIZE - 1, "%sx%s",
+ opvp_adjust_num_string(nbuff1),
+ opvp_adjust_num_string(nbuff2));
+
+ return opvp_alloc_string(&buff, nbuff);
+}
+
+static char *
+opvp_get_mediasize(gx_device *pdev)
+{
+ int i;
+ char wbuff[OPVP_BUFF_SIZE];
+ static char *buff = NULL;
+ const char *region;
+ const char *name;
+ float width;
+ float height;
+ const char *unit;
+ bool landscape;
+
+ i = opvp_get_papertable_index(pdev);
+
+ if (paperTable[i].name) {
+ region = paperTable[i].region;
+ name = paperTable[i].name;
+ width = paperTable[i].width / PS_DPI;
+ height = paperTable[i].height / PS_DPI;
+ if((strcmp(region, "na" ) == 0) ||
+ (strcmp(region, "asme") == 0) ||
+ (strcmp(region, "roc" ) == 0) ||
+ (strcmp(region, "oe" ) == 0)) {
+ unit = "in";
+ } else {
+ width *= MMPI;
+ height *= MMPI;
+ unit = "mm";
+ }
+ } else {
+ landscape = (pdev->MediaSize[0] < pdev->MediaSize[1] ?
+ false : true);
+ region = "custom";
+ name = "opvp";
+ width = (landscape ? pdev->MediaSize[1] : pdev->MediaSize[0])
+ / PS_DPI;
+ height = (landscape ? pdev->MediaSize[0] : pdev->MediaSize[1])
+ / PS_DPI;
+ unit = "in";
+ }
+ memset((void*)wbuff, 0, OPVP_BUFF_SIZE);
+ snprintf(wbuff, OPVP_BUFF_SIZE - 1, "%s_%s_%s%s", region, name,
+ opvp_get_sizestring(width, height),
+ unit);
+ buff = opvp_alloc_string(&buff, wbuff);
+
+ return buff;
+}
+
+static char *
+opvp_gen_page_info(gx_device *dev)
+{
+ static char *buff = NULL;
+ int num_copies = 1;
+ bool landscape;
+ char tbuff[OPVP_BUFF_SIZE];
+
+ /* copies */
+ if (!inkjet) {
+ if (dev->IgnoreNumCopies) {
+ num_copies = 1;
+ } else if (dev->NumCopies_set > 0) {
+ num_copies = dev->NumCopies;
+ }
+ }
+
+ landscape = (dev->MediaSize[0] < dev->MediaSize[1] ? false
+ : true);
+ memset((void*)tbuff, 0, OPVP_BUFF_SIZE);
+ snprintf(tbuff, OPVP_BUFF_SIZE - 1,
+ "MediaCopy=%d;DeviceResolution=deviceResolution_%s;"
+ "MediaPageRotation=%s;MediaSize=%s",
+ num_copies,
+ opvp_get_sizestring(dev->x_pixels_per_inch, dev->y_pixels_per_inch),
+ (landscape ? "landscape" : "portrait"),
+ opvp_get_mediasize(dev));
+
+ opvp_alloc_string(&buff, tbuff);
+
+ return buff;
+}
+
+static char *
+opvp_gen_doc_info(gx_device *dev)
+{
+ return opvp_gen_page_info(dev);
+}
+
+static char *
+opvp_gen_job_info(gx_device *dev)
+{
+ return opvp_gen_doc_info(dev);
+}
+
+static int
+opvp_set_brush_color(gx_device_opvp *pdev, gx_color_index color,
+ opvp_brush_t *brush)
+{
+ int code;
+ int ecode = 0;
+ gx_color_value rgb[3];
+
+ code = opvp_map_color_rgb((gx_device *)pdev, color, rgb);
+ if (code) {
+ ecode = -1;
+ } else {
+#if ENABLE_SIMPLE_MODE
+ brush->colorSpace = colorSpace;
+#else
+ opvp_result_t r = -1;
+ /* call GetColorSpace */
+ if (apiEntry->opvpGetColorSpace) {
+ r = apiEntry->opvpGetColorSpace(printerContext,
+ &(brush->colorSpace));
+ }
+ if (r != OPVP_OK) {
+ brush->colorSpace = OPVP_CSPACE_DEVICEKRGB;
+ }
+#endif
+ brush->pbrush = NULL;
+ brush->xorg = brush->yorg = 0;
+ brush->color[3] = (color == gx_no_color_index ? -1 : 0);
+ brush->color[2] = rgb[0];
+ brush->color[1] = rgb[1];
+ brush->color[0] = rgb[2];
+ }
+
+ return ecode;
+}
+
+static int
+opvp_draw_image(
+ gx_device_opvp *pdev,
+ int depth,
+ int sw,
+ int sh,
+ int dw,
+ int dh,
+ int raster,
+ int mask,
+ const byte *data)
+{
+ opvp_result_t r = -1;
+ int ecode = 0;
+ int count;
+
+ /* check page-in */
+ if (opvp_check_in_page(pdev)) return -1;
+
+ /* image size */
+ count = raster * sh;
+
+ /* call DrawImage */
+ if (apiEntry->opvpDrawImage) {
+ r = apiEntry->opvpDrawImage(printerContext,
+ sw,sh,
+ raster,
+ mask ? OPVP_IFORMAT_MASK : OPVP_IFORMAT_RAW,
+ dw,dh,
+ /* discard 'const' qualifier */
+ (void *)data);
+ }
+ if (r != OPVP_OK) {
+ /* call StartDrawImage */
+ if (apiEntry->opvpStartDrawImage) {
+ r = apiEntry->opvpStartDrawImage(printerContext,
+ sw,sh,
+ raster,
+ mask ? OPVP_IFORMAT_MASK : OPVP_IFORMAT_RAW,
+ dw,dh);
+ }
+ if (r == OPVP_OK) {
+ /* call TansferDrawImage */
+ if (apiEntry->opvpTransferDrawImage) {
+ r = apiEntry->opvpTransferDrawImage(
+ printerContext,
+ count,
+ /* discard 'const' qualifier */
+ (void *)data);
+ }
+ if (r != OPVP_OK) ecode = -1;
+
+ /* call EndDrawImage */
+ if (apiEntry->opvpEndDrawImage) {
+ apiEntry->opvpEndDrawImage(printerContext);
+ }
+ } else {
+ ecode = 0; /* continue... */
+ }
+ }
+
+ return ecode;
+}
+
+/* ----- load/unload vector driver ----- */
+
+/*
+ * load vector-driver
+ */
+static int
+opvp_load_vector_driver(void)
+{
+ char **list = NULL;
+ int i;
+ void *h;
+
+ if (handle) {
+ opvp_unload_vector_driver();
+ }
+
+ if (vectorDriver) {
+ list = opvp_gen_dynamic_lib_name();
+ }
+
+ if (list) {
+ i = 0;
+ while (list[i]) {
+ if ((h = dlopen(list[i],RTLD_NOW))) {
+ OpenPrinter = dlsym(h,"opvpOpenPrinter");
+ ErrorNo = dlsym(h,"opvpErrorNo");
+ if (OpenPrinter && ErrorNo) {
+ handle = h;
+ break;
+ }
+ OpenPrinter = NULL;
+ ErrorNo = NULL;
+ /* try version 0.2 driver */
+ OpenPrinter_0_2 = dlsym(h,"OpenPrinter");
+ ErrorNo = dlsym(h,"errorno");
+ if (OpenPrinter_0_2 && ErrorNo) {
+ handle = h;
+ break;
+ }
+ OpenPrinter_0_2 = NULL;
+ ErrorNo = NULL;
+ }
+ i++;
+ }
+ }
+
+ if (handle) {
+ return 0;
+ } else {
+ return -1;
+ }
+}
+
+/*
+ * unload vector-driver
+ */
+static int
+opvp_unload_vector_driver(void)
+{
+ if (handle) {
+ dlclose(handle);
+ handle = NULL;
+ OpenPrinter = NULL;
+ ErrorNo = NULL;
+ }
+ return 0;
+}
+
+/*
+ * prepare open
+ */
+static int
+prepare_open(gx_device *dev)
+{
+ int ecode = 0;
+ int code;
+ opvp_result_t r = -1;
+ opvp_api_procs_t *api_entry;
+ int dumFD = -1;
+ opvp_dc_t dumContext = -1;
+ opvp_cspace_t cspace = OPVP_CSPACE_STANDARDRGB;
+
+ /* open dummy device */
+ code = open("/dev/null", O_RDWR);
+ if (code < 0) ecode = code;
+ else dumFD = code;
+
+ /* load vector driver */
+ if (!ecode) {
+ if ((code = opvp_load_vector_driver())) {
+ ecode = code;
+ }
+ }
+
+ /* prepare array of function pointer for PDAPI */
+ if (!ecode) {
+ if (!apiEntry) {
+ if (!(apiEntry = calloc(sizeof(opvp_api_procs_t), 1))) {
+ ecode = -1;
+ }
+ } else {
+ memset(apiEntry, 0, sizeof(opvp_api_procs_t));
+ }
+ }
+
+ /* call opvpOpenPrinter as dummy */
+ if (!ecode) {
+ opvp_dc_t dc;
+ opvp_int_t apiVersion[2];
+
+ /* require version 1.0 */
+ apiVersion[0] = 1;
+ apiVersion[1] = 0;
+ dc = OpenPrinterWrapper(dumFD, (opvp_char_t *)printerModel,
+ apiVersion,&api_entry);
+ if (dc == -1) {
+ ecode = -1;
+ } else {
+ dumContext = dc;
+ }
+ }
+
+ /* set apiEntry */
+ if (!ecode) {
+ nApiEntry = sizeof(opvp_api_procs_t)/sizeof(void *);
+ memcpy(apiEntry, api_entry, nApiEntry*sizeof(void *));
+ } else {
+ if (apiEntry) free(apiEntry);
+ apiEntry = NULL;
+ }
+
+ /* check vector fucntion */
+ if (apiEntry) {
+ if (!inkjet) {
+ if (!(apiEntry->opvpNewPath) ||
+ !(apiEntry->opvpEndPath) ||
+ !(apiEntry->opvpStrokePath) ||
+ !(apiEntry->opvpSetCurrentPoint) ||
+ !(apiEntry->opvpLinePath) ||
+ !(apiEntry->opvpBezierPath)) {
+ /* NOT avail vector drawing mode */
+ vector = false;
+ }
+ }
+ /* call GetColorSpace */
+ if (apiEntry->opvpGetColorSpace) {
+ r = apiEntry->opvpGetColorSpace(dumContext, &cspace);
+ }
+ if (cspace == OPVP_CSPACE_BW) {
+ /* mono-color */
+ colorSpace = cspace;
+ dev->color_info.num_components = 1;
+ dev->color_info.depth = 1;
+ dev->color_info.max_gray = 0;
+ dev->color_info.max_color = 0;
+ dev->color_info.dither_grays = 1;
+ dev->color_info.dither_colors = 1;
+ } else if (cspace == OPVP_CSPACE_DEVICEGRAY) {
+ /* gray-scale */
+ colorSpace = cspace;
+ dev->color_info.num_components = 1;
+ dev->color_info.depth = 8;
+ dev->color_info.max_gray = 255;
+ dev->color_info.max_color = 255;
+ dev->color_info.dither_grays = 256;
+ dev->color_info.dither_colors = 256;
+ } else {
+ /* rgb color */
+ colorSpace = OPVP_CSPACE_STANDARDRGB;
+ dev->color_info.num_components = 3;
+ dev->color_info.depth = 24;
+ dev->color_info.max_gray = 255;
+ dev->color_info.max_color = 255;
+ dev->color_info.dither_grays = 256;
+ dev->color_info.dither_colors = 256;
+ }
+#if GS_VERSION_MAJOR >= 8
+ dev->procs.get_color_mapping_procs = NULL;
+ dev->procs.get_color_comp_index = NULL;
+ gx_device_fill_in_procs(dev);
+#endif
+ }
+
+ /* call Closerinter as dummy */
+ if (dumContext != -1) {
+ /* call ClosePrinter */
+ if (apiEntry->opvpClosePrinter) {
+ apiEntry->opvpClosePrinter(dumContext);
+ }
+ dumContext = -1;
+ }
+
+ /* close device for dummy */
+ if (dumFD != -1) {
+ close(dumFD);
+ dumFD = -1;
+ }
+
+ /* un-load vector driver */
+ opvp_unload_vector_driver();
+
+ return ecode;
+}
+
+/* ----- driver procs ----- */
+/*
+ * open device
+ */
+static int
+opvp_open(gx_device *dev)
+{
+ gx_device_opvp *pdev = (gx_device_opvp *)dev;
+ gx_device_oprp *rdev = (gx_device_oprp *)dev;
+ int ecode = 0;
+ int code;
+ opvp_result_t r = -1;
+ opvp_dc_t dc;
+ opvp_api_procs_t *api_entry;
+ char *job_info = NULL;
+ char *doc_info = NULL;
+ char *tmp_info = NULL;
+ float margin_width = 0;
+ float margin_height = 0;
+ float adj_margins[4];
+ opvp_int_t apiVersion[2];
+
+ /* prepare open : load and open as dummy */
+ code = prepare_open(dev);
+ if (code) {
+ ecode = code;
+ return ecode;
+ }
+
+ /* set margins */
+ if (zoomAuto) {
+ margin_width = (margins[0] + margins[2])
+ * dev->HWResolution[0];
+ margin_height = (margins[1] + margins[3])
+ * dev->HWResolution[1];
+ zoom[0] = (dev->width - margin_width) / dev->width;
+ zoom[1] = (dev->height - margin_height) / dev->height;
+ if (zoom[0] < zoom[1]) {
+ zoom[1] = zoom[0];
+ } else {
+ zoom[0] = zoom[1];
+ }
+ }
+ if (inkjet) {
+ if ((margins[0] != 0) ||
+ (margins[1] != 0) || (margins[3] != 0)) {
+ shift[0] = margins[0] * dev->HWResolution[0];
+ shift[1] = (margins[1] + margins[3])
+ * dev->HWResolution[1];
+ zooming = true;
+ }
+ dev->width -= margins[2] * dev->HWResolution[0];
+ dev->height -= margins[1] * dev->HWResolution[1];
+ } else {
+ if ((margins[0] != 0) || (margins[1] != 0)) {
+ shift[0] = margins[0] * dev->HWResolution[0];
+ shift[1] = margins[3] * dev->HWResolution[1];
+ zooming = true;
+ }
+ adj_margins[0] = 0;
+ adj_margins[3] = 0;
+ adj_margins[1] = dev->height * zoom[1] / dev->HWResolution[1]
+ - (dev->MediaSize[1] / PS_DPI
+ - (margins[1] + margins[3]));
+ if (adj_margins[1] < 0) adj_margins[0] = 0;
+ adj_margins[2] = dev->width * zoom[0] / dev->HWResolution[0]
+ - (dev->MediaSize[0] / PS_DPI
+ - (margins[0] + margins[2]));
+ if (adj_margins[2] < 0) adj_margins[2] = 0;
+ gx_device_set_margins(dev, adj_margins, true);
+ }
+ if ((zoom[0] != 1) || (zoom[1] != 1)) zooming = true;
+
+ /* open file for output device */
+ if (!inkjet) {
+ pdev->v_memory = gs_memory_stable(pdev->memory);
+ /* open output stream */
+ code = gdev_vector_open_file_options((gx_device_vector*)dev,
+ 512,
+ (VECTOR_OPEN_FILE_SEQUENTIAL
+ |VECTOR_OPEN_FILE_BBOX
+ ));
+ if (code < 0) {
+ ecode = code;
+ return ecode;
+ }
+ while (dev->child) {
+ dev = dev->child;
+ }
+ rdev = (gx_device_oprp *)(dev);
+ pdev = (gx_device_opvp *)(dev);
+#if GS_VERSION_MAJOR >= 8
+ if (pdev->bbox_device != NULL) {
+ if (pdev->bbox_device->memory == NULL) {
+ pdev->bbox_device->memory = gs_memory_stable(dev->memory);
+ }
+ }
+#endif
+ outputFD = fileno(pdev->file);
+ } else {
+ /* open printer device */
+ code = gdev_prn_open(dev);
+ if (code < 0) {
+ ecode = ecode;
+ return ecode;
+ }
+ while (dev->child) {
+ dev = dev->child;
+ }
+ rdev = (gx_device_oprp *)(dev);
+ pdev = (gx_device_opvp *)(dev);
+ /* open output stream */
+ code = gdev_prn_open_printer_seekable(dev, true, false);
+ if (code < 0) {
+ ecode = code;
+ return ecode;
+ }
+ outputFD = fileno(rdev->file);
+ }
+
+ /* RE-load vector driver */
+ if ((code = opvp_load_vector_driver())) {
+ ecode = code;
+ return ecode;
+ }
+
+ /* call opvpOpenPrinter */
+ /* require version 1.0 */
+ apiVersion[0] = 1;
+ apiVersion[1] = 0;
+ dc = OpenPrinterWrapper(outputFD,(opvp_char_t *)printerModel,
+ apiVersion,&api_entry);
+ if (!apiEntry) {
+ if (!(apiEntry = calloc(sizeof(opvp_api_procs_t), 1))) {
+ ecode = -1;
+ }
+ } else {
+ memset(apiEntry, 0, sizeof(opvp_api_procs_t));
+ }
+ if (dc == -1) {
+ ecode = -1;
+ if (apiEntry) free(apiEntry);
+ apiEntry = NULL;
+ opvp_unload_vector_driver();
+ if (inkjet) gdev_prn_close(dev);
+ else gdev_vector_close_file((gx_device_vector *)pdev);
+ return ecode;
+ }
+ printerContext = dc;
+ nApiEntry = sizeof(opvp_api_procs_t)/sizeof(void *);
+ memcpy(apiEntry, api_entry, nApiEntry*sizeof(void *));
+
+ /* initialize */
+ if ((!ecode) && (!inkjet)) {
+ pdev->vec_procs = &opvp_vector_procs;
+ if (vector) gdev_vector_init((gx_device_vector *)pdev);
+ }
+
+ if (apiEntry->opvpQueryColorSpace) {
+ int n = sizeof(cspace_available);
+ int nn = n;
+ opvp_cspace_t *p = malloc(n*sizeof(opvp_cspace_t));
+
+ if ((r = apiEntry->opvpQueryColorSpace(printerContext,&nn,p))
+ == OPVP_PARAMERROR && nn > n) {
+ /* realloc buffer and retry */
+ p = realloc(p,nn*sizeof(opvp_cspace_t));
+ r = apiEntry->opvpQueryColorSpace(printerContext,&nn,p);
+ }
+ if (r == OPVP_OK) {
+ int i;
+
+ for (i = 0;i < nn;i++) {
+ if (p[i] < sizeof(cspace_available)) {
+ cspace_available[p[i]] = 1;
+ }
+ }
+ }
+ free(p);
+ }
+ /* start job */
+ if (!ecode) {
+ /* job info */
+ if (jobInfo) {
+ if (strlen(jobInfo) > 0) {
+ job_info = opvp_alloc_string(&job_info,jobInfo);
+ }
+ }
+ tmp_info = opvp_alloc_string(&tmp_info,opvp_gen_job_info(dev));
+ if (tmp_info) {
+ if (strlen(tmp_info) > 0) {
+ if (job_info) {
+ if (strlen(job_info) > 0) {
+ opvp_cat_string(&job_info, ";");
+ }
+ }
+ job_info = opvp_cat_string(&job_info,OPVP_INFO_PREFIX);
+ job_info = opvp_cat_string(&job_info,tmp_info);
+ }
+ }
+
+ /* call StartJob */
+ if (apiEntry->opvpStartJob) {
+ r = apiEntry->opvpStartJob(printerContext,
+ (opvp_char_t *)opvp_to_utf8(job_info));
+ }
+ if (r != OPVP_OK) {
+ ecode = -1;
+ }
+ }
+
+ /* start doc */
+ if (!ecode) {
+ /* doc info */
+ if (docInfo) {
+ if (strlen(docInfo) > 0) {
+ doc_info = opvp_alloc_string(&doc_info,docInfo);
+ }
+ }
+ tmp_info = opvp_alloc_string(&tmp_info, opvp_gen_doc_info(dev));
+ if (tmp_info) {
+ if (strlen(tmp_info) > 0) {
+ if (doc_info) {
+ if (strlen(doc_info) > 0) {
+ opvp_cat_string(&doc_info, ";");
+ }
+ }
+ doc_info = opvp_cat_string(&doc_info,OPVP_INFO_PREFIX);
+ doc_info = opvp_cat_string(&doc_info,tmp_info);
+ }
+ }
+
+ /* call StartDoc */
+ if (apiEntry->opvpStartDoc) {
+ r = apiEntry->opvpStartDoc(printerContext,
+ (opvp_char_t *)opvp_to_utf8(doc_info));
+ }
+ if (r != OPVP_OK) {
+ ecode = -1;
+ }
+ }
+
+ if (tmp_info) opvp_alloc_string(&tmp_info, NULL);
+ if (doc_info) opvp_alloc_string(&doc_info, NULL);
+ if (job_info) opvp_alloc_string(&job_info, NULL);
+
+ return ecode;
+}
+
+/*
+ * open device for inkjet
+ */
+static int
+oprp_open(gx_device *dev)
+{
+ /* set inkjet mode */
+ vector = false;
+ inkjet = true;
+
+ /* matrix */
+ dev->procs.get_initial_matrix = opvp_get_initial_matrix;
+ return opvp_open(dev);
+}
+
+/*
+ * get initial matrix
+ */
+static void
+opvp_get_initial_matrix(gx_device *dev, gs_matrix *pmat)
+{
+ gx_device_opvp *pdev = (gx_device_opvp *)dev;
+ opvp_ctm_t omat;
+
+ gx_default_get_initial_matrix(dev,pmat);
+ if (zooming) {
+ /* gs matrix */
+ pmat->xx *= zoom[0];
+ pmat->xy *= zoom[1];
+ pmat->yx *= zoom[0];
+ pmat->yy *= zoom[1];
+ pmat->tx = pmat->tx * zoom[0] + shift[0];
+ pmat->ty = pmat->ty * zoom[1] + shift[1];
+ }
+
+ if (pdev->is_open) {
+ /* call ResetCTM */
+ if (apiEntry->opvpResetCTM) {
+ apiEntry->opvpResetCTM(printerContext);
+ } else {
+ /* call SetCTM */
+ omat.a = 1;
+ omat.b = 0;
+ omat.c = 0;
+ omat.d = 1;
+ omat.e = 0;
+ omat.f = 0;
+ if (apiEntry->opvpSetCTM) {
+ apiEntry->opvpSetCTM(printerContext, &omat);
+ }
+ }
+ }
+
+ return;
+}
+
+/*
+ * output page
+ */
+static int
+opvp_output_page(gx_device *dev, int num_copies, int flush)
+{
+ gx_device_opvp *pdev = (gx_device_opvp *)dev;
+ int ecode = 0;
+ int code = -1;
+
+ if (inkjet) return gdev_prn_output_page(dev, num_copies, flush);
+
+#ifdef OPVP_IGNORE_BLANK_PAGE
+ if (pdev->in_page) {
+#else
+ /* check page-in */
+ if (opvp_check_in_page(pdev)) return -1;
+#endif
+ /* end page */
+ code = opvp_endpage();
+ if (code) ecode = code;
+
+ pdev->in_page = false;
+ beginPage = false;
+#ifdef OPVP_IGNORE_BLANK_PAGE
+ }
+#endif
+
+ if (vector) {
+ gdev_vector_reset((gx_device_vector *)pdev);
+ }
+
+ code = gx_finish_output_page(dev, num_copies, flush);
+ if (code) ecode = code;
+
+ return ecode;
+}
+
+/*
+ * print page
+ */
+static int
+oprp_print_page(gx_device_printer *pdev, FILE *prn_stream)
+{
+ int ecode = 0;
+ int code = -1;
+ opvp_result_t r = -1;
+ int raster_size;
+ int buff_size;
+ byte *buff = NULL;
+ int line;
+ int scan_lines;
+ byte *data;
+ int rasterWidth;
+ bool start_page = false;
+ bool start_raster = false;
+#if ENABLE_SKIP_RASTER
+ int i;
+ byte check;
+#endif
+
+ /* get raster/pixel size */
+ raster_size = gx_device_raster((gx_device *)pdev, 0);
+ buff_size = ((raster_size + 3) >> 2) << 2;
+ scan_lines = dev_print_scan_lines(pdev);
+ rasterWidth = pdev->width;
+
+ /* allocate buffer */
+ buff = (byte*)calloc(1, buff_size);
+ if (!buff) return ecode = -1;
+
+ /* start page */
+ if (!ecode) {
+ code = opvp_startpage((gx_device *)pdev);
+ if (code) ecode = code;
+ else start_page = true;
+ }
+
+ /* moveto origin */
+ if (!ecode)
+ opvp_moveto((gx_device_vector*)pdev, 0, 0, 0, 0, 0);
+
+ /* call StartRaster */
+ if (!ecode) {
+ if (apiEntry->opvpStartRaster) {
+ r = apiEntry->opvpStartRaster(printerContext,rasterWidth);
+ }
+ if (r != OPVP_OK) {
+ ecode = r;
+ } else {
+ start_raster = true;
+ }
+ }
+
+ /* line */
+ for (line = 0; (line < scan_lines) && (!ecode); line++) {
+ /* get raster data */
+ if (!ecode) {
+ code = gdev_prn_get_bits(pdev, line, buff, &data);
+ if (code) {
+ ecode = code;
+ break;
+ }
+ }
+#if ENABLE_SKIP_RASTER
+ /* check support SkipRaster */
+ if (apiEntry->opvpSkipRaster) {
+ /* check all white */
+ if (pdev->color_info.depth > 8) {
+ for (check = 0xff, i = 0; i < raster_size; i++)
+ {
+ check &= data[i];
+ if (check != 0xff) break;
+ }
+ /* if all white call SkipRaster */
+ if (check == 0xff) {
+ r = apiEntry->opvpSkipRaster(printerContext, 1);
+ if (r == OPVP_OK) continue;
+ }
+ } else {
+ for (check = 0, i = 0; i < raster_size; i++) {
+ check |= data[i];
+ if (check) break;
+ }
+ /* if all zero call SkipRaster */
+ if (check) {
+ r = apiEntry->opvpSkipRaster(printerContext, 1);
+ if (r == OPVP_OK) continue;
+ }
+ }
+ }
+#endif
+ /* call TransferRasterData */
+ if (!ecode) {
+ if (apiEntry->opvpTransferRasterData) {
+ r = apiEntry->opvpTransferRasterData(printerContext,
+ raster_size,
+ data);
+ }
+ if (r != OPVP_OK) ecode = r;
+ }
+ }
+
+ /* call EndRaster */
+ if (start_raster) {
+ if (apiEntry->opvpEndRaster) {
+ r = apiEntry->opvpEndRaster(printerContext);
+ }
+ if (r != OPVP_OK) ecode = r;
+ start_raster = false;
+ }
+
+ /* end page */
+ if (start_page) {
+ code = opvp_endpage();
+ if (code) ecode = code;
+ start_page = false;
+ }
+
+ /* free buffer */
+ if (buff) {
+ free(buff);
+ buff = NULL;
+ }
+
+ return ecode;
+}
+
+/*
+ * close device
+ */
+static int
+opvp_close(gx_device *dev)
+{
+ gx_device_opvp *pdev = (gx_device_opvp *)dev;
+ int ecode = 0;
+
+ /* finalize */
+ if (printerContext != -1) {
+ /* call EndDoc */
+ if (apiEntry->opvpEndDoc) {
+ apiEntry->opvpEndDoc(printerContext);
+ }
+
+ /* call EndJob */
+ if (apiEntry->opvpEndJob) {
+ apiEntry->opvpEndJob(printerContext);
+ }
+
+ /* call ClosePrinter */
+ if (apiEntry->opvpClosePrinter) {
+ apiEntry->opvpClosePrinter(printerContext);
+ }
+ printerContext = -1;
+ }
+
+ /* unload vector driver */
+ if (apiEntry) free(apiEntry);
+ apiEntry = NULL;
+ opvp_unload_vector_driver();
+
+ if (inkjet) {
+ /* close printer */
+ gdev_prn_close(dev);
+ } else {
+ /* close output stream */
+ gdev_vector_close_file((gx_device_vector *)pdev);
+ }
+ outputFD = -1;
+
+ return ecode;
+}
+
+/*
+ * map rgb color
+ */
+#if GS_VERSION_MAJOR >= 8
+static gx_color_index
+opvp_map_rgb_color(gx_device *dev,
+ const gx_color_value *prgb /* modified for gs 8.15 */)
+#else
+static gx_color_index
+opvp_map_rgb_color(gx_device *dev,
+ gx_color_value r,
+ gx_color_value g,
+ gx_color_value b)
+#endif
+{
+ opvp_cspace_t cs;
+ uint c, m, y, k;
+
+#if !(ENABLE_SIMPLE_MODE)
+ gx_device_opvp *pdev;
+ opvp_result_t r;
+#endif
+
+#if GS_VERSION_MAJOR >= 8
+ gx_color_value r, g, b; /* added for gs 8.15 */
+ r = prgb[0];
+ g = prgb[1];
+ b = prgb[2];
+#endif
+
+#if !(ENABLE_SIMPLE_MODE)
+ pdev = (gx_device_opvp *)dev;
+ r = -1;
+#endif
+ cs = OPVP_CSPACE_STANDARDRGB;
+
+#if ENABLE_SIMPLE_MODE
+ cs = colorSpace;
+#else
+ if (pdev->is_open) {
+ /* call GetColorSpace */
+ if (apiEntry->opvpGetColorSpace) {
+ r = apiEntry->opvpGetColorSpace(printerContext, &cs);
+ }
+ if (r != OPVP_OK) {
+ if (pdev->color_info.depth > 32) {
+ cs = OPVP_CSPACE_STANDARDRGB64;
+ } else if (pdev->color_info.depth > 8 ) {
+ cs = OPVP_CSPACE_STANDARDRGB;
+ } else if (pdev->color_info.depth > 1 ) {
+ cs = OPVP_CSPACE_DEVICEGRAY;
+ } else {
+ cs = OPVP_CSPACE_BW;
+ }
+ }
+ }
+#endif
+
+ switch (cs) {
+ case OPVP_CSPACE_STANDARDRGB64:
+ /* unsupported */
+ if (sizeof(gx_color_index) >= 6) {
+ return (long long)b
+ + ((long long)g << 16)
+ + ((long long)b << 32);
+ } else {
+ return gx_color_value_to_byte(b)
+ + ((uint)gx_color_value_to_byte(g) << 8)
+ + ((ulong)gx_color_value_to_byte(r) << 16);
+ }
+ break;
+ case OPVP_CSPACE_DEVICECMYK:
+ case OPVP_CSPACE_DEVICECMY:
+ /* unsupported */
+ c = gx_color_value_to_byte(~r);
+ m = gx_color_value_to_byte(~g);
+ y = gx_color_value_to_byte(~b);
+ if (cs == OPVP_CSPACE_DEVICECMYK) {
+ k = (c<m ? (c<y ? c : y) : (m<y ? m : y));
+ c -= k;
+ m -= k;
+ y -= k;
+ } else {
+ k = 0;
+ }
+ return (k + (y << 8) + (m << 16) + (c << 24));
+ break;
+ case OPVP_CSPACE_DEVICEGRAY:
+#if GS_VERSION_MAJOR >= 8
+ {
+ gx_color_value rgb[3];
+ rgb[0] = rgb[1] = rgb[2] = r;
+ return gx_default_gray_map_rgb_color(dev, rgb);
+ }
+#else
+ return gx_default_gray_map_rgb_color(dev, r, g, b);
+#endif
+ break;
+ case OPVP_CSPACE_BW :
+#if GS_VERSION_MAJOR >= 8
+ return gx_default_b_w_map_rgb_color(dev, prgb);
+#else
+ return gx_default_b_w_map_rgb_color(dev, r, g, b);
+#endif
+ break;
+ case OPVP_CSPACE_STANDARDRGB:
+ case OPVP_CSPACE_DEVICEKRGB:
+ default:
+#if GS_VERSION_MAJOR >= 8
+ return gx_default_rgb_map_rgb_color(dev, prgb);
+#else
+ return gx_default_rgb_map_rgb_color(dev, r, g, b);
+#endif
+ break;
+ }
+}
+
+/*
+ * map color rgb
+ */
+static int
+opvp_map_color_rgb(gx_device *dev, gx_color_index color,
+ gx_color_value prgb[3])
+{
+#if !(ENABLE_SIMPLE_MODE)
+ gx_device_opvp *pdev = (gx_device_opvp *)dev;
+ opvp_result_t r = -1;
+#endif
+ opvp_cspace_t cs = OPVP_CSPACE_STANDARDRGB;
+ uint c, m, y, k;
+
+#if ENABLE_SIMPLE_MODE
+ cs = colorSpace;
+#else
+ /* call GetColorSpace */
+ if (pdev->is_open) {
+ if (apiEntry->opvpGetColorSpace) {
+ r = apiEntry->opvpGetColorSpace(printerContext, &cs);
+ }
+ if (r != OPVP_OK) {
+ if (pdev->color_info.depth > 32) {
+ cs = OPVP_CSPACE_STANDARDRGB64;
+ } else if (pdev->color_info.depth > 8 ) {
+ cs = OPVP_CSPACE_STANDARDRGB;
+ } else if (pdev->color_info.depth > 1 ) {
+ cs = OPVP_CSPACE_DEVICEGRAY;
+ } else {
+ cs = OPVP_CSPACE_BW;
+ }
+ }
+ }
+#endif
+
+ switch (cs) {
+ case OPVP_CSPACE_STANDARDRGB64:
+ /* unsupported */
+ if (sizeof(gx_color_index) >= 6) {
+ prgb[0] = ((long long)color >> 32) & 0xffff;
+ prgb[1] = ((long long)color >> 16) & 0xffff;
+ prgb[2] = color & 0xffff;
+ } else {
+ prgb[0] = gx_color_value_from_byte((color >> 16) & 0xff);
+ prgb[1] = gx_color_value_from_byte((color >> 8) & 0xff);
+ prgb[2] = gx_color_value_from_byte(color & 0xff);
+ }
+ break;
+ case OPVP_CSPACE_DEVICECMYK:
+ case OPVP_CSPACE_DEVICECMY:
+ /* unsupported */
+ c = gx_color_value_from_byte((color >> 24) & 0xff);
+ m = gx_color_value_from_byte((color >> 16) & 0xff);
+ y = gx_color_value_from_byte((color >> 8) & 0xff);
+ if (cs == OPVP_CSPACE_DEVICECMYK) {
+ k = gx_color_value_from_byte(color & 0xff);
+ c += k; if (c > 255) c = 255;
+ m += k; if (m > 255) m = 255;
+ y += k; if (y > 255) y = 255;
+ }
+ prgb[0] = gx_color_value_from_byte(~c & 0xff);
+ prgb[1] = gx_color_value_from_byte(~m & 0xff);
+ prgb[2] = gx_color_value_from_byte(~y & 0xff);
+ break;
+ case OPVP_CSPACE_DEVICEGRAY:
+ return gx_default_gray_map_color_rgb(dev, color, prgb);
+ break;
+ case OPVP_CSPACE_BW:
+ return gx_default_b_w_map_color_rgb(dev, color, prgb);
+ break;
+ case OPVP_CSPACE_STANDARDRGB:
+ case OPVP_CSPACE_DEVICEKRGB:
+ default:
+ return gx_default_rgb_map_color_rgb(dev, color, prgb);
+ break;
+ }
+
+ return 0;
+}
+
+/*
+ * fill rectangle
+ */
+static int
+opvp_fill_rectangle(
+ gx_device *dev,
+ int x,
+ int y,
+ int w,
+ int h,
+ gx_color_index color)
+{
+ gx_device_opvp *pdev = (gx_device_opvp *)dev;
+ byte data[8] = {0xC0, 0, 0, 0, 0xC0, 0, 0, 0};
+ int code = -1;
+ int ecode = 0;
+ opvp_brush_t brush;
+ opvp_point_t point;
+
+ if (vector) {
+ return gdev_vector_fill_rectangle( dev, x, y, w, h, color);
+ }
+
+ /* check page-in */
+ if (opvp_check_in_page(pdev)) return -1;
+
+#if !(ENABLE_SIMPLE_MODE)
+ /* call SaveGS */
+ if (apiEntry->opvpSaveGS) {
+ apiEntry->opvpSaveGS(printerContext);
+ }
+#endif
+
+ /* one-color */
+ opvp_set_brush_color(pdev, color, &brush);
+
+ /* call SetFillColor */
+ if (apiEntry->opvpSetFillColor) {
+ apiEntry->opvpSetFillColor(printerContext, &brush);
+ }
+
+ /* call SetCurrentPoint */
+ OPVP_I2FIX(x, point.x);
+ OPVP_I2FIX(y, point.y);
+ if (apiEntry->opvpSetCurrentPoint) {
+ apiEntry->opvpSetCurrentPoint(printerContext,point.x, point.y);
+ }
+
+ /* draw image */
+ code = opvp_draw_image(pdev,
+ 1,
+ 2, 2,
+ w, h,
+ 4,
+ 0,
+ data);
+ if (code) {
+ ecode = code;
+ }
+
+ /* restore fill color */
+ if (vectorFillColor) {
+ /* call SetFillColor */
+ if (apiEntry->opvpSetFillColor) {
+ apiEntry->opvpSetFillColor(printerContext,vectorFillColor);
+ }
+ }
+
+#if !(ENABLE_SIMPLE_MODE)
+ /* call RestoreGS */
+ if (apiEntry->opvpRestoreGS) {
+ apiEntry->opvpRestoreGS(printerContext);
+ }
+#endif
+
+ return ecode;
+}
+
+/*
+ * copy mono
+ */
+static int
+opvp_copy_mono(
+ gx_device *dev,
+ const byte *data,
+ int data_x,
+ int raster,
+ gx_bitmap_id id,
+ int x,
+ int y,
+ int w,
+ int h,
+ gx_color_index zero,
+ gx_color_index one)
+{
+ gx_device_opvp *pdev = (gx_device_opvp *)dev;
+ int code = -1;
+ int ecode = 0;
+ opvp_brush_t brush;
+ opvp_point_t point;
+ const byte *buff = data;
+ byte *mybuf = NULL;
+ int i, j;
+ byte *d;
+ const byte *s;
+ int byte_offset = 0;
+ int byte_length = raster;
+ int bit_shift = 0;
+ int adj_raster = raster;
+ unsigned char bit_mask = 0xff;
+ bool reverse = false;
+
+ /* check page-in */
+ if (opvp_check_in_page(pdev)) return -1;
+
+ /* data offset */
+ if (data_x) {
+ byte_offset = data_x >> 3;
+ bit_shift = data_x & 0x07;
+ if (bit_shift) bit_mask <<= (8 - bit_shift);
+
+ byte_length = ((w + 7) >> 3);
+ adj_raster = ((byte_length + 3) >> 2) << 2;
+
+ buff = mybuf = calloc(adj_raster, h);
+ if (!mybuf) {
+ /* memory error */
+ return -1;
+ }
+ s = &(data[byte_offset]);
+ d = mybuf;
+ if (bit_shift) {
+ for (i = 0;i < h; i++, d += adj_raster, s+= raster) {
+ for (j = 0; j < byte_length; j++) {
+ d[j] = ((s[j] & ~bit_mask) << bit_shift)
+ | ((s[j + 1] & bit_mask) >> (8 - bit_shift));
+ }
+ }
+ } else {
+ for (i = 0;i < h; i++, d += adj_raster, s+= raster) {
+ for (j = 0; j < byte_length; j++) {
+ d[j] = s[j];
+ }
+ }
+ }
+ byte_offset = 0;
+ }
+
+#if !(ENABLE_SIMPLE_MODE)
+ /* call SaveGS */
+ if (apiEntry->opvpSaveGS) {
+ apiEntry->opvpSaveGS(printerContext);
+ }
+#endif
+ if (one == gx_no_color_index) {
+ gx_color_index tc;
+
+ reverse = (!reverse);
+ tc = zero;
+ zero = one;
+ one = tc;
+ }
+
+ if (zero != gx_no_color_index) {
+ /* not mask */
+ /* Set PaintMode */
+ if (apiEntry->opvpSetPaintMode) {
+ apiEntry->opvpSetPaintMode(printerContext,OPVP_PAINTMODE_OPAQUE);
+ }
+ /* zero-color */
+ opvp_set_brush_color(pdev, zero, &brush);
+
+ /* call SetBgColor */
+ if (apiEntry->opvpSetBgColor) {
+ apiEntry->opvpSetBgColor(printerContext, &brush);
+ }
+ }
+
+ /* one-color */
+ opvp_set_brush_color(pdev, one, &brush);
+
+ /* call SetFillColor */
+ if (apiEntry->opvpSetFillColor) {
+ apiEntry->opvpSetFillColor(printerContext, &brush);
+ }
+
+ if (reverse) {
+ /* 0/1 reverse image */
+ int n = adj_raster*h;
+
+ if (buff == data) {
+ /* buff was not allocated from this function yet */
+ /* allocate here */
+ if ((mybuf = malloc(n)) == 0) return -1;
+ }
+ for (i = 0;i < n;i++) {
+ mybuf[i] = ~buff[i];
+ }
+ buff = mybuf;
+ }
+ /* call SetCurrentPoint */
+ OPVP_I2FIX(x, point.x);
+ OPVP_I2FIX(y, point.y);
+ if (apiEntry->opvpSetCurrentPoint) {
+ apiEntry->opvpSetCurrentPoint(printerContext,point.x, point.y);
+ }
+
+ /* draw image */
+ code = opvp_draw_image(pdev,
+ 1,
+ w, h,
+ w, h,
+ adj_raster,
+ 1,
+ &(buff[byte_offset]));
+ if (code) {
+ ecode = code;
+ }
+
+ if (zero != gx_no_color_index) {
+ /* restore PaintMode */
+ if (apiEntry->opvpSetPaintMode) {
+ apiEntry->opvpSetPaintMode(printerContext,
+ OPVP_PAINTMODE_TRANSPARENT);
+ }
+ }
+ /* restore fill color */
+ if (vectorFillColor) {
+ /* call SetFillColor */
+ if (apiEntry->opvpSetFillColor) {
+ apiEntry->opvpSetFillColor(printerContext,vectorFillColor);
+ }
+ }
+
+#if !(ENABLE_SIMPLE_MODE)
+ /* call RestoreGS */
+ if (apiEntry->opvpRestoreGS) {
+ apiEntry->opvpRestoreGS(printerContext);
+ }
+#endif
+
+ if (buff != data) {
+ /* buff was allocated from this function */
+ if (mybuf) free(mybuf);
+ }
+
+ return ecode;
+}
+
+/*
+ * copy color
+ */
+static int
+opvp_copy_color(
+ gx_device *dev,
+ const byte *data,
+ int data_x,
+ int raster,
+ gx_bitmap_id id,
+ int x,
+ int y,
+ int w,
+ int h)
+{
+ gx_device_opvp *pdev = (gx_device_opvp *)dev;
+ int code = -1;
+ int ecode = 0;
+ opvp_point_t point;
+ const byte *buff = data;
+ byte *mybuf = NULL;
+ int i;
+ byte *d;
+ const byte *s;
+ int byte_length = raster;
+ int depth;
+ int pixel;
+ int adj_raster = raster;
+
+ /* check page-in */
+ if (opvp_check_in_page(pdev)) return -1;
+
+ /* data offset */
+ if (data_x) {
+ depth = pdev->color_info.depth;
+ pixel = (depth + 7) >> 3;
+ byte_length = pixel * w;
+ adj_raster = ((byte_length + 3) >> 2) << 2;
+
+ buff = mybuf = malloc(adj_raster * h);
+ if (!mybuf) {
+ /* memory error */
+ return -1;
+ }
+ s = &(data[data_x*pixel]);
+ d = mybuf;
+ for (i = 0;i < h; i++, d += adj_raster, s += raster) {
+ memcpy(d, s, byte_length);
+ }
+ data_x = 0;
+ }
+
+#if !(ENABLE_SIMPLE_MODE)
+ /* call SaveGS */
+ if (apiEntry->opvpSaveGS) {
+ apiEntry->opvpSaveGS(printerContext);
+ }
+#endif
+
+ /* call SetCurrentPoint */
+ OPVP_I2FIX(x, point.x);
+ OPVP_I2FIX(y, point.y);
+ if (apiEntry->opvpSetCurrentPoint) {
+ apiEntry->opvpSetCurrentPoint(printerContext, point.x, point.y);
+ }
+
+ /* draw image */
+ code = opvp_draw_image(pdev,
+ pdev->color_info.depth,
+ w, h,
+ w, h,
+ adj_raster,
+ 0,
+ &(buff[data_x]));
+ if (code) {
+ ecode = code;
+ }
+
+#if !(ENABLE_SIMPLE_MODE)
+ /* call RestoreGS */
+ if (apiEntry->opvpRestoreGS) {
+ apiEntry->opvpRestoreGS(printerContext);
+ }
+#endif
+
+ if (buff != data) {
+ /* buff was allocated from this function */
+ if (mybuf) free(mybuf);
+ }
+
+ return ecode;
+}
+
+/*
+ * get params
+ */
+static int
+_get_params(gs_param_list *plist)
+{
+ int code;
+ int ecode = 0;
+ gs_param_name pname;
+ gs_param_string vdps;
+ gs_param_string pmps;
+ gs_param_string jips;
+ gs_param_string dips;
+ gs_param_string fips;
+ gs_param_string mlps;
+ gs_param_string mtps;
+ gs_param_string mrps;
+ gs_param_string mbps;
+ gs_param_string zmps;
+ char buff[OPVP_BUFF_SIZE];
+
+ /* get params */
+
+ /* vector driver name */
+ pname = "Driver";
+ vdps.data = (byte *)vectorDriver;
+ vdps.size = (vectorDriver ? strlen(vectorDriver) + 1 : 0);
+ vdps.persistent = false;
+ code = param_write_string(plist, pname, &vdps);
+ if (code) ecode = code;
+
+ /* printer model name */
+ pname = "Model";
+ pmps.data = (byte *)printerModel;
+ pmps.size = (printerModel ? strlen(printerModel) + 1 : 0);
+ pmps.persistent = false;
+ code = param_write_string(plist, pname, &pmps);
+ if (code) ecode = code;
+
+ /* job info */
+ pname = "JobInfo";
+ jips.data = (byte *)jobInfo;
+ jips.size = (jobInfo ? strlen(jobInfo) + 1 : 0);
+ jips.persistent = false;
+ code = param_write_string(plist, pname, &jips);
+ if (code) ecode = code;
+
+ /* doc info */
+ pname = "DocInfo";
+ dips.data = (byte *)docInfo;
+ dips.size = (docInfo ? strlen(docInfo) + 1 : 0);
+ dips.persistent = false;
+ code = param_write_string(plist, pname, &dips);
+ if (code) ecode = code;
+
+ /* fast image support */
+ switch (FastImageMode) {
+ case FastImageNoCTM:
+ opvp_alloc_string(&fastImage, "NoCTM");
+ break;
+ case FastImageNoRotate:
+ opvp_alloc_string(&fastImage, "NoRotateCTM");
+ break;
+ case FastImageRightAngle:
+ opvp_alloc_string(&fastImage, "RightAngleCTM");
+ break;
+ case FastImageReverseAngle:
+ opvp_alloc_string(&fastImage, "ReverseAngleCTM");
+ break;
+ case FastImageAll:
+ opvp_alloc_string(&fastImage, "All");
+ break;
+ case FastImageDisable:
+ default:
+ opvp_alloc_string(&fastImage, NULL);
+ break;
+ }
+ pname = "FastImage";
+ fips.data = (byte *)fastImage;
+ fips.size = (fastImage ? strlen(fastImage) + 1 : 0);
+ fips.persistent = false;
+ code = param_write_string(plist, pname, &fips);
+ if (code) ecode = code;
+
+ /* margins */
+ memset((void*)buff, 0, OPVP_BUFF_SIZE);
+ pname = "MarginLeft";
+ snprintf(buff, OPVP_BUFF_SIZE - 1, "%f",margins[0]);
+ mlps.data = (byte *)buff;
+ mlps.size = strlen(buff) + 1;
+ mlps.persistent = false;
+ code = param_write_string(plist, pname, &mlps);
+ if (code) ecode = code;
+ pname = "MarginTop";
+ snprintf(buff, OPVP_BUFF_SIZE - 1, "%f",margins[3]);
+ mtps.data = (byte *)buff;
+ mtps.size = strlen(buff) + 1;
+ mtps.persistent = false;
+ code = param_write_string(plist, pname, &mtps);
+ if (code) ecode = code;
+ pname = "MarginRight";
+ snprintf(buff, OPVP_BUFF_SIZE - 1, "%f",margins[2]);
+ mrps.data = (byte *)buff;
+ mrps.size = strlen(buff) + 1;
+ mrps.persistent = false;
+ code = param_write_string(plist, pname, &mrps);
+ if (code) ecode = code;
+ pname = "MarginBottom";
+ snprintf(buff, OPVP_BUFF_SIZE - 1, "%f",margins[1]);
+ mbps.data = (byte *)buff;
+ mbps.size = strlen(buff) + 1;
+ mbps.persistent = false;
+ code = param_write_string(plist, pname, &mbps);
+ if (code) ecode = code;
+
+ /* zoom */
+ pname = "Zoom";
+ snprintf(buff, OPVP_BUFF_SIZE - 1, "%f",zoom[0]);
+ zmps.data = (byte *)buff;
+ zmps.size = strlen(buff) + 1;
+ zmps.persistent = false;
+ code = param_write_string(plist, pname, &zmps);
+ if (code) ecode = code;
+
+ return ecode;
+}
+
+/*
+ * get params for vector
+ */
+static int
+opvp_get_params(gx_device *dev, gs_param_list *plist)
+{
+ int code;
+
+ /* get default params */
+ code = gdev_vector_get_params(dev, plist);
+ if (code) return code;
+
+ /* get params */
+ return _get_params(plist);
+}
+
+/*
+ * get params for inkjet
+ */
+static int
+oprp_get_params(gx_device *dev, gs_param_list *plist)
+{
+ int code;
+
+ /* get default params */
+ code = gdev_prn_get_params(dev, plist);
+ if (code) return code;
+
+ /* get params */
+ return _get_params(plist);
+}
+
+/*
+ * put params
+ */
+static int
+_put_params(gs_param_list *plist)
+{
+ int code;
+ int ecode = 0;
+ gs_param_name pname;
+ char *buff = NULL;
+ gs_param_string vdps;
+ gs_param_string pmps;
+ gs_param_string jips;
+ gs_param_string dips;
+ gs_param_string fips;
+ gs_param_string mlps;
+ gs_param_string mtps;
+ gs_param_string mrps;
+ gs_param_string mbps;
+ gs_param_string zmps;
+
+ /* vector driver name */
+ pname = "Driver";
+ code = param_read_string(plist, pname, &vdps);
+ switch (code) {
+ case 0:
+ buff = realloc(buff, vdps.size + 1);
+ memcpy(buff, vdps.data, vdps.size);
+ buff[vdps.size] = 0;
+ opvp_alloc_string(&vectorDriver, buff);
+ break;
+ case 1:
+ /* opvp_alloc_string(&vectorDriver, NULL);*/
+ break;
+ default:
+ ecode = code;
+ param_signal_error(plist, pname, ecode);
+ }
+
+ /* printer model name */
+ pname = "Model";
+ code = param_read_string(plist, pname, &pmps);
+ switch (code) {
+ case 0:
+ buff = realloc(buff, pmps.size + 1);
+ memcpy(buff, pmps.data, pmps.size);
+ buff[pmps.size] = 0;
+ opvp_alloc_string(&printerModel, buff);
+ break;
+ case 1:
+ /*opvp_alloc_string(&printerModel, NULL);*/
+ break;
+ default:
+ ecode = code;
+ param_signal_error(plist, pname, ecode);
+ }
+
+ /* job info */
+ pname = "JobInfo";
+ code = param_read_string(plist, pname, &jips);
+ switch (code) {
+ case 0:
+ buff = realloc(buff, jips.size + 1);
+ memcpy(buff, jips.data, jips.size);
+ buff[jips.size] = 0;
+ opvp_alloc_string(&jobInfo, buff);
+ break;
+ case 1:
+ /*opvp_alloc_string(&jobInfo, NULL);*/
+ break;
+ default:
+ ecode = code;
+ param_signal_error(plist, pname, ecode);
+ }
+
+ /* doc info */
+ pname = "DocInfo";
+ code = param_read_string(plist, pname, &dips);
+ switch (code) {
+ case 0:
+ buff = realloc(buff, dips.size + 1);
+ memcpy(buff, dips.data, dips.size);
+ buff[dips.size] = 0;
+ opvp_alloc_string(&docInfo, buff);
+ break;
+ case 1:
+ /*opvp_alloc_string(&docInfo, NULL);*/
+ break;
+ default:
+ ecode = code;
+ param_signal_error(plist, pname, ecode);
+ }
+
+ /* fast image support */
+ pname = "FastImage";
+ code = param_read_string(plist, pname, &fips);
+ switch (code) {
+ case 0:
+ buff = realloc(buff, fips.size + 1);
+ memcpy(buff, fips.data, fips.size);
+ buff[fips.size] = 0;
+ opvp_alloc_string(&fastImage, buff);
+ if (strcasecmp(fastImage,"NoCTM")==0) {
+ FastImageMode = FastImageNoCTM;
+ } else if (strncasecmp(fastImage,"NoRotate",8)==0) {
+ FastImageMode = FastImageNoRotate;
+ } else if (strncasecmp(fastImage,"Right",5)==0) {
+ FastImageMode = FastImageRightAngle;
+ } else if (strncasecmp(fastImage,"Reverse",7)==0) {
+ FastImageMode = FastImageReverseAngle;
+ } else if (strncasecmp(fastImage,"All",3)==0) {
+ FastImageMode = FastImageAll;
+ } else {
+ FastImageMode = FastImageDisable;
+ }
+ break;
+ case 1:
+ /*opvp_alloc_string(&fastImage, NULL);*/
+ break;
+ default:
+ ecode = code;
+ param_signal_error(plist, pname, ecode);
+ }
+
+ /* margins */
+ pname = "MarginLeft";
+ code = param_read_string(plist, pname, &mlps);
+ switch (code) {
+ case 0:
+ buff = realloc(buff, mlps.size + 1);
+ memcpy(buff, mlps.data, mlps.size);
+ buff[mlps.size] = 0;
+ margins[0] = atof(buff);
+ break;
+ case 1:
+ break;
+ default:
+ ecode = code;
+ param_signal_error(plist, pname, ecode);
+ }
+ pname = "MarginTop";
+ code = param_read_string(plist, pname, &mtps);
+ switch (code) {
+ case 0:
+ buff = realloc(buff, mtps.size + 1);
+ memcpy(buff, mtps.data, mtps.size);
+ buff[mtps.size] = 0;
+ margins[3] = atof(buff);
+ break;
+ case 1:
+ break;
+ default:
+ ecode = code;
+ param_signal_error(plist, pname, ecode);
+ }
+ pname = "MarginRight";
+ code = param_read_string(plist, pname, &mrps);
+ switch (code) {
+ case 0:
+ buff = realloc(buff, mrps.size + 1);
+ memcpy(buff, mrps.data, mrps.size);
+ buff[mrps.size] = 0;
+ margins[2] = atof(buff);
+ break;
+ case 1:
+ break;
+ default:
+ ecode = code;
+ param_signal_error(plist, pname, ecode);
+ }
+ pname = "MarginBottom";
+ code = param_read_string(plist, pname, &mbps);
+ switch (code) {
+ case 0:
+ buff = realloc(buff, mbps.size + 1);
+ memcpy(buff, mbps.data, mbps.size);
+ buff[mbps.size] = 0;
+ margins[1] = atof(buff);
+ break;
+ case 1:
+ break;
+ default:
+ ecode = code;
+ param_signal_error(plist, pname, ecode);
+ }
+
+ /* zoom */
+ pname = "Zoom";
+ code = param_read_string(plist, pname, &zmps);
+ switch (code) {
+ case 0:
+ buff = realloc(buff, zmps.size + 1);
+ memcpy(buff, zmps.data, zmps.size);
+ buff[zmps.size] = 0;
+ if (strncasecmp(buff, "Auto", 4)) {
+ zoom[0] = atof(buff);
+ if (zoom[0] > 0) {
+ zoom[1] = zoom[0];
+ } else {
+ zoom[0] = zoom[1] = 1;
+ }
+ } else {
+ zoom[0] = zoom[1] = 1;
+ zoomAuto = true;
+ }
+ break;
+ case 1:
+ break;
+ default:
+ ecode = code;
+ param_signal_error(plist, pname, ecode);
+ }
+
+ if (buff) free(buff);
+
+ return ecode;
+}
+
+/*
+ * put params for vector
+ */
+static int
+opvp_put_params(gx_device *dev, gs_param_list *plist)
+{
+ int code;
+
+ /* put params */
+ code = _put_params(plist);
+ if (code) return code;
+
+ /* put default params */
+ return gdev_vector_put_params(dev, plist);
+}
+
+/*
+ * put params for inkjet
+ */
+static int
+oprp_put_params(gx_device *dev, gs_param_list *plist)
+{
+ int code;
+
+ /* put params */
+ code = _put_params(plist);
+ if (code) return code;
+
+ /* put default params */
+ return gdev_prn_put_params(dev, plist);
+}
+
+static int checkPath(const gx_path *ppath)
+{
+ unsigned int npoints = 0;
+ fixed vs[6];
+ int op;
+ gs_path_enum path;
+
+ gx_path_enum_init(&path, ppath);
+
+ while ((op = gx_path_enum_next(&path, (gs_fixed_point *)vs)) != 0) {
+ switch (op) {
+ case gs_pe_lineto:
+ case gs_pe_moveto:
+ npoints += 1;
+ break;
+ case gs_pe_curveto:
+ npoints += 3;
+ break;
+ case gs_pe_closepath:
+ break;
+ default:
+ break;
+ }
+ if (npoints > MAX_PATH_POINTS) {
+ return 0;
+ }
+
+ }
+ return 1;
+}
+
+static int checkCPath(const gx_clip_path *pcpath)
+{
+ const gx_clip_list *list;
+ const gx_clip_rect *prect;
+ int npoints;
+
+ if (pcpath == 0) return 1;
+ if (pcpath->path_valid) {
+ return checkPath(&pcpath->path);
+ }
+ list = gx_cpath_list(pcpath);
+ prect = list->head;
+ if (prect == 0) {
+ prect = &list->single;
+ }
+ npoints = 0;
+ for (;prect != 0;prect = prect->next) {
+ npoints += 4;
+ if (npoints > MAX_PATH_POINTS) {
+ return 0;
+ }
+ }
+ return 1;
+}
+
+/*
+ * fill path
+ */
+static int
+opvp_fill_path(
+ gx_device *dev,
+ const gs_imager_state *pis,
+ gx_path *ppath,
+ const gx_fill_params *params,
+ const gx_device_color *pdevc,
+ const gx_clip_path *pxpath)
+{
+ bool draw_image = false;
+ gs_fixed_rect inner, outer;
+
+ /* check if paths are too complex */
+ if (!checkPath(ppath) || !checkCPath(pxpath)) {
+ return gx_default_fill_path(dev, pis, ppath, params, pdevc, pxpath);
+ }
+ /* check clippath support */
+ if (!(apiEntry->opvpSetClipPath)) {
+ /* get clipping box area */
+ gx_cpath_inner_box(pxpath,&inner);
+ gx_cpath_outer_box(pxpath,&outer);
+ /* check difference between inner-box and outer-box */
+ if ((inner.p.x != outer.p.x) || (inner.p.y != outer.p.y) ||
+ (inner.q.x != outer.q.x) || (inner.q.y != outer.q.y)) {
+ /* set draw by image */
+ draw_image = true;
+ }
+ }
+
+ if (!vector || draw_image) {
+ return gx_default_fill_path(dev, pis, ppath, params, pdevc, pxpath);
+ }
+
+ return gdev_vector_fill_path(dev, pis, ppath, params, pdevc, pxpath);
+}
+
+/*
+ * stroke path
+ */
+static int
+opvp_stroke_path(
+ gx_device *dev,
+ const gs_imager_state *pis,
+ gx_path *ppath,
+ const gx_stroke_params *params,
+ const gx_drawing_color *pdcolor,
+ const gx_clip_path *pxpath)
+{
+ bool draw_image = false;
+ gs_fixed_rect inner, outer;
+
+ /* check if paths are too complex */
+ if (!checkPath(ppath) || !checkCPath(pxpath)) {
+ return gx_default_stroke_path(dev, pis, ppath,
+ params, pdcolor, pxpath);
+ }
+ /* check clippath support */
+ if (!(apiEntry->opvpSetClipPath)) {
+ /* get clipping box area */
+ gx_cpath_inner_box(pxpath,&inner);
+ gx_cpath_outer_box(pxpath,&outer);
+ /* check difference between inner-box and outer-box */
+ if ((inner.p.x != outer.p.x) || (inner.p.y != outer.p.y) ||
+ (inner.q.x != outer.q.x) || (inner.q.y != outer.q.y)) {
+ /* set draw by image */
+ draw_image = true;
+ }
+ }
+
+ if (!vector || draw_image) {
+ return gx_default_stroke_path(dev, pis, ppath,
+ params, pdcolor, pxpath);
+ }
+
+ return gdev_vector_stroke_path(dev, pis, ppath,
+ params, pdcolor, pxpath);
+}
+
+/*
+ * fill mask
+ */
+static int
+opvp_fill_mask(
+ gx_device *dev,
+ const byte *data,
+ int data_x,
+ int raster,
+ gx_bitmap_id id,
+ int x,
+ int y,
+ int w,
+ int h,
+ const gx_drawing_color *pdcolor,
+ int depth,
+ gs_logical_operation_t lop,
+ const gx_clip_path *pcpath)
+{
+ if (vector) {
+#if GS_VERSION_MAJOR >= 8 /* for gs 8.15 */
+ gdev_vector_update_fill_color((gx_device_vector *)dev, NULL, pdcolor);
+#else
+ gdev_vector_update_fill_color((gx_device_vector *)dev, pdcolor);
+#endif
+ gdev_vector_update_clip_path((gx_device_vector *)dev, pcpath);
+ gdev_vector_update_log_op((gx_device_vector *)dev, lop);
+ }
+
+ return gx_default_fill_mask(dev, data, data_x, raster, id,
+ x, y, w, h, pdcolor, depth, lop, pcpath);
+}
+
+/*
+ * begin image
+ */
+static int
+opvp_begin_image(
+ gx_device *dev,
+ const gs_imager_state *pis,
+ const gs_image_t *pim,
+ gs_image_format_t format,
+ const gs_int_rect *prect,
+ const gx_drawing_color *pdcolor,
+ const gx_clip_path *pcpath,
+ gs_memory_t *mem,
+ gx_image_enum_common_t **pinfo)
+{
+ gx_device_vector *vdev =(gx_device_vector *)dev;
+ gdev_vector_image_enum_t *vinfo;
+ gs_matrix mtx;
+ opvp_ctm_t ctm;
+ bool draw_image = false;
+ bool supported_angle = false;
+ int code = -1;
+ opvp_result_t r = -1;
+ int ecode = 0;
+ int bits_per_pixel = 24;
+ bool can_reverse = false;
+ int p;
+ float mag[2] = {1, 1};
+ const gs_color_space *pcs = pim->ColorSpace;
+
+ /* check if paths are too complex */
+ if (!checkCPath(pcpath)) {
+ return gx_default_begin_image(
+ dev, pis, pim, format,
+ prect, pdcolor, pcpath,
+ mem, pinfo);
+ }
+
+ color_index = 0;
+
+ vinfo = gs_alloc_struct(mem, gdev_vector_image_enum_t,
+ &st_vector_image_enum,
+ "opvp_begin_image");
+
+ if (vinfo) {
+ memcpy(imageDecode,pim->Decode,sizeof(pim->Decode));
+ vinfo->memory =mem;
+ code = gdev_vector_begin_image(vdev, pis, pim, format, prect,
+ pdcolor, pcpath, mem,
+ &opvp_image_enum_procs,
+ vinfo);
+ if (code) ecode = code;
+
+ if (!ecode) {
+ /* bits per pixel */
+ for (bits_per_pixel=0, p=0; p < vinfo->num_planes; p++) {
+ bits_per_pixel += vinfo->plane_depths[p];
+ }
+
+ /* for indexed color */
+ if (!(pim->ImageMask)) {
+ color_index = gs_color_space_get_index(pcs);
+ if (color_index == gs_color_space_index_Indexed) {
+ base_color_index
+ = gs_color_space_indexed_base_space(pcs)->type->index;
+ if (((pcs->params.indexed.hival + 1) > 256)
+ || (bits_per_pixel != 8 && bits_per_pixel != 1)) {
+ return gx_default_begin_image(
+ dev, pis, pim, format,
+ prect, pdcolor, pcpath,
+ mem, pinfo);
+ } else if (base_color_index
+ == gs_color_space_index_DeviceCMYK) {
+ /* for CMYK indexed color */
+ int count;
+ const unsigned char *p
+ = pcs->params.indexed.lookup.table.data;
+ frac rgb[3];
+
+ for(count = 0;count <
+ (pcs->params.indexed.hival + 1); count++) {
+ memset(rgb, 0, sizeof(rgb));
+ color_cmyk_to_rgb(
+ byte2frac((*(p + 0 + (count * 4)))),
+ byte2frac((*(p + 1 + (count * 4)))),
+ byte2frac((*(p + 2 + (count * 4)))),
+ byte2frac((*(p + 3 + (count * 4)))),
+#if GS_VERSION_MAJOR >= 9
+ pis, rgb, mem);
+#else
+ pis, rgb);
+#endif
+ *(palette + 0 + (count * 3)) = frac2byte(rgb[0]);
+ *(palette + 1 + (count * 3)) = frac2byte(rgb[1]);
+ *(palette + 2 + (count * 3)) = frac2byte(rgb[2]);
+ }
+
+ bits_per_pixel = 24;
+ } else if (base_color_index
+ == gs_color_space_index_DeviceRGB ||
+ base_color_index == gs_color_space_index_CIEABC) {
+ /* for RGB or CalRGB indexed color */
+ memcpy(palette, pcs->params.indexed.lookup.table.data,\
+ pcs->params.indexed.lookup.table.size);
+ bits_per_pixel = 24;
+ } else if (base_color_index
+ == gs_color_space_index_DeviceGray ||
+ base_color_index == gs_color_space_index_CIEA) {
+ /* for Gray or CalGray indexed color */
+ memcpy(palette, pcs->params.indexed.lookup.table.data,\
+ pcs->params.indexed.lookup.table.size);
+ bits_per_pixel = 8;
+ } else {
+ /* except CMYK and RGB */
+ return gx_default_begin_image(
+ dev, pis, pim, format,
+ prect, pdcolor, pcpath,
+ mem, pinfo);
+ }
+ }
+ }
+
+#if ENABLE_AUTO_REVERSE
+ if (bits_per_pixel % 8 == 0) {
+ can_reverse = true;
+ }
+#endif
+ /* adjust matrix */
+ reverse_image = false;
+ gs_matrix_invert(&pim->ImageMatrix, &mtx);
+ gs_matrix_multiply(&mtx, &ctm_only(pis), &mtx);
+ switch (FastImageMode) {
+ case FastImageNoCTM:
+ if ((mtx.xy==0)&&(mtx.yx==0)&& (mtx.yy>=0)) {
+ if (mtx.xx>=0) {
+ mag[0] = mtx.xx;
+ mag[1] = mtx.yy;
+ mtx.xx = 1;
+ mtx.yy = 1;
+ supported_angle = true;
+ } else if (can_reverse) {
+ mtx.xx *= -1;
+ mag[0] = mtx.xx;
+ mag[1] = mtx.yy;
+ mtx.xx = 1;
+ mtx.yy = 1;
+ mtx.tx -= vinfo->width
+ * mag[0];
+ supported_angle = true;
+ reverse_image = true;
+ }
+ }
+ break;
+ case FastImageNoRotate:
+ if ((mtx.xy==0)&&(mtx.yx==0)&& (mtx.yy>=0)) {
+ if (mtx.xx>=0) {
+ supported_angle = true;
+ } else if (can_reverse) {
+ mtx.xx *= -1;
+ mtx.tx -= vinfo->width
+ * mtx.xx;
+ supported_angle = true;
+ reverse_image = true;
+ }
+ }
+ break;
+ case FastImageRightAngle:
+ if ((mtx.xy==0)&&(mtx.yx==0)) {
+ if (((mtx.xx>=0)&&(mtx.yy>=0))||
+ ((mtx.xx<=0)&&(mtx.yy<=0))){
+ supported_angle = true;
+ } else if (can_reverse) {
+ mtx.xx *= -1;
+ mtx.tx -= vinfo->width
+ * mtx.xx;
+ supported_angle = true;
+ reverse_image = true;
+ }
+ } else if ((mtx.xx==0)&&(mtx.yy==0)) {
+ if (((mtx.xy>=0)&&(mtx.yx<=0))||
+ ((mtx.xy<=0)&&(mtx.yx>=0))){
+ supported_angle = true;
+ } else if (can_reverse) {
+ mtx.xy *= -1;
+ mtx.ty -= vinfo->height
+ * mtx.xy;
+ supported_angle = true;
+ reverse_image = true;
+ }
+ }
+ break;
+ case FastImageReverseAngle:
+ if (((mtx.xy==0)&&(mtx.yx==0))||
+ ((mtx.xx==0)&&(mtx.yy==0))) {
+ supported_angle = true;
+ }
+ break;
+ case FastImageAll:
+ supported_angle = true;
+ break;
+ case FastImageDisable:
+ default:
+ break;
+ }
+ }
+
+ if ((!ecode) && supported_angle) {
+ if ((!prect) &&
+ ((vinfo->num_planes == 1) ||
+ ((vinfo->num_planes == 3) &&
+ (vinfo->plane_depths[0] == 8) &&
+ (vinfo->plane_depths[1] == 8) &&
+ (vinfo->plane_depths[2] == 8))
+ )
+ ) {
+ /*
+ * avail only
+ * 1 plane image
+ * or
+ * 3 planes 24 bits color image
+ * (8 bits per plane)
+ */
+ if (apiEntry->opvpStartDrawImage) {
+ draw_image = true;
+ }
+ }
+ }
+ }
+
+ if (draw_image) {
+ *pinfo = (gx_image_enum_common_t *)vinfo;
+
+ if (!ecode) {
+ if (!pim->ImageMask) {
+ /* call SetPaintMode */
+ if (apiEntry->opvpSetPaintMode) {
+ apiEntry->opvpSetPaintMode(printerContext,
+ OPVP_PAINTMODE_OPAQUE);
+ change_paint_mode = true;
+ }
+ /* set color space */
+ if (apiEntry->opvpSetColorSpace != NULL) {
+ opvp_cspace_t ncspace;
+
+ savedColorSpace = colorSpace;
+ switch (bits_per_pixel) {
+ case 1:
+ ncspace = OPVP_CSPACE_DEVICEGRAY;
+ bits_per_pixel = 8;
+ if (!cspace_available[ncspace]) {
+ ncspace = OPVP_CSPACE_STANDARDRGB;
+ bits_per_pixel = 24;
+ }
+ break;
+ case 8:
+ ncspace = OPVP_CSPACE_DEVICEGRAY;
+ if (!cspace_available[ncspace]) {
+ ncspace = OPVP_CSPACE_STANDARDRGB;
+ bits_per_pixel = 24;
+ }
+ break;
+ case 24:
+ ncspace = OPVP_CSPACE_DEVICERGB;
+ if (!cspace_available[ncspace]) {
+ ncspace = OPVP_CSPACE_STANDARDRGB;
+ }
+ break;
+ default:
+ r = -1;
+ goto fallthrough;
+ break;
+ }
+ if (ncspace != colorSpace) {
+ if (apiEntry->opvpSetColorSpace(printerContext,ncspace)
+ != OPVP_OK) {
+ r = -1;
+ goto fallthrough;
+ }
+ colorSpace = ncspace;
+ change_cspace = true;
+ }
+ }
+ }
+ }
+ if (!ecode) {
+ if (supported_angle) {
+ /* moveto */
+ opvp_moveto(vdev, 0, 0, mtx.tx, mtx.ty, 0);
+ }
+ if ((supported_angle) && (FastImageMode != FastImageNoCTM)) {
+ /* call SetCTM */
+ ctm.a = mtx.xx;
+ ctm.b = mtx.xy;
+ ctm.c = mtx.yx;
+ ctm.d = mtx.yy;
+ ctm.e = mtx.tx;
+ ctm.f = mtx.ty;
+ if (apiEntry->opvpSetCTM) {
+ r = apiEntry->opvpSetCTM(printerContext, &ctm);
+ }
+ else r = -1;
+ if (r != OPVP_OK) ecode = r;
+ }
+ }
+ if (!ecode) {
+ int dw,dh;
+
+ /* image size */
+ if (mag[0] != 1) {
+ dw = floor(vinfo->width * mag[0]+0.5);
+ } else {
+ dw = vinfo->width;
+ }
+ if (mag[1] != 1) {
+ dh = floor(vinfo->height * mag[1]+0.5);
+ } else {
+ dh = vinfo->height;
+ }
+ /* call StartDrawImage */
+ if (apiEntry->opvpStartDrawImage) {
+ opvp_int_t adj_raster;
+
+ adj_raster = bits_per_pixel*vinfo->width;
+ adj_raster = ((adj_raster+31) >> 5) << 2;
+ r = apiEntry->opvpStartDrawImage(
+ printerContext,
+ vinfo->width,
+ vinfo->height,
+ adj_raster,
+ pim->ImageMask ?
+ OPVP_IFORMAT_MASK:
+ OPVP_IFORMAT_RAW,
+ dw,dh);
+ if(r != OPVP_OK) {
+ if (apiEntry->opvpEndDrawImage) {
+ apiEntry->opvpEndDrawImage(printerContext);
+ }
+ }
+ }
+
+ /* bugfix for 32bit CMYK image print error */
+fallthrough:
+ if(r != OPVP_OK) {
+ if (change_paint_mode) {
+ /* restore paint mode */
+ if (apiEntry->opvpSetPaintMode) {
+ apiEntry->opvpSetPaintMode(printerContext,
+ OPVP_PAINTMODE_TRANSPARENT);
+ }
+ change_paint_mode = false;
+ }
+ if (change_cspace) {
+ /* restore color space */
+ colorSpace = savedColorSpace;
+ if (apiEntry->opvpSetColorSpace) {
+ apiEntry->opvpSetColorSpace(printerContext,
+ colorSpace);
+ }
+ change_cspace = false;
+ }
+ if(apiEntry->opvpResetCTM) {
+ apiEntry->opvpResetCTM(printerContext); /* reset CTM */
+ }
+ return gx_default_begin_image(dev, pis, pim, format,
+ prect, pdcolor, pcpath, mem, pinfo);
+ }
+ }
+
+ if (!ecode) {
+ begin_image = true;
+ }
+
+ return ecode;
+ }
+
+ return gx_default_begin_image(dev, pis, pim, format, prect,
+ pdcolor, pcpath, mem, pinfo);
+}
+
+/*
+ * plane data
+ */
+static int
+opvp_image_plane_data(
+ gx_image_enum_common_t *info,
+ const gx_image_plane_t *planes,
+ int height,
+ int *rows_used)
+{
+ gdev_vector_image_enum_t *vinfo;
+ byte *tmp_buf = NULL;
+ byte *buf = NULL;
+ int bits_per_pixel;
+ int data_bytes, dst_bytes;
+ int raster_length, dst_length;
+ int p;
+ int x;
+ int d;
+ int h;
+ int ecode = 0;
+ int i, j;
+ byte *src_ptr, *dst_ptr, *ppalette;
+ byte *ptr;
+ bbox_image_enum *pbe;
+ gx_image_enum *tinfo;
+ const gs_imager_state *pis;
+
+ vinfo = (gdev_vector_image_enum_t *)info;
+
+ if (!begin_image) return 0;
+
+ for (bits_per_pixel=0, p=0; p < vinfo->num_planes; p++) {
+ bits_per_pixel += vinfo->plane_depths[p];
+ }
+
+ data_bytes = (bits_per_pixel * vinfo->width + 7) >> 3;
+ raster_length = ((data_bytes + 3) >> 2) << 2;
+ buf = calloc(raster_length, height);
+
+ if (vinfo->default_info) {
+ gx_image_plane_data(vinfo->default_info, planes, height);
+ }
+ if (vinfo->bbox_info) {
+ gx_image_plane_data(vinfo->bbox_info, planes, height);
+ }
+
+ if (buf) {
+ /* Adjust image data gamma */
+ pbe = (bbox_image_enum *)vinfo->bbox_info;
+ tinfo = (gx_image_enum *)pbe->target_info;
+ pis = tinfo->pis;
+
+ if (vinfo->num_planes == 1) {
+ for (h = 0; h < height; h++) {
+ d = raster_length * h;
+ if (reverse_image) {
+ int bytes_per_pixel = bits_per_pixel / 8;
+ for (x = data_bytes * (h + 1) - bytes_per_pixel;
+ x >= data_bytes * h;
+ x-=bytes_per_pixel,
+ d+=bytes_per_pixel) {
+ memcpy(buf+d, planes[0].data+x, bytes_per_pixel);
+ }
+ } else {
+ memcpy(buf + d,
+ planes[0].data
+ + (data_bytes * h),
+ data_bytes);
+ }
+ }
+ } else {
+ for (h = 0; h < height; h++) {
+ d = raster_length * h;
+ if (reverse_image) {
+ for (x = vinfo->width * (h + 1) - 1;
+ x >= vinfo->width * h;
+ x--) {
+ for (p = 0;
+ p < vinfo->num_planes;
+ p++, d++) {
+ buf[d] = (byte)(planes[p].data[x]);
+ }
+ }
+ } else {
+ for (x = vinfo->width * h;
+ x < vinfo->width * (h + 1);
+ x++) {
+ for (p = 0;
+ p < vinfo->num_planes;
+ p++, d++) {
+ buf[d] = (byte)
+ (planes[p].data[x]);
+ }
+ }
+ }
+ }
+ }
+
+ if (tinfo->masked) {
+ bool reverse = false;
+
+ /* image mask */
+ if (imageDecode[0] == 0) {
+ reverse = true;
+ }
+ if (reverse) {
+ for (i = 0; i < height; i++) {
+ src_ptr = buf + raster_length * i;
+ for (j = 0; j < data_bytes; j++) {
+ src_ptr[j] ^= 0xff;
+ }
+ }
+ }
+ } else {
+ if(color_index == gs_color_space_index_Indexed) {
+ if (base_color_index == gs_color_space_index_DeviceGray ||
+ base_color_index == gs_color_space_index_CIEA) {
+ if (colorSpace == OPVP_CSPACE_DEVICEGRAY) {
+ /* Convert indexed gray color -> Gray */
+ if (bits_per_pixel == 8) { /* 8bit image */
+ dst_bytes = data_bytes;
+ dst_length = ((dst_bytes + 3) >> 2) << 2;
+
+ tmp_buf = calloc(dst_length, height);
+ if (tmp_buf) {
+ for (i = 0; i < height; i++) {
+ src_ptr = buf + raster_length * i;
+ dst_ptr = tmp_buf + dst_length * i;
+ for (j = 0; j < data_bytes; j++) {
+ ppalette = palette + src_ptr[j] ;
+ dst_ptr[j] = ppalette[0];
+ }
+ }
+
+ free (buf);
+ buf = tmp_buf;
+ data_bytes = dst_bytes;
+ raster_length = dst_length;
+ vinfo->bits_per_pixel = 8;
+ }
+ } else { /* 1bit image */
+ dst_bytes = vinfo->width;
+ dst_length = ((dst_bytes + 3) >> 2) << 2;
+
+ tmp_buf = calloc(dst_length, height);
+ if (tmp_buf) {
+ for (i = 0; i < height; i++) {
+ src_ptr = buf + raster_length * i;
+ dst_ptr = tmp_buf + dst_length * i;
+ for (j = 0; j < vinfo->width; j++) {
+ int o = ((src_ptr[j/8] & (1 << (7 - (j & 7))))
+ != 0);
+ ppalette = palette + o;
+ dst_ptr[j] = ppalette[0];
+ }
+ }
+
+ free (buf);
+ buf = tmp_buf;
+ data_bytes = dst_bytes;
+ raster_length = dst_length;
+ vinfo->bits_per_pixel = 8;
+ }
+ }
+ } else {
+ /* Convert indexed Gray color -> RGB */
+ if (bits_per_pixel == 8) { /* 8bit image */
+ dst_bytes = data_bytes * 3;
+ dst_length = ((dst_bytes + 3) >> 2) << 2;
+
+ tmp_buf = calloc(dst_length, height);
+ if (tmp_buf) {
+ for (i = 0; i < height; i++) {
+ src_ptr = buf + raster_length * i;
+ dst_ptr = tmp_buf + dst_length * i;
+ for (j = 0; j < data_bytes; j++) {
+ ppalette = palette + src_ptr[j] * 3;
+ dst_ptr[j*3] = ppalette[0]; /* R */
+ dst_ptr[j*3 + 1] = ppalette[0]; /* G */
+ dst_ptr[j*3 + 2] = ppalette[0]; /* B */
+ }
+ }
+
+ free (buf);
+ buf = tmp_buf;
+ data_bytes = dst_bytes;
+ raster_length = dst_length;
+ vinfo->bits_per_pixel = 24;
+ }
+ } else { /* 1bit image */
+ dst_bytes = vinfo->width * 3;
+ dst_length = ((dst_bytes + 3) >> 2) << 2;
+
+ tmp_buf = calloc(dst_length, height);
+ if (tmp_buf) {
+ for (i = 0; i < height; i++) {
+ src_ptr = buf + raster_length * i;
+ dst_ptr = tmp_buf + dst_length * i;
+ for (j = 0; j < vinfo->width; j++) {
+ int o = ((src_ptr[j/8] & (1 << (7 - (j & 7))))
+ != 0);
+ ppalette = palette + o * 3;
+ dst_ptr[j*3] = ppalette[0]; /* R */
+ dst_ptr[j*3 + 1] = ppalette[0]; /* G */
+ dst_ptr[j*3 + 2] = ppalette[0]; /* B */
+ }
+ }
+
+ free (buf);
+ buf = tmp_buf;
+ data_bytes = dst_bytes;
+ raster_length = dst_length;
+ vinfo->bits_per_pixel = 24;
+ }
+ }
+ }
+ } else {
+ /* Convert indexed color -> RGB */
+ if (bits_per_pixel == 8) { /* 8bit image */
+ dst_bytes = data_bytes * 3;
+ dst_length = ((dst_bytes + 3) >> 2) << 2;
+
+ tmp_buf = calloc(dst_length, height);
+ if (tmp_buf) {
+ for (i = 0; i < height; i++) {
+ src_ptr = buf + raster_length * i;
+ dst_ptr = tmp_buf + dst_length * i;
+ for (j = 0; j < data_bytes; j++) {
+ ppalette = palette + src_ptr[j] * 3;
+ dst_ptr[j*3] = ppalette[0]; /* R */
+ dst_ptr[j*3 + 1] = ppalette[1]; /* G */
+ dst_ptr[j*3 + 2] = ppalette[2]; /* B */
+ }
+ }
+
+ free (buf);
+ buf = tmp_buf;
+ data_bytes = dst_bytes;
+ raster_length = dst_length;
+ vinfo->bits_per_pixel = 24;
+ }
+ } else { /* 1bit image */
+ dst_bytes = vinfo->width * 3;
+ dst_length = ((dst_bytes + 3) >> 2) << 2;
+
+ tmp_buf = calloc(dst_length, height);
+ if (tmp_buf) {
+ for (i = 0; i < height; i++) {
+ src_ptr = buf + raster_length * i;
+ dst_ptr = tmp_buf + dst_length * i;
+ for (j = 0; j < vinfo->width; j++) {
+ int o = ((src_ptr[j/8] & (1 << (7 - (j & 7))))
+ != 0);
+ ppalette = palette + o * 3;
+ dst_ptr[j*3] = ppalette[0]; /* R */
+ dst_ptr[j*3 + 1] = ppalette[1]; /* G */
+ dst_ptr[j*3 + 2] = ppalette[2]; /* B */
+ }
+ }
+
+ free (buf);
+ buf = tmp_buf;
+ data_bytes = dst_bytes;
+ raster_length = dst_length;
+ vinfo->bits_per_pixel = 24;
+ }
+ }
+ }
+ }
+
+ /* Convert Gray */
+ if(color_index == gs_color_space_index_DeviceGray ||
+ color_index == gs_color_space_index_CIEA) {
+ if (colorSpace == OPVP_CSPACE_STANDARDRGB
+ || colorSpace == OPVP_CSPACE_DEVICERGB) {
+ /* convert to RGB */
+ if (bits_per_pixel == 8) { /* 8bit image */
+ dst_bytes = data_bytes * 3;
+ dst_length = ((dst_bytes + 3) >> 2) << 2;
+
+ tmp_buf = calloc(dst_length, height);
+ if (tmp_buf) {
+ for (i = 0; i < height; i++) {
+ src_ptr = buf + raster_length * i;
+ dst_ptr = tmp_buf + dst_length * i;
+ for (j = 0; j < data_bytes; j++) {
+ unsigned char d = floor(
+ imageDecode[0]*255 + src_ptr[j]*
+ (imageDecode[1]-imageDecode[0])+0.5);
+
+ dst_ptr[j*3] = d; /* R */
+ dst_ptr[j*3 + 1] = d; /* G */
+ dst_ptr[j*3 + 2] = d; /* B */
+ }
+ }
+
+ free (buf);
+ buf = tmp_buf;
+ data_bytes = dst_bytes;
+ raster_length = dst_length;
+ vinfo->bits_per_pixel = 24;
+ }
+ } else { /* 1bit image */
+ dst_bytes = vinfo->width * 3;
+ dst_length = ((dst_bytes + 3) >> 2) << 2;
+
+ tmp_buf = calloc(dst_length, height);
+ if (tmp_buf) {
+ for (i = 0; i < height; i++) {
+ src_ptr = buf + raster_length * i;
+ dst_ptr = tmp_buf + dst_length * i;
+ for (j = 0; j < vinfo->width; j++) {
+ int o = ((src_ptr[j/8] & (1 << (7 - (j & 7))))
+ != 0);
+ unsigned char d = floor(
+ imageDecode[0]*255 + o*
+ (imageDecode[1]-imageDecode[0])*255+0.5);
+ dst_ptr[j*3] = d; /* R */
+ dst_ptr[j*3 + 1] = d; /* G */
+ dst_ptr[j*3 + 2] =d; /* B */
+ }
+ }
+
+ free (buf);
+ buf = tmp_buf;
+ data_bytes = dst_bytes;
+ raster_length = dst_length;
+ vinfo->bits_per_pixel = 24;
+ }
+ }
+ } else if (colorSpace == OPVP_CSPACE_DEVICEGRAY) {
+ if (bits_per_pixel == 1) { /* 1bit image */
+ dst_bytes = vinfo->width;
+ dst_length = ((dst_bytes + 3) >> 2) << 2;
+
+ tmp_buf = calloc(dst_length, height);
+ if (tmp_buf) {
+ for (i = 0; i < height; i++) {
+ src_ptr = buf + raster_length * i;
+ dst_ptr = tmp_buf + dst_length * i;
+ for (j = 0; j < vinfo->width; j++) {
+ int o = ((src_ptr[j/8] & (1 << (7 - (j & 7))))
+ != 0);
+ unsigned char d = floor(
+ imageDecode[0]*255 + o*
+ (imageDecode[1]-imageDecode[0])*255+0.5);
+ dst_ptr[j] = d; /* R */
+ }
+ }
+
+ free (buf);
+ buf = tmp_buf;
+ data_bytes = dst_bytes;
+ raster_length = dst_length;
+ vinfo->bits_per_pixel = 8;
+ }
+ }
+ }
+ }
+ }
+#if GS_VERSION_MAJOR >= 8
+ if (vinfo->bits_per_pixel == 24) { /* 24bit RGB color */
+ for (i = 0; i < height; i++) {
+ ptr = buf + raster_length * i;
+ for (j = 0; j < vinfo->width; j++) {
+ ptr[j*3] = min(255, frac2cv(gx_map_color_frac(pis,
+ cv2frac(ptr[j*3]), effective_transfer[0])));
+ ptr[j*3+1] = min(255, frac2cv(gx_map_color_frac(pis,
+ cv2frac(ptr[j*3+1]), effective_transfer[1])));
+ ptr[j*3+2] = min(255, frac2cv(gx_map_color_frac(pis,
+ cv2frac(ptr[j*3+2]), effective_transfer[2])));
+ }
+ }
+ } else if (vinfo->bits_per_pixel == 8) { /* 8bit Gray image */
+ for (i = 0; i < height; i++) {
+ ptr = buf + raster_length * i;
+ for (j=0; j < vinfo->width; j++) {
+ ptr[j] = min(255, frac2cv(gx_map_color_frac(pis,
+ cv2frac(ptr[j]), effective_transfer[3])));
+ }
+ }
+ }
+#else
+ if (vinfo->bits_per_pixel == 24) { /* 24bit RGB color */
+ for (i = 0; i < height; i++) {
+ ptr = buf + raster_length * i;
+ for (j = 0; j < vinfo->width; j++) {
+ ptr[j*3] = min(255, frac2cv(gx_map_color_frac(pis,
+ cv2frac(ptr[j*3]), effective_transfer.colored.red)));
+ ptr[j*3+1] = min(255, frac2cv(gx_map_color_frac(pis,
+ cv2frac(ptr[j*3+1]), effective_transfer.colored.green)));
+ ptr[j*3+2] = min(255, frac2cv(gx_map_color_frac(pis,
+ cv2frac(ptr[j*3+2]), effective_transfer.colored.blue)));
+ }
+ }
+ } else if (vinfo->bits_per_pixel == 8) { /* 8bit Gray image */
+ for (i = 0; i < height; i++) {
+ ptr = buf + raster_length * i;
+ for (j = 0; j < vinfo->width; j++) {
+ ptr[j] = min(255, frac2cv(gx_map_color_frac(pis,
+ cv2frac(ptr[j]), effective_transfer.colored.gray)));
+ }
+ }
+ }
+#endif
+
+ /* call TansferDrawImage */
+ if (apiEntry->opvpTransferDrawImage) {
+ apiEntry->opvpTransferDrawImage(printerContext,
+ raster_length * height, (void *)buf);
+ }
+ if (buf) {
+ free(buf); /* free buffer */
+ }
+ }
+
+ vinfo->y += height;
+ ecode = (vinfo->y >= vinfo->height);
+
+ return ecode;
+}
+
+/*
+ * end image
+ */
+static int
+opvp_image_end_image(gx_image_enum_common_t *info, bool draw_last)
+{
+ gx_device *dev = info->dev;
+ gx_device_vector *vdev = (gx_device_vector *)dev;
+ gdev_vector_image_enum_t *vinfo;
+ opvp_ctm_t ctm;
+
+ vinfo = (gdev_vector_image_enum_t *)info;
+
+ if (begin_image) {
+ /* call EndDrawImage */
+ if (apiEntry->opvpEndDrawImage) {
+ apiEntry->opvpEndDrawImage(printerContext);
+ }
+
+ begin_image = false;
+
+ if (FastImageMode != FastImageNoCTM) {
+ /* call ResetCTM */
+ if (apiEntry->opvpResetCTM) {
+ apiEntry->opvpResetCTM(printerContext);
+ } else {
+ /* call SetCTM */
+ ctm.a = 1;
+ ctm.b = 0;
+ ctm.c = 0;
+ ctm.d = 1;
+ ctm.e = 0;
+ ctm.f = 0;
+ if (apiEntry->opvpSetCTM) {
+ apiEntry->opvpSetCTM(printerContext, &ctm);
+ }
+ }
+ }
+ if (change_paint_mode) {
+ /* restore paint mode */
+ if (apiEntry->opvpSetPaintMode) {
+ apiEntry->opvpSetPaintMode(printerContext,
+ OPVP_PAINTMODE_TRANSPARENT);
+ }
+ change_paint_mode = false;
+ }
+ if (change_cspace) {
+ /* restore color space */
+ colorSpace = savedColorSpace;
+ if (apiEntry->opvpSetColorSpace) {
+ apiEntry->opvpSetColorSpace(printerContext,
+ colorSpace);
+ }
+ change_cspace = false;
+ }
+ }
+
+ return gdev_vector_end_image(vdev, vinfo, draw_last, vdev->white);
+}
+
+/* ----- vector driver procs ----- */
+/*
+ * begin page
+ */
+static int
+opvp_beginpage(gx_device_vector *vdev)
+{
+ gx_device_opvp *pdev = (gx_device_opvp *)vdev;
+ int code = -1;
+ int ecode = 0;
+
+#ifdef OPVP_IGNORE_BLANK_PAGE
+ if (pdev->in_page) return 0;
+#endif
+ /* start page */
+ code = opvp_startpage((gx_device *)pdev);
+ if (code) {
+ ecode = code;
+ } else {
+ pdev->in_page = true; /* added '05.12.07 */
+ beginPage = true;
+ }
+
+ return ecode;
+}
+
+/*
+ * set line width
+ */
+static int
+opvp_setlinewidth(gx_device_vector *vdev, double width)
+{
+ gx_device_opvp *pdev = (gx_device_opvp *)vdev;
+ opvp_result_t r = -1;
+ int ecode = 0;
+ opvp_fix_t w;
+
+ /* check page-in */
+ if (opvp_check_in_page(pdev)) return -1;
+
+ /* call SetLineWidth */
+ OPVP_F2FIX(width, w);
+ if (apiEntry->opvpSetLineWidth) {
+ r = apiEntry->opvpSetLineWidth(printerContext, w);
+ }
+ if (r != OPVP_OK) {
+ ecode = -1;
+ }
+
+ return ecode;
+}
+
+/*
+ * set line cap
+ */
+static int
+opvp_setlinecap(gx_device_vector *vdev, gs_line_cap cap)
+{
+ gx_device_opvp *pdev = (gx_device_opvp *)vdev;
+ opvp_result_t r = -1;
+ int ecode = 0;
+ opvp_linecap_t linecap;
+
+ /* check page-in */
+ if (opvp_check_in_page(pdev)) return -1;
+
+ switch (cap) {
+ case gs_cap_butt:
+ linecap = OPVP_LINECAP_BUTT;
+ break;
+ case gs_cap_round:
+ linecap = OPVP_LINECAP_ROUND;
+ break;
+ case gs_cap_square:
+ linecap = OPVP_LINECAP_SQUARE;
+ break;
+ case gs_cap_triangle:
+ default:
+ linecap = OPVP_LINECAP_BUTT;
+ break;
+ }
+
+ /* call SetLineCap */
+ if (apiEntry->opvpSetLineCap) {
+ r = apiEntry->opvpSetLineCap(printerContext, linecap);
+ }
+ if (r != OPVP_OK) {
+ ecode = -1;
+ }
+
+ return ecode;
+}
+
+/*
+ * set line join
+ */
+static int
+opvp_setlinejoin(gx_device_vector *vdev, gs_line_join join)
+{
+ gx_device_opvp *pdev = (gx_device_opvp *)vdev;
+ opvp_result_t r = -1;
+ int ecode = 0;
+ opvp_linejoin_t linejoin;
+
+ /* check page-in */
+ if (opvp_check_in_page(pdev)) return -1;
+
+ switch (join) {
+ case gs_join_miter:
+ linejoin = OPVP_LINEJOIN_MITER;
+ break;
+ case gs_join_round:
+ linejoin = OPVP_LINEJOIN_ROUND;
+ break;
+ case gs_join_bevel:
+ linejoin = OPVP_LINEJOIN_BEVEL;
+ break;
+ case gs_join_none:
+ case gs_join_triangle:
+ default:
+ linejoin = OPVP_LINEJOIN_MITER;
+ break;
+ }
+
+ /* call SetLineJoin */
+ if (apiEntry->opvpSetLineJoin) {
+ r = apiEntry->opvpSetLineJoin(printerContext, linejoin);
+ }
+ if (r != OPVP_OK) {
+ ecode = -1;
+ }
+
+ return ecode;
+}
+
+/*
+ * set miter limit
+ */
+static int
+opvp_setmiterlimit(gx_device_vector *vdev, double limit)
+{
+ gx_device_opvp *pdev = (gx_device_opvp *)vdev;
+ opvp_result_t r = -1;
+ int ecode = 0;
+ opvp_fix_t l;
+
+ /* check page-in */
+ if (opvp_check_in_page(pdev)) return -1;
+
+ /* call SetMiterLimit */
+ OPVP_F2FIX(limit, l);
+ if (apiEntry->opvpSetMiterLimit) {
+ r = apiEntry->opvpSetMiterLimit(printerContext, l);
+ }
+ if (r != OPVP_OK) {
+ ecode = -1;
+ }
+
+ return ecode;
+}
+
+/*
+ * set dash
+ */
+static int
+opvp_setdash(
+ gx_device_vector *vdev,
+ const float *pattern,
+ uint count,
+ double offset)
+{
+ gx_device_opvp *pdev = (gx_device_opvp *)vdev;
+ opvp_result_t r = -1;
+ int ecode = 0;
+ opvp_fix_t *p = NULL;
+ opvp_fix_t o;
+ int i;
+
+ /* check page-in */
+ if (opvp_check_in_page(pdev)) return -1;
+
+ /* pattern */
+ if (count) {
+ p = calloc(sizeof(opvp_fix_t), count);
+ if (p) {
+ for (i = 0; i < count; i++) {
+ OPVP_F2FIX(pattern[i], p[i]);
+ }
+ } else {
+ ecode = -1;
+ }
+ }
+
+ /* call SetLineDash */
+ if (!ecode) {
+ if (apiEntry->opvpSetLineDash) {
+ r = apiEntry->opvpSetLineDash(printerContext, count,p);
+ }
+ if (r != OPVP_OK) {
+ ecode = -1;
+ }
+ }
+
+ /* call SetLineDashOffset */
+ if (!ecode) {
+ OPVP_F2FIX(offset, o);
+ if (apiEntry->opvpSetLineDashOffset) {
+ r = apiEntry->opvpSetLineDashOffset(printerContext, o);
+ }
+ if (r != OPVP_OK) {
+ ecode = -1;
+ }
+ }
+
+ /* call SetLineStyle */
+ if (!ecode) {
+ if (apiEntry->opvpSetLineStyle) {
+ r = apiEntry->opvpSetLineStyle(printerContext,
+ (count ?
+ OPVP_LINESTYLE_DASH :
+ OPVP_LINESTYLE_SOLID));
+ }
+ if (r != OPVP_OK) {
+ ecode = -1;
+ }
+ }
+
+ if (p) free(p);
+
+ return ecode;
+}
+
+/*
+ * set flat
+ */
+static int
+opvp_setflat(gx_device_vector *vdev, double flatness)
+{
+ gx_device_opvp *pdev = (gx_device_opvp *)vdev;
+ int ecode = 0;
+
+ /* check page-in */
+ if (opvp_check_in_page(pdev)) return -1;
+
+ /* what to do ? */
+
+ return ecode;
+}
+
+/*
+ * set logical operation
+ */
+static int
+opvp_setlogop(
+ gx_device_vector *vdev,
+ gs_logical_operation_t lop,
+ gs_logical_operation_t diff)
+{
+ /* nothing done */
+ return 0;
+}
+
+#if GS_VERSION_MAJOR >= 8
+/*--- added for Ghostscritp 8.15 ---*/
+static int
+opvp_can_handle_hl_color(gx_device_vector * vdev,
+ const gs_imager_state * pis1, const gx_drawing_color * pdc)
+{
+ return false; /* High level color is not implemented yet. */
+}
+#endif
+
+/*
+ * set fill color
+ */
+#if GS_VERSION_MAJOR >= 8
+static int
+opvp_setfillcolor(
+ gx_device_vector *vdev,
+ const gs_imager_state *pis, /* added for gs 8.15 */
+ const gx_drawing_color *pdc)
+#else
+static int
+opvp_setfillcolor(gx_device_vector *vdev, const gx_drawing_color *pdc)
+#endif
+{
+ gx_device_opvp *pdev = (gx_device_opvp *)vdev;
+ opvp_result_t r = -1;
+ int ecode = 0;
+ gx_color_index color;
+ static opvp_brush_t brush;
+
+ /* check page-in */
+ if (opvp_check_in_page(pdev)) return -1;
+
+ if (!gx_dc_is_pure(pdc)) return_error(gs_error_rangecheck);
+
+ /* color */
+ if (!vectorFillColor) vectorFillColor = &brush;
+ color = gx_dc_pure_color(pdc);
+ opvp_set_brush_color(pdev, color, vectorFillColor);
+
+ /* call SetFillColor */
+ if (apiEntry->opvpSetFillColor) {
+ r = apiEntry->opvpSetFillColor(printerContext, vectorFillColor);
+ }
+ if (r != OPVP_OK) {
+ ecode = -1;
+ }
+
+ return ecode;
+}
+
+/*
+ * set stroke color
+ */
+#if GS_VERSION_MAJOR >= 8
+static int
+opvp_setstrokecolor(
+ gx_device_vector *vdev,
+ const gs_imager_state *pis, /* added for gs 8.15 */
+ const gx_drawing_color *pdc)
+#else
+static int
+opvp_setstrokecolor(gx_device_vector *vdev, const gx_drawing_color *pdc)
+#endif
+{
+ gx_device_opvp *pdev = (gx_device_opvp *)vdev;
+ opvp_result_t r = -1;
+ int ecode = 0;
+ gx_color_index color;
+ opvp_brush_t brush;
+
+ /* check page-in */
+ if (opvp_check_in_page(pdev)) return -1;
+
+ if (!gx_dc_is_pure(pdc)) return_error(gs_error_rangecheck);
+
+ /* color */
+ color = gx_dc_pure_color(pdc);
+ opvp_set_brush_color(pdev, color, &brush);
+
+ /* call SetStrokeColor */
+ if (apiEntry->opvpSetStrokeColor) {
+ r = apiEntry->opvpSetStrokeColor(printerContext, &brush);
+ }
+ if (r != OPVP_OK) {
+ ecode = -1;
+ }
+
+ return ecode;
+}
+
+#define OPVP_OPT_MULTI_PATH
+
+/*
+ * vector do path
+ */
+static int
+opvp_vector_dopath(
+ gx_device_vector *vdev,
+ const gx_path *ppath,
+ gx_path_type_t type,
+ const gs_matrix *pmat)
+{
+ gx_device_opvp *pdev = (gx_device_opvp *)vdev;
+ opvp_result_t r = -1;
+ int code = -1;
+ int ecode = 0;
+ gs_fixed_rect rect;
+ gs_path_enum path;
+ gs_point scale;
+ int op;
+#ifdef OPVP_OPT_MULTI_PATH
+ int i;
+ int pop = 0;
+ int npoints = 0;
+ int *cp_num = NULL;
+ _fPoint *points = NULL;
+ opvp_point_t *opvp_p = NULL;
+ _fPoint current;
+#else
+ _fPoint points[4];
+#endif
+ _fPoint start;
+ fixed vs[6];
+ bool begin = true;
+
+ start.x = start.y = 0;
+#ifdef OPVP_OPT_MULTI_PATH
+ current.x = current.y = 0;
+#endif
+ /* check page-in */
+ if (opvp_check_in_page(pdev)) return -1;
+
+ if (gx_path_is_rectangle(ppath, &rect))
+ return (*vdev_proc(vdev, dorect))(vdev,
+ rect.p.x, rect.p.y,
+ rect.q.x, rect.q.y,
+ type);
+
+ /* begin path */
+ code = (*vdev_proc(vdev, beginpath))(vdev, type);
+ if (code) ecode = code;
+ scale = vdev->scale;
+ gx_path_enum_init(&path, ppath);
+
+ while (!ecode) {
+ op = gx_path_enum_next(&path, (gs_fixed_point *)vs);
+ if (begin) {
+ /* start point */
+ start.x = fixed2float(vs[0]) / scale.x;
+ start.y = fixed2float(vs[1]) / scale.y;
+ begin = false;
+
+#ifdef OPVP_OPT_MULTI_PATH
+ npoints = 1;
+ points = realloc(points, sizeof(_fPoint));
+ current = start;
+#endif
+
+ points[0] = start;
+
+#ifdef OPVP_OPT_MULTI_PATH
+ } else if (op != pop) {
+ /* convert float to Fix */
+ opvp_p = realloc(opvp_p, sizeof(opvp_point_t) * npoints);
+ for (i = 0; i < npoints; i++) {
+ OPVP_F2FIX(points[i].x, opvp_p[i].x);
+ OPVP_F2FIX(points[i].y, opvp_p[i].y);
+ }
+
+ switch (pop) {
+ case gs_pe_moveto:
+ /* call SetCurrentPoint */
+ if (apiEntry->opvpSetCurrentPoint) {
+ r = apiEntry->opvpSetCurrentPoint(
+ printerContext,
+ opvp_p[npoints-1].x,
+ opvp_p[npoints-1].y);
+ }
+ if (r != OPVP_OK) ecode = -1;
+ break;
+ case gs_pe_lineto:
+ /* call LinePath */
+ if (apiEntry->opvpLinePath) {
+ r = apiEntry->opvpLinePath(
+ printerContext,
+ OPVP_PATHOPEN,
+ npoints - 1,
+ &(opvp_p[1]));
+ }
+ if (r != OPVP_OK) ecode = -1;
+ break;
+ case gs_pe_curveto:
+ /* npoints */
+ if (!cp_num)
+ cp_num = calloc(sizeof(int), 2);
+ cp_num[0] = npoints;
+ cp_num[1] = 0;
+
+ /* call BezierPath */
+ if (apiEntry->opvpBezierPath) {
+ r = apiEntry->opvpBezierPath(
+ printerContext,
+ npoints - 1,
+ &(opvp_p[1])
+ );
+ }
+ if (r != OPVP_OK) ecode = -1;
+ break;
+ case gs_pe_closepath:
+ /* close path */
+ break;
+ default:
+ /* error */
+ return_error(gs_error_unknownerror);
+ break;
+ }
+
+ /* reset */
+ npoints = 1;
+ if (cp_num) free(cp_num), cp_num = NULL;
+ points = realloc(points, sizeof(_fPoint));
+ points[0] = current;
+#endif
+ }
+
+ if (!op) break; /* END */
+
+ switch (op) {
+ case gs_pe_moveto:
+#ifdef OPVP_OPT_MULTI_PATH
+ /* move to */
+ i = npoints;
+ npoints += 1;
+ points = realloc(points, sizeof(_fPoint) * npoints);
+ points[i].x = fixed2float(vs[0]) / scale.x;
+ points[i].y = fixed2float(vs[1]) / scale.y;
+ current = points[i];
+ start = current;
+
+#else
+
+ /* move to */
+ points[1].x = fixed2float(vs[0]) / scale.x;
+ points[1].y = fixed2float(vs[1]) / scale.y;
+ code = (*vdev_proc(vdev, moveto))(vdev,
+ points[0].x,
+ points[0].y,
+ points[1].x,
+ points[1].y,
+ type);
+ if (code) ecode = code;
+ points[0] = points[1];
+ start = points[0];
+#endif
+ break;
+ case gs_pe_lineto:
+#ifdef OPVP_OPT_MULTI_PATH
+ /* line to */
+ i = npoints;
+ npoints += 1;
+ points = realloc(points, sizeof(_fPoint) * npoints);
+ points[i].x = fixed2float(vs[0]) / scale.x;
+ points[i].y = fixed2float(vs[1]) / scale.y;
+ current = points[i];
+#else
+ /* line to */
+ points[1].x = fixed2float(vs[0]) / scale.x;
+ points[1].y = fixed2float(vs[1]) / scale.y;
+ code = (*vdev_proc(vdev, lineto))(vdev,
+ points[0].x,
+ points[0].y,
+ points[1].x,
+ points[1].y,
+ type);
+ if (code) ecode = code;
+ points[0] = points[1];
+#endif
+ break;
+ case gs_pe_curveto:
+#ifdef OPVP_OPT_MULTI_PATH
+ /* curve to */
+
+ i = npoints;
+ npoints += 3;
+ points = realloc(points, sizeof(_fPoint) * npoints);
+ points[i ].x = fixed2float(vs[0]) / scale.x;
+ points[i ].y = fixed2float(vs[1]) / scale.y;
+ points[i+1].x = fixed2float(vs[2]) / scale.x;
+ points[i+1].y = fixed2float(vs[3]) / scale.y;
+ points[i+2].x = fixed2float(vs[4]) / scale.x;
+ points[i+2].y = fixed2float(vs[5]) / scale.y;
+ current = points[i+2];
+#else
+ /* curve to */
+ points[1].x = fixed2float(vs[0]) / scale.x;
+ points[1].y = fixed2float(vs[1]) / scale.y;
+ points[2].x = fixed2float(vs[2]) / scale.x;
+ points[2].y = fixed2float(vs[3]) / scale.y;
+ points[3].x = fixed2float(vs[4]) / scale.x;
+ points[3].y = fixed2float(vs[5]) / scale.y;
+ code = (*vdev_proc(vdev, curveto))(vdev,
+ points[0].x,
+ points[0].y,
+ points[1].x,
+ points[1].y,
+ points[2].x,
+ points[2].y,
+ points[3].x,
+ points[3].y,
+ type);
+ if (code) ecode = code;
+ points[0] = points[3];
+#endif
+ break;
+ case gs_pe_closepath:
+ /* close path */
+ code = (*vdev_proc(vdev, closepath))(
+ vdev,
+ points[0].x,
+ points[0].y,
+ start.x,
+ start.y,
+ type);
+ if (code) ecode = code;
+ points[0] = start;
+#ifdef OPVP_OPT_MULTI_PATH
+ current = start;
+#endif
+ break;
+ default:
+ /* error */
+ return_error(gs_error_unknownerror);
+ break;
+ }
+
+#ifdef OPVP_OPT_MULTI_PATH
+ pop = op;
+#endif
+ }
+
+ /* end path */
+ code = (*vdev_proc(vdev, endpath))(vdev, type);
+ if (code) ecode = code;
+
+#ifdef OPVP_OPT_MULTI_PATH
+ if (points) free(points);
+ if (opvp_p) free(opvp_p);
+ if (cp_num) free(cp_num);
+#endif
+ return ecode;
+}
+
+/*
+ * vector do rect
+ */
+static int
+opvp_vector_dorect(
+ gx_device_vector *vdev,
+ fixed x0,
+ fixed y0,
+ fixed x1,
+ fixed y1,
+ gx_path_type_t type)
+{
+ gx_device_opvp *pdev = (gx_device_opvp *)vdev;
+ opvp_result_t r = -1;
+ int code = -1;
+ int ecode = 0;
+ gs_point scale;
+ opvp_rectangle_t rectangles[1];
+ _fPoint p;
+
+ /* check page-in */
+ if (opvp_check_in_page(pdev)) return -1;
+
+ /* begin path */
+ code = (*vdev_proc(vdev, beginpath))(vdev, type);
+ if (code) ecode = code;
+ scale = vdev->scale;
+
+ if (!ecode) {
+ /* rectangle */
+ p.x = fixed2float(x0) / scale.x;
+ p.y = fixed2float(y0) / scale.y;
+ OPVP_F2FIX(p.x, rectangles[0].p0.x);
+ OPVP_F2FIX(p.y, rectangles[0].p0.y);
+ p.x = fixed2float(x1) / scale.x;
+ p.y = fixed2float(y1) / scale.y;
+ OPVP_F2FIX(p.x, rectangles[0].p1.x);
+ OPVP_F2FIX(p.y, rectangles[0].p1.y);
+
+ /* call RectanglePath */
+ if (apiEntry->opvpRectanglePath) {
+ r = apiEntry->opvpRectanglePath(printerContext,
+ 1,
+ rectangles);
+ }
+ if (r != OPVP_OK) {
+ ecode = -1;
+ }
+ }
+
+ /* end path */
+ if (!ecode) {
+ code = (*vdev_proc(vdev, endpath))(vdev, type);
+ if (code) ecode = code;
+ }
+
+ /* fallback */
+ if (ecode) return gdev_vector_dorect(vdev,x0,y0,x1,y1,type);
+
+ return ecode;
+}
+
+/*
+ * begin path
+ */
+static int
+opvp_beginpath(gx_device_vector *vdev, gx_path_type_t type)
+{
+ gx_device_opvp *pdev = (gx_device_opvp *)vdev;
+ opvp_result_t r = -1;
+ int ecode = 0;
+
+ /* check page-in */
+ if (opvp_check_in_page(pdev)) return -1;
+
+ /* check clip-path */
+ if (type & gx_path_type_clip) {
+ if (apiEntry->opvpResetClipPath)
+ apiEntry->opvpResetClipPath(printerContext);
+ }
+
+ /* call NewPath */
+ if (apiEntry->opvpNewPath) {
+ r = apiEntry->opvpNewPath(printerContext);
+ }
+ if (r != OPVP_OK) {
+ ecode = -1;
+ }
+
+ return ecode;
+}
+
+/*
+ * move to
+ */
+static int
+opvp_moveto(
+ gx_device_vector *vdev,
+ double x0,
+ double y0,
+ double x1,
+ double y1,
+ gx_path_type_t type)
+{
+ gx_device_opvp *pdev = (gx_device_opvp *)vdev;
+ opvp_result_t r = -1;
+ int ecode = 0;
+ opvp_point_t p;
+
+ /* check page-in */
+ if (opvp_check_in_page(pdev)) return -1;
+
+ /* call SetCurrentPoint */
+ OPVP_F2FIX(x1, p.x);
+ OPVP_F2FIX(y1, p.y);
+ if (apiEntry->opvpSetCurrentPoint) {
+ r = apiEntry->opvpSetCurrentPoint(printerContext, p.x, p.y);
+ }
+ if (r != OPVP_OK) {
+ ecode = -1;
+ }
+
+ return ecode;
+}
+
+/*
+ * line to
+ */
+static int
+opvp_lineto(
+ gx_device_vector *vdev,
+ double x0,
+ double y0,
+ double x1,
+ double y1,
+ gx_path_type_t type)
+{
+ gx_device_opvp *pdev = (gx_device_opvp *)vdev;
+ opvp_result_t r = -1;
+ int ecode = 0;
+ opvp_point_t points[1];
+
+ /* check page-in */
+ if (opvp_check_in_page(pdev)) return -1;
+
+ /* point */
+ OPVP_F2FIX(x1, points[0].x);
+ OPVP_F2FIX(y1, points[0].y);
+
+ /* call LinePath */
+ if (apiEntry->opvpLinePath) {
+ r = apiEntry->opvpLinePath(printerContext, OPVP_PATHOPEN, 1, points);
+ }
+ if (r != OPVP_OK) {
+ ecode = -1;
+ }
+
+ return ecode;
+}
+
+/*
+ * curve to
+ */
+static int
+opvp_curveto(
+ gx_device_vector *vdev,
+ double x0,
+ double y0,
+ double x1,
+ double y1,
+ double x2,
+ double y2,
+ double x3,
+ double y3,
+ gx_path_type_t type)
+{
+ gx_device_opvp *pdev = (gx_device_opvp *)vdev;
+ opvp_result_t r = -1;
+ int ecode = 0;
+ opvp_point_t points[4];
+
+ /* check page-in */
+ if (opvp_check_in_page(pdev)) return -1;
+
+ /* points */
+ OPVP_F2FIX(x0, points[0].x);
+ OPVP_F2FIX(y0, points[0].y);
+ OPVP_F2FIX(x1, points[1].x);
+ OPVP_F2FIX(y1, points[1].y);
+ OPVP_F2FIX(x2, points[2].x);
+ OPVP_F2FIX(y2, points[2].y);
+ OPVP_F2FIX(x3, points[3].x);
+ OPVP_F2FIX(y3, points[3].y);
+
+ /* call BezierPath */
+ if (apiEntry->opvpBezierPath) {
+ r = apiEntry->opvpBezierPath(printerContext,
+ 3,
+ &(points[1])
+ );
+ }
+ if (r != OPVP_OK) {
+ ecode = -1;
+ }
+
+ return ecode;
+}
+
+/*
+ * close path
+ */
+static int
+opvp_closepath(
+ gx_device_vector *vdev,
+ double x,
+ double y,
+ double x_start,
+ double y_start,
+ gx_path_type_t type)
+{
+ gx_device_opvp *pdev = (gx_device_opvp *)vdev;
+ opvp_result_t r = -1;
+ int ecode = 0;
+ opvp_point_t points[1];
+
+ /* check page-in */
+ if (opvp_check_in_page(pdev)) return -1;
+
+ /* point */
+ OPVP_F2FIX(x_start, points[0].x);
+ OPVP_F2FIX(y_start, points[0].y);
+
+ /* call LinePath */
+ if (apiEntry->opvpLinePath) {
+ r = apiEntry->opvpLinePath(printerContext, OPVP_PATHCLOSE, 1, points);
+ }
+ if (r != OPVP_OK) {
+ ecode = -1;
+ }
+
+ return ecode;
+}
+
+/*
+ * end path
+ */
+static int
+opvp_endpath(gx_device_vector *vdev, gx_path_type_t type)
+{
+ gx_device_opvp *pdev = (gx_device_opvp *)vdev;
+ opvp_result_t r = -1;
+ int ecode = 0;
+
+ /* check page-in */
+ if (opvp_check_in_page(pdev)) return -1;
+
+ /* call EndPath */
+ if (apiEntry->opvpEndPath) {
+ r = apiEntry->opvpEndPath(printerContext);
+ }
+ if (r != OPVP_OK) {
+ ecode = -1;
+ }
+
+ if (type & gx_path_type_fill) {
+ /* fill mode */
+ if (type & gx_path_type_even_odd) {
+ /* call SetFillMode */
+ if (apiEntry->opvpSetFillMode) {
+ r = apiEntry->opvpSetFillMode(
+ printerContext,
+ OPVP_FILLMODE_EVENODD
+ );
+ }
+ if (r != OPVP_OK) {
+ ecode = -1;
+ }
+ } else {
+ /* call SetFillMode */
+ if (apiEntry->opvpSetFillMode) {
+ r = apiEntry->opvpSetFillMode(
+ printerContext,
+ OPVP_FILLMODE_WINDING
+ );
+ }
+ if (r != OPVP_OK) {
+ ecode = -1;
+ }
+ }
+
+ if (type & gx_path_type_stroke) {
+ /* call StrokeFillPath */
+ if (apiEntry->opvpStrokeFillPath) {
+ r = apiEntry->opvpStrokeFillPath(printerContext);
+ }
+ if (r != OPVP_OK) {
+ ecode = -1;
+ }
+ } else {
+ /* call FillPath */
+ if (apiEntry->opvpFillPath) {
+ r = apiEntry->opvpFillPath(printerContext);
+ }
+ if (r != OPVP_OK) {
+ ecode = -1;
+ }
+ }
+ } else if (type & gx_path_type_clip) {
+ /* call SetClipPath */
+ if (apiEntry->opvpSetClipPath) {
+ r = apiEntry->opvpSetClipPath(
+ printerContext,
+ (type & gx_path_type_even_odd
+ ? OPVP_CLIPRULE_EVENODD
+ : OPVP_CLIPRULE_WINDING));
+ }
+ if (r != OPVP_OK) {
+ ecode = -1;
+ }
+ } else if (type & gx_path_type_stroke) {
+ /* call StrokePath */
+ if (apiEntry->opvpStrokePath) {
+ r = apiEntry->opvpStrokePath(printerContext);
+ }
+ if (r != OPVP_OK) {
+ ecode = -1;
+ }
+ }
+
+ return ecode;
+}
diff --git a/contrib/opvp/opvp.h b/contrib/opvp/opvp.h
new file mode 100644
index 000000000..426e8cf74
--- /dev/null
+++ b/contrib/opvp/opvp.h
@@ -0,0 +1,299 @@
+/*
+ * OpenPrinting Vector Printer Driver API Definitions [opvp.h]
+ *
+ * Copyright (c) 2006 Free Standards Group
+ * Copyright (c) 2006 Fuji Xerox Printing Systems Co., Ltd.
+ * Copyright (c) 2006 Canon Inc.
+ * Copyright (c) 2003-2006 AXE Inc.
+ *
+ * All Rights Reserverd.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software
+ * and its documentation for any purpose is hereby granted without
+ * fee, provided that the above copyright notice appear in all copies
+ * and that both that copyright notice and this permission notice
+ * appear in supporting documentation.
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+ * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+ /*
+ 2007 Modified for OPVP 1.0 by BBR Inc.
+ */
+
+#ifndef _OPVP_H_
+#define _OPVP_H_
+
+/* Return Values and Error Codes */
+#define OPVP_OK 0 /* -1 for errors */
+#define OPVP_FATALERROR -1 /* error: cannot be recovered */
+#define OPVP_BADREQUEST -2 /* error: called where it should
+ not be called */
+#define OPVP_BADCONTEXT -3 /* error: invalid printer context */
+#define OPVP_NOTSUPPORTED -4 /* error: combination of
+ parameters are set
+ which cannot be handled
+ by driver or printer */
+#define OPVP_JOBCANCELED -5 /* error: job has been canceled
+ by some cause */
+#define OPVP_PARAMERROR -6 /* error: invalid parameter */
+#define OPVP_VERSIONERROR -7 /* error: invalid API version */
+
+/* Basic Types */
+typedef int opvp_dc_t; /* driver/device context */
+typedef int opvp_result_t; /* return value */
+typedef unsigned char opvp_byte_t; /* BYTE */
+typedef unsigned char opvp_char_t; /* character (string) */
+typedef int opvp_int_t; /* integer */
+typedef int opvp_fix_t; /* fixed integer */
+typedef float opvp_float_t; /* float */
+typedef unsigned int opvp_flag_t; /* flags */
+typedef unsigned int opvp_rop_t; /* raster operation */
+
+/* for opvp_fix_t */
+#define OPVP_FIX_FRACT_WIDTH 8
+#define OPVP_FIX_FRACT_DENOM (1<<OPVP_FIX_FRACT_WIDTH)
+#define OPVP_FIX_FLOOR_WIDTH (sizeof(int)*8-OPVP_FIX_FRACT_WIDTH)
+
+/* convert macro */
+#define OPVP_I2FIX(i,fix) (fix=i<<OPVP_FIX_FRACT_WIDTH)
+#define OPVP_F2FIX(f,fix) (fix=((int)floor(f)<<OPVP_FIX_FRACT_WIDTH)\
+ |((int)((f-floor(f))*OPVP_FIX_FRACT_DENOM)\
+ &(OPVP_FIX_FRACT_DENOM-1)))
+
+/* graphic elements */
+typedef struct _opvp_point {
+ opvp_fix_t x, y;
+} opvp_point_t;
+
+typedef struct _opvp_rectangle {
+ opvp_point_t p0; /* start point */
+ opvp_point_t p1; /* diagonal point */
+} opvp_rectangle_t;
+
+typedef struct _opvp_roundrectangle {
+ opvp_point_t p0; /* start point */
+ opvp_point_t p1; /* diagonal point */
+ opvp_fix_t xellipse, yellipse;
+} opvp_roundrectangle_t;
+
+/* Image Formats */
+typedef enum _opvp_imageformat {
+ OPVP_IFORMAT_RAW = 0,
+ OPVP_IFORMAT_MASK = 1,
+ OPVP_IFORMAT_RLE = 2,
+ OPVP_IFORMAT_JPEG = 3,
+ OPVP_IFORMAT_PNG = 4
+} opvp_imageformat_t;
+
+/* Color Presentation */
+typedef enum _opvp_colormapping {
+ OPVP_CMAP_DIRECT = 0,
+ OPVP_CMAP_INDEXED = 1
+} opvp_colormapping_t;
+
+typedef enum _opvp_cspace {
+ OPVP_CSPACE_BW = 0,
+ OPVP_CSPACE_DEVICEGRAY = 1,
+ OPVP_CSPACE_DEVICECMY = 2,
+ OPVP_CSPACE_DEVICECMYK = 3,
+ OPVP_CSPACE_DEVICERGB = 4,
+ OPVP_CSPACE_DEVICEKRGB = 5,
+ OPVP_CSPACE_STANDARDRGB = 6,
+ OPVP_CSPACE_STANDARDRGB64 = 7
+} opvp_cspace_t;
+
+/* Fill, Paint, Clip */
+typedef enum _opvp_fillmode {
+ OPVP_FILLMODE_EVENODD = 0,
+ OPVP_FILLMODE_WINDING = 1
+} opvp_fillmode_t;
+
+typedef enum _opvp_paintmode {
+ OPVP_PAINTMODE_OPAQUE = 0,
+ OPVP_PAINTMODE_TRANSPARENT = 1
+} opvp_paintmode_t;
+
+typedef enum _opvp_cliprule {
+ OPVP_CLIPRULE_EVENODD = 0,
+ OPVP_CLIPRULE_WINDING = 1
+} opvp_cliprule_t;
+
+/* Line */
+typedef enum _opvp_linestyle {
+ OPVP_LINESTYLE_SOLID = 0,
+ OPVP_LINESTYLE_DASH = 1
+} opvp_linestyle_t;
+
+typedef enum _opvp_linecap {
+ OPVP_LINECAP_BUTT = 0,
+ OPVP_LINECAP_ROUND = 1,
+ OPVP_LINECAP_SQUARE = 2
+} opvp_linecap_t;
+
+typedef enum _opvp_linejoin {
+ OPVP_LINEJOIN_MITER = 0,
+ OPVP_LINEJOIN_ROUND = 1,
+ OPVP_LINEJOIN_BEVEL = 2
+} opvp_linejoin_t;
+
+/* Brush */
+typedef enum _opvp_bdtype {
+ OPVP_BDTYPE_NORMAL = 0
+} opvp_bdtype_t;
+
+typedef struct _opvp_brushdata {
+ opvp_bdtype_t type;
+ opvp_int_t width, height, pitch;
+#if defined(__GNUC__) && __GNUC__ <= 2
+ opvp_byte_t data[1];
+#elif defined(__SUNPRO_C)
+ opvp_byte_t data[1];
+#elif defined(__HP_cc)
+ opvp_byte_t data[1];
+#else
+ opvp_byte_t data[];
+#endif
+
+} opvp_brushdata_t;
+
+typedef struct _opvp_brush {
+ opvp_cspace_t colorSpace;
+ opvp_int_t color[4]; /* aRGB quadruplet */
+ opvp_int_t xorg, yorg; /* brush origin */
+ /* ignored for opvpSetBgColor */
+ opvp_brushdata_t *pbrush; /* pointer to brush data */
+ /* solid brush used, if NULL */
+} opvp_brush_t;
+
+/* Misc. Flags */
+typedef enum _opvp_arcmode {
+ OPVP_ARC = 0,
+ OPVP_CHORD = 1,
+ OPVP_PIE = 2
+} opvp_arcmode_t;
+
+typedef enum _opvp_arcdir {
+ OPVP_CLOCKWISE = 0,
+ OPVP_COUNTERCLOCKWISE = 1
+} opvp_arcdir_t;
+
+typedef enum _opvp_pathmode {
+ OPVP_PATHCLOSE = 0,
+ OPVP_PATHOPEN = 1
+} opvp_pathmode_t;
+
+/* CTM */
+typedef struct _opvp_ctm {
+ opvp_float_t a, b, c, d, e, f;
+} opvp_ctm_t;
+
+/* Device Information and Capabilites */
+typedef enum _opvp_queryinfoflags {
+ OPVP_QF_DEVICERESOLUTION = 0x00000001,
+ OPVP_QF_MEDIASIZE = 0x00000002,
+ OPVP_QF_PAGEROTATION = 0x00000004,
+ OPVP_QF_MEDIANUP = 0x00000008,
+ OPVP_QF_MEDIADUPLEX = 0x00000010,
+ OPVP_QF_MEDIASOURCE = 0x00000020,
+ OPVP_QF_MEDIADESTINATION = 0x00000040,
+ OPVP_QF_MEDIATYPE = 0x00000080,
+ OPVP_QF_MEDIACOPY = 0x00000100, /* Maximum copy number
+ supported */
+ OPVP_QF_PRINTREGION = 0x00010000 /* only for opvpQueryDeviceInfo */
+} opvp_queryinfoflags_t;
+
+/* API Procedure Entries */
+typedef struct _opvp_api_procs {
+ opvp_dc_t (*opvpOpenPrinter)(opvp_int_t,const opvp_char_t*,const opvp_int_t[2],struct _opvp_api_procs**);
+ opvp_result_t (*opvpClosePrinter)(opvp_dc_t);
+ opvp_result_t (*opvpStartJob)(opvp_dc_t,const opvp_char_t*);
+ opvp_result_t (*opvpEndJob)(opvp_dc_t);
+ opvp_result_t (*opvpAbortJob)(opvp_dc_t);
+ opvp_result_t (*opvpStartDoc)(opvp_dc_t,const opvp_char_t*);
+ opvp_result_t (*opvpEndDoc)(opvp_dc_t);
+ opvp_result_t (*opvpStartPage)(opvp_dc_t,const opvp_char_t*);
+ opvp_result_t (*opvpEndPage)(opvp_dc_t);
+ opvp_result_t (*opvpQueryDeviceCapability)(opvp_dc_t,opvp_flag_t,opvp_int_t*,opvp_byte_t*);
+ opvp_result_t (*opvpQueryDeviceInfo)(opvp_dc_t,opvp_flag_t,opvp_int_t*,opvp_char_t*);
+ opvp_result_t (*opvpResetCTM)(opvp_dc_t);
+ opvp_result_t (*opvpSetCTM)(opvp_dc_t,const opvp_ctm_t*);
+ opvp_result_t (*opvpGetCTM)(opvp_dc_t,opvp_ctm_t*);
+ opvp_result_t (*opvpInitGS)(opvp_dc_t);
+ opvp_result_t (*opvpSaveGS)(opvp_dc_t);
+ opvp_result_t (*opvpRestoreGS)(opvp_dc_t);
+ opvp_result_t (*opvpQueryColorSpace)(opvp_dc_t,opvp_int_t*,opvp_cspace_t*);
+ opvp_result_t (*opvpSetColorSpace)(opvp_dc_t,opvp_cspace_t);
+ opvp_result_t (*opvpGetColorSpace)(opvp_dc_t,opvp_cspace_t*);
+ opvp_result_t (*opvpSetFillMode)(opvp_dc_t,opvp_fillmode_t);
+ opvp_result_t (*opvpGetFillMode)(opvp_dc_t,opvp_fillmode_t*);
+ opvp_result_t (*opvpSetAlphaConstant)(opvp_dc_t,opvp_float_t);
+ opvp_result_t (*opvpGetAlphaConstant)(opvp_dc_t,opvp_float_t*);
+ opvp_result_t (*opvpSetLineWidth)(opvp_dc_t,opvp_fix_t);
+ opvp_result_t (*opvpGetLineWidth)(opvp_dc_t,opvp_fix_t*);
+ opvp_result_t (*opvpSetLineDash)(opvp_dc_t,opvp_int_t,const opvp_fix_t*);
+ opvp_result_t (*opvpGetLineDash)(opvp_dc_t,opvp_int_t*,opvp_fix_t*);
+ opvp_result_t (*opvpSetLineDashOffset)(opvp_dc_t,opvp_fix_t);
+ opvp_result_t (*opvpGetLineDashOffset)(opvp_dc_t,opvp_fix_t*);
+ opvp_result_t (*opvpSetLineStyle)(opvp_dc_t,opvp_linestyle_t);
+ opvp_result_t (*opvpGetLineStyle)(opvp_dc_t,opvp_linestyle_t*);
+ opvp_result_t (*opvpSetLineCap)(opvp_dc_t,opvp_linecap_t);
+ opvp_result_t (*opvpGetLineCap)(opvp_dc_t,opvp_linecap_t*);
+ opvp_result_t (*opvpSetLineJoin)(opvp_dc_t,opvp_linejoin_t);
+ opvp_result_t (*opvpGetLineJoin)(opvp_dc_t,opvp_linejoin_t*);
+ opvp_result_t (*opvpSetMiterLimit)(opvp_dc_t,opvp_fix_t);
+ opvp_result_t (*opvpGetMiterLimit)(opvp_dc_t,opvp_fix_t*);
+ opvp_result_t (*opvpSetPaintMode)(opvp_dc_t,opvp_paintmode_t);
+ opvp_result_t (*opvpGetPaintMode)(opvp_dc_t,opvp_paintmode_t*);
+ opvp_result_t (*opvpSetStrokeColor)(opvp_dc_t,const opvp_brush_t*);
+ opvp_result_t (*opvpSetFillColor)(opvp_dc_t,const opvp_brush_t*);
+ opvp_result_t (*opvpSetBgColor)(opvp_dc_t,const opvp_brush_t*);
+ opvp_result_t (*opvpNewPath)(opvp_dc_t);
+ opvp_result_t (*opvpEndPath)(opvp_dc_t);
+ opvp_result_t (*opvpStrokePath)(opvp_dc_t);
+ opvp_result_t (*opvpFillPath)(opvp_dc_t);
+ opvp_result_t (*opvpStrokeFillPath)(opvp_dc_t);
+ opvp_result_t (*opvpSetClipPath)(opvp_dc_t,opvp_cliprule_t);
+ opvp_result_t (*opvpResetClipPath)(opvp_dc_t);
+ opvp_result_t (*opvpSetCurrentPoint)(opvp_dc_t,opvp_fix_t,opvp_fix_t);
+ opvp_result_t (*opvpLinePath)(opvp_dc_t,opvp_pathmode_t,opvp_int_t,const opvp_point_t*);
+ opvp_result_t (*opvpPolygonPath)(opvp_dc_t,opvp_int_t,const opvp_int_t*,const opvp_point_t*);
+ opvp_result_t (*opvpRectanglePath)(opvp_dc_t,opvp_int_t,const opvp_rectangle_t*);
+ opvp_result_t (*opvpRoundRectanglePath)(opvp_dc_t,opvp_int_t,const opvp_roundrectangle_t*);
+ opvp_result_t (*opvpBezierPath)(opvp_dc_t,opvp_int_t,const opvp_point_t*);
+ opvp_result_t (*opvpArcPath)(opvp_dc_t,opvp_arcmode_t,opvp_arcdir_t,opvp_fix_t,opvp_fix_t,opvp_fix_t,opvp_fix_t,opvp_fix_t,opvp_fix_t,opvp_fix_t,opvp_fix_t);
+ opvp_result_t (*opvpDrawImage)(opvp_dc_t,opvp_int_t,opvp_int_t,opvp_int_t,opvp_imageformat_t,opvp_int_t, opvp_int_t ,const void*);
+ opvp_result_t (*opvpStartDrawImage)(opvp_dc_t,opvp_int_t,opvp_int_t,opvp_int_t,opvp_imageformat_t,opvp_int_t, opvp_int_t);
+ opvp_result_t (*opvpTransferDrawImage)(opvp_dc_t,opvp_int_t,const void*);
+ opvp_result_t (*opvpEndDrawImage)(opvp_dc_t);
+ opvp_result_t (*opvpStartScanline)(opvp_dc_t,opvp_int_t);
+ opvp_result_t (*opvpScanline)(opvp_dc_t,opvp_int_t,const opvp_int_t*);
+ opvp_result_t (*opvpEndScanline)(opvp_dc_t);
+ opvp_result_t (*opvpStartRaster)(opvp_dc_t,opvp_int_t);
+ opvp_result_t (*opvpTransferRasterData)(opvp_dc_t,opvp_int_t,const opvp_byte_t*);
+ opvp_result_t (*opvpSkipRaster)(opvp_dc_t,opvp_int_t);
+ opvp_result_t (*opvpEndRaster)(opvp_dc_t);
+ opvp_result_t (*opvpStartStream)(opvp_dc_t);
+ opvp_result_t (*opvpTransferStreamData)(opvp_dc_t,opvp_int_t,const void*);
+ opvp_result_t (*opvpEndStream)(opvp_dc_t);
+} opvp_api_procs_t;
+
+/* Function prototype */
+opvp_dc_t opvpOpenPrinter(
+ opvp_int_t outputFD,
+ const opvp_char_t *printerModel,
+ const opvp_int_t apiVersion[2],
+ opvp_api_procs_t **apiProcs);
+
+/* error no */
+extern opvp_int_t opvpErrorNo;
+
+#endif /* _OPVP_H_ */
diff --git a/contrib/opvp/opvp_0_2_0.h b/contrib/opvp/opvp_0_2_0.h
new file mode 100644
index 000000000..6030971a3
--- /dev/null
+++ b/contrib/opvp/opvp_0_2_0.h
@@ -0,0 +1,298 @@
+/*
+
+Copyright (c) 2003-2004, AXE, Inc. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+*/
+/* $Id: opvp_0_2_0.h 85 2007-02-15 08:48:56Z sho-otani $ */
+/* opvp_common.h ver.1.00 rel.1.0 26 Nov 2004 */
+/* OpenPrinting Vector Printer Driver Glue Code */
+
+#ifndef _FSGPD_0_2_0_H
+#define _FSGPD_0_2_0_H
+
+#define _PDAPI_VERSION_MAJOR_ 0
+#define _PDAPI_VERSION_MINOR_ 2
+
+/* Return Values */
+#define OPVP_OK 0 /* error is -1 */
+
+/* Error Codes */
+#define OPVP_FATALERROR -101 /* unrecoverable error occurred within the */
+ /* library */
+#define OPVP_BADREQUEST -102 /* invalid function parameters */
+#define OPVP_BADCONTEXT -103 /* bad parameter precontext */
+#define OPVP_NOTSUPPORTED -104 /* printer or driver request not supported */
+#define OPVP_JOBCANCELED -105 /* job cancelled */
+#define OPVP_PARAMERROR -106 /* illegal parameter combination */
+
+/* Info params */
+#define OPVP_INFO_PREFIX "updf:"
+
+/* Fix */
+#define OPVP_FIX_FRACT_WIDTH 8
+#define OPVP_FIX_FRACT_DENOM (1<<OPVP_FIX_FRACT_WIDTH)
+#define OPVP_FIX_FLOOR_WIDTH (sizeof(int)*8-OPVP_FIX_FRACT_WIDTH)
+#if 0
+typedef struct {
+ unsigned int fract : OPVP_FIX_FRACT_WIDTH;
+ signed int floor : OPVP_FIX_FLOOR_WIDTH;
+} OPVP_Fix;
+#define OPVP_i2Fix(i,fix) (fix.fract=0,fix.floor=i)
+#define OPVP_Fix2f(fix,f) (f=(double)fix.floor\
+ +(double)(fix.fract)/OPVP_FIX_FRACT_DENOM)
+#define OPVP_f2Fix(f,fix) (fix.fract=(f-floor(f))*OPVP_FIX_FRACT_DENOM,\
+ fix.floor=floor(f))
+#else
+typedef int OPVP_Fix;
+#define OPVP_i2Fix(i,fix) (fix=i<<8)
+#define OPVP_f2Fix(f,fix) (fix=((int)floor(f)<<8)\
+ |((int)((f-floor(f))*OPVP_FIX_FRACT_DENOM)\
+ &0x000000ff))
+#endif
+
+/* Basic Types */
+typedef struct _OPVP_Point {
+ OPVP_Fix x;
+ OPVP_Fix y;
+} OPVP_Point;
+
+typedef struct _OPVP_Rectangle {
+ OPVP_Point p0; /* start point */
+ OPVP_Point p1; /* end point */
+} OPVP_Rectangle;
+
+typedef struct _OPVP_RoundRectangle {
+ OPVP_Point p0; /* start point */
+ OPVP_Point p1; /* end point */
+ OPVP_Fix xellipse;
+ OPVP_Fix yellipse;
+} OPVP_RoundRectangle;
+
+/* Image Formats */
+typedef enum _OPVP_ImageFormat {
+ OPVP_iformatRaw = 0,
+ OPVP_iformatRLE = 1,
+ OPVP_iformatJPEG = 2,
+ OPVP_iformatPNG = 3
+} OPVP_ImageFormat;
+
+/* Color Presentation */
+typedef enum _OPVP_ColorMapping {
+ OPVP_cmapDirect = 0,
+ OPVP_cmapIndexed = 1
+} OPVP_ColorMapping;
+
+typedef enum _OPVP_ColorSpace {
+ OPVP_cspaceBW = 0,
+ OPVP_cspaceDeviceGray = 1,
+ OPVP_cspaceDeviceCMY = 2,
+ OPVP_cspaceDeviceCMYK = 3,
+ OPVP_cspaceDeviceRGB = 4,
+ OPVP_cspaceStandardRGB = 5,
+ OPVP_cspaceStandardRGB64 = 6
+} OPVP_ColorSpace;
+
+/* Raster Operation modes */
+typedef enum _OPVP_ROP {
+ OPVP_ropPset = 0,
+ OPVP_ropPreset = 1,
+ OPVP_ropOr = 2,
+ OPVP_ropAnd = 3,
+ OPVP_ropXor = 4
+} OPVP_ROP;
+
+/* Fill, Paint, Clip */
+typedef enum _OPVP_FillMode {
+ OPVP_fillModeEvenOdd = 0,
+ OPVP_fillModeWinding = 1
+} OPVP_FillMode;
+
+typedef enum _OPVP_PaintMode {
+ OPVP_paintModeOpaque = 0,
+ OPVP_paintModeTransparent = 1
+} OPVP_PaintMode;
+
+typedef enum _OPVP_ClipRule {
+ OPVP_clipRuleEvenOdd = 0,
+ OPVP_clipRuleWinding = 1
+} OPVP_ClipRule;
+
+/* Line */
+typedef enum _OPVP_LineStyle {
+ OPVP_lineStyleSolid = 0,
+ OPVP_lineStyleDash = 1
+} OPVP_LineStyle;
+
+typedef enum _OPVP_LineCap {
+ OPVP_lineCapButt = 0,
+ OPVP_lineCapRound = 1,
+ OPVP_lineCapSquare = 2
+} OPVP_LineCap;
+
+typedef enum _OPVP_LineJoin {
+ OPVP_lineJoinMiter = 0,
+ OPVP_lineJoinRound = 1,
+ OPVP_lineJoinBevel = 2
+} OPVP_LineJoin;
+
+/* Brush */
+typedef enum _OPVP_BrushDataType {
+ OPVP_bdtypeNormal = 0
+} OPVP_BrushDataType;
+
+typedef struct _OPVP_BrushData {
+ OPVP_BrushDataType type;
+ int width;
+ int height;
+ int pitch;
+#if (_PDAPI_VERSION_MAJOR_ == 0 && _PDAPI_VERSION_MINOR_ < 2)
+ void *data; /* pointer to actual data */
+#else
+ char data[1];
+#endif
+} OPVP_BrushData;
+
+typedef struct _OPVP_Brush {
+ OPVP_ColorSpace colorSpace;
+ int color[4]; /* aRGB quadruplet */
+#if (_PDAPI_VERSION_MAJOR_ == 0 && _PDAPI_VERSION_MINOR_ < 2)
+ OPVP_BrushData *pbrush; /* pointer to brush data */
+ /* solid brush used, if null */
+ int xorg; /* brush origin */
+ int yorg; /* ignored for SetBgColor */
+#else
+ int xorg; /* brush origin */
+ int yorg; /* ignored for SetBgColor */
+ OPVP_BrushData *pbrush; /* pointer to brush data */
+ /* solid brush used, if null */
+#endif
+} OPVP_Brush;
+
+/* Misc. Flags */
+#define OPVP_Arc 0 /* circular arc */
+#define OPVP_Chord 1 /* arch */
+#define OPVP_Pie 2 /* pie section */
+#define OPVP_Clockwise 0 /* clockwise */
+#define OPVP_Counterclockwise 1 /* counter-clockwise */
+#define OPVP_PathClose 0 /* Close path when using LinePath */
+#define OPVP_PathOpen 1 /* Do not close path when using LinePath */
+
+/* CTM */
+typedef struct _OPVP_CTM {
+ float a;
+ float b;
+ float c;
+ float d;
+ float e;
+ float f;
+} OPVP_CTM;
+
+/* Vector Driver API Proc. Entries */
+typedef struct _OPVP_api_procs {
+ int (*OpenPrinter)(int,char *,int *,struct _OPVP_api_procs **);
+ int (*ClosePrinter)(int);
+ int (*StartJob)(int,char *);
+ int (*EndJob)(int);
+ int (*StartDoc)(int,char *);
+ int (*EndDoc)(int);
+ int (*StartPage)(int,char *);
+ int (*EndPage)(int);
+#if (_PDAPI_VERSION_MAJOR_ > 0 || _PDAPI_VERSION_MINOR_ >= 2)
+ int (*QueryDeviceCapability)(int,int,int,char *);
+ int (*QueryDeviceInfo)(int,int,int,char *);
+#endif
+ int (*ResetCTM)(int);
+ int (*SetCTM)(int,OPVP_CTM *);
+ int (*GetCTM)(int,OPVP_CTM *);
+ int (*InitGS)(int);
+ int (*SaveGS)(int);
+ int (*RestoreGS)(int);
+ int (*QueryColorSpace)(int,OPVP_ColorSpace *,int *);
+ int (*SetColorSpace)(int,OPVP_ColorSpace);
+ int (*GetColorSpace)(int,OPVP_ColorSpace *);
+ int (*QueryROP)(int,int *,int *);
+ int (*SetROP)(int,int);
+ int (*GetROP)(int,int *);
+ int (*SetFillMode)(int,OPVP_FillMode);
+ int (*GetFillMode)(int,OPVP_FillMode *);
+ int (*SetAlphaConstant)(int,float);
+ int (*GetAlphaConstant)(int,float *);
+ int (*SetLineWidth)(int,OPVP_Fix);
+ int (*GetLineWidth)(int,OPVP_Fix *);
+ int (*SetLineDash)(int,OPVP_Fix *,int);
+ int (*GetLineDash)(int,OPVP_Fix *,int *);
+ int (*SetLineDashOffset)(int,OPVP_Fix);
+ int (*GetLineDashOffset)(int,OPVP_Fix *);
+ int (*SetLineStyle)(int,OPVP_LineStyle);
+ int (*GetLineStyle)(int,OPVP_LineStyle *);
+ int (*SetLineCap)(int,OPVP_LineCap);
+ int (*GetLineCap)(int,OPVP_LineCap *);
+ int (*SetLineJoin)(int,OPVP_LineJoin);
+ int (*GetLineJoin)(int,OPVP_LineJoin *);
+ int (*SetMiterLimit)(int,OPVP_Fix);
+ int (*GetMiterLimit)(int,OPVP_Fix *);
+ int (*SetPaintMode)(int,OPVP_PaintMode);
+ int (*GetPaintMode)(int,OPVP_PaintMode *);
+ int (*SetStrokeColor)(int,OPVP_Brush *);
+ int (*SetFillColor)(int,OPVP_Brush *);
+ int (*SetBgColor)(int,OPVP_Brush *);
+ int (*NewPath)(int);
+ int (*EndPath)(int);
+ int (*StrokePath)(int);
+ int (*FillPath)(int);
+ int (*StrokeFillPath)(int);
+ int (*SetClipPath)(int,OPVP_ClipRule);
+#if (_PDAPI_VERSION_MAJOR_ > 0 || _PDAPI_VERSION_MINOR_ >= 2)
+ int (*ResetClipPath)(int);
+#endif
+ int (*SetCurrentPoint)(int,OPVP_Fix,OPVP_Fix);
+ int (*LinePath)(int,int,int,OPVP_Point *);
+ int (*PolygonPath)(int,int,int *,OPVP_Point *);
+ int (*RectanglePath)(int,int,OPVP_Rectangle *);
+ int (*RoundRectanglePath)(int,int,OPVP_RoundRectangle *);
+#if (_PDAPI_VERSION_MAJOR_ == 0 && _PDAPI_VERSION_MINOR_ < 2)
+ int (*BezierPath)(int,int *,OPVP_Point *);
+#else
+ int (*BezierPath)(int,int,OPVP_Point *);
+#endif
+ int (*ArcPath)(int,int,int,OPVP_Fix,OPVP_Fix,OPVP_Fix,OPVP_Fix,
+ OPVP_Fix,OPVP_Fix,OPVP_Fix,OPVP_Fix);
+ int (*DrawBitmapText)(int,int,int,int,void *);
+ int (*DrawImage)(int,int,int,int,
+ OPVP_ImageFormat,OPVP_Rectangle,int,void *);
+ int (*StartDrawImage)(int,int,int,int,
+ OPVP_ImageFormat,OPVP_Rectangle);
+ int (*TransferDrawImage)(int,int,void *);
+ int (*EndDrawImage)(int);
+ int (*StartScanline)(int,int);
+ int (*Scanline)(int,int,int *);
+ int (*EndScanline)(int);
+ int (*StartRaster)(int,int);
+ int (*TransferRasterData)(int,int,unsigned char *);
+ int (*SkipRaster)(int,int);
+ int (*EndRaster)(int);
+ int (*StartStream)(int);
+ int (*TransferStreamData)(int,int,void *);
+ int (*EndStream)(int);
+} OPVP_api_procs;
+
+#endif /* _OPVP_COMMON_H_ */
diff --git a/contrib/opvp/opvp_common.h b/contrib/opvp/opvp_common.h
new file mode 100644
index 000000000..9161c4bc6
--- /dev/null
+++ b/contrib/opvp/opvp_common.h
@@ -0,0 +1,53 @@
+/*
+
+Copyright (c) 2003-2004, AXE, Inc. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+*/
+/* OpenPrinting Vector Printer Driver Glue Code */
+
+#ifndef _OPVP_COMMON_H_
+#define _OPVP_COMMON_H_
+
+#include "opvp_0_2_0.h"
+#undef _PDAPI_VERSION_MAJOR_
+#undef _PDAPI_VERSION_MINOR_
+/* undefine conflicted macros */
+#undef OPVP_INFO_PREFIX
+#undef OPVP_OK
+#undef OPVP_FATALERROR
+#undef OPVP_BADREQUEST
+#undef OPVP_BADCONTEXT
+#undef OPVP_NOTSUPPORTED
+#undef OPVP_JOBCANCELED
+#undef OPVP_PARAMERROR
+/* define 0_2 error no as different macros */
+#define OPVP_FATALERROR_0_2 -101
+#define OPVP_BADREQUEST_0_2 -102
+#define OPVP_BADCONTEXT_0_2 -103
+#define OPVP_NOTSUPPORTED_0_2 -104
+#define OPVP_JOBCANCELED_0_2 -105
+#define OPVP_PARAMERROR_0_2 -106
+
+#include "opvp.h"
+#define OPVP_INFO_PREFIX ""
+
+#endif /* _OPVP_COMMON_H_ */
diff --git a/contrib/opvp/opvp_media.def b/contrib/opvp/opvp_media.def
new file mode 100644
index 000000000..33fb81db6
--- /dev/null
+++ b/contrib/opvp/opvp_media.def
@@ -0,0 +1,166 @@
+/* $Id: opvp_media.def 74 2005-06-10 16:53:36Z gishi $ */
+{"iso" ,"a10" , 26/MMPI*PS_DPI, 37/MMPI*PS_DPI},
+{"iso" ,"c10" , 28/MMPI*PS_DPI, 40/MMPI*PS_DPI},
+{"iso" ,"b10" , 31/MMPI*PS_DPI, 44/MMPI*PS_DPI},
+{"jis" ,"b10" , 32/MMPI*PS_DPI, 45/MMPI*PS_DPI},
+{"iso" ,"a9" , 37/MMPI*PS_DPI, 52/MMPI*PS_DPI},
+{"iso" ,"c9" , 40/MMPI*PS_DPI, 57/MMPI*PS_DPI},
+{"iso" ,"b9" , 44/MMPI*PS_DPI, 62/MMPI*PS_DPI},
+{"jis" ,"b9" , 45/MMPI*PS_DPI, 64/MMPI*PS_DPI},
+{"iso" ,"a8" , 52/MMPI*PS_DPI, 74/MMPI*PS_DPI},
+{"iso" ,"c8" , 57/MMPI*PS_DPI, 81/MMPI*PS_DPI},
+{"iso" ,"b8" , 62/MMPI*PS_DPI, 88/MMPI*PS_DPI},
+{"jis" ,"b8" , 64/MMPI*PS_DPI, 91/MMPI*PS_DPI},
+{"iso" ,"a7" , 74/MMPI*PS_DPI, 105/MMPI*PS_DPI},
+{"na" ,"index-3x5" , 3*PS_DPI, 5*PS_DPI},/*76.2x127*/
+{"iso" ,"c7" , 81/MMPI*PS_DPI, 114/MMPI*PS_DPI},
+{"iso" ,"c7c6" , 81/MMPI*PS_DPI, 162/MMPI*PS_DPI},
+{"iso" ,"b7" , 88/MMPI*PS_DPI, 125/MMPI*PS_DPI},
+{"jpn" ,"chou4" , 90/MMPI*PS_DPI, 205/MMPI*PS_DPI},
+{"jis" ,"b7" , 91/MMPI*PS_DPI, 128/MMPI*PS_DPI},
+{"na" ,"personal" , 3.625*PS_DPI, 6.5*PS_DPI},/*92.075x165.1*/
+{"prc" ,"32k" , 97/MMPI*PS_DPI, 151/MMPI*PS_DPI},
+{"na" ,"monarch" , 3.875*PS_DPI, 7.5*PS_DPI},/*98.425x190.5*/
+{"na" ,"number-9" , 3.875*PS_DPI, 8.875*PS_DPI},/*98.425x225.425*/
+{"jpn" ,"hagaki" , 100/MMPI*PS_DPI, 148/MMPI*PS_DPI},
+{"om" ,"small-photo" , 100/MMPI*PS_DPI, 150/MMPI*PS_DPI},
+{"om" ,"italian" , 100/MMPI*PS_DPI, 230/MMPI*PS_DPI},
+{"na" ,"index-4x6" , 4*PS_DPI, 6*PS_DPI},/*101.6x152.4*/
+{"prc" ,"1" , 102/MMPI*PS_DPI, 165/MMPI*PS_DPI},
+{"prc" ,"2" , 102/MMPI*PS_DPI, 176/MMPI*PS_DPI},
+{"na" ,"number-10" , 4.125*PS_DPI, 9.5*PS_DPI},/*104.775x241.3*/
+{"iso" ,"a6" , 105/MMPI*PS_DPI, 148/MMPI*PS_DPI},
+{"jpn" ,"you4" , 105/MMPI*PS_DPI, 235/MMPI*PS_DPI},
+{"prc" ,"4" , 110/MMPI*PS_DPI, 208/MMPI*PS_DPI},
+{"iso" ,"dl" , 110/MMPI*PS_DPI, 220/MMPI*PS_DPI},
+{"prc" ,"5" , 110/MMPI*PS_DPI, 220/MMPI*PS_DPI},
+{"jpn" ,"chou2" ,111.1/MMPI*PS_DPI, 146/MMPI*PS_DPI},
+{"na" ,"a2" , 4.375*PS_DPI, 5.75*PS_DPI},/*111.125x146.05*/
+{"iso" ,"c6" , 114/MMPI*PS_DPI, 162/MMPI*PS_DPI},
+{"iso" ,"c6c5" , 114/MMPI*PS_DPI, 229/MMPI*PS_DPI},
+{"om" ,"postfix" , 114/MMPI*PS_DPI, 229/MMPI*PS_DPI},
+{"na" ,"number-11" , 4.5*PS_DPI, 10.375*PS_DPI},/*114.3x263.525*/
+{"jpn" ,"chou3" , 120/MMPI*PS_DPI, 235/MMPI*PS_DPI},
+{"prc" ,"8" , 120/MMPI*PS_DPI, 309/MMPI*PS_DPI},
+{"prc" ,"6" , 120/MMPI*PS_DPI, 320/MMPI*PS_DPI},
+{"na" ,"number-12" , 4.75*PS_DPI, 11*PS_DPI},/*120.65x279.4*/
+{"iso" ,"b6" , 125/MMPI*PS_DPI, 176/MMPI*PS_DPI},
+{"prc" ,"3" , 125/MMPI*PS_DPI, 176/MMPI*PS_DPI},
+{"iso" ,"b6c4" , 125/MMPI*PS_DPI, 324/MMPI*PS_DPI},
+{"na" ,"5x7" , 5*PS_DPI, 7*PS_DPI},/*127x177.8*/
+{"na" ,"index-5x8" , 5*PS_DPI, 8*PS_DPI},/*127x203.2*/
+{"na" ,"number-14" , 5*PS_DPI, 11.5*PS_DPI},/*127x292.1*/
+{"jis" ,"b6" , 128/MMPI*PS_DPI, 182/MMPI*PS_DPI},
+{"na" ,"invoice" , 5.5*PS_DPI, 8.5*PS_DPI},/*139.7x215.9*/
+{"prc" ,"16k" , 146/MMPI*PS_DPI, 215/MMPI*PS_DPI},
+{"jpn" ,"oufuku" , 148/MMPI*PS_DPI, 200/MMPI*PS_DPI},
+{"iso" ,"a5" , 148/MMPI*PS_DPI, 210/MMPI*PS_DPI},
+{"na" ,"index-4x6-ext", 6*PS_DPI, 8*PS_DPI},/*152.4x203.2*/
+{"na" ,"6x9" , 6*PS_DPI, 9*PS_DPI},/*152.4x228.6*/
+{"prc" ,"7" , 160/MMPI*PS_DPI, 230/MMPI*PS_DPI},
+{"iso" ,"c5" , 162/MMPI*PS_DPI, 229/MMPI*PS_DPI},
+{"na" ,"c5" , 6.5*PS_DPI, 9.5*PS_DPI},/*165.1x241.3*/
+{"iso" ,"a5-extra" , 174/MMPI*PS_DPI, 235/MMPI*PS_DPI},
+{"iso" ,"b5" , 176/MMPI*PS_DPI, 250/MMPI*PS_DPI},
+{"na" ,"7x9" , 7*PS_DPI, 9*PS_DPI},/*177.8x228.6*/
+{"jis" ,"b5" , 182/MMPI*PS_DPI, 257/MMPI*PS_DPI},
+{"na" ,"executive" , 7.25*PS_DPI, 10.5*PS_DPI},/*184.15x266.7*/
+{"roc" ,"16k" , 7.75*PS_DPI, 10.75*PS_DPI},/*196.85x273.05*/
+{"om" ,"juuro-ku-kai" , 198/MMPI*PS_DPI, 275/MMPI*PS_DPI},
+{"om" ,"large-photo" , 200/MMPI*PS_DPI, 300/MMPI*PS_DPI},
+{"iso" ,"b5-extra" , 201/MMPI*PS_DPI, 276/MMPI*PS_DPI},
+{"na" ,"govt-letter" , 8*PS_DPI, 10*PS_DPI},/*203.2x254*/
+{"na" ,"govt-legal" , 8*PS_DPI, 13*PS_DPI},/*203.2x330.2*/
+{"iso" ,"a4" , 210/MMPI*PS_DPI, 297/MMPI*PS_DPI},
+{"om" ,"folio" , 210/MMPI*PS_DPI, 330/MMPI*PS_DPI},
+{"om" ,"folio-sp" , 215/MMPI*PS_DPI, 315/MMPI*PS_DPI},
+{"na" ,"quarto" , 8.5*PS_DPI, 10.83*PS_DPI},/*215.9x275.082*/
+{"na" ,"letter" , 8.5*PS_DPI, 11*PS_DPI},/*215.9x279.4*/
+{"na" ,"fanfold-eur" , 8.5*PS_DPI, 12*PS_DPI},/*215.9x304.8*/
+{"na" ,"letter-plus" , 8.5*PS_DPI, 12.69*PS_DPI},/*215.9x322.326*/
+{"na" ,"foolscap" , 8.5*PS_DPI, 13*PS_DPI},/*215.9x330.2*/
+{"na" ,"legal" , 8.5*PS_DPI, 14*PS_DPI},/*215.9x355.6*/
+{"jis" ,"exec" , 216/MMPI*PS_DPI, 330/MMPI*PS_DPI},
+{"om" ,"invite" , 220/MMPI*PS_DPI, 220/MMPI*PS_DPI},
+{"iso" ,"a4-tab" , 225/MMPI*PS_DPI, 297/MMPI*PS_DPI},
+{"na" ,"super-a" , 8.94*PS_DPI, 14*PS_DPI},/*227.076x355.6*/
+{"na" ,"9x11" , 9*PS_DPI, 11*PS_DPI},/*228.6x279.4*/
+{"na" ,"arch-a" , 9*PS_DPI, 12*PS_DPI},/*228.6x304.8*/
+{"iso" ,"c4" , 229/MMPI*PS_DPI, 324/MMPI*PS_DPI},
+{"iso" ,"a4-extra" ,235.5/MMPI*PS_DPI,322.3/MMPI*PS_DPI},
+{"jpn" ,"kahu" , 240/MMPI*PS_DPI,322.1/MMPI*PS_DPI},
+{"jpn" ,"kaku2" , 240/MMPI*PS_DPI, 332/MMPI*PS_DPI},
+{"na" ,"letter-extra" , 9.5*PS_DPI, 12*PS_DPI},/*241.3x304.8*/
+{"na" ,"legal-extra" , 9.5*PS_DPI, 15*PS_DPI},/*241.3x381*/
+{"iso" ,"b4" , 250/MMPI*PS_DPI, 353/MMPI*PS_DPI},
+{"na" ,"10x11" , 10*PS_DPI, 11*PS_DPI},/*254x279.4*/
+{"na" ,"10x13" , 10*PS_DPI, 13*PS_DPI},/*254x330.2*/
+{"na" ,"10x14" , 10*PS_DPI, 14*PS_DPI},/*254x355.6*/
+{"na" ,"10x15" , 10*PS_DPI, 15*PS_DPI},/*254x381*/
+{"jis" ,"b4" , 257/MMPI*PS_DPI, 364/MMPI*PS_DPI},
+{"om" ,"pa-kai" , 267/MMPI*PS_DPI, 389/MMPI*PS_DPI},
+{"roc" ,"8k" , 10.75*PS_DPI, 15.5*PS_DPI},/*273.05x393.7*/
+{"om" ,"dai-pa-kai" , 275/MMPI*PS_DPI, 395/MMPI*PS_DPI},
+{"na" ,"11x12" , 11*PS_DPI, 12*PS_DPI},/*279.4x304.8*/
+{"na" ,"edp" , 11*PS_DPI, 14*PS_DPI},/*279.4x355.6*/
+{"na" ,"fanfold-us" , 11*PS_DPI, 14.875*PS_DPI},/*279.4x377.825*/
+{"na" ,"11x15" , 11*PS_DPI, 15*PS_DPI},/*279.4x381*/
+{"na" ,"ledger" , 11*PS_DPI, 17*PS_DPI},/*279.4x431.8*/
+{"iso" ,"a3" , 297/MMPI*PS_DPI, 420/MMPI*PS_DPI},
+{"iso" ,"a4x3" , 297/MMPI*PS_DPI, 630/MMPI*PS_DPI},
+{"iso" ,"a4x4" , 297/MMPI*PS_DPI, 841/MMPI*PS_DPI},
+{"iso" ,"a4x5" , 297/MMPI*PS_DPI, 1051/MMPI*PS_DPI},
+{"iso" ,"a4x6" , 297/MMPI*PS_DPI, 1261/MMPI*PS_DPI},
+{"iso" ,"a4x7" , 297/MMPI*PS_DPI, 1471/MMPI*PS_DPI},
+{"iso" ,"a4x8" , 297/MMPI*PS_DPI, 1682/MMPI*PS_DPI},
+{"iso" ,"a4x9" , 297/MMPI*PS_DPI, 1892/MMPI*PS_DPI},
+{"na" ,"eur-edp" , 12*PS_DPI, 14*PS_DPI},/*304.8x355.6*/
+{"na" ,"arch-b" , 12*PS_DPI, 18*PS_DPI},/*304.8x457.2*/
+{"na" ,"12x19" , 12*PS_DPI, 19*PS_DPI},/*304.8x482.6*/
+{"na" ,"b-plus" , 12*PS_DPI, 19.17*PS_DPI},/*304.8x486.918*/
+{"iso" ,"a3-extra" , 322/MMPI*PS_DPI, 445/MMPI*PS_DPI},
+{"iso" ,"c3" , 324/MMPI*PS_DPI, 458/MMPI*PS_DPI},
+{"prc" ,"10" , 324/MMPI*PS_DPI, 458/MMPI*PS_DPI},
+{"na" ,"super-b" , 13*PS_DPI, 19*PS_DPI},/*330.2x482.6*/
+{"iso" ,"b3" , 353/MMPI*PS_DPI, 500/MMPI*PS_DPI},
+{"jis" ,"b3" , 364/MMPI*PS_DPI, 515/MMPI*PS_DPI},
+{"iso" ,"a2" , 420/MMPI*PS_DPI, 594/MMPI*PS_DPI},
+{"iso" ,"a3x3" , 420/MMPI*PS_DPI, 891/MMPI*PS_DPI},
+{"iso" ,"a3x4" , 420/MMPI*PS_DPI, 1189/MMPI*PS_DPI},
+{"iso" ,"a3x5" , 420/MMPI*PS_DPI, 1486/MMPI*PS_DPI},
+{"iso" ,"a3x6" , 420/MMPI*PS_DPI, 1783/MMPI*PS_DPI},
+{"iso" ,"a3x7" , 420/MMPI*PS_DPI, 2080/MMPI*PS_DPI},
+{"iso" ,"ra2" , 430/MMPI*PS_DPI, 610/MMPI*PS_DPI},
+{"na" ,"c" , 17*PS_DPI, 22*PS_DPI},/*431.8x558.8*/
+{"iso" ,"sra2" , 450/MMPI*PS_DPI, 640/MMPI*PS_DPI},
+{"na" ,"arch-c" , 18*PS_DPI, 24*PS_DPI},/*457.2x609.6*/
+{"iso" ,"c2" , 458/MMPI*PS_DPI, 648/MMPI*PS_DPI},
+{"iso" ,"b2" , 500/MMPI*PS_DPI, 707/MMPI*PS_DPI},
+{"jis" ,"b2" , 515/MMPI*PS_DPI, 728/MMPI*PS_DPI},
+{"na" ,"d" , 22*PS_DPI, 34*PS_DPI},/*558.8x863.6*/
+{"iso" ,"a1" , 594/MMPI*PS_DPI, 841/MMPI*PS_DPI},
+{"iso" ,"a2x3" , 594/MMPI*PS_DPI, 1261/MMPI*PS_DPI},
+{"iso" ,"a2x4" , 594/MMPI*PS_DPI, 1682/MMPI*PS_DPI},
+{"iso" ,"a2x5" , 594/MMPI*PS_DPI, 2102/MMPI*PS_DPI},
+{"na" ,"arch-d" , 24*PS_DPI, 36*PS_DPI},/*609.6x914.4*/
+{"iso" ,"ra1" , 610/MMPI*PS_DPI, 860/MMPI*PS_DPI},
+{"iso" ,"sra1" , 640/MMPI*PS_DPI, 900/MMPI*PS_DPI},
+{"iso" ,"c1" , 648/MMPI*PS_DPI, 917/MMPI*PS_DPI},
+{"iso" ,"b1" , 707/MMPI*PS_DPI, 1000/MMPI*PS_DPI},
+{"asme","f" , 28*PS_DPI, 40*PS_DPI},/*711.2x1016*/
+{"jis" ,"b1" , 728/MMPI*PS_DPI, 1030/MMPI*PS_DPI},
+{"na" ,"wide-format" , 30*PS_DPI, 42*PS_DPI},/*762x1066.8*/
+{"iso" ,"a0" , 841/MMPI*PS_DPI, 1189/MMPI*PS_DPI},
+{"iso" ,"a1x3" , 841/MMPI*PS_DPI, 1783/MMPI*PS_DPI},
+{"iso" ,"a1x4" , 841/MMPI*PS_DPI, 2378/MMPI*PS_DPI},
+{"iso" ,"ra0" , 860/MMPI*PS_DPI, 1220/MMPI*PS_DPI},
+{"na" ,"e" , 34*PS_DPI, 44*PS_DPI},/*863.6x1117.6*/
+{"iso" ,"sra0" , 900/MMPI*PS_DPI, 1280/MMPI*PS_DPI},
+{"na" ,"arch-e" , 36*PS_DPI, 48*PS_DPI},/*914.4x1219.2*/
+{"iso" ,"c0" , 917/MMPI*PS_DPI, 1297/MMPI*PS_DPI},
+{"iso" ,"b0" , 1000/MMPI*PS_DPI, 1414/MMPI*PS_DPI},
+{"jis" ,"b0" , 1030/MMPI*PS_DPI, 1456/MMPI*PS_DPI},
+{"na" ,"f" , 44*PS_DPI, 68*PS_DPI},/*1117.6x1727.2*/
+{"iso" ,"2a0" , 1189/MMPI*PS_DPI, 1682/MMPI*PS_DPI},
+{"iso" ,"a0x3" , 1189/MMPI*PS_DPI, 2523/MMPI*PS_DPI},
+{"iso" ,"4a0" , 1682/MMPI*PS_DPI, 2378/MMPI*PS_DPI},
View Lorry Controller Status