Subversion Repositories planix.SVN

/*

  Copyright (C) 2001-2004 artofcode LLC.

  This software is provided AS-IS with no warranty, either express or

  implied.

  This software is distributed under license and may not be copied,

  modified or distributed except as expressly authorized under the terms

  of the license contained in the file LICENSE in this distribution.

  For more information about licensing, please refer to

  http://www.ghostscript.com/licensing/. For information on

  commercial licensing, go to http://www.artifex.com/licensing/ or

  contact Artifex Software, Inc., 101 Lucas Valley Road #110,

  San Rafael, CA  94903, U.S.A., +1(415)492-9861.

  Author: Raph Levien <raph@artofcode.com>

*/

/* $Id: gdevp14.c,v 1.35 2005/10/10 18:58:18 leonardo Exp $	*/

/* Compositing devices for implementing	PDF 1.4	imaging	model */

#include "math_.h"

#include "memory_.h"

#include "gx.h"

#include "gserrors.h"

#include "gscdefs.h"

#include "gxdevice.h"

#include "gsdevice.h"

#include "gsstruct.h"

#include "gxistate.h"

#include "gxdcolor.h"

#include "gxiparam.h"

#include "gstparam.h"

#include "gxblend.h"

#include "gxtext.h"

#include "gsdfilt.h"

#include "gsimage.h"

#include "gsrect.h"

#include "gzstate.h"

#include "gdevp14.h"

#include "gsovrc.h"

#include "gxcmap.h"

#include "gscolor1.h"

#include "gstrans.h"

#include "gsutil.h"

#include "gxcldev.h"

/* #define DUMP_TO_PNG */

#ifdef DUMP_TO_PNG

#include "png_.h"

#endif

# define INCR(v) DO_NOTHING

/* Buffer stack	data structure */

#define	PDF14_MAX_PLANES 16

/* GC procedures for buffer stack */

private

ENUM_PTRS_WITH(pdf14_buf_enum_ptrs, pdf14_buf *buf)

    return 0;

    case 0: return ENUM_OBJ(buf->saved);

    case 1: return ENUM_OBJ(buf->data);

    case 2: return ENUM_OBJ(buf->transfer_fn);

ENUM_PTRS_END

private

RELOC_PTRS_WITH(pdf14_buf_reloc_ptrs, pdf14_buf	*buf)

{

    RELOC_VAR(buf->saved);

    RELOC_VAR(buf->data);

    RELOC_VAR(buf->transfer_fn);

}

RELOC_PTRS_END

gs_private_st_composite(st_pdf14_buf, pdf14_buf, "pdf14_buf",

			pdf14_buf_enum_ptrs, pdf14_buf_reloc_ptrs);

gs_private_st_ptrs2(st_pdf14_ctx, pdf14_ctx, "pdf14_ctx",

		    pdf14_ctx_enum_ptrs, pdf14_ctx_reloc_ptrs,

		    stack, maskbuf);

/* ------ The device descriptors ------	*/

/*

 * Default X and Y resolution.

 */

#define	X_DPI 72

#define	Y_DPI 72

private	int pdf14_open(gx_device * pdev);

private	dev_proc_close_device(pdf14_close);

private	int pdf14_output_page(gx_device	* pdev,	int num_copies,	int flush);

private	dev_proc_put_params(pdf14_put_params);

private	dev_proc_encode_color(pdf14_encode_color);

private	dev_proc_decode_color(pdf14_decode_color);

private	dev_proc_fill_rectangle(pdf14_fill_rectangle);

private	dev_proc_fill_rectangle(pdf14_mark_fill_rectangle);

private	dev_proc_fill_rectangle(pdf14_mark_fill_rectangle_ko_simple);

private	dev_proc_fill_path(pdf14_fill_path);

private	dev_proc_stroke_path(pdf14_stroke_path);

private	dev_proc_begin_typed_image(pdf14_begin_typed_image);

private	dev_proc_text_begin(pdf14_text_begin);

private	dev_proc_create_compositor(pdf14_create_compositor);

private	dev_proc_create_compositor(pdf14_forward_create_compositor);

private	dev_proc_begin_transparency_group(pdf14_begin_transparency_group);

