Subversion Repositories planix.SVN

/* Copyright (C) 1998, 1999 Aladdin Enterprises.  All rights reserved.

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

  implied.

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

  modified or distributed except as expressly authorized under the terms

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

  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.

*/

/* $Id: gdevplnx.c,v 1.10 2004/08/04 19:36:12 stefan Exp $*/

/* Plane extraction device */

#include "gx.h"

#include "gserrors.h"

#include "gsbitops.h"

#include "gsrop.h"		/* for logical op access */

#include "gsstruct.h"

#include "gsutil.h"

#include "gxdcolor.h"

#include "gxcmap.h"		/* requires gxdcolor.h */

#include "gxdevice.h"

#include "gxdevmem.h"

#include "gxdither.h"

#include "gxgetbit.h"

#include "gxiparam.h"

#include "gxistate.h"

#include "gdevplnx.h"

/* Define the size of the locally allocated bitmap buffers. */

#define COPY_COLOR_BUF_SIZE 100

#define TILE_RECTANGLE_BUF_SIZE 100

#define COPY_ROP_SOURCE_BUF_SIZE 100

#define COPY_ROP_TEXTURE_BUF_SIZE 100

/* GC procedures */

private 

ENUM_PTRS_WITH(device_plane_extract_enum_ptrs, gx_device_plane_extract *edev)

    ENUM_PREFIX(st_device_forward, 1);

case 0: ENUM_RETURN(gx_device_enum_ptr(edev->target));

ENUM_PTRS_END

private RELOC_PTRS_WITH(device_plane_extract_reloc_ptrs, gx_device_plane_extract *edev)

{

    RELOC_PREFIX(st_device_forward);

    edev->plane_dev = gx_device_reloc_ptr(edev->plane_dev, gcst);

}

RELOC_PTRS_END

public_st_device_plane_extract();

/* Driver procedures */

private dev_proc_open_device(plane_open_device);

private dev_proc_fill_rectangle(plane_fill_rectangle);

private dev_proc_copy_mono(plane_copy_mono);

private dev_proc_copy_color(plane_copy_color);

private dev_proc_copy_alpha(plane_copy_alpha);

private dev_proc_fill_path(plane_fill_path);

private dev_proc_stroke_path(plane_stroke_path);

private dev_proc_fill_mask(plane_fill_mask);

private dev_proc_fill_parallelogram(plane_fill_parallelogram);

private dev_proc_fill_triangle(plane_fill_triangle);

private dev_proc_strip_tile_rectangle(plane_strip_tile_rectangle);

private dev_proc_strip_copy_rop(plane_strip_copy_rop);

private dev_proc_begin_typed_image(plane_begin_typed_image);

private dev_proc_get_bits_rectangle(plane_get_bits_rectangle);

/* Device prototype */

private const gx_device_plane_extract gs_plane_extract_device = {

    std_device_std_body(gx_device_plane_extract, 0, "plane_extract",

			0, 0, 72, 72),

    {

	plane_open_device,

	NULL,

	NULL,

	NULL,

	gx_default_close_device,

	NULL,

	NULL,

	plane_fill_rectangle,

	gx_default_tile_rectangle,

	plane_copy_mono,

	plane_copy_color,

	gx_default_draw_line,

	gx_default_get_bits,

	NULL,

	NULL,

	NULL,

	NULL,

	NULL,

	NULL,

	NULL,

	NULL,

	plane_copy_alpha,

	NULL,

	gx_default_copy_rop,

	plane_fill_path,

	plane_stroke_path,

	plane_fill_mask,

	gx_default_fill_trapezoid,

	plane_fill_parallelogram,

	plane_fill_triangle,

	gx_default_draw_thin_line,

	gx_default_begin_image,

	gx_default_image_data,

	gx_default_end_image,

	plane_strip_tile_rectangle,

	plane_strip_copy_rop,

	NULL,

	plane_begin_typed_image,

	plane_get_bits_rectangle,

	NULL,

	gx_no_create_compositor, /* WRONG */

	NULL,

	gx_default_text_begin

    },

    /* device-specific members */

    NULL,				/* target */

    NULL,				/* plane_dev */

    { 0 },				/* plane */

    0,					/* plane_white */

    0,					/* plane_mask */

    0,					/* plane_dev_is_memory */

    1 /*true*/				/* any_marks */

};

