/* Copyright (C) 2001-2025 Artifex Software, Inc.

   All Rights Reserved.

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

   implied.

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

   modified or distributed except as expressly authorized under the terms

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

   Refer to licensing information at http://www.artifex.com or contact

   Artifex Software, Inc.,  39 Mesa Street, Suite 108A, San Francisco,

   CA 94129, USA, for further information.

*/

/* Any-depth planar "memory" (stored bitmap) device */

#include "memory_.h"

#include "gx.h"

#include "gserrors.h"

#include "gsbitops.h"

#include "gxdevice.h"

#include "gxdcolor.h"   /* for gx_fill_rectangle_device_rop */

#include "gxpcolor.h"           /* for gx_dc_devn_masked */

#include "gxdevmem.h"           /* semi-public definitions */

#include "gxgetbit.h"

#include "gdevmem.h"            /* private definitions */

#include "gdevmpla.h"           /* interface */

#include "gxdevsop.h"

/* procedures */

static dev_proc_open_device(mem_planar_open);

static dev_proc_open_device(mem_planar_open_interleaved);

declare_mem_procs(mem_planar_copy_mono, mem_planar_copy_color, mem_planar_fill_rectangle);

static dev_proc_copy_color(mem_planar_copy_color_24to8);

static dev_proc_copy_color(mem_planar_copy_color_4to1);

static dev_proc_copy_planes(mem_planar_copy_planes);

/* Not static due to an optimized case in tile_clip_fill_rectangle_hl_color*/

static dev_proc_strip_tile_rectangle(mem_planar_strip_tile_rectangle);

static dev_proc_strip_tile_rect_devn(mem_planar_strip_tile_rect_devn);

static dev_proc_strip_copy_rop2(mem_planar_strip_copy_rop2);

static dev_proc_get_bits_rectangle(mem_planar_get_bits_rectangle);

static dev_proc_fill_rectangle_hl_color(mem_planar_fill_rectangle_hl_color);

static dev_proc_put_image(mem_planar_put_image);

int

mem_spec_op(gx_device *pdev, int dev_spec_op,

            void *data, int size)

{

    cmm_dev_profile_t *dev_profile;

    gx_device_memory *mdev = (gx_device_memory *)pdev;

    if (pdev->num_planar_planes &&

        (dev_spec_op == gxdso_supports_devn ||

         dev_spec_op == gxdso_skip_icc_component_validation)) {

        dev_proc(pdev, get_profile)(pdev, &dev_profile);

        if (dev_profile != NULL && dev_profile->supports_devn &&

            dev_proc(pdev, fill_rectangle_hl_color) == mem_planar_fill_rectangle_hl_color)

            return 1;

    }

    if (dev_spec_op == gxdso_is_std_cmyk_1bit)

         return dev_proc(pdev, copy_color) == mem_planar_copy_color_4to1;

    if (dev_spec_op == gxdso_is_pdf14_device || dev_spec_op == gxdso_pattern_handles_clip_path)

         return 0;

    if (mdev->owner)

        return dev_proc(mdev->owner, dev_spec_op)(mdev->owner, dev_spec_op, data, size);

    return gx_default_dev_spec_op(pdev, dev_spec_op, data, size);

}

/*

 * Set up a planar memory device, after calling gs_make_mem_device but

 * before opening the device.  The pre-existing device provides the color

 * mapping procedures, but not the drawing procedures.  Requires: num_planes

 * > 0, plane_depths[0 ..  num_planes - 1] > 0, sum of plane depths =

 * mdev->color_info.depth.

 *

 * Note that this is the only public procedure in this file, and the only

 * sanctioned way to set up a planar memory device.

 */

int

gdev_mem_set_planar(gx_device_memory * mdev, int num_planes,

                    const gx_render_plane_t *planes /*[num_planes]*/)

{

    return gdev_mem_set_planar_interleaved(mdev, num_planes, planes, 0);

}

int

gdev_mem_set_planar_interleaved(gx_device_memory * mdev, int num_planes,

                                const gx_render_plane_t *planes /*[num_planes]*/,

                                int interleaved)