private	dev_proc_end_transparency_group(pdf14_end_transparency_group);

private	dev_proc_begin_transparency_mask(pdf14_begin_transparency_mask);

private	dev_proc_end_transparency_mask(pdf14_end_transparency_mask);

private	const gx_color_map_procs *

    pdf14_get_cmap_procs(const gs_imager_state *, const gx_device *);

#define	XSIZE (int)(8.5	* X_DPI)	/* 8.5 x 11 inch page, by default */

#define	YSIZE (int)(11 * Y_DPI)

/* 24-bit color. */

#define	pdf14_procs(get_color_mapping_procs, get_color_comp_index) \

{\

	pdf14_open,			/* open */\

	NULL,				/* get_initial_matrix */\

	NULL,				/* sync_output */\

	pdf14_output_page,		/* output_page */\

	pdf14_close,			/* close */\

	pdf14_encode_color,		/* rgb_map_rgb_color */\

	pdf14_decode_color,		/* gx_default_rgb_map_color_rgb */\

	pdf14_fill_rectangle,		/* fill_rectangle */\

	NULL,				/* tile_rectangle */\

	NULL,				/* copy_mono */\

	NULL,				/* copy_color */\

	NULL,				/* draw_line */\

	NULL,				/* get_bits */\

	NULL,				/* get_params */\

	pdf14_put_params,		/* put_params */\

	NULL,				/* map_cmyk_color */\

	NULL,				/* get_xfont_procs */\

	NULL,				/* get_xfont_device */\

	NULL,				/* map_rgb_alpha_color */\

	NULL,				/* get_page_device */\

	NULL,				/* get_alpha_bits */\

	NULL,				/* copy_alpha */\

	NULL,				/* get_band */\

	NULL,				/* copy_rop */\

	pdf14_fill_path,		/* fill_path */\

	pdf14_stroke_path,		/* stroke_path */\

	NULL,				/* fill_mask */\

	NULL,				/* fill_trapezoid */\

	NULL,				/* fill_parallelogram */\

	NULL,				/* fill_triangle */\

	NULL,				/* draw_thin_line */\

	NULL,				/* begin_image */\

	NULL,				/* image_data */\

	NULL,				/* end_image */\

	NULL,				/* strip_tile_rectangle */\

	NULL,				/* strip_copy_rop, */\

	NULL,				/* get_clipping_box */\

	pdf14_begin_typed_image,	/* begin_typed_image */\

	NULL,				/* get_bits_rectangle */\

	NULL,				/* map_color_rgb_alpha */\

	pdf14_create_compositor,	/* create_compositor */\

	NULL,				/* get_hardware_params */\

	pdf14_text_begin,		/* text_begin */\

	NULL,				/* finish_copydevice */\

	pdf14_begin_transparency_group,\

	pdf14_end_transparency_group,\

	pdf14_begin_transparency_mask,\

	pdf14_end_transparency_mask,\

	NULL,				/* discard_transparency_layer */\

	get_color_mapping_procs,	/* get_color_mapping_procs */\

	get_color_comp_index,		/* get_color_comp_index */\

	pdf14_encode_color,		/* encode_color */\

	pdf14_decode_color		/* decode_color */\

}

private	const gx_device_procs pdf14_Gray_procs =

	pdf14_procs(gx_default_DevGray_get_color_mapping_procs,

			gx_default_DevGray_get_color_comp_index);

private	const gx_device_procs pdf14_RGB_procs =

	pdf14_procs(gx_default_DevRGB_get_color_mapping_procs,

			gx_default_DevRGB_get_color_comp_index);

private	const gx_device_procs pdf14_CMYK_procs =

	pdf14_procs(gx_default_DevCMYK_get_color_mapping_procs,

			gx_default_DevCMYK_get_color_comp_index);

gs_private_st_composite_use_final(st_pdf14_device, pdf14_device, "pdf14_device",

				  pdf14_device_enum_ptrs, pdf14_device_reloc_ptrs,

			  gx_device_finalize);

