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

   All Rights Reserved.

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

   implied.

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

   modified or distributed except as expressly authorized under the terms

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

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

   Artifex Software, Inc.,  1305 Grant Avenue - Suite 200, Novato,

   CA 94945, U.S.A., +1(415)492-9861, for further information.

*/

/* Command list interpreter/rasterizer */

#include "memory_.h"

#include "gx.h"

#include "gp.h"                 /* for gp_fmode_rb */

#include "gpcheck.h"

#include "gserrors.h"

#include "gscdefs.h"            /* for image type table */

#include "gsbitops.h"

#include "gsparams.h"

#include "gsstate.h"            /* (should only be gs_gstate) */

#include "gstrans.h"    /* for gs_is_pdf14trans_compositor */

#include "gxdcolor.h"

#include "gxdevice.h"

#include "gscoord.h"            /* requires gsmatrix.h */

#include "gsdevice.h"           /* for gs_deviceinitialmatrix */

#include "gsiparm4.h"

#include "gxdevmem.h"           /* must precede gxcldev.h */

#include "gxcldev.h"

#include "gxclpath.h"

#include "gxcmap.h"

#include "gxcolor2.h"

#include "gxcspace.h"           /* for gs_color_space_type */

#include "gxdhtres.h"

#include "gxgetbit.h"

#include "gxpaint.h"            /* for gx_fill/stroke_params */

#include "gxpcolor.h"

#include "gxhttile.h"

#include "gxiparam.h"

#include "gximask.h"

#include "gzpath.h"

#include "gzcpath.h"

#include "gzacpath.h"

#include "stream.h"

#include "strimpl.h"

#include "gxcomp.h"

#include "gsserial.h"

#include "gxdhtserial.h"

#include "gzht.h"

#include "gxshade.h"

#include "gxshade4.h"

#include "gsicc_manage.h"

#include "gsicc.h"

extern_gx_device_halftone_list();

extern_gx_image_type_table();

/* We need color space types for constructing temporary color spaces. */

extern const gs_color_space_type gs_color_space_type_Indexed;

/* Print a bitmap for tracing */

#ifdef DEBUG

static void

cmd_print_bits(gs_memory_t *mem, const byte * data, int width, int height, int raster)

{

    int i, j;

    dmlprintf3(mem, "[L]width=%d, height=%d, raster=%d\n",

              width, height, raster);

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

        const byte *row = data + i * raster;

        dmlprintf(mem, "[L]");

        for (j = 0; j < raster; j++)

            dmprintf1(mem, " %02x", row[j]);

        dmputc(mem, '\n');

    }

}

#else

#  define cmd_print_bits(mem, data, width, height, raster) DO_NOTHING

#endif

/* Get a variable-length integer operand. */

#define cmd_getw(var, p)\

  BEGIN\

    if ( *p < 0x80 ) var = *p++;\

    else { const byte *_cbp; var = cmd_get_w(p, &_cbp); p = _cbp; }\

  END

static long

cmd_get_w(const byte * p, const byte ** rp)

{

    int val = *p++ & 0x7f;

    int shift = 7;

    for (; val |= (int)(*p & 0x7f) << shift, *p++ > 0x7f; shift += 7);

    *rp = p;

    return val;

}

/* Get a variable-length fractional operand. */

#define cmd_getfrac(var, p)\

  BEGIN\

    if ( !(*p & 1) ) var = (*p++) << 24;\

    else { const byte *_cbp; var = cmd_get_frac31(p, &_cbp); p = _cbp; }\

  END

static frac31

cmd_get_frac31(const byte * p, const byte ** rp)

{

    frac31 val = (*p++ & 0xFE) << 24;

    int shift = 24 - 7;

    for (; val |= (frac31)(*p & 0xFE) << shift, *p++ & 1; shift -= 7);

    *rp = p;

    return val;

}

/*

 * Define the structure for keeping track of the command reading buffer.

 *

 * The ptr member is only used for passing the current pointer to, and

 * receiving an updated pointer from, commands implemented as separate

 * procedures: normally it is kept in a register.

 */

typedef struct command_buf_s {

    byte *data;                 /* actual buffer, guaranteed aligned */

    uint size;

    const byte *ptr;            /* next byte to be read (see above) */

    const byte *warn_limit;     /* refill warning point */

    const byte *end;            /* byte just beyond valid data */

    stream *s;                  /* for refilling buffer */

    int end_status;

} command_buf_t;

/* Set the end of a command buffer. */

static void

set_cb_end(command_buf_t *pcb, const byte *end)

{

    pcb->end = end;

    pcb->warn_limit = pcb->data + (pcb->size - cmd_largest_size + 1);

    if ( pcb->warn_limit > pcb->end )

        pcb->warn_limit = pcb->end;     /**** This is dangerous. Other places ****/

                                        /**** assume that the limit is a soft ****/

                                        /**** limit and should check 'end'    ****/

}