/* ---------------- Utilities ---------------- */

/* Extract the selected plane from a color (gx_color_index). */

#define COLOR_PIXEL(edev, color)\

  ( ((color) >> (edev)->plane.shift) & (edev)->plane_mask )

/* Do the same if the color might be transparent. */

#define TRANS_COLOR_PIXEL(edev, color)\

 ((color) == gx_no_color_index ? gx_no_color_index : COLOR_PIXEL(edev, color))

/*

 * Reduce the drawing color to one for the selected plane.

 * All we care about is whether the drawing operation should be skipped.

 */

typedef enum {

    REDUCE_SKIP,

    REDUCE_DRAW,

    REDUCE_FAILED			/* couldn't reduce */

} reduced_color_t;

#define REDUCE_PURE(edev, pixel)\

  ((pixel) == (edev)->plane_white && !(edev)->any_marks ?  REDUCE_SKIP :\

   ((edev)->any_marks = true, REDUCE_DRAW))

private reduced_color_t

reduce_drawing_color(gx_device_color *ppdc, gx_device_plane_extract *edev,

		     const gx_drawing_color *pdevc,

		     gs_logical_operation_t *plop)

{

    reduced_color_t reduced;

    if (gx_dc_is_pure(pdevc)) {

	gx_color_index pixel = COLOR_PIXEL(edev, gx_dc_pure_color(pdevc));

	set_nonclient_dev_color(ppdc, pixel);

	reduced = REDUCE_PURE(edev, pixel);

    } else if (gx_dc_is_binary_halftone(pdevc)) {

	gx_color_index pixel0 =

	    TRANS_COLOR_PIXEL(edev, gx_dc_binary_color0(pdevc));

	gx_color_index pixel1 =

	    TRANS_COLOR_PIXEL(edev, gx_dc_binary_color1(pdevc));

	if (pixel0 == pixel1) {

	    set_nonclient_dev_color(ppdc, pixel0);

	    reduced = REDUCE_PURE(edev, pixel0);

	} else {

	    *ppdc = *pdevc;

	    ppdc->colors.binary.color[0] = pixel0;

	    ppdc->colors.binary.color[1] = pixel1;

	    edev->any_marks = true;

	    reduced = REDUCE_DRAW;

	}

    } else if (color_is_colored_halftone(pdevc)) {

	int plane = edev->plane.index;

	int i;

	*ppdc = *pdevc;

	for (i = 0; i < countof(ppdc->colors.colored.c_base); ++i)

	    if (i != edev->plane.index) {

		ppdc->colors.colored.c_base[i] = 0;

		ppdc->colors.colored.c_level[i] = 0;

	    }

	ppdc->colors.colored.plane_mask &= 1 << plane;

	if (ppdc->colors.colored.c_level[plane] == 0) {

	    gx_devn_reduce_colored_halftone(ppdc, (gx_device *)edev);

	    ppdc->colors.pure = COLOR_PIXEL(edev, ppdc->colors.pure);

	    reduced = REDUCE_PURE(edev, gx_dc_pure_color(ppdc));

	} else if (ppdc->colors.colored.alpha != gx_max_color_value)

	    return REDUCE_FAILED; /* can't reduce */

	else {

	    gx_devn_reduce_colored_halftone(ppdc, (gx_device *)edev);

	    ppdc->colors.binary.color[0] =

		COLOR_PIXEL(edev, ppdc->colors.binary.color[0]);

	    ppdc->colors.binary.color[1] =

		COLOR_PIXEL(edev, ppdc->colors.binary.color[1]);

	    gx_color_load(ppdc, NULL, (gx_device *)edev);

	    edev->any_marks = true;

	    reduced = REDUCE_DRAW;

	}

    } else

	return REDUCE_FAILED;		/* can't handle it */

    if (*plop & lop_T_transparent) {

	/*

	 * If the logical operation invokes transparency for the texture, we

	 * must do some extra work, since a color that was originally opaque

	 * may become transparent (white) if reduced to a single plane.  If

	 * RasterOp transparency were calculated before halftoning, life

	 * would be easy: we would simply turn off texture transparency in

	 * the logical operation iff the original (not reduced) color was

	 * not white.  Unfortunately, RasterOp transparency is calculated

	 * after halftoning.  (This is arguably wrong, but it's how we've

	 * defined it.)  Therefore, if transparency is involved with a

	 * white color or a halftone that can include white, we must keep

	 * the entire pixel together for the RasterOp.

	 */

	gx_color_index white = gx_device_white((gx_device *)edev);

	/*

	 * Given that we haven't failed, the only possible colors at this

	 * point are pure or binary halftone.

	 */

	if (gx_dc_is_pure(ppdc)) {

	    if (gx_dc_pure_color(pdevc) != white)

		*plop &= ~lop_T_transparent;

	    else if (!gx_dc_is_pure(pdevc))

		return REDUCE_FAILED;

	} else {

	    if (gx_dc_binary_color0(pdevc) != white &&

		gx_dc_binary_color1(pdevc) != white) {

		*plop &= ~lop_T_transparent;

	    } else

		return REDUCE_FAILED;

	}

    }

    return reduced;

}