const pdf14_device gs_pdf14_Gray_device	= {

    std_device_color_stype_body(pdf14_device, &pdf14_Gray_procs, "pdf14gray",

				&st_pdf14_device,

				XSIZE, YSIZE, X_DPI, Y_DPI, 8, 255, 256),

    { 0 }

};

const pdf14_device gs_pdf14_RGB_device = {

    std_device_color_stype_body(pdf14_device, &pdf14_RGB_procs, "pdf14RGB",

				&st_pdf14_device,

				XSIZE, YSIZE, X_DPI, Y_DPI, 24, 255, 256),

    { 0 }

};

const pdf14_device gs_pdf14_CMYK_device	= {

    std_device_std_color_full_body_type(pdf14_device, &pdf14_CMYK_procs,

	"PDF14cmyk", &st_pdf14_device, XSIZE, YSIZE, X_DPI, Y_DPI, 32,

	0, 0, 0, 0, 0, 0),

    { 0 }

};

/* GC procedures */

private	

ENUM_PTRS_WITH(pdf14_device_enum_ptrs, pdf14_device *pdev) return 0;

case 0:	return ENUM_OBJ(pdev->ctx);

case 1:	ENUM_RETURN(gx_device_enum_ptr(pdev->target));

ENUM_PTRS_END

private	RELOC_PTRS_WITH(pdf14_device_reloc_ptrs, pdf14_device *pdev)

{

    RELOC_VAR(pdev->ctx);

    pdev->target = gx_device_reloc_ptr(pdev->target, gcst);

}

RELOC_PTRS_END

/* ------ Private definitions ------ */

/**

 * pdf14_buf_new: Allocate a new PDF 1.4 buffer.

 * @n_chan: Number of pixel channels including alpha.

 *

 * Return value: Newly allocated buffer, or NULL on failure.

 **/

private	pdf14_buf *

pdf14_buf_new(gs_int_rect *rect, bool has_alpha_g, bool	has_shape,

	       int n_chan,

	       gs_memory_t *memory)

{

    pdf14_buf *result;

    int rowstride = (rect->q.x - rect->p.x + 3) & -4;

    int height = (rect->q.y - rect->p.y);

    int n_planes = n_chan + (has_shape ? 1 : 0) + (has_alpha_g ? 1 : 0);

    int planestride;

    double dsize = (((double) rowstride) * height) * n_planes;

    if (dsize > (double)max_uint)

      return NULL;

    result = gs_alloc_struct(memory, pdf14_buf, &st_pdf14_buf,

			     "pdf14_buf_new");

    if (result == NULL)

	return result;

    result->isolated = false;

    result->knockout = false;

    result->has_alpha_g = has_alpha_g;

    result->has_shape = has_shape;

    result->rect = *rect;

    result->n_chan = n_chan;

    result->n_planes = n_planes;

    result->rowstride = rowstride;

    result->transfer_fn = NULL;

    if (height < 0) {

	/* Empty clipping - will skip all drawings. */

	result->planestride = 0;

	result->data = 0;

    } else {

	planestride = rowstride * height;

	result->planestride = planestride;

	result->data = gs_alloc_bytes(memory, planestride * n_planes,

					"pdf14_buf_new");

	if (result->data == NULL) {

	    gs_free_object(memory, result, "pdf_buf_new");

	    return NULL;

	}

	if (has_alpha_g) {

	    int alpha_g_plane = n_chan + (has_shape ? 1 : 0);

	    memset (result->data + alpha_g_plane * planestride, 0, planestride);

	}

    }

    result->bbox.p.x = max_int;

    result->bbox.p.y = max_int;

    result->bbox.q.x = min_int;

    result->bbox.q.y = min_int;

    return result;

}

private	void

pdf14_buf_free(pdf14_buf *buf, gs_memory_t *memory)

{

    gs_free_object(memory, buf->transfer_fn, "pdf14_buf_free");

    gs_free_object(memory, buf->data, "pdf14_buf_free");

    gs_free_object(memory, buf, "pdf14_buf_free");

}

private	pdf14_ctx *

pdf14_ctx_new(gs_int_rect *rect, int n_chan, bool additive, gs_memory_t	*memory)

{

    pdf14_ctx *result;

    pdf14_buf *buf;

    result = gs_alloc_struct(memory, pdf14_ctx, &st_pdf14_ctx,

			     "pdf14_ctx_new");

    if (result == NULL)

	return result;

    buf = pdf14_buf_new(rect, false, false, n_chan, memory);

    if (buf == NULL) {

	gs_free_object(memory, result, "pdf14_ctx_new");

	return NULL;

    }

    if_debug3('v', "[v]base buf: %d x %d, %d channels\n",

	      buf->rect.q.x, buf->rect.q.y, buf->n_chan);

    memset(buf->data, 0, buf->planestride * buf->n_planes);

    buf->saved = NULL;

    result->stack = buf;

    result->maskbuf = NULL;

    result->n_chan = n_chan;

    result->memory = memory;

    result->rect = *rect;

    result->additive = additive;

    return result;

}

private	void

pdf14_ctx_free(pdf14_ctx *ctx)

{

    pdf14_buf *buf, *next;

    for (buf = ctx->stack; buf != NULL; buf = next) {

	next = buf->saved;

	pdf14_buf_free(buf, ctx->memory);

    }

    gs_free_object (ctx->memory, ctx, "pdf14_ctx_free");

}

/**

 * pdf14_find_backdrop_buf: Find backdrop buffer.

 *

 * Return value: Backdrop buffer for current group operation, or NULL

 * if backdrop is fully transparent.

 **/

private	pdf14_buf *

pdf14_find_backdrop_buf(pdf14_ctx *ctx)

{

    pdf14_buf *buf = ctx->stack;

    while (buf != NULL) {

	if (buf->isolated) return NULL;

	if (!buf->knockout) return buf->saved;

	buf = buf->saved;

    }

    /* this really shouldn't happen, as bottom-most buf should be

       non-knockout */

    return NULL;

}

private	int

pdf14_push_transparency_group(pdf14_ctx	*ctx, gs_int_rect *rect,

			      bool isolated, bool knockout,

			      byte alpha, byte shape,

			      gs_blend_mode_t blend_mode)

{

    pdf14_buf *tos = ctx->stack;

    pdf14_buf *buf, *backdrop;

    bool has_shape;

    /* todo: fix this hack, which makes all knockout groups isolated.

       For the vast majority of files, there won't be any visible

       effects, but it still isn't correct. The pixel compositing code

       for non-isolated knockout groups gets pretty hairy, which is

       why this is here. */

    if (knockout) 

	isolated = true;

    has_shape = tos->has_shape || tos->knockout;

    buf = pdf14_buf_new(rect, !isolated, has_shape, ctx->n_chan, ctx->memory);

    if_debug3('v', "[v]push buf: %d x %d, %d channels\n", buf->rect.p.x, buf->rect.p.y, buf->n_chan);

    if (buf == NULL)

	return_error(gs_error_VMerror);

    buf->isolated = isolated;

    buf->knockout = knockout;

    buf->alpha = alpha;

    buf->shape = shape;

    buf->blend_mode = blend_mode;

    buf->saved = tos;

    ctx->stack = buf;

    backdrop = pdf14_find_backdrop_buf(ctx);

    if (backdrop == NULL) {

	memset(buf->data, 0, buf->planestride * (buf->n_chan +

						 (buf->has_shape ? 1 : 0)));

    } else {

	/* make copy of backdrop for compositing */

	byte *buf_plane = buf->data;

	byte *tos_plane = tos->data + buf->rect.p.x - tos->rect.p.x +

	    (buf->rect.p.y - tos->rect.p.y) * tos->rowstride;

	int width = buf->rect.q.x - buf->rect.p.x;

	int y0 = buf->rect.p.y;

	int y1 = buf->rect.q.y;

	int i;

	int n_chan_copy = buf->n_chan + (tos->has_shape ? 1 : 0);

	for (i = 0; i < n_chan_copy; i++) {

	    byte *buf_ptr = buf_plane;

	    byte *tos_ptr = tos_plane;

	    int y;

	    for (y = y0; y < y1; ++y) {

		memcpy (buf_ptr, tos_ptr, width); 

		buf_ptr += buf->rowstride;

		tos_ptr += tos->rowstride;

	    }

	    buf_plane += buf->planestride;

	    tos_plane += tos->planestride;

	}

	if (has_shape && !tos->has_shape)

	    memset (buf_plane, 0, buf->planestride);

    }

    return 0;

}