static inline void

advance_buffer(command_buf_t *pcb, const byte *cbp)

{

#ifdef DEBUG

    stream_state *st = pcb->s->state;

    top_up_offset_map(st, pcb->data, cbp, pcb->end);

#endif

    memmove(pcb->data, cbp, pcb->end - cbp);

}

static inline void

next_is_skip(command_buf_t *pcb)

{

#ifdef DEBUG

    stream_state *st = pcb->s->state;

    offset_map_next_data_out_of_band(st);

#endif

}

/* Read more data into a command buffer. */

static int

top_up_cbuf(command_buf_t *pcb, const byte **pcbp)

{

    uint nread;

    const byte *cbp = *pcbp;

    byte *cb_top = pcb->data + (pcb->end - cbp);

    if (cbp < pcb->data || cbp > pcb->end) {

        errprintf(pcb->s->memory, "Clist I/O error: cbp outside of buffer\n");

        return (gs_error_ioerror);

    }

    if (seofp(pcb->s)) {

        /* Can't use offset_map, because s_close resets s->state. Don't top up. */

        pcb->end_status = pcb->s->end_status;

        return 0;

    }

    advance_buffer(pcb, cbp);

    nread = pcb->end - cb_top;

    pcb->end_status = sgets(pcb->s, cb_top, nread, &nread);

    if ( nread == 0 ) {

        /* No data for this band at all. */

        if (cb_top >= pcb->end) {

            /* should not happen */

            *pcbp = pcb->data;

            pcb->data[0] = cmd_opv_end_run;

            return_error(gs_error_ioerror);

        }

        *cb_top = cmd_opv_end_run;

        nread = 1;

    }

    set_cb_end(pcb, cb_top + nread);

    process_interrupts(pcb->s->memory);

    *pcbp = pcb->data;

    return 0;

}

/* Read data from the command buffer and stream. */

/* From the command_buffer pcb, read rsize bytes to ptr, starting from cbp.

 * Return the new value for pcb->ptr. */

static const byte *

cmd_read_data(command_buf_t *pcb, byte *ptr, uint rsize, const byte *cbp)

{

    if (pcb->end - cbp >= rsize) {

        memmove(ptr, cbp, rsize);

        return cbp + rsize;

    } else {

        uint cleft = pcb->end - cbp;

        uint rleft = rsize - cleft;

        memmove(ptr, cbp, cleft);

        sgets(pcb->s, ptr + cleft, rleft, &rleft);

#ifdef DEBUG

        {

            stream_state *st = pcb->s->state;

            adjust_offset_map_for_skipped_data(st, (uint)(pcb->end - pcb->data), rleft);

        }

#endif

        return pcb->end;

    }

}

/* Read a fixed-size value from the command buffer. */

static inline const byte *

cmd_copy_value(void *pvar, int var_size, const byte *cbp)

{

    memcpy(pvar, cbp, var_size);

    return cbp + var_size;

}

#define cmd_get_value(var, cbp)\

  cbp = cmd_copy_value(&var, sizeof(var), cbp)

/*

 * Define a buffer structure to hold a serialized halftone. This is

 * used only if the serialized halftone is too large to fit into

 * the command buffer.

 */

typedef struct ht_buff_s {

    uint    ht_size, read_size;

    byte *  pcurr;

    byte *  pbuff;

} ht_buff_t;

/*

 * Render one band to a specified target device.  Note that if

 * action == setup, target may be 0.

 */

static int read_set_tile_size(command_buf_t *pcb, tile_slot *bits, bool for_pattern);

static int read_set_bits(command_buf_t *pcb, tile_slot *bits,

                          int compress, gx_clist_state *pcls,

                          gx_strip_bitmap *tile, tile_slot **pslot,

                          gx_device_clist_reader *cdev, gs_memory_t *mem);

static int read_set_misc2(command_buf_t *pcb, gs_gstate *pgs,

                           segment_notes *pnotes);

static int read_set_color_space(command_buf_t *pcb, gs_gstate *pgs,

                                 gx_device_clist_reader *cdev, gs_memory_t *mem);

static int read_begin_image(command_buf_t *pcb, gs_image_common_t *pic,

                             gs_color_space *pcs);

static int read_put_params(command_buf_t *pcb, gs_gstate *pgs,

                            gx_device_clist_reader *cdev,

                            gs_memory_t *mem);

static int read_composite(command_buf_t *pcb, gs_memory_t *mem, gs_composite_t **ppcomp);

static int apply_composite(gx_device_clist_reader *cdev, gs_gstate *pgs,

                                   gs_memory_t *mem, gs_composite_t *pcomp,

                                   int x0, int y0, gx_device **ptarget);

static int read_alloc_ht_buff(ht_buff_t *, uint, gs_memory_t *);

static int read_ht_segment(ht_buff_t *, command_buf_t *, gs_gstate *,

                            gx_device *, gs_memory_t *);