{

    int total_depth;

    int same_depth = planes[0].depth;

    gx_color_index covered = 0;

    int pi;

    const gdev_mem_functions *fns =

                    gdev_mem_functions_for_bits(mdev->color_info.depth);

    if (num_planes < 1 || num_planes > GX_DEVICE_COLOR_MAX_COMPONENTS || num_planes < mdev->color_info.num_components)

        return_error(gs_error_rangecheck);

    for (pi = 0, total_depth = 0; pi < num_planes; ++pi) {

        int shift = planes[pi].shift;

        int plane_depth = planes[pi].depth;

        gx_color_index mask;

        if (shift < 0 || plane_depth > 16 ||

            !gdev_mem_device_for_bits(plane_depth))

            return_error(gs_error_rangecheck);

        /* Don't test overlap if shift is too large to fit in the variable */

        if (shift < 8*sizeof(gx_color_index))

        {

            mask = (((gx_color_index)1 << plane_depth) - 1) << shift;

            if (covered & mask)

                return_error(gs_error_rangecheck);

            covered |= mask;

        }

        if (plane_depth != same_depth)

            same_depth = 0;

        total_depth += plane_depth;

    }

    if (total_depth > mdev->color_info.depth)

        return_error(gs_error_rangecheck);

    mdev->num_planar_planes = num_planes;

    memcpy(mdev->planes, planes, num_planes * sizeof(planes[0]));

    mdev->plane_depth = same_depth;

    /* Change the drawing procedures. */

    if (interleaved)

        set_dev_proc(mdev, open_device, mem_planar_open_interleaved);

    else

        set_dev_proc(mdev, open_device, mem_planar_open);

    /* Regardless of how many planes we are using, always let the

     * device know how to handle hl_color. Even if we spot that we

     * can get away with a normal device, our callers may want to

     * feed us single component devn data. */

    set_dev_proc(mdev, fill_rectangle_hl_color,

                 mem_planar_fill_rectangle_hl_color);

    if (num_planes == 1) {

        /* For 1 plane, just use a normal device */

        set_dev_proc(mdev, fill_rectangle, fns->fill_rectangle);

        set_dev_proc(mdev, copy_mono,  fns->copy_mono);

        set_dev_proc(mdev, copy_color, fns->copy_color);

        set_dev_proc(mdev, copy_alpha, fns->copy_alpha);

        set_dev_proc(mdev, strip_tile_rectangle, fns->strip_tile_rectangle);

        set_dev_proc(mdev, strip_copy_rop2, fns->strip_copy_rop2);

        set_dev_proc(mdev, get_bits_rectangle, fns->get_bits_rectangle);

    } else {

        /* If we are going out to a separation device or one that has more than

           four planes then use the high level color filling procedure.  Also

           make use of the put_image operation to go from the pdf14 device

           directly to the planar buffer. */

        if (num_planes >= 4) {

            /* put_image always gives us our data in bytes (or 16bits) per

             * component. When we have a suitably deep device we can assume

             * that this will match our own representation, and use a fast

             * copy_planes based implementation. If not, we have to use the

             * default's copy-via-image implementation. */

            if (mdev->color_info.depth / num_planes >= 8)

               set_dev_proc(mdev, put_image, mem_planar_put_image);

        }

        set_dev_proc(mdev, fill_rectangle, mem_planar_fill_rectangle);

        set_dev_proc(mdev, copy_alpha_hl_color, gx_default_copy_alpha_hl_color);

        set_dev_proc(mdev, copy_mono, mem_planar_copy_mono);

        if ((mdev->color_info.depth == 24) &&

            (num_planes == 3) &&

            (mdev->planes[0].depth == 8) && (mdev->planes[0].shift == 16) &&

            (mdev->planes[1].depth == 8) && (mdev->planes[1].shift == 8) &&

            (mdev->planes[2].depth == 8) && (mdev->planes[2].shift == 0))

            set_dev_proc(mdev, copy_color, mem_planar_copy_color_24to8);

        else if ((mdev->color_info.depth == 4) &&

                 (num_planes == 4) &&

                 (mdev->planes[0].depth == 1) && (mdev->planes[0].shift == 3) &&

                 (mdev->planes[1].depth == 1) && (mdev->planes[1].shift == 2) &&

                 (mdev->planes[2].depth == 1) && (mdev->planes[2].shift == 1) &&

                 (mdev->planes[3].depth == 1) && (mdev->planes[3].shift == 0)) {

            set_dev_proc(mdev, copy_color, mem_planar_copy_color_4to1);

        } else

            set_dev_proc(mdev, copy_color, mem_planar_copy_color);

        set_dev_proc(mdev, copy_alpha, gx_default_copy_alpha);

        set_dev_proc(mdev, strip_tile_rectangle, mem_planar_strip_tile_rectangle);

        set_dev_proc(mdev, strip_tile_rect_devn, mem_planar_strip_tile_rect_devn);

        set_dev_proc(mdev, strip_copy_rop2, mem_planar_strip_copy_rop2);

        set_dev_proc(mdev, get_bits_rectangle, mem_planar_get_bits_rectangle);

    }

    fill_dev_proc(mdev, dev_spec_op, mem_spec_op);

    set_dev_proc(mdev, copy_planes, mem_planar_copy_planes);

    return 0;

}

/* Open a planar memory device. */

static int

mem_planar_open(gx_device * dev)

{

    gx_device_memory *const mdev = (gx_device_memory *)dev;

    /* Check that we aren't trying to open a chunky device as planar. */

    if (!dev->num_planar_planes)

        return_error(gs_error_rangecheck);

    return gdev_mem_open_scan_lines(mdev, dev->height);

}

static int

mem_planar_open_interleaved(gx_device * dev)

{

    gx_device_memory *const mdev = (gx_device_memory *)dev;

    /* Check that we aren't trying to open a chunky device as planar. */

    if (!dev->num_planar_planes)

        return_error(gs_error_rangecheck);

    return gdev_mem_open_scan_lines_interleaved(mdev, dev->height, 1);

}

/*

 * We execute drawing operations by patching a few parameters in the

 * device structure and then calling the procedure appropriate to the

 * plane depth.

 */

typedef struct mem_save_params_s {

    int depth;                  /* color_info.depth */

    byte *base;

    byte **line_ptrs;

} mem_save_params_t;

#define MEM_SAVE_PARAMS(mdev, msp)\

  (msp.depth = mdev->color_info.depth,\

   msp.base = mdev->base,\

   msp.line_ptrs = mdev->line_ptrs)

/* Previous versions of MEM_SET_PARAMS calculated raster as

 * bitmap_raster(mdev->width * plane_depth), but this restricts us to

 * non interleaved frame buffers. Now we calculate it from the difference

 * between the first 2 line pointers; this clearly only works if there are

 * at least 2 line pointers to use. Otherwise, we fall back to the old

 * method.

 */

/* FIXME: Find a nicer way of calculating raster. This is only required if

 * we allow the plane_depth to vary per plane, and the rest of the code

 * assumes that it never does. This can probably be simplified now. */

#define MEM_SET_PARAMS(mdev, plane_depth)\

  (mdev->color_info.depth = plane_depth, /* maybe not needed */\

   mdev->base = mdev->line_ptrs[0],\

   mdev->raster = (mdev->height > 1 ? mdev->line_ptrs[1]-mdev->line_ptrs[0] : bitmap_raster(mdev->width * plane_depth)))

#define MEM_RESTORE_PARAMS(mdev, msp)\

  (mdev->color_info.depth = msp.depth,\

   mdev->base = msp.base,\

   mdev->line_ptrs = msp.line_ptrs)

/* Note tag_offset == 0 if there is no tag plane. Tags always follow the

   color data, but not neccessarily right after. */

static int

put_image_copy_planes(gx_device * dev, const byte **base_ptr, int sourcex,

                      int sraster, gx_bitmap_id id,

                      int x, int y, int w, int h, int tag_offset)

{

    gx_device_memory * const mdev = (gx_device_memory *)dev;

    int plane_depth;

    mem_save_params_t save;

    const gdev_mem_functions *fns;

    int code = 0;

    int plane;

    const byte *base;

    int last_plane = mdev->num_planar_planes - 1;

    MEM_SAVE_PARAMS(mdev, save);

    for (plane = 0; plane < mdev->num_planar_planes; plane++)

    {

        if (tag_offset && plane == last_plane)

            base = base_ptr[tag_offset];

        else

            base = base_ptr[plane];

        plane_depth = mdev->planes[plane].depth;

        fns = gdev_mem_functions_for_bits(plane_depth);

        if (base == NULL) {

            /* Blank the plane */

            code = fns->fill_rectangle(dev, x, y, w, h,

                (gx_color_index)(dev->color_info.polarity == GX_CINFO_POLARITY_ADDITIVE ? 0 : -1));

        } else if (plane_depth == 1)

            code = fns->copy_mono(dev, base, sourcex, sraster, id,

                                  x, y, w, h,

                                  (gx_color_index)0, (gx_color_index)1);

        else

            fns->copy_color(dev, base, sourcex, sraster, id, x, y, w, h);

        mdev->line_ptrs += mdev->height;

    }

    MEM_RESTORE_PARAMS(mdev, save);

    return code;

}

/* Put image command for copying the planar image buffers with or without

   alpha directly to the device buffer */

static int

mem_planar_put_image(gx_device *pdev, gx_device *pmdev, const byte **buffers, int num_chan, int xstart,

              int ystart, int width, int height, int row_stride,

              int alpha_plane_index, int tag_plane_index)

{

    /* We don't want alpha, return 0 to ask for the pdf14 device to do the

       alpha composition. We also do not want chunky data coming in */

    if (alpha_plane_index != 0)

        return 0;

    put_image_copy_planes(pdev, buffers, 0, row_stride,

                          gx_no_bitmap_id, xstart, ystart,

                          width, height, tag_plane_index);

    /* we used all of the data */

    return height;

}

/* Fill a rectangle with a high level color.  This is used for separation

   devices. (e.g. tiffsep, psdcmyk) */

static int

mem_planar_fill_rectangle_hl_color(gx_device *dev, const gs_fixed_rect *rect,

    const gs_gstate *pgs, const gx_drawing_color *pdcolor,

    const gx_clip_path *pcpath)

{

    gx_device_memory * const mdev = (gx_device_memory *)dev;

    mem_save_params_t save;

    int pi;

    int x = fixed2int(rect->p.x);

    int y = fixed2int(rect->p.y);

    int w = fixed2int(rect->q.x) - x;

    int h = fixed2int(rect->q.y) - y;

    int has_tags = device_encodes_tags(dev);

    int npp = mdev->num_planar_planes - has_tags;

    /* We can only handle devn cases, so use the default if not */

    /* We can get called here from gx_dc_devn_masked_fill_rectangle */

    if (pdcolor->type != gx_dc_type_devn && pdcolor->type != &gx_dc_devn_masked) {

        return gx_fill_rectangle_device_rop( x, y, w, h, pdcolor, dev, lop_default);

    }

    MEM_SAVE_PARAMS(mdev, save);

    for (pi = 0; pi < npp; ++pi) {

        int plane_depth = mdev->planes[pi].depth;

        gx_color_index mask = ((gx_color_index)1 << plane_depth) - 1;

        int shift = 16 - plane_depth;

        const gdev_mem_functions *fns =

                               gdev_mem_functions_for_bits(plane_depth);

        MEM_SET_PARAMS(mdev, plane_depth);

        fns->fill_rectangle(dev, x, y, w, h,

                            (pdcolor->colors.devn.values[pi]) >> shift & mask);

        mdev->line_ptrs += mdev->height;

    }

    if (has_tags) {

        int plane_depth = mdev->planes[pi].depth;

        gx_color_index mask = ((gx_color_index)1 << plane_depth) - 1;

        const gdev_mem_functions *fns =

                    gdev_mem_functions_for_bits(plane_depth);

        MEM_SET_PARAMS(mdev, plane_depth);

        fns->fill_rectangle(dev, x, y, w, h,

                    (pdcolor->colors.devn.values[pi]) & mask);

        mdev->line_ptrs += mdev->height;

    }

    MEM_RESTORE_PARAMS(mdev, save);

    return 0;

}

/* Fill a rectangle with a color. */

static int