private	int

pdf14_pop_transparency_group(pdf14_ctx *ctx)

{

    pdf14_buf *tos = ctx->stack;

    pdf14_buf *nos = tos->saved;

    pdf14_buf *maskbuf = ctx->maskbuf;

    int y0 = tos->rect.p.y;

    int y1 = tos->rect.q.y;

    if (y0 < y1) {

	int x0 = tos->rect.p.x;

	int x1 = tos->rect.q.x;

	int n_chan = ctx->n_chan;

	int num_comp = n_chan - 1;

	byte alpha = tos->alpha;

	byte shape = tos->shape;

	byte blend_mode = tos->blend_mode;

	byte *tos_ptr = tos->data;

	byte *nos_ptr = nos->data + x0 - nos->rect.p.x +

	    (y0 - nos->rect.p.y) * nos->rowstride;

	byte *mask_ptr = NULL;

	int tos_planestride = tos->planestride;

	int nos_planestride = nos->planestride;

	int mask_planestride = 0x0badf00d; /* Quiet compiler. */

	byte mask_bg_alpha = 0; /* Quiet compiler. */

	int width = x1 - x0;

	int x, y;

	int i;

	byte tos_pixel[PDF14_MAX_PLANES];

	byte nos_pixel[PDF14_MAX_PLANES];

	bool tos_isolated = tos->isolated;

	bool nos_knockout = nos->knockout;

	byte *nos_alpha_g_ptr;

	int tos_shape_offset = n_chan * tos_planestride;

	int tos_alpha_g_offset = tos_shape_offset +

	(tos->has_shape ? tos_planestride : 0);

	int nos_shape_offset = n_chan * nos_planestride;

	bool nos_has_shape = nos->has_shape;

	byte *mask_tr_fn = NULL; /* Quiet compiler. */

	bool additive = ctx->additive;

	if (nos == NULL)

	    return_error(gs_error_rangecheck);

	rect_merge(nos->bbox, tos->bbox);

	if_debug6('v', "pdf14_pop_transparency_group y0 = %d, y1 = %d, w = %d, alpha = %d, shape = %d, bm = %d\n",

			    y0, y1, width, alpha, shape, blend_mode);

	if (nos->has_alpha_g)

	    nos_alpha_g_ptr = nos_ptr + n_chan * nos_planestride;

	else

	    nos_alpha_g_ptr = NULL;

	if (maskbuf != NULL) {

	    mask_ptr = maskbuf->data + x0 - maskbuf->rect.p.x +

		    (y0 - maskbuf->rect.p.y) * maskbuf->rowstride;

	    mask_planestride = maskbuf->planestride;

	    mask_bg_alpha = maskbuf->alpha;

	    mask_tr_fn = maskbuf->transfer_fn;

	}

	for (y = y0; y < y1; ++y) {

	    for (x = 0; x < width; ++x) {

		byte pix_alpha = alpha;

		/* Complement the components for subtractive color spaces */

		if (additive) {

		    for (i = 0; i < n_chan; ++i) {

			tos_pixel[i] = tos_ptr[x + i * tos_planestride];

			nos_pixel[i] = nos_ptr[x + i * nos_planestride];

		    }

		} else {

		    for (i = 0; i < num_comp; ++i) {

			tos_pixel[i] = 255 - tos_ptr[x + i * tos_planestride];

			nos_pixel[i] = 255 - nos_ptr[x + i * nos_planestride];

		    }

		    tos_pixel[num_comp] = tos_ptr[x + num_comp * tos_planestride];

		    nos_pixel[num_comp] = nos_ptr[x + num_comp * nos_planestride];

		}

		if (mask_ptr != NULL) {

		    int mask_alpha = mask_ptr[x + num_comp * mask_planestride];

		    int tmp;

		    byte mask;

			/*

			* The mask data is really monochrome.  Thus for additive (RGB)

			* we use the R channel for alpha since R = G = B.  For

			* subtractive (CMYK) we use the K channel.

			*/

		    if (mask_alpha == 255) {

			/* todo: rgba->mask */

			mask = additive ? mask_ptr[x]

					: 255 - mask_ptr[x + 3 * mask_planestride];

		    } else if (mask_alpha == 0)

			mask = mask_bg_alpha;

		    else {

			int t2 = additive ? mask_ptr[x]

					: 255 - mask_ptr[x + 3 * mask_planestride];

			t2 = (t2 - mask_bg_alpha) * mask_alpha + 0x80;

			mask = mask_bg_alpha + ((t2 + (t2 >> 8)) >> 8);

		    }

		    mask = mask_tr_fn[mask];

		    tmp = pix_alpha * mask + 0x80;

		    pix_alpha = (tmp + (tmp >> 8)) >> 8;

		}

		if (nos_knockout) {

		    byte *nos_shape_ptr = nos_has_shape ?

			&nos_ptr[x + nos_shape_offset] : NULL;

		    byte tos_shape = tos_ptr[x + tos_shape_offset];

		    art_pdf_composite_knockout_isolated_8(nos_pixel,

							nos_shape_ptr,

							tos_pixel,

							n_chan - 1,

							tos_shape,

							pix_alpha, shape);

		} else if (tos_isolated) {

		    art_pdf_composite_group_8(nos_pixel, nos_alpha_g_ptr,

						tos_pixel,

						n_chan - 1,

						pix_alpha, blend_mode);

		} else {

		    byte tos_alpha_g = tos_ptr[x + tos_alpha_g_offset];

		    art_pdf_recomposite_group_8(nos_pixel, nos_alpha_g_ptr,

						tos_pixel, tos_alpha_g,

						n_chan - 1,

						pix_alpha, blend_mode);

		}

		if (nos_has_shape) {

		    nos_ptr[x + nos_shape_offset] =

			art_pdf_union_mul_8 (nos_ptr[x + nos_shape_offset],

						tos_ptr[x + tos_shape_offset],

						shape);

		}

		/* Complement the results for subtractive color spaces */

		if (additive) {

		    for (i = 0; i < n_chan; ++i) {

			nos_ptr[x + i * nos_planestride] = nos_pixel[i];

		    }

		} else {

		    for (i = 0; i < num_comp; ++i)

			nos_ptr[x + i * nos_planestride] = 255 - nos_pixel[i];

		    nos_ptr[x + num_comp * nos_planestride] = nos_pixel[num_comp];

		}

		if (nos_alpha_g_ptr != NULL)

		    ++nos_alpha_g_ptr;

	    }

	    tos_ptr += tos->rowstride;

	    nos_ptr += nos->rowstride;

	    if (nos_alpha_g_ptr != NULL)

		nos_alpha_g_ptr += nos->rowstride - width;

	    if (mask_ptr != NULL)

		mask_ptr += maskbuf->rowstride;

	}

    }

    ctx->stack = nos;

    if_debug0('v', "[v]pop buf\n");

    pdf14_buf_free(tos, ctx->memory);

    if (maskbuf != NULL) {

	pdf14_buf_free(maskbuf, ctx->memory);

	ctx->maskbuf = NULL;

    }

    return 0;

}

private	int

pdf14_push_transparency_mask(pdf14_ctx *ctx, gs_int_rect *rect,	byte bg_alpha,

			     byte *transfer_fn)

{

    pdf14_buf *buf;

    if_debug0('v', "[v]pdf_push_transparency_mask\n");

    buf = pdf14_buf_new(rect, false, false, ctx->n_chan, ctx->memory);

    if (buf == NULL)

	return_error(gs_error_VMerror);

    /* fill in, but these values aren't really used */

    buf->isolated = true;

    buf->knockout = false;

    buf->alpha = bg_alpha;

    buf->shape = 0xff;

    buf->blend_mode = BLEND_MODE_Normal;

    buf->transfer_fn = transfer_fn;

    buf->saved = ctx->stack;

    ctx->stack = buf;

    memset(buf->data, 0, buf->planestride * buf->n_chan);

    return 0;

}

private	int

pdf14_pop_transparency_mask(pdf14_ctx *ctx)

{

    pdf14_buf *tos = ctx->stack;

    ctx->stack = tos->saved;

    ctx->maskbuf = tos;

    return 0;

}

private	int

pdf14_open(gx_device *dev)

{

    pdf14_device *pdev = (pdf14_device *)dev;

    gs_int_rect rect;

    if_debug2('v', "[v]pdf14_open: width = %d, height = %d\n",

	     dev->width, dev->height);

    rect.p.x = 0;

    rect.p.y = 0;

    rect.q.x = dev->width;

    rect.q.y = dev->height;

    pdev->ctx = pdf14_ctx_new(&rect, dev->color_info.num_components + 1,

	pdev->color_info.polarity != GX_CINFO_POLARITY_SUBTRACTIVE, dev->memory);

    if (pdev->ctx == NULL)

	return_error(gs_error_VMerror);

    return 0;

}