static const byte *cmd_read_rect(int, gx_cmd_rect *, const byte *);

static const byte *cmd_read_short_bits(command_buf_t *pcb, byte *data, int tot_bytes,

                                        int width_bytes, int height,

                                        uint raster, const byte *cbp);

static int cmd_select_map(cmd_map_index, cmd_map_contents,

                           gs_gstate *, int **,

                           frac **, uint *, gs_memory_t *);

static int cmd_create_dev_ht(gx_device_halftone **, gs_memory_t *);

static int cmd_resize_halftone(gx_device_halftone **, uint,

                                gs_memory_t *);

static int clist_decode_segment(gx_path *, int, fixed[6],

                                 gs_fixed_point *, int, int,

                                 segment_notes);

static int clist_do_polyfill(gx_device *, gx_path *,

                              const gx_drawing_color *,

                              gs_logical_operation_t);

static inline void

enqueue_compositor(gs_composite_t **ppcomp_first, gs_composite_t **ppcomp_last, gs_composite_t *pcomp)

{

    if (*ppcomp_last == NULL) {

        pcomp->prev = pcomp->next = NULL;

        *ppcomp_last = *ppcomp_first = pcomp;

    } else {

        (*ppcomp_last)->next = pcomp;

        pcomp->prev = *ppcomp_last;

        pcomp->next = NULL;

        *ppcomp_last = pcomp;

    }

}

#if 0 /* Appears unused - keep for a while. */

static inline gs_composite_t *

dequeue_last_compositor(gs_composite_t **ppcomp_first, gs_composite_t **ppcomp_last)

{

    gs_composite_t *pcomp = *ppcomp_last;

    if (*ppcomp_first == *ppcomp_last)

        *ppcomp_first = *ppcomp_last = NULL;

    else {

        *ppcomp_last = (*ppcomp_last)->prev;

        pcomp->prev = NULL;

        (*ppcomp_last)->next = NULL;

    }

    return pcomp;

}

static inline gs_composite_t *

dequeue_first_compositor(gs_composite_t **ppcomp_first, gs_composite_t **ppcomp_last)

{

    gs_composite_t *pcomp = *ppcomp_first;

    if (*ppcomp_first == *ppcomp_last)

        *ppcomp_first = *ppcomp_last = NULL;

    else {

        *ppcomp_first = (*ppcomp_first)->next;

        pcomp->next = NULL;

        (*ppcomp_last)->prev = NULL;

    }

    return pcomp;

}

#endif

static inline int

dequeue_compositor(gs_composite_t **ppcomp_first, gs_composite_t **ppcomp_last, gs_composite_t *pcomp)

{

    if (*ppcomp_last == *ppcomp_first) {

        if (*ppcomp_last == pcomp) {

            *ppcomp_last = *ppcomp_first = NULL;

            return 0;

        } else

            return_error(gs_error_unregistered); /* Must not happen. */

    } else {

        gs_composite_t *pcomp_next = pcomp->next, *pcomp_prev = pcomp->prev;

        if (*ppcomp_last == pcomp)

            *ppcomp_last = pcomp->prev;

        else

            pcomp_next->prev = pcomp_prev;

        if (*ppcomp_first == pcomp)

            *ppcomp_first = pcomp->next;

        else

            pcomp_prev->next = pcomp_next;

        pcomp->next = pcomp->prev = NULL;

        return 0;

    }

}

static inline void

free_compositor(gs_composite_t *pcomp, gs_memory_t *mem)

{

    gs_free_object(mem, pcomp, "free_compositor");

}

static inline bool

is_null_compositor_op(const byte *cbp, int *length)

{

    if (cbp[0] == cmd_opv_end_run) {

        *length = 1;

        return true;

    }

    return false;

}

static int

execute_compositor_queue(gx_device_clist_reader *cdev, gx_device **target, gx_device **tdev, gs_gstate *pgs,

                         gs_composite_t **ppcomp_first, gs_composite_t **ppcomp_last, gs_composite_t *pcomp_from,

                         int x0, int y0, gs_memory_t *mem, bool idle)

{

    while (pcomp_from != NULL) {

        gs_composite_t *pcomp = pcomp_from;

        int code;

        pcomp_from = pcomp->next;

        code = dequeue_compositor(ppcomp_first, ppcomp_last, pcomp);

        if (code < 0)

            return code;

        pcomp->idle |= idle;

        code = apply_composite(cdev, pgs, mem, pcomp, x0, y0, target); /* Releases the compositor. */

        if (code < 0)

            return code;

        *tdev = *target;

    }

    return 0;

}

static void

mark_as_idle(gs_composite_t *pcomp_start, gs_composite_t *pcomp_end)

{

    gs_composite_t *pcomp = pcomp_start;

    while (pcomp != NULL) {

        pcomp->idle = true;

        if (pcomp == pcomp_end)

            break;

        pcomp = pcomp->next;

    }

}