/*

 * Set up to create the plane-extracted bitmap corresponding to a

 * source or halftone pixmap.  If the bitmap doesn't fit in the locally

 * allocated buffer, we may either do the operation in pieces, or allocate

 * a buffer on the heap.  The control structure is:

 *	begin_tiling(&state, ...);

 *	do {

 *	    extract_partial_tile(&state);

 *	    ... process tile in buffer ...

 *	} while (next_tile(&state));

 *	end_tiling(&state);

 * If partial_ok is false, there is only a single tile, so the do ... while

 * is not used.

 */

typedef struct tiling_state_s {

	/* Save the original operands. */

    const gx_device_plane_extract *edev;

    const byte *data;

    int data_x;

    uint raster;

    int width, height;

    int dest_x;			/* only for copy_color, defaults to 0 */

	/* Define the (aligned) buffer for doing the operation. */

    struct tsb_ {

	byte *data;

	uint size;

	uint raster;

	bool on_heap;

    } buffer;

	/* Record the current tile available for processing. */

	/* The client may read these out. */

    gs_int_point offset;

    gs_int_point size;

	/* Record private tiling parameters. */

    int per_tile_width;

} tiling_state_t;

/*

 * Extract the plane's data from one subrectangle of a source tile.

 */

inline private int /* ignore the return value */

extract_partial_tile(const tiling_state_t *pts)

{

    const gx_device_plane_extract * const edev = pts->edev;

    bits_plane_t dest, source;

    dest.data.write = pts->buffer.data + pts->offset.y * pts->buffer.raster;

    dest.raster = pts->buffer.raster;

    dest.depth = edev->plane.depth;

    dest.x = pts->dest_x;

    source.data.read = pts->data + pts->offset.y * pts->raster;

    source.raster = pts->raster;

    source.depth = edev->color_info.depth;

    source.x = pts->data_x + pts->offset.x;

    bits_extract_plane(&dest, &source, edev->plane.shift,

		       pts->size.x, pts->size.y);

    return 0;

}

/*

 * Set up to start (possibly) tiling.  Return 0 if the entire tile fit,

 * 1 if a partial tile fit, or a negative error code.

 */

private int

begin_tiling(tiling_state_t *pts, gx_device_plane_extract *edev,

    const byte *data, int data_x, uint raster, int width, int height,

    byte *local_buffer, uint buffer_size, bool partial_ok)

{

    uint width_raster =

	bitmap_raster(width * edev->plane_dev->color_info.depth);

    uint full_size = width_raster * height;

    pts->edev = edev;

    pts->data = data, pts->data_x = data_x, pts->raster = raster;

    pts->width = width, pts->height = height;

    pts->dest_x = 0;

    if (full_size <= buffer_size) {

	pts->buffer.data = local_buffer;

	pts->buffer.size = buffer_size;

	pts->buffer.raster = width_raster;

	pts->buffer.on_heap = false;

	pts->size.x = width, pts->size.y = height;

    } else if (partial_ok) {

	pts->buffer.data = local_buffer;

	pts->buffer.size = buffer_size;

	pts->buffer.on_heap = false;

	if (buffer_size >= width_raster) {

	    pts->buffer.raster = width_raster;

	    pts->size.x = width;

	    pts->size.y = buffer_size / width_raster;

	} else {

	    pts->buffer.raster = buffer_size & -align_bitmap_mod;

	    pts->size.x =

		pts->buffer.raster * (8 / edev->plane_dev->color_info.depth);

	    pts->size.y = 1;

	}

    } else {

	pts->buffer.data =

	    gs_alloc_bytes(edev->memory, full_size, "begin_tiling");

	if (!pts->buffer.data)

	    return_error(gs_error_VMerror);

	pts->buffer.size = full_size;

	pts->buffer.raster = width_raster;

	pts->buffer.on_heap = true;

	pts->size.x = width, pts->size.y = height;

    }

    pts->buffer.raster = width_raster;

    pts->offset.x = pts->offset.y = 0;

    pts->per_tile_width = pts->size.x;

    return pts->buffer.size < full_size;

}

/*

 * Advance to the next tile.  Return true if there are more tiles to do.

 */

private bool

next_tile(tiling_state_t *pts)

{

    if ((pts->offset.x += pts->size.x) >= pts->width) {

	if ((pts->offset.y += pts->size.y) >= pts->height)

	    return false;

	pts->offset.x = 0;

	pts->size.x = pts->per_tile_width;

	if (pts->offset.y + pts->size.y >= pts->height)

	    pts->size.y = pts->height - pts->offset.y;

    } else if (pts->offset.x + pts->size.x >= pts->width)

	pts->size.x = pts->width - pts->offset.x;

    return true;

}

/*

 * Finish tiling by freeing the buffer if necessary.

 */

private void

end_tiling(tiling_state_t *pts)

{

    if (pts->buffer.on_heap)

	gs_free_object(pts->edev->memory, pts->buffer.data, "end_tiling");

}

/* ---------------- Initialization ---------------- */

int

plane_device_init(gx_device_plane_extract *edev, gx_device *target,

    gx_device *plane_dev, const gx_render_plane_t *render_plane, bool clear)

{

    /* Check for compatibility of the plane specification. */

    if (render_plane->depth > plane_dev->color_info.depth)

	return_error(gs_error_rangecheck);

    gx_device_init((gx_device *)edev,

		   (const gx_device *)&gs_plane_extract_device,

		   edev->memory, true);

    check_device_separable((gx_device *)edev);

    gx_device_forward_fill_in_procs((gx_device_forward *)edev);

    gx_device_set_target((gx_device_forward *)edev, target);

    gx_device_copy_params((gx_device *)edev, target);

    edev->plane_dev = plane_dev;

    edev->plane = *render_plane;

    plane_open_device((gx_device *)edev);

    if (clear) {

	dev_proc(plane_dev, fill_rectangle)

	    (plane_dev, 0, 0, plane_dev->width, plane_dev->height,

	     edev->plane_white);

	edev->any_marks = false;

    }

    return 0;

}

/* ---------------- Driver procedures ---------------- */

private int

plane_open_device(gx_device *dev)

{

    gx_device_plane_extract * const edev = (gx_device_plane_extract *)dev;

    gx_device * const plane_dev = edev->plane_dev;

    int plane_depth = plane_dev->color_info.depth;

    const gx_device_memory * const mdproto =

	gdev_mem_device_for_bits(plane_depth);

    edev->plane_white = gx_device_white(plane_dev);

    edev->plane_mask = (1 << plane_depth) - 1;

    edev->plane_dev_is_memory = mdproto != 0 &&

	dev_proc(plane_dev, copy_color) == dev_proc(mdproto, copy_color);

    /* We don't set or clear any_marks here: see ...init above. */

    return 0;

}

private int

plane_fill_rectangle(gx_device *dev,

    int x, int y, int w, int h, gx_color_index color)

{

    gx_device_plane_extract * const edev = (gx_device_plane_extract *)dev;

    gx_device * const plane_dev = edev->plane_dev;

    gx_color_index pixel = COLOR_PIXEL(edev, color);

    if (pixel != edev->plane_white)

	edev->any_marks = true;

    else if (!edev->any_marks)

	return 0;

    return dev_proc(plane_dev, fill_rectangle)

	(plane_dev, x, y, w, h, pixel);

}

private int

plane_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 color0, gx_color_index color1)

{

    gx_device_plane_extract * const edev = (gx_device_plane_extract *)dev;

    gx_device * const plane_dev = edev->plane_dev;

    gx_color_index pixel0 = TRANS_COLOR_PIXEL(edev, color0);

    gx_color_index pixel1 = TRANS_COLOR_PIXEL(edev, color1);

    if (pixel0 == pixel1)

	return plane_fill_rectangle(dev, x, y, w, h, color0);

    if ((pixel0 == edev->plane_white || pixel0 == gx_no_color_index) &&

	(pixel1 == edev->plane_white || pixel1 == gx_no_color_index)) {

	/* This operation will only write white. */

	if (!edev->any_marks)

	    return 0;

    } else

	edev->any_marks = true;

    return dev_proc(plane_dev, copy_mono)

	(plane_dev, data, data_x, raster, id, x, y, w, h, pixel0, pixel1);

}

private int

plane_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_plane_extract * const edev = (gx_device_plane_extract *)dev;

    gx_device * const plane_dev = edev->plane_dev;

    tiling_state_t state;

    long buf[COPY_COLOR_BUF_SIZE / sizeof(long)];

    int code;

    if (edev->plane_dev_is_memory) {

	/* Reduce the source directly into the plane device. */

	gx_device_memory * const mdev = (gx_device_memory *)plane_dev;

	fit_copy(edev, data, data_x, raster, id, x, y, w, h);

	code = begin_tiling(&state, edev, data, data_x, raster, w, h,

			    scan_line_base(mdev, y), max_uint, false);

	if (code < 0)

	    return code;

	state.dest_x = x;

	state.buffer.raster = mdev->raster;

	extract_partial_tile(&state);

	end_tiling(&state);

	edev->any_marks = true;

	return 0;

    }

    code = begin_tiling(&state, edev, data, data_x, raster,

			w, h, (byte *)buf, sizeof(buf), true);

    if (code < 0)

	return code;

    do {

	extract_partial_tile(&state);

	code = dev_proc(plane_dev, copy_color)

	    (plane_dev, state.buffer.data, 0, state.buffer.raster,

	     gx_no_bitmap_id, x + state.offset.x, y + state.offset.y,

	     state.size.x, state.size.y);

    } while (code >= 0 && next_tile(&state));

    end_tiling(&state);

    edev->any_marks = true;

    return code;

}

private int

plane_copy_alpha(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 color, int depth)

{

    gx_device_plane_extract * const edev = (gx_device_plane_extract *)dev;

    gx_device * const plane_dev = edev->plane_dev;

    gx_color_index pixel = COLOR_PIXEL(edev, color);

    if (pixel != edev->plane_white)

	edev->any_marks = true;

    else if (!edev->any_marks)

	return 0;

    return dev_proc(plane_dev, copy_alpha)

	(plane_dev, data, data_x, raster, id, x, y, w, h, pixel, depth);

}

private int

plane_fill_path(gx_device *dev,

    const gs_imager_state *pis, gx_path *ppath,

    const gx_fill_params *params,

    const gx_drawing_color *pdevc, const gx_clip_path *pcpath)

{

    gx_device_plane_extract * const edev = (gx_device_plane_extract *)dev;

    gx_device * const plane_dev = edev->plane_dev;

    gs_logical_operation_t lop_orig =

	gs_current_logical_op((const gs_state *)pis);

    gs_logical_operation_t lop = lop_orig;

    gx_device_color dcolor;

    switch (reduce_drawing_color(&dcolor, edev, pdevc, &lop)) {

    case REDUCE_SKIP:

	return 0;

    case REDUCE_DRAW: {

	gs_imager_state lopis;

	const gs_imager_state *pis_draw = pis;

	if (lop != lop_orig) {

	    lopis = *pis;

	    gs_set_logical_op((gs_state *)&lopis, lop);

	    pis_draw = &lopis;

	}

	return dev_proc(plane_dev, fill_path)

	    (plane_dev, pis_draw, ppath, params, &dcolor, pcpath);

    }

    default /*REDUCE_FAILED*/:

	return gx_default_fill_path(dev, pis, ppath, params, pdevc, pcpath);

    }

}

private int

plane_stroke_path(gx_device *dev,

    const gs_imager_state *pis, gx_path *ppath,

    const gx_stroke_params *params,

    const gx_drawing_color *pdevc, const gx_clip_path *pcpath)

{

    gx_device_plane_extract * const edev = (gx_device_plane_extract *)dev;

    gx_device * const plane_dev = edev->plane_dev;

    gs_logical_operation_t lop_orig =

	gs_current_logical_op((const gs_state *)pis);

    gs_logical_operation_t lop = lop_orig;

    gx_device_color dcolor;

    switch (reduce_drawing_color(&dcolor, edev, pdevc, &lop)) {

    case REDUCE_SKIP:

	return 0;

    case REDUCE_DRAW: {

	gs_imager_state lopis;

	const gs_imager_state *pis_draw = pis;

	if (lop != lop_orig) {

	    lopis = *pis;

	    gs_set_logical_op((gs_state *)&lopis, lop);

	    pis_draw = &lopis;

	}

	return dev_proc(plane_dev, stroke_path)

	    (plane_dev, pis_draw, ppath, params, &dcolor, pcpath);

    }

    default /*REDUCE_FAILED*/:

	return gx_default_stroke_path(dev, pis, ppath, params, pdevc, pcpath);

    }

}

private int

plane_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)

{

    gx_device_plane_extract * const edev = (gx_device_plane_extract *)dev;

    gx_device * const plane_dev = edev->plane_dev;

    gx_device_color dcolor;

    switch (reduce_drawing_color(&dcolor, edev, pdcolor, &lop)) {

    case REDUCE_SKIP:

	return 0;

    case REDUCE_DRAW:

	return dev_proc(plane_dev, fill_mask)

	    (plane_dev, data, data_x, raster, gx_no_bitmap_id, x, y, w, h,

	     &dcolor, depth, lop, pcpath);

    default /*REDUCE_FAILED*/:

	return gx_default_fill_mask(dev, data, data_x, raster, gx_no_bitmap_id,

				    x, y, w, h, &dcolor, depth, lop, pcpath);

    }

}

private int

plane_fill_parallelogram(gx_device * dev,

    fixed px, fixed py, fixed ax, fixed ay, fixed bx, fixed by,

    const gx_drawing_color * pdcolor, gs_logical_operation_t lop)

{

    gx_device_plane_extract * const edev = (gx_device_plane_extract *)dev;

    gx_device * const plane_dev = edev->plane_dev;

    gx_device_color dcolor;

    switch (reduce_drawing_color(&dcolor, edev, pdcolor, &lop)) {

    case REDUCE_SKIP:

	return 0;

    case REDUCE_DRAW:

	return dev_proc(plane_dev, fill_parallelogram)

	    (plane_dev, px, py, ax, ay, bx, by, &dcolor, lop);

    default /*REDUCE_FAILED*/:

	return gx_default_fill_parallelogram(dev, px, py, ax, ay, bx, by,

					     pdcolor, lop);

    }

}

private int

plane_fill_triangle(gx_device * dev,

    fixed px, fixed py, fixed ax, fixed ay, fixed bx, fixed by,

    const gx_drawing_color * pdcolor, gs_logical_operation_t lop)

{

    gx_device_plane_extract * const edev = (gx_device_plane_extract *)dev;

    gx_device * const plane_dev = edev->plane_dev;

    gx_device_color dcolor;

    switch (reduce_drawing_color(&dcolor, edev, pdcolor, &lop)) {

    case REDUCE_SKIP:

	return 0;

    case REDUCE_DRAW:

	return dev_proc(plane_dev, fill_triangle)

	    (plane_dev, px, py, ax, ay, bx, by, &dcolor, lop);

    default /*REDUCE_FAILED*/:

	return gx_default_fill_triangle(dev, px, py, ax, ay, bx, by,

					pdcolor, lop);

    }

}

private int

plane_strip_tile_rectangle(gx_device *dev,

    const gx_strip_bitmap *tiles, int x, int y, int w, int h,

    gx_color_index color0, gx_color_index color1,

    int phase_x, int phase_y)

{

    gx_device_plane_extract * const edev = (gx_device_plane_extract *)dev;

    gx_device * const plane_dev = edev->plane_dev;

    gx_color_index pixel0 = TRANS_COLOR_PIXEL(edev, color0);

    gx_color_index pixel1 = TRANS_COLOR_PIXEL(edev, color1);

    if (pixel0 == pixel1) {

	if (pixel0 != gx_no_color_index)

	    return plane_fill_rectangle(dev, x, y, w, h, color0);

	/* The tile is a pixmap rather than a bitmap. */

	/* We should use the default implementation if it is small.... */

	{

	    gx_strip_bitmap plane_tile;

	    tiling_state_t state;

	    long buf[TILE_RECTANGLE_BUF_SIZE / sizeof(long)];

	    int code = begin_tiling(&state, edev, tiles->data, 0, tiles->raster,

			tiles->size.x, tiles->size.y,

				(byte *)buf, sizeof(buf), false);

	    if (code < 0)

		return gx_default_strip_tile_rectangle(dev, tiles, x, y, w, h,

					color0, color1, phase_x, phase_y);

	    extract_partial_tile(&state);

	    plane_tile = *tiles;

	    plane_tile.data = state.buffer.data;

	    plane_tile.raster = state.buffer.raster;

	    plane_tile.id = gx_no_bitmap_id;

	    code = dev_proc(plane_dev, strip_tile_rectangle)

		(plane_dev, &plane_tile, x, y, w, h, pixel0, pixel1,

		 phase_x, phase_y);

	    end_tiling(&state);

	    edev->any_marks = true;

	    return code;

	}

    }

    if ((pixel0 == edev->plane_white || pixel0 == gx_no_color_index) &&

	(pixel1 == edev->plane_white || pixel1 == gx_no_color_index)) {

	/* This operation will only write white. */

	if (!edev->any_marks)

	    return 0;

    } else

	edev->any_marks = true;

    return dev_proc(plane_dev, strip_tile_rectangle)

	(plane_dev, tiles, x, y, w, h, pixel0, pixel1, phase_x, phase_y);

}

private int

plane_strip_copy_rop(gx_device *dev,

    const byte *sdata, int sourcex, uint sraster, gx_bitmap_id id,

    const gx_color_index *scolors,

    const gx_strip_bitmap *textures, const gx_color_index *tcolors,

    int x, int y, int w, int h,

    int phase_x, int phase_y, gs_logical_operation_t lop)

{

    gx_device_plane_extract * const edev = (gx_device_plane_extract *)dev;

    gx_device * const plane_dev = edev->plane_dev;

    gs_rop3_t rop = lop_rop(lop);

    struct crp_ {

	gx_color_index pixels[2];

	gx_color_index *colors;

	tiling_state_t state;

    } source, texture;

    long sbuf[COPY_ROP_SOURCE_BUF_SIZE / sizeof(long)];

    long tbuf[COPY_ROP_TEXTURE_BUF_SIZE / sizeof(long)];

    const byte *plane_source;

    uint plane_raster = 0xbaadf00d; /* Initialize against indeterminizm. */

    gx_strip_bitmap plane_texture;

    const gx_strip_bitmap *plane_textures = NULL;

    int code;

    /* We should do better than this on transparency.... */

    if (lop & (lop_S_transparent | lop_T_transparent))

	return gx_default_strip_copy_rop(dev, sdata, sourcex, sraster, id,

					 scolors, textures, tcolors,

					 x, y, w, h, phase_x, phase_y, lop);

    if (!rop3_uses_S(rop)) {

	sdata = 0;

	source.colors = 0;

    } else if (scolors) {

	source.pixels[0] = COLOR_PIXEL(edev, scolors[0]);

	source.pixels[1] = COLOR_PIXEL(edev, scolors[1]);

	if (source.pixels[0] == source.pixels[1])

	    sdata = 0;

	source.colors = source.pixels;

    }

    else

	source.colors = 0;

    if (!rop3_uses_T(rop)) {

	textures = 0;

	texture.colors = 0;

    } else if (tcolors) {

	texture.pixels[0] = COLOR_PIXEL(edev, tcolors[0]);

	texture.pixels[1] = COLOR_PIXEL(edev, tcolors[1]);

	if (texture.pixels[0] == texture.pixels[1])

	    textures = 0;

	texture.colors = texture.pixels;

    }

    else

	texture.colors = 0;

    if (sdata) {

	code = begin_tiling(&source.state, edev, sdata, sourcex, sraster, w, y,

			    (byte *)sbuf, sizeof(sbuf), true);

	if (code < 0)

	    return gx_default_strip_copy_rop(dev, sdata, sourcex, sraster, id,

					     scolors, textures, tcolors,

					     x, y, w, h, phase_x, phase_y, lop);

	plane_source = source.state.buffer.data;

	plane_raster = source.state.buffer.raster;

    } else

	plane_source = 0;

    if (textures) {

	code = begin_tiling(&texture.state, edev, textures->data, 0,

			    textures->raster, textures->size.x,

			    textures->size.y, (byte *)tbuf, sizeof(tbuf),

			    false);

	if (code < 0) {

	    if (plane_source)

		end_tiling(&source.state);

	    return code;

	}

	plane_texture = *textures;

	plane_texture.data = texture.state.buffer.data;

	plane_texture.raster = texture.state.buffer.raster;

	plane_textures = &plane_texture;

    }

    if (textures)

	extract_partial_tile(&texture.state);

    do {

	if (sdata)

	    extract_partial_tile(&source.state);

	code = dev_proc(plane_dev, strip_copy_rop)

	    (plane_dev, plane_source, sourcex, plane_raster, gx_no_bitmap_id,

	     source.colors, plane_textures, texture.colors,

	     x, y, w, h, phase_x, phase_y, lop);

    } while (code >= 0 && sdata && next_tile(&source.state));

    if (textures)

	end_tiling(&texture.state);

    if (sdata)

	end_tiling(&source.state);

    return code;

}

/* ---------------- Images ---------------- */

/* Define the state for image rendering. */

typedef struct plane_image_enum_s {

    gx_image_enum_common;

    gs_memory_t *memory;

    gx_image_enum_common_t *info; /* plane device enumerator */

    const gs_imager_state *pis;	/* original imager state */

    gs_imager_state *pis_image;	/* modified imager state */

} plane_image_enum_t;

gs_private_st_suffix_add3(st_plane_image_enum, plane_image_enum_t,

  "plane_image_enum_t", plane_image_enum_enum_ptrs,

  plane_image_enum_reloc_ptrs, st_gx_image_enum_common, info, pis, pis_image);

/*

 * Reduce drawing colors returned by color mapping.  Note that these

 * assume that the call of reduce_drawing_color will not fail:

 * plane_begin_typed_image must ensure this.

 *

 * In the imager state passed to these procedures, the client data is

 * the plane_image_enum_t.

 */

private void

plane_cmap_gray(frac gray, gx_device_color * pdc,

    const gs_imager_state *pis_image, gx_device *dev, gs_color_select_t select)

{

    const plane_image_enum_t *ppie =

	(const plane_image_enum_t *)pis_image->client_data;

    gx_device_plane_extract * const edev =

	(gx_device_plane_extract *)ppie->dev;

    gs_logical_operation_t lop = gs_current_logical_op_inline(pis_image);

    gx_device_color dcolor;

    gx_remap_concrete_gray(gray, &dcolor, ppie->pis,

			   (gx_device *)edev, select);

    reduce_drawing_color(pdc, edev, &dcolor, &lop);

}

private void

plane_cmap_rgb(frac r, frac g, frac b, gx_device_color * pdc,

    const gs_imager_state *pis_image, gx_device *dev, gs_color_select_t select)

{

    const plane_image_enum_t *ppie =

	(const plane_image_enum_t *)pis_image->client_data;

    gx_device_plane_extract * const edev =

	(gx_device_plane_extract *)ppie->dev;

    gs_logical_operation_t lop = gs_current_logical_op_inline(pis_image);

    gx_device_color dcolor;