/*

 * Encode a list of colorant values into a gx_color_index_value.

 */

private	gx_color_index

pdf14_encode_color(gx_device *dev, const gx_color_value	colors[])

{

    int drop = sizeof(gx_color_value) * 8 - 8;

    gx_color_index color = 0;

    int i;

    int ncomp = dev->color_info.num_components;

    for (i = 0; i < ncomp; i++) {

	color <<= 8;

	color |= (colors[i] >> drop);

    }

    return (color == gx_no_color_index ? color ^ 1 : color);

}

/*

 * Decode a gx_color_index value back to a list of colorant values.

 */

private	int

pdf14_decode_color(gx_device * dev, gx_color_index color, gx_color_value * out)

{

    int i;

    int ncomp = dev->color_info.num_components;

    for (i = 0; i < ncomp; i++) {

	out[ncomp - i - 1] = (gx_color_value) ((color & 0xff) * 0x101);

	color >>= 8;

    }

    return 0;

}

#ifdef DUMP_TO_PNG

/* Dumps a planar RGBA image to	a PNG file. */

private	int

dump_planar_rgba(gs_memory_t *mem, 

		 const byte *buf, int width, int height, int rowstride, int planestride)

{

    int rowbytes = width << 2;

    byte *row = gs_malloc(mem, rowbytes, 1, "png raster buffer");

    png_struct *png_ptr =

    png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);

    png_info *info_ptr =

    png_create_info_struct(png_ptr);

    const char *software_key = "Software";

    char software_text[256];

    png_text text_png;

    const byte *buf_ptr = buf;

    FILE *file;

    int code;

    int y;

	file = fopen ("c:\\temp\\tmp.png", "wb");

    if_debug0('v', "[v]pnga_output_page\n");

    if (row == 0 || png_ptr == 0 || info_ptr == 0) {

	code = gs_note_error(gs_error_VMerror);

	goto done;

    }

    /* set error handling */

    if (setjmp(png_ptr->jmpbuf)) {

	/* If we get here, we had a problem reading the file */

	code = gs_note_error(gs_error_VMerror);

	goto done;

    }

    code = 0;			/* for normal path */

    /* set up the output control */

    png_init_io(png_ptr, file);

    /* set the file information here */

    info_ptr->width = width;

    info_ptr->height = height;

    /* resolution is in pixels per meter vs. dpi */

    info_ptr->x_pixels_per_unit =

	(png_uint_32) (96.0 * (100.0 / 2.54));

    info_ptr->y_pixels_per_unit =

	(png_uint_32) (96.0 * (100.0 / 2.54));

    info_ptr->phys_unit_type = PNG_RESOLUTION_METER;

    info_ptr->valid |= PNG_INFO_pHYs;

    /* At present, only supporting 32-bit rgba */

    info_ptr->bit_depth = 8;

    info_ptr->color_type = PNG_COLOR_TYPE_RGB_ALPHA;

    /* add comment */

    sprintf(software_text, "%s %d.%02d", gs_product,

	    (int)(gs_revision / 100), (int)(gs_revision % 100));

    text_png.compression = -1;	/* uncompressed */

    text_png.key = (char *)software_key;	/* not const, unfortunately */

    text_png.text = software_text;

    text_png.text_length = strlen(software_text);

    info_ptr->text = &text_png;

    info_ptr->num_text = 1;

    /* write the file information */

    png_write_info(png_ptr, info_ptr);

    /* don't write the comments twice */

    info_ptr->num_text = 0;

    info_ptr->text = NULL;

    /* Write the contents of the image. */

    for (y = 0; y < height; ++y) {

	int x;

	for (x = 0; x < width; ++x) {

	    row[(x << 2)] = buf_ptr[x];

	    row[(x << 2) + 1] = buf_ptr[x + planestride];

	    row[(x << 2) + 2] = buf_ptr[x + planestride * 2];

	    row[(x << 2) + 3] = buf_ptr[x + planestride * 3];

	}

	png_write_row(png_ptr, row);

	buf_ptr += rowstride;

    }

    /* write the rest of the file */

    png_write_end(png_ptr, info_ptr);

  done:

    /* free the structures */

    png_destroy_write_struct(&png_ptr, &info_ptr);

    gs_free(mem, row, rowbytes, 1, "png raster buffer");

    fclose (file);

    return code;

}