static inline int

drop_compositor_queue(gs_composite_t **ppcomp_first, gs_composite_t **ppcomp_last,

                      gs_composite_t *pcomp_from, gs_memory_t *mem, int x0, int y0,

                      gs_gstate *pgs)

{

    gs_composite_t *pcomp;

    do {

        int code;

        pcomp = *ppcomp_last;

        if (pcomp == NULL)

            return 0;

        dequeue_compositor(ppcomp_first, ppcomp_last, *ppcomp_last);

        code = pcomp->type->procs.adjust_ctm(pcomp, x0, y0, pgs);

        if (code < 0)

            return code;

        free_compositor(pcomp, mem);

    } while (pcomp != pcomp_from);

    return 0;

}

static int

read_set_misc_map(byte cb, command_buf_t *pcb, gs_gstate *pgs, gs_memory_t *mem)

{

    const byte *cbp = pcb->ptr;

    frac *mdata;

    int *pcomp_num;

    uint count = 0;   /* quiet compiler */

    cmd_map_contents cont =

        (cmd_map_contents)(cb & 0x30) >> 4;

    int code;

    code = cmd_select_map(cb & 0xf, cont,

                          pgs,

                          &pcomp_num,

                          &mdata, &count, mem);

    if (code < 0)

        return code;

    /* Get component number if relevant */

    if (pcomp_num == NULL)

        cbp++;

    else {

        *pcomp_num = (int) *cbp++;

        if_debug1m('L', mem, " comp_num=%d", *pcomp_num);

    }

    if (cont == cmd_map_other) {

        cbp = cmd_read_data(pcb, (byte *)mdata, count, cbp);

#ifdef DEBUG

        if (gs_debug_c('L')) {

            uint i;

            for (i = 0; i < count / sizeof(*mdata); ++i)

                dmprintf1(mem, " 0x%04x", mdata[i]);

            dmputc(mem, '\n');

        }

    } else {

        if_debug0m('L', mem, " none\n");

#endif

    }

    /* Recompute the effective transfer, */

    /* in case this was a transfer map. */

    gx_gstate_set_effective_xfer(pgs);

    pcb->ptr = cbp;

    return 0;

}

#ifdef DEBUG

void clist_debug_op(gs_memory_t *mem, const unsigned char *cbp)

{

    unsigned char op = *cbp++;

    const char *const *sub = cmd_sub_op_names[op >> 4];

    if (op == cmd_opv_extend) {

        unsigned char op2 = *cbp;

        if (cmd_extend_op_names[op2])

            dmlprintf1(mem, " %s", cmd_extend_op_names[op2]);

        else

            dmlprintf1(mem, " ?0x%02x?", (int)op2);

    } else if (sub)

        dmlprintf1(mem, " %s", sub[op & 0xf]);

    else

        dmlprintf2(mem, " %s %d", cmd_op_names[op >> 4], op & 0xf);

}

#endif

int

clist_playback_band(clist_playback_action playback_action, /* lgtm [cpp/use-of-goto] */

                    gx_device_clist_reader *cdev, stream *s,

                    gx_device *target, int x0, int y0,

                    gs_memory_t * mem)