mem_planar_fill_rectangle(gx_device * dev, int x, int y, int w, int h,

                          gx_color_index color)

{

    gx_device_memory * const mdev = (gx_device_memory *)dev;

    mem_save_params_t save;

    int pi;

    MEM_SAVE_PARAMS(mdev, save);

    for (pi = 0; pi < mdev->num_planar_planes; ++pi) {

        int plane_depth = mdev->planes[pi].depth;

        gx_color_index mask = ((gx_color_index)1 << plane_depth) - 1;

        const gdev_mem_functions *fns =

                               gdev_mem_functions_for_bits(plane_depth);

        MEM_SET_PARAMS(mdev, plane_depth);

        fns->fill_rectangle(dev, x, y, w, h,

                            (color >> mdev->planes[pi].shift) & mask);

        mdev->line_ptrs += mdev->height;

    }

    MEM_RESTORE_PARAMS(mdev, save);

    return 0;

}

/* Copy a bitmap. */

static int

mem_planar_copy_mono(gx_device * dev, const byte * base, int sourcex,

                     int sraster, gx_bitmap_id id, int x, int y, int w, int h,

                     gx_color_index color0, gx_color_index color1)

{

    gx_device_memory * const mdev = (gx_device_memory *)dev;

    mem_save_params_t save;

    int pi;

    MEM_SAVE_PARAMS(mdev, save);

    for (pi = 0; pi < mdev->num_planar_planes; ++pi) {

        int plane_depth = mdev->planes[pi].depth;

        int shift = mdev->planes[pi].shift;

        gx_color_index mask = ((gx_color_index)1 << plane_depth) - 1;

        const gdev_mem_functions *fns =

                               gdev_mem_functions_for_bits(plane_depth);

        gx_color_index c0 =

            (color0 == gx_no_color_index ? gx_no_color_index :

             (color0 >> shift) & mask);

        gx_color_index c1 =

            (color1 == gx_no_color_index ? gx_no_color_index :

             (color1 >> shift) & mask);

        MEM_SET_PARAMS(mdev, plane_depth);

        if (c0 == c1)

            fns->fill_rectangle(dev, x, y, w, h, c0);

        else

            fns->copy_mono(dev, base, sourcex, sraster, id,

                           x, y, w, h, c0, c1);

        mdev->line_ptrs += mdev->height;

    }

    MEM_RESTORE_PARAMS(mdev, save);

    return 0;

}

/* Copy color: Special case the 24 -> 8+8+8 case. */

static int

mem_planar_copy_color_24to8(gx_device * dev, const byte * base, int sourcex,

                            int sraster, gx_bitmap_id id,

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

{

    gx_device_memory * const mdev = (gx_device_memory *)dev;

#define BUF_LONGS 100   /* arbitrary, >= 1 */

#define BUF_BYTES (BUF_LONGS * ARCH_SIZEOF_LONG)

    union b_ {

        ulong l[BUF_LONGS];

        byte b[BUF_BYTES];

    } buf, buf1, buf2;

    mem_save_params_t save;

    dev_proc_copy_color((*copy_color)) =

                             gdev_mem_functions_for_bits(8)->copy_color;

    uint plane_raster = bitmap_raster(w<<3);

    int br, bw, bh, cx, cy, cw, ch, ix, iy;

    fit_copy(dev, base, sourcex, sraster, id, x, y, w, h);

    MEM_SAVE_PARAMS(mdev, save);

    MEM_SET_PARAMS(mdev, 8);

    if (plane_raster > BUF_BYTES) {

        br = BUF_BYTES;

        bw = BUF_BYTES;

        bh = 1;

    } else {

        br = plane_raster;

        bw = w;

        bh = BUF_BYTES / plane_raster;

    }

    for (cy = y; cy < y + h; cy += ch) {

        ch = min(bh, y + h - cy);

        for (cx = x; cx < x + w; cx += cw) {

            int sx = sourcex + cx - x;

            const byte *source_base = base + sraster * (cy - y);

            cw = min(bw, x + w - cx);

            source_base += sx * 3;

            for (iy = 0; iy < ch; ++iy) {

                const byte *sptr = source_base;

                byte *dptr0 = buf.b  + br * iy;

                byte *dptr1 = buf1.b + br * iy;

                byte *dptr2 = buf2.b + br * iy;

                ix = cw;

                do {

                    /* Use the temporary variables below to free the C compiler

                     * to interleave load/stores for latencies sake despite the

                     * pointer aliasing rules. */

                    byte r = *sptr++;

                    byte g = *sptr++;

                    byte b = *sptr++;

                    *dptr0++ = r;

                    *dptr1++ = g;

                    *dptr2++ = b;

                } while (--ix);

                source_base += sraster;

            }

            copy_color(dev, buf.b, 0, br, gx_no_bitmap_id, cx, cy, cw, ch);

            mdev->line_ptrs += mdev->height;

            copy_color(dev, buf1.b, 0, br, gx_no_bitmap_id, cx, cy, cw, ch);

            mdev->line_ptrs += mdev->height;

            copy_color(dev, buf2.b, 0, br, gx_no_bitmap_id, cx, cy, cw, ch);

            mdev->line_ptrs -= 2*mdev->height;

        }

    }

    MEM_RESTORE_PARAMS(mdev, save);

    return 0;

}

/* Copy color: Special case the 4 -> 1+1+1+1 case. */

/* Two versions of this routine; the first does bit comparisons. This should

 * work well on architectures with small cache and conditional execution

 * (such as ARM). Hurts on x86 due to the ifs in the loop all causing small

 * skips ahead that defeat the branch predictor.

 * Second version uses a table lookup; 1K of table is nothing on x86, and

 * so this runs much faster. */

#ifdef PREFER_ALTERNATIION_TO_TABLES

static int

mem_planar_copy_color_4to1(gx_device * dev, const byte * base, int sourcex,

                            int sraster, gx_bitmap_id id,

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

{

    gx_device_memory * const mdev = (gx_device_memory *)dev;

#define BUF_LONGS 100   /* arbitrary, >= 1 */

#define BUF_BYTES (BUF_LONGS * ARCH_SIZEOF_LONG)

    union b_ {

        ulong l[BUF_LONGS];

        byte b[BUF_BYTES];

    } buf0, buf1, buf2, buf3;

    mem_save_params_t save;

    dev_proc_copy_mono((*copy_mono)) =

                        gdev_mem_fill_functions_for_bits(1)->copy_mono;

    uint plane_raster = bitmap_raster(w);

    int br, bw, bh, cx, cy, cw, ch, ix, iy;

#ifdef MEMENTO

    /* Pacify valgrind */

    memset(buf0.l, 0, sizeof(ulong) * BUF_LONGS);

    memset(buf1.l, 0, sizeof(ulong) * BUF_LONGS);

    memset(buf2.l, 0, sizeof(ulong) * BUF_LONGS);

    memset(buf3.l, 0, sizeof(ulong) * BUF_LONGS);

#endif

    fit_copy(dev, base, sourcex, sraster, id, x, y, w, h);

    MEM_SAVE_PARAMS(mdev, save);

    MEM_SET_PARAMS(mdev, 1);

    if (plane_raster > BUF_BYTES) {

        br = BUF_BYTES;

        bw = BUF_BYTES<<3;

        bh = 1;

    } else {

        br = plane_raster;

        bw = w;

        bh = BUF_BYTES / plane_raster;

    }

    for (cy = y; cy < y + h; cy += ch) {

        ch = min(bh, y + h - cy);

        for (cx = x; cx < x + w; cx += cw) {

            int sx = sourcex + cx - x;

            const byte *source_base = base + sraster * (cy - y) + (sx>>1);

            cw = min(bw, x + w - cx);

            if ((sx & 1) == 0) {

                for (iy = 0; iy < ch; ++iy) {

                    const byte *sptr = source_base;

                    byte *dptr0 = buf0.b + br * iy;

                    byte *dptr1 = buf1.b + br * iy;

                    byte *dptr2 = buf2.b + br * iy;

                    byte *dptr3 = buf3.b + br * iy;

                    byte roll = 0x80;

                    byte bc = 0;

                    byte bm = 0;

                    byte by = 0;

                    byte bk = 0;

                    ix = cw;

                    do {

                        byte b = *sptr++;

                        if (b & 0x80)

                            bc |= roll;

                        if (b & 0x40)

                            bm |= roll;

                        if (b & 0x20)

                            by |= roll;

                        if (b & 0x10)

                            bk |= roll;

                        roll >>= 1;

                        if (b & 0x08)

                            bc |= roll;

                        if (b & 0x04)

                            bm |= roll;

                        if (b & 0x02)

                            by |= roll;

                        if (b & 0x01)

                            bk |= roll;

                        roll >>= 1;

                        if (roll == 0) {

                            *dptr0++ = bc;

                            *dptr1++ = bm;

                            *dptr2++ = by;

                            *dptr3++ = bk;

                            bc = 0;

                            bm = 0;

                            by = 0;

                            bk = 0;

                            roll = 0x80;

                        }

                        ix -= 2;

                    } while (ix > 0);

                    if (roll != 0x80) {

                        *dptr0++ = bc;

                        *dptr1++ = bm;

                        *dptr2++ = by;

                        *dptr3++ = bk;

                    }

                    source_base += sraster;

                }

            } else {

                for (iy = 0; iy < ch; ++iy) {

                    const byte *sptr = source_base;

                    byte *dptr0 = buf0.b + br * iy;

                    byte *dptr1 = buf1.b + br * iy;

                    byte *dptr2 = buf2.b + br * iy;

                    byte *dptr3 = buf3.b + br * iy;

                    byte roll = 0x80;

                    byte bc = 0;

                    byte bm = 0;

                    byte by = 0;

                    byte bk = 0;

                    byte b = *sptr++;

                    ix = cw;

                    goto loop_entry;

                    do {

                        b = *sptr++;

                        if (b & 0x80)

                            bc |= roll;

                        if (b & 0x40)

                            bm |= roll;

                        if (b & 0x20)

                            by |= roll;

                        if (b & 0x10)

                            bk |= roll;

                        roll >>= 1;

                        if (roll == 0) {

                            *dptr0++ = bc;

                            *dptr1++ = bm;

                            *dptr2++ = by;

                            *dptr3++ = bk;

                            bc = 0;

                            bm = 0;

                            by = 0;

                            bk = 0;

                            roll = 0x80;

                        }

loop_entry:

                        if (b & 0x08)

                            bc |= roll;

                        if (b & 0x04)

                            bm |= roll;

                        if (b & 0x02)

                            by |= roll;

                        if (b & 0x01)

                            bk |= roll;

                        roll >>= 1;

                        ix -= 2;

                    } while (ix >= 0); /* ix == -2 means 1 extra done */

                    if ((ix == -2) && (roll == 0x40)) {

                        /* We did an extra one, and it was the last thing

                         * we did. Nothing to store. */

                    } else {

                        /* Flush the stored bytes */

                        *dptr0++ = bc;

                        *dptr1++ = bm;

                        *dptr2++ = by;

                        *dptr3++ = bk;

                    }

                    source_base += sraster;

                }

            }

            copy_mono(dev, buf0.b, 0, br, gx_no_bitmap_id, cx, cy, cw, ch,

                      (gx_color_index)0, (gx_color_index)1);

            mdev->line_ptrs += mdev->height;

            copy_mono(dev, buf1.b, 0, br, gx_no_bitmap_id, cx, cy, cw, ch,

                      (gx_color_index)0, (gx_color_index)1);

            mdev->line_ptrs += mdev->height;

            copy_mono(dev, buf2.b, 0, br, gx_no_bitmap_id, cx, cy, cw, ch,

                      (gx_color_index)0, (gx_color_index)1);

            mdev->line_ptrs += mdev->height;

            copy_mono(dev, buf3.b, 0, br, gx_no_bitmap_id, cx, cy, cw, ch,

                      (gx_color_index)0, (gx_color_index)1);

            mdev->line_ptrs -= 3*mdev->height;

        }

    }

    MEM_RESTORE_PARAMS(mdev, save);

    return 0;

}

#else

static bits32 expand_4to1[256] =

{

0x00000000,0x00000001,0x00000100,0x00000101,

0x00010000,0x00010001,0x00010100,0x00010101,

0x01000000,0x01000001,0x01000100,0x01000101,

0x01010000,0x01010001,0x01010100,0x01010101,

0x00000002,0x00000003,0x00000102,0x00000103,

0x00010002,0x00010003,0x00010102,0x00010103,

0x01000002,0x01000003,0x01000102,0x01000103,

0x01010002,0x01010003,0x01010102,0x01010103,

0x00000200,0x00000201,0x00000300,0x00000301,

0x00010200,0x00010201,0x00010300,0x00010301,

0x01000200,0x01000201,0x01000300,0x01000301,

0x01010200,0x01010201,0x01010300,0x01010301,

0x00000202,0x00000203,0x00000302,0x00000303,

0x00010202,0x00010203,0x00010302,0x00010303,

0x01000202,0x01000203,0x01000302,0x01000303,

0x01010202,0x01010203,0x01010302,0x01010303,

0x00020000,0x00020001,0x00020100,0x00020101,

0x00030000,0x00030001,0x00030100,0x00030101,

0x01020000,0x01020001,0x01020100,0x01020101,

0x01030000,0x01030001,0x01030100,0x01030101,

0x00020002,0x00020003,0x00020102,0x00020103,

0x00030002,0x00030003,0x00030102,0x00030103,

0x01020002,0x01020003,0x01020102,0x01020103,

0x01030002,0x01030003,0x01030102,0x01030103,

0x00020200,0x00020201,0x00020300,0x00020301,

0x00030200,0x00030201,0x00030300,0x00030301,

0x01020200,0x01020201,0x01020300,0x01020301,

0x01030200,0x01030201,0x01030300,0x01030301,

0x00020202,0x00020203,0x00020302,0x00020303,

0x00030202,0x00030203,0x00030302,0x00030303,

0x01020202,0x01020203,0x01020302,0x01020303,

0x01030202,0x01030203,0x01030302,0x01030303,

0x02000000,0x02000001,0x02000100,0x02000101,

0x02010000,0x02010001,0x02010100,0x02010101,

0x03000000,0x03000001,0x03000100,0x03000101,

0x03010000,0x03010001,0x03010100,0x03010101,

0x02000002,0x02000003,0x02000102,0x02000103,

0x02010002,0x02010003,0x02010102,0x02010103,

0x03000002,0x03000003,0x03000102,0x03000103,

0x03010002,0x03010003,0x03010102,0x03010103,

0x02000200,0x02000201,0x02000300,0x02000301,

0x02010200,0x02010201,0x02010300,0x02010301,

0x03000200,0x03000201,0x03000300,0x03000301,

0x03010200,0x03010201,0x03010300,0x03010301,

0x02000202,0x02000203,0x02000302,0x02000303,

0x02010202,0x02010203,0x02010302,0x02010303,

0x03000202,0x03000203,0x03000302,0x03000303,

0x03010202,0x03010203,0x03010302,0x03010303,

0x02020000,0x02020001,0x02020100,0x02020101,

0x02030000,0x02030001,0x02030100,0x02030101,

0x03020000,0x03020001,0x03020100,0x03020101,

0x03030000,0x03030001,0x03030100,0x03030101,

0x02020002,0x02020003,0x02020102,0x02020103,

0x02030002,0x02030003,0x02030102,0x02030103,

0x03020002,0x03020003,0x03020102,0x03020103,

0x03030002,0x03030003,0x03030102,0x03030103,

0x02020200,0x02020201,0x02020300,0x02020301,

0x02030200,0x02030201,0x02030300,0x02030301,

0x03020200,0x03020201,0x03020300,0x03020301,

0x03030200,0x03030201,0x03030300,0x03030301,

0x02020202,0x02020203,0x02020302,0x02020303,

0x02030202,0x02030203,0x02030302,0x02030303,

0x03020202,0x03020203,0x03020302,0x03020303,

0x03030202,0x03030203,0x03030302,0x03030303

};

static int

mem_planar_copy_color_4to1(gx_device * dev, const byte * base, int sourcex,

                            int sraster, gx_bitmap_id id,

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

{

    gx_device_memory * const mdev = (gx_device_memory *)dev;

#define BUF_LONGS 100   /* arbitrary, >= 1 */

#define BUF_BYTES (BUF_LONGS * ARCH_SIZEOF_LONG)

    union b_ {

        ulong l[BUF_LONGS];

        byte b[BUF_BYTES];

    } buf0, buf1, buf2, buf3;

    mem_save_params_t save;

    dev_proc_copy_mono((*copy_mono)) =

                         gdev_mem_functions_for_bits(1)->copy_mono;

    uint plane_raster = bitmap_raster(w);

    int br, bw, bh, cx, cy, cw, ch, ix, iy;

    fit_copy(dev, base, sourcex, sraster, id, x, y, w, h);

    MEM_SAVE_PARAMS(mdev, save);

    MEM_SET_PARAMS(mdev, 1);

    if (plane_raster > BUF_BYTES) {

        br = BUF_BYTES;

        bw = BUF_BYTES<<3;

        bh = 1;

    } else {

        br = plane_raster;

        bw = w;

        bh = BUF_BYTES / plane_raster;

    }

    for (cy = y; cy < y + h; cy += ch) {

        ch = min(bh, y + h - cy);

        for (cx = x; cx < x + w; cx += cw) {

            int sx = sourcex + cx - x;

            const byte *source_base = base + sraster * (cy - y) + (sx>>1);

            cw = min(bw, x + w - cx);

            if ((sx & 1) == 0) {

                for (iy = 0; iy < ch; ++iy) {

                    const byte *sptr = source_base;

                    byte *dptr0 = buf0.b + br * iy;

                    byte *dptr1 = buf1.b + br * iy;

                    byte *dptr2 = buf2.b + br * iy;

                    byte *dptr3 = buf3.b + br * iy;

                    int roll = 6;

                    int cmyk = 0;

                    ix = cw;

                    do {

                        cmyk |= expand_4to1[*sptr++]<<roll;

                        roll -= 2;

                        if (roll < 0) {

                            *dptr0++ = cmyk>>24;

                            *dptr1++ = cmyk>>16;

                            *dptr2++ = cmyk>>8;

                            *dptr3++ = cmyk;

                            cmyk = 0;

                            roll = 6;

                        }

                        ix -= 2;

                    } while (ix > 0);

                    if (roll != 6) {

                        *dptr0++ = cmyk>>24;

                        *dptr1++ = cmyk>>16;

                        *dptr2++ = cmyk>>8;

                        *dptr3++ = cmyk;

                    }

                    source_base += sraster;

                }

            } else {

                for (iy = 0; iy < ch; ++iy) {

                    const byte *sptr = source_base;

                    byte *dptr0 = buf0.b + br * iy;

                    byte *dptr1 = buf1.b + br * iy;

                    byte *dptr2 = buf2.b + br * iy;

                    byte *dptr3 = buf3.b + br * iy;

                    int roll = 7;

                    int cmyk = 0;

                    byte b = *sptr++ & 0x0f;

                    ix = cw;

                    goto loop_entry;

                    do {

                        b = *sptr++;

                        roll -= 2;

                        if (roll < 0)

                        {

                            cmyk |= expand_4to1[b & 0xf0]>>1;

                            *dptr0++ = cmyk>>24;

                            *dptr1++ = cmyk>>16;

                            *dptr2++ = cmyk>>8;

                            *dptr3++ = cmyk;

                            cmyk = 0;

                            roll = 7;

                            b &= 0x0f;

                        }

loop_entry:

                        cmyk |= expand_4to1[b]<<roll;

                        ix -= 2;

                    } while (ix >= 0); /* ix == -2 means 1 extra done */

                    if ((ix == -2) && (roll == 7)) {

                        /* We did an extra one, and it was the last thing

                         * we did. Nothing to store. */

                    } else {

                        /* Flush the stored bytes */

                        *dptr0++ = cmyk>>24;

                        *dptr1++ = cmyk>>16;

                        *dptr2++ = cmyk>>8;

                        *dptr3++ = cmyk;

                    }

                    source_base += sraster;

                }

            }

            copy_mono(dev, buf0.b, 0, br, gx_no_bitmap_id, cx, cy, cw, ch,

                      (gx_color_index)0, (gx_color_index)1);

            mdev->line_ptrs += mdev->height;

            copy_mono(dev, buf1.b, 0, br, gx_no_bitmap_id, cx, cy, cw, ch,

                      (gx_color_index)0, (gx_color_index)1);

            mdev->line_ptrs += mdev->height;

            copy_mono(dev, buf2.b, 0, br, gx_no_bitmap_id, cx, cy, cw, ch,

                      (gx_color_index)0, (gx_color_index)1);

            mdev->line_ptrs += mdev->height;

            copy_mono(dev, buf3.b, 0, br, gx_no_bitmap_id, cx, cy, cw, ch,

                      (gx_color_index)0, (gx_color_index)1);

            mdev->line_ptrs -= 3*mdev->height;

        }

    }

    MEM_RESTORE_PARAMS(mdev, save);

    return 0;

}

#endif

/* Copy a color bitmap. */

/* This is slow and messy. */

static int

mem_planar_copy_color(gx_device * dev, const byte * base, int sourcex,

                      int sraster, gx_bitmap_id id,

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

{

    gx_device_memory * const mdev = (gx_device_memory *)dev;

#define BUF_LONGS 100   /* arbitrary, >= 1 */

#define BUF_BYTES (BUF_LONGS * ARCH_SIZEOF_LONG)

    union b_ {

        ulong l[BUF_LONGS];

        byte b[BUF_BYTES];

    } buf;

    int source_depth = dev->color_info.depth;

    mem_save_params_t save;

    int pi;

    /* This routine cannot copy from 3bit chunky data, as 3 bit

     * things don't pack nicely into bytes or words. Accordingly

     * treat 3 bit things as 4 bit things. This is appropriate as

     * 3 bit data will generally have been passed to us as 4bit

     * data - such as halftones. */

    if (source_depth == 3)

        source_depth = 4;

    fit_copy(dev, base, sourcex, sraster, id, x, y, w, h);

    MEM_SAVE_PARAMS(mdev, save);

    for (pi = 0; pi < mdev->num_planar_planes; ++pi) {

        int plane_depth = mdev->planes[pi].depth;

        int shift = mdev->planes[pi].shift;

        gx_color_index mask = ((gx_color_index)1 << plane_depth) - 1;

        const gdev_mem_functions *fns =

                               gdev_mem_functions_for_bits(plane_depth);

        /*

         * Divide up the transfer into chunks that can be assembled

         * within the fixed-size buffer.  This code can be simplified

         * a lot if all planes have the same depth, by simply using

         * copy_color to transfer one column at a time, but it might

         * be very inefficient.

         */

        uint plane_raster = bitmap_raster(plane_depth * w);

        int br, bw, bh, cx, cy, cw, ch, ix, iy;

        MEM_SET_PARAMS(mdev, plane_depth);

        if (plane_raster > BUF_BYTES) {

            br = BUF_BYTES;

            bw = BUF_BYTES * 8 / plane_depth;

            bh = 1;

        } else {

            br = plane_raster;

            bw = w;

            bh = BUF_BYTES / plane_raster;

        }

        /*

         * We could do the extraction with get_bits_rectangle

         * selecting a single plane, but this is critical enough

         * code that we more or less replicate it here.

         */

        for (cy = y; cy < y + h; cy += ch) {

            ch = min(bh, y + h - cy);

            for (cx = x; cx < x + w; cx += cw) {

                int sx = sourcex + cx - x;

                const byte *source_base = base + sraster * (cy - y);

                int source_bit = 0;

                cw = min(bw, x + w - cx);

                if (sx) {

                    int xbit = sx * source_depth;

                    source_base += xbit >> 3;

                    source_bit = xbit & 7;

                }

                for (iy = 0; iy < ch; ++iy) {

                    const byte *sptr =source_base;

                    int sbit = source_bit;

                    byte *dptr = buf.b + br * iy;

                    int dbit = 0;

                    byte dbbyte = (dbit ? (byte)(*dptr & (0xff00 >> dbit)) : 0);

                    for (ix = 0; ix < cw; ++ix) {

                        gx_color_index value;

                        if (sizeof(value) > 4){

                            if (sample_load_next64((uint64_t *)&value, &sptr, &sbit, source_depth) < 0)

                                return_error(gs_error_rangecheck);

                        }

                        else {

                            if (sample_load_next32((uint32_t *)&value, &sptr, &sbit, source_depth) < 0)

                                return_error(gs_error_rangecheck);

                        }

                        value = (value >> shift) & mask;

                        if (sample_store_next16(value, &dptr, &dbit, plane_depth,

                                            &dbbyte) < 0)

                            return_error(gs_error_rangecheck);

                    }

                    sample_store_flush(dptr, dbit, dbbyte);

                    source_base += sraster;

                }

                /*

                 * Detect and bypass the possibility that copy_color is

                 * defined in terms of copy_mono.

                 */

                if (plane_depth == 1)

                    fns->copy_mono

                        (dev, buf.b, 0, br, gx_no_bitmap_id, cx, cy, cw, ch,

                         (gx_color_index)0, (gx_color_index)1);

                else

                    fns->copy_color

                        (dev, buf.b, 0, br, gx_no_bitmap_id, cx, cy, cw, ch);

            }

        }

        mdev->line_ptrs += mdev->height;

    }

    MEM_RESTORE_PARAMS(mdev, save);

    return 0;

#undef BUF_BYTES

#undef BUF_LONGS

}

/* Copy a given bitmap into a bitmap. */

static int

mem_planar_copy_planes(gx_device * dev, const byte * base, int sourcex,

                       int sraster, gx_bitmap_id id,

                       int x, int y, int w, int h, int plane_height)

{

    gx_device_memory * const mdev = (gx_device_memory *)dev;

    mem_save_params_t save;

    int code = 0;

    int plane;

    MEM_SAVE_PARAMS(mdev, save);

    for (plane = 0; plane < mdev->num_planar_planes; plane++)

    {

        int plane_depth = mdev->planes[plane].depth;

        const gdev_mem_functions *fns =

                               gdev_mem_functions_for_bits(plane_depth);

        if (plane_depth == 1)

            code = fns->copy_mono(dev, base, sourcex, sraster, id,

                                  x, y, w, h,

                                  (gx_color_index)0, (gx_color_index)1);

        else

            code = fns->copy_color(dev, base, sourcex, sraster,

                                   id, x, y, w, h);

        base += sraster * (size_t)plane_height;

        mdev->line_ptrs += mdev->height;

    }

    MEM_RESTORE_PARAMS(mdev, save);

    return code;

}

int

mem_planar_strip_tile_rect_devn(gx_device * dev, const gx_strip_bitmap * tiles,

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

                                const gx_drawing_color *pdcolor0,

                                const gx_drawing_color *pdcolor1, int px, int py)

{

    gx_device_memory * const mdev = (gx_device_memory *)dev;