#endif

/**

 * pdf14_put_image: Put rendered image to target device.

 * @pdev: The PDF 1.4 rendering device.

 * @pgs: State for image draw operation.

 * @target: The target device.

 *

 * Puts the rendered image in @pdev's buffer to @target. This is called

 * as part of the sequence of popping the PDF 1.4 device filter.

 *

 * Return code: negative on error.

 **/

private	int

pdf14_put_image(pdf14_device *pdev, gs_imager_state *pis, gx_device *target)

{

    int code;

    gs_image1_t image;

    gs_matrix pmat;

    gx_image_enum_common_t *info;

    int width = pdev->width;

    int height = pdev->height;

    int y;

    pdf14_buf *buf = pdev->ctx->stack;

    int planestride = buf->planestride;

    int num_comp = buf->n_chan - 1;

    byte *buf_ptr = buf->data;

    byte *linebuf;

    gs_color_space cs;

    const byte bg = pdev->ctx->additive ? 255 : 0;

#ifdef DUMP_TO_PNG

    dump_planar_rgba(pdev->memory, buf_ptr, width, height,

		     buf->rowstride, buf->planestride);

#endif

#if 0

    /* Set graphics state device to target, so that image can set up

       the color mapping properly. */

    rc_increment(pdev);

    gs_setdevice_no_init(pgs, target);

#endif

    if_debug0('v', "[v]pdf14_put_image\n");

    /*

     * Set color space to either Gray, RGB, or CMYK in preparation for sending

     * an image.

     */

    switch (num_comp) {

	case 1:				/* DeviceGray */

	    gs_cspace_init_DeviceGray(pis->memory, &cs);

	    break;

	case 3:				/* DeviceRGB */

	    gs_cspace_init_DeviceRGB(pis->memory, &cs);

	    break;

	case 4:				/* DeviceCMYK */

	    gs_cspace_init_DeviceCMYK(pis->memory, &cs);

	    break;

	default:			/* Should never occur */

	    return_error(gs_error_rangecheck);

	    break;

    }

    gs_image_t_init_adjust(&image, &cs, false);

    image.ImageMatrix.xx = (float)width;

    image.ImageMatrix.yy = (float)height;

    image.Width = width;

    image.Height = height;

    image.BitsPerComponent = 8;

    pmat.xx = (float)width;

    pmat.xy = 0;

    pmat.yx = 0;

    pmat.yy = (float)height;

    pmat.tx = 0;

    pmat.ty = 0;

    code = dev_proc(target, begin_typed_image) (target,

						pis, &pmat,

						(gs_image_common_t *)&image,

						NULL, NULL, NULL,

						pis->memory, &info);

    if (code < 0)

	return code;

    linebuf = gs_alloc_bytes(pdev->memory, width * num_comp, "pdf14_put_image");

    for (y = 0; y < height; y++) {

	gx_image_plane_t planes;

	int x;

	int rows_used;

	for (x = 0; x < width; x++) {

	    byte comp, a;

	    int tmp, comp_num;

	    /* composite RGBA (or CMYKA, etc.) pixel with over solid background */

	    a = buf_ptr[x + planestride * num_comp];