{

    byte *cbuf_storage;

    command_buf_t cbuf;

    /* data_bits is for short copy_* bits and copy_* compressed, */

    /* must be aligned */

    byte *data_bits = 0;

    const byte *cbp;

    int dev_depth;              /* May vary due to compositing devices */

    int dev_depth_bytes;

    int odd_delta_shift;

    int num_zero_bytes;

    gx_device *tdev;

    gx_clist_state state;

    gx_color_index *set_colors;

    gx_device_color *set_dev_colors;

    tile_slot *state_slot;

    gx_strip_bitmap state_tile; /* parameters for reading tiles */

    tile_slot tile_bits;        /* parameters of current tile */

    gs_int_point tile_phase;

    gx_path path;

    bool in_path;

    gs_fixed_point ppos;

    gx_clip_path clip_path;

    bool use_clip;

    gx_clip_path *pcpath;

    gx_device_cpath_accum clip_accum;

    gs_fixed_rect target_box;

    struct _cas {

        bool lop_enabled;

        gx_device_color dcolor;

        gs_fixed_point fa_save;

    } clip_save;

    bool in_clip = false;

    gs_gstate gs_gstate;

    gx_device_color fill_color = { 0 };

    gx_device_color stroke_color = { 0 };

    float dash_pattern[cmd_max_dash];

    gx_fill_params fill_params;

    gx_stroke_params stroke_params;

#ifdef DEBUG

    gs_halftone_type halftone_type;

#endif

    union im_ {

        gs_image_common_t c;

        gs_data_image_t d;

        gs_image1_t i1;

        gs_image4_t i4;

    } image;

    gs_int_rect image_rect;

    gs_color_space *pcs = NULL;

    gx_image_enum_common_t *image_info;

    gx_image_plane_t planes[32];

    uint data_height;

    uint data_size;

    byte *data_on_heap;

    fixed vs[6];

    segment_notes notes;

    int data_x;

    int code = 0;

    ht_buff_t  ht_buff;

    gx_device *const orig_target = target;

    gx_device_clip clipper_dev;

    bool clipper_dev_open;

    patch_fill_state_t pfs;

    int op = 0;

    int plane_height = 0;

#ifdef DEBUG

    stream_state *st = s->state; /* Save because s_close resets s->state. */

#endif

    gs_composite_t *pcomp_first = NULL, *pcomp_last = NULL;

    tile_slot bits;             /* parameters for reading bits */

    /* pad the cbuf data area a bit (just in case) */

    if ((cbuf_storage = gs_alloc_bytes(mem, cbuf_size + sizeof(double),

                               "clist_playback_band(cbuf_storage)")) == NULL) {

        return_error(gs_error_VMerror);

    }

    cbuf.data = (byte *)cbuf_storage;

    cbuf.size = cbuf_size;

    cbuf.s = s;

    cbuf.end_status = 0;

    set_cb_end(&cbuf, cbuf.data + cbuf.size);

    cbp = cbuf.end;

    pfs.dev = NULL; /* Indicate "not initialized". */

    memset(&ht_buff, 0, sizeof(ht_buff));

    /* The following initializations are to quiet gcc warnings. */

    memset(&bits, 0, sizeof(bits));

    memset(&tile_bits, 0, sizeof(tile_bits));

    memset(&clip_save, 0, sizeof(clip_save));

    memset(&state_slot, 0, sizeof(state_slot));

    ppos.x = ppos.y = 0;

in:                             /* Initialize for a new page. */

    tdev = target;

    set_colors = state.colors;

    set_dev_colors = state.tile_color_devn;

    use_clip = false;

    pcpath = NULL;

    clipper_dev_open = false;

    notes = sn_none;

    data_x = 0;

    {

        static const gx_clist_state cls_initial = { cls_initial_values };

        state = cls_initial;

    }

    state_tile.id = gx_no_bitmap_id;

    state_tile.shift = state_tile.rep_shift = 0;

    state_tile.size.x = state_tile.size.y = 0;

    state_tile.num_planes = 1;

    tile_phase.x = x0;

    tile_phase.y = y0;

    gx_path_init_local(&path, mem);

    in_path = false;

    /*

     * Initialize the clipping region to the full page.

     * (Since we also initialize use_clip to false, this is arbitrary.)

     */

    {

        gs_fixed_rect cbox;

        gx_cpath_init_local(&clip_path, mem);

        cbox.p.x = 0;

        cbox.p.y = 0;

        cbox.q.x = cdev->width;

        cbox.q.y = cdev->height;

        gx_cpath_from_rectangle(&clip_path, &cbox);

    }

    if (target != 0)

        (*dev_proc(target, get_clipping_box))(target, &target_box);

    memset(&gs_gstate, 0, sizeof(gs_gstate));

    GS_STATE_INIT_VALUES_CLIST((&gs_gstate));

    code = gs_gstate_initialize(&gs_gstate, mem);

    if (code < 0)

        goto out;

    gs_gstate.device = tdev;

    gs_gstate.view_clip = NULL; /* Avoid issues in pdf14 fill stroke */

    gs_gstate.clip_path = &clip_path;

    pcs = gs_cspace_new_DeviceGray(mem);

    if (pcs == NULL) {

        code = gs_note_error(gs_error_VMerror);

        goto out;

    }

    code = pcs->type->install_cspace(pcs, &gs_gstate);

    if (code < 0) {

        rc_decrement(pcs, "clist_playback_band");

        goto out;

    }

    gs_gstate.color[0].color_space = pcs; /* we already have one ref */

    gs_gstate.color[1].color_space = pcs;

    rc_increment_cs(pcs); /* increment for second ref */

    /* Initialize client color and device color */

    gs_gstate.color[0].ccolor =

        gs_alloc_struct(mem, gs_client_color, &st_client_color, "clist_playback_band");

    gs_gstate.color[1].ccolor =

        gs_alloc_struct(mem, gs_client_color, &st_client_color, "clist_playback_band");

    gs_gstate.color[0].dev_color =

        gs_alloc_struct(mem, gx_device_color, &st_device_color, "clist_playback_band");

    gs_gstate.color[1].dev_color =

        gs_alloc_struct(mem, gx_device_color, &st_device_color, "clist_playback_band");

    if (gs_gstate.color[0].ccolor == 0 || gs_gstate.color[0].dev_color == 0 ||

        gs_gstate.color[1].ccolor == 0 || gs_gstate.color[1].dev_color == 0

        ) {

        gs_free_object(mem, gs_gstate.color[1].ccolor, "clist_playback_band");

        gs_free_object(mem, gs_gstate.color[0].dev_color, "clist_playback_band");

        gs_free_object(mem, gs_gstate.color[1].dev_color, "clist_playback_band");

        return_error(gs_error_VMerror);

    }

    gs_gstate.color[0].color_space->pclient_color_space_data =

        pcs->pclient_color_space_data;

    cs_full_init_color(gs_gstate.color[0].ccolor, pcs);

    gx_unset_dev_color(&gs_gstate);

    gs_gstate.color[1].color_space->pclient_color_space_data =

        pcs->pclient_color_space_data;

    cs_full_init_color(gs_gstate.color[1].ccolor, pcs);

    gx_unset_dev_color(&gs_gstate);

    /* Remove the ICC link cache and replace with the device link cache

       so that we share the cache across bands */

    rc_decrement(gs_gstate.icc_link_cache,"clist_playback_band");

    gs_gstate.icc_link_cache = cdev->icc_cache_cl;

    /* Need to lock during the increment of the link cache */

    gx_monitor_enter(cdev->icc_cache_cl->lock);

    rc_increment(cdev->icc_cache_cl);

    gx_monitor_leave(cdev->icc_cache_cl->lock); /* let everyone run */

    if (code < 0)

        goto out;

    gs_gstate.line_params.dash.pattern = dash_pattern;

    if (tdev != 0) {

        gx_set_cmap_procs(&gs_gstate, tdev);

    }

    gx_gstate_setscreenphase(&gs_gstate, -x0, -y0, gs_color_select_all);

#ifdef DEBUG

    halftone_type = ht_type_none;

#endif

    fill_color.ccolor_valid = false;

    color_unset(&fill_color);

    data_bits = gs_alloc_bytes(mem, data_bits_size,

                               "clist_playback_band(data_bits)");

    if (data_bits == 0) {

        code = gs_note_error(gs_error_VMerror);

        goto out;

    }

    while (code >= 0) {

        int compress;

        int depth = 0x7badf00d; /* Initialize against indeterminizm. */

        int raster = 0x7badf00d; /* Initialize against indeterminizm. */

        byte *source = NULL;  /* Initialize against indeterminizm. */

        gx_color_index colors[2];

        gx_color_index *pcolor;

        gx_device_color *pdcolor = NULL;

        gs_logical_operation_t log_op;

        /* Make sure the buffer contains a full command. */

        if (cbp >= cbuf.warn_limit) {

            if (cbuf.end_status < 0) {  /* End of file or error. */

                if (cbp >= cbuf.end) {

                    code = (cbuf.end_status == EOFC ? 0 :

                            gs_note_error(gs_error_ioerror));

                    break;

                }

            } else {

                code = top_up_cbuf(&cbuf, &cbp);

                if (code < 0)

                    goto top_up_failed;

            }

        }

        op = *cbp++;

#ifdef DEBUG

        if (gs_debug_c('L')) {

            int64_t offset = clist_file_offset(st, cbp - 1 - cbuf.data);

            dmlprintf1(mem, "[L] %"PRIu64":", offset);

            clist_debug_op(mem, cbp-1);

        }

#endif

        switch (op >> 4) {

            case cmd_op_misc >> 4:

                switch (op) {

                    case cmd_opv_end_run:

                        if_debug0m('L', mem, "\n");

                        continue;

                    case cmd_opv_set_tile_size:

                        cbuf.ptr = cbp;

                        code = read_set_tile_size(&cbuf, &tile_bits,

                                    gx_device_is_pattern_clist((gx_device *)cdev));

                        cbp = cbuf.ptr;

                        if (code < 0)

                            goto out;

                        continue;

                    case cmd_opv_set_tile_phase:

                        cmd_getw(state.tile_phase.x, cbp);

                        cmd_getw(state.tile_phase.y, cbp);

                        if_debug2m('L', mem, " (%d,%d)\n",

                                   state.tile_phase.x,

                                   state.tile_phase.y);

                        goto set_tile_phase;

                    case cmd_opv_set_screen_phaseT:

                        cmd_getw(state.screen_phase[gs_color_select_texture].x, cbp);

                        cmd_getw(state.screen_phase[gs_color_select_texture].y, cbp);

                        if_debug2m('L', mem, " (%d,%d)\n",

                                   state.screen_phase[0].x,

                                   state.screen_phase[gs_color_select_texture].y);

                        gx_gstate_setscreenphase(&gs_gstate,

                                                 state.screen_phase[gs_color_select_texture].x - x0,

                                                 state.screen_phase[gs_color_select_texture].y - y0,

                                                 gs_color_select_texture);

                        continue;

                    case cmd_opv_set_screen_phaseS:

                        cmd_getw(state.screen_phase[gs_color_select_source].x, cbp);

                        cmd_getw(state.screen_phase[gs_color_select_source].y, cbp);

                        if_debug2m('L', mem, " (%d,%d)\n",

                                   state.screen_phase[gs_color_select_source].x,

                                   state.screen_phase[gs_color_select_source].y);

                        gx_gstate_setscreenphase(&gs_gstate,

                                                 state.screen_phase[gs_color_select_source].x - x0,

                                                 state.screen_phase[gs_color_select_source].y - y0,

                                                 gs_color_select_source);

                        continue;

                    case cmd_opv_set_tile_bits:

                        bits = tile_bits;

                        compress = 0;

                      stb:

                        cbuf.ptr = cbp;

                        code = read_set_bits(&cbuf, &bits, compress,

                                             &state, &state_tile, &state_slot,

                                             cdev, mem);

                        cbp = cbuf.ptr;

                        if (code < 0)

                            goto out;

                        goto stp;

                    case cmd_opv_set_bits:

do_opv_set_bits:

                        compress = *cbp & 3;

                        bits.head.depth = *cbp++ >> 2;

                        cmd_getw(bits.width, cbp);

                        cmd_getw(bits.height, cbp);

                        if (op == cmd_opv_set_bits_planar)

                            cmd_getw(bits.num_planes, cbp);

                        else

                            bits.num_planes = 1;

                        if_debug5m('L', mem, " compress=%d depth=%d size=(%d,%d) planes=%d",

                                   compress, bits.head.depth,

                                   bits.width, bits.height, bits.num_planes);

                        bits.raster =

                            bitmap_raster(bits.width * bits.head.depth);

                        bits.x_reps = bits.y_reps = 1;

                        bits.shift = bits.rep_shift = 0;

                        goto stb;

                    case cmd_opv_set_tile_color:

                        set_colors = state.tile_colors;

                        if_debug0m('L', mem, "\n");

                        continue;

                    case cmd_opv_set_misc:

                        {

                            uint cb = *cbp++;

                            switch (cb >> 6) {

                                case cmd_set_misc_lop >> 6:

                                    cmd_getw(state.lop, cbp);

                                    state.lop = (state.lop << 6) + (cb & 0x3f);

                                    if_debug1m('L', mem, " lop=0x%x\n", state.lop);

                                    if (state.lop_enabled)

                                        gs_gstate.log_op = state.lop;

                                    break;

                                case cmd_set_misc_data_x >> 6:

                                    if (cb & 0x20)

                                        cmd_getw(data_x, cbp);

                                    else

                                        data_x = 0;

                                    data_x = (data_x << 5) + (cb & 0x1f);

                                    if_debug1m('L', mem, " data_x=%d\n", data_x);

                                    break;

                                case cmd_set_misc_map >> 6:

                                    cbuf.ptr = cbp;

                                    code = read_set_misc_map(cb, &cbuf, &gs_gstate, mem);

                                    if (code < 0)

                                        goto out;

                                    cbp = cbuf.ptr;

                                    break;

                                case cmd_set_misc_halftone >> 6: {

                                    uint num_comp;

#ifdef DEBUG

                                    halftone_type = cb & 0x3f;

#endif

                                    cmd_getw(num_comp, cbp);

#ifdef DEBUG

                                    if_debug2m('L', mem, " halftone type=%d num_comp=%u\n",

                                               halftone_type, num_comp);

#endif

                                    code = cmd_resize_halftone(

                                                        &gs_gstate.dev_ht[HT_OBJTYPE_DEFAULT],

                                                        num_comp, mem);

                                    if (code < 0)

                                        goto out;

                                    break;

                                }

                                default:

                                    goto bad_op;

                            }

                        }

                        continue;

                    case cmd_opv_enable_lop:

                        state.lop_enabled = true;

                        gs_gstate.log_op = state.lop;

                        if_debug0m('L', mem, "\n");

                        continue;

                    case cmd_opv_disable_lop:

                        state.lop_enabled = false;

                        gs_gstate.log_op = lop_default;

                        if_debug0m('L', mem, "\n");

                        continue;

                    case cmd_opv_end_page:

                        if_debug0m('L', mem, "\n");

                        /*

                         * Do end-of-page cleanup, then reinitialize if

                         * there are more pages to come.

                         */

                        goto out;

                    case cmd_opv_delta_color0:

                        pcolor = &set_colors[0];

                        goto delta2_c;

                    case cmd_opv_delta_color1:

                        pcolor = &set_colors[1];

                      delta2_c:set_colors = state.colors;

                        /* See comments for cmd_put_color() in gxclutil.c. */

                        {

                            gx_color_index delta = 0;

                            uint data;

                            dev_depth = (tdev->color_info.depth <= 8*sizeof(gx_color_index) ?

                                         tdev->color_info.depth : 8*sizeof(gx_color_index));

                            dev_depth_bytes = (dev_depth + 7) >> 3;

                            switch (dev_depth_bytes) {

                                /* For cases with an even number of bytes */

                                case 8:

                                    data = *cbp++;

                                    delta = (((gx_color_index)

                                        ((data & 0xf0) << 4) + (data & 0x0f)) << 24) << 24;

                                    /* fall through */

                                case 6:

                                    data = *cbp++;

                                    delta |= (((gx_color_index)

                                        ((data & 0xf0) << 4) + (data & 0x0f)) << 16) << 16;

                                    /* fall through */

                                case 4:

                                    data = *cbp++;

                                    delta |= ((gx_color_index)

                                        ((data & 0xf0) << 4) + (data & 0x0f)) << 16;

                                    /* fall through */

                                case 2:

                                    data = *cbp++;

                                    delta |= ((gx_color_index)

                                        ((data & 0xf0) << 4) + (data & 0x0f));

                                    break;

                                /* For cases with an odd number of bytes */

                                case 7:

                                    data = *cbp++;

                                    delta = ((gx_color_index)

                                        ((data & 0xf0) << 4) + (data & 0x0f)) << 16;

                                    /* fall through */

                                case 5:

                                    data = *cbp++;

                                    delta |= ((gx_color_index)

                                        ((data & 0xf0) << 4) + (data & 0x0f));

                                    /* fall through */

                                case 3:

                                    data = *cbp++;

                                    odd_delta_shift = (dev_depth_bytes - 3) * 8;

                                    delta |= ((gx_color_index)

                                        ((data & 0xe0) << 3) + (data & 0x1f)) << odd_delta_shift;

                                    data = *cbp++;

                                    delta |= ((gx_color_index) ((data & 0xf8) << 2) + (data & 0x07))

                                                        << (odd_delta_shift + 11);

                            }

                            *pcolor += delta - cmd_delta_offsets[dev_depth_bytes];

                        }

                        if (sizeof(*pcolor) <= sizeof(ulong))

                            if_debug1m('L', mem, " 0x%lx\n", (ulong)*pcolor);

                        else

                            if_debug2m('L', mem, " 0x%8lx%08lx\n",

                                       (ulong)(*pcolor >> 8*(sizeof(*pcolor) - sizeof(ulong))), (ulong)*pcolor);

                        continue;

                    case cmd_opv_set_copy_color:

                        state.color_is_alpha = 0;

                        if_debug0m('L', mem, "\n");

                        continue;

                    case cmd_opv_set_copy_alpha:

                        state.color_is_alpha = 1;

                        if_debug0m('L', mem, "\n");

                        continue;

                    default:

                        goto bad_op;

                }

                /*NOTREACHED */

            case cmd_op_set_color0 >> 4:

                pcolor = &set_colors[0];

                goto set_color;

            case cmd_op_set_color1 >> 4:

                pcolor = &set_colors[1];

              set_color:set_colors = state.colors;

                /*

                 * We have a special case for gx_no_color_index. If the low

                 * order 4 bits are "cmd_no_color_index" then we really

                 * have a value of gx_no_color_index.  Otherwise the these

                 * bits indicate the number of low order zero bytes in the

                 * value.  See comments for cmd_put_color() in gxclutil.c.

                 */

                num_zero_bytes = op & 0x0f;

                if (num_zero_bytes == cmd_no_color_index)

                    *pcolor = gx_no_color_index;

                else {

                    gx_color_index color = 0;

                    dev_depth = (tdev->color_info.depth < 8*sizeof(gx_color_index) ?

                                 tdev->color_info.depth : 8*sizeof(gx_color_index));

                    dev_depth_bytes = (dev_depth + 7) >> 3;

                    switch (dev_depth_bytes - num_zero_bytes) {

                        case 8:

                            color = (gx_color_index) * cbp++;

                        case 7:

                            color = (color << 8) | (gx_color_index) * cbp++;

                        case 6:

                            color = (color << 8) | (gx_color_index) * cbp++;

                        case 5:

                            color = (color << 8) | (gx_color_index) * cbp++;

                        case 4:

                            color = (color << 8) | (gx_color_index) * cbp++;

                        case 3:

                            color = (color << 8) | (gx_color_index) * cbp++;

                        case 2:

                            color = (color << 8) | (gx_color_index) * cbp++;

                        case 1:

                            color = (color << 8) | (gx_color_index) * cbp++;

                        default:

                            break;

                    }

                    color <<= num_zero_bytes * 8;

                    *pcolor = color;

                }

                if (sizeof(*pcolor) <= sizeof(ulong))

                    if_debug1m('L', mem, " 0x%lx\n", (ulong)*pcolor);

                else

                    if_debug2m('L', mem, " 0x%8lx%08lx\n",

                               (ulong)(*pcolor >> 8*(sizeof(*pcolor) - sizeof(ulong))), (ulong)*pcolor);

                continue;

            case cmd_op_fill_rect >> 4: