/* Copyright (C) 2001-2024 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.

*/

/* Higher-level image operations for band lists */

#include "math_.h"

#include "memory_.h"

#include "string_.h"    /* for strcmp */

#include "gx.h"

#include "gserrors.h"

#include "gscspace.h"

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

#include "gxarith.h"

#include "gxcspace.h"

#include "gxpcolor.h"

#include "gxdevice.h"

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

#include "gxcldev.h"

#include "gxclpath.h"

#include "gxfmap.h"

#include "gxiparam.h"

#include "gxpath.h"

#include "stream.h"

#include "strimpl.h"            /* for sisparam.h */

#include "sisparam.h"

#include "gxcomp.h"

#include "gsserial.h"

#include "gxdhtserial.h"

#include "gsptype1.h"

#include "gsicc_manage.h"

#include "gsicc_cache.h"

#include "gxdevsop.h"

#include "gscindex.h"

#include "gsicc_cms.h"

#include "gximdecode.h"

extern_gx_image_type_table();

/* Define whether we should use high-level images. */

/* (See below for additional restrictions.) */

static const bool USE_HL_IMAGES = true;

/* Forward references */

static int cmd_put_set_data_x(gx_device_clist_writer * cldev,

                               gx_clist_state * pcls, int data_x);

static bool check_rect_for_trivial_clip(

    const gx_clip_path *pcpath,  /* May be NULL, clip to evaluate */

    int px, int py, int qx, int qy  /* corners of box to test */

);

static bool

palette_has_color(const gs_color_space *pcs, const gs_pixel_image_t * const pim)

{

    gs_color_space *pbcs = pcs->base_space;

    gs_color_space_index base_type = gs_color_space_get_index(pbcs);

    bool ((*is_neutral)(void*, int));

    int bps = pim->BitsPerComponent;

    int num_entries = 1 << bps;

    int k;

    byte psrc[4];

    switch(base_type) {

    case gs_color_space_index_DeviceGray:

    case gs_color_space_index_CIEA:

        return false;

        break;

    case gs_color_space_index_DeviceRGB:

    case gs_color_space_index_CIEABC:

    case gs_color_space_index_CIEDEF:

        is_neutral = &gsicc_mcm_monitor_rgb;

        break;

    case gs_color_space_index_DeviceCMYK:

    case gs_color_space_index_CIEDEFG:

        is_neutral = &gsicc_mcm_monitor_cmyk;

        break;

     case gs_color_space_index_DevicePixel:

     case gs_color_space_index_DeviceN:

     case gs_color_space_index_Separation:

     case gs_color_space_index_Indexed:

     case gs_color_space_index_Pattern:

        return true;

        break;

     case gs_color_space_index_ICC:

        switch(pbcs->cmm_icc_profile_data->data_cs) {

        case gsRGB:

            is_neutral = &gsicc_mcm_monitor_rgb;

            break;

        case gsCMYK:

            is_neutral = &gsicc_mcm_monitor_cmyk;

            break;

        case gsCIELAB:

            is_neutral = &gsicc_mcm_monitor_lab;

            break;

        default:

            return true;

        }

        break;

     default:

        return true;

    }

    /* Now go through the palette with the check color function */

    for (k = 0; k < num_entries; k++) {

        (void)gs_cspace_indexed_lookup_bytes(pcs, (float) k, psrc); /* this always returns 0 */

        if (!is_neutral(psrc, 1)) {

            /* Has color end this now */

            return true;

        }

    }

    /* Must not have color */

    return false;

}

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

int

clist_fill_mask(gx_device * dev,

                const byte * data, int data_x, int raster, gx_bitmap_id id,

                int rx, int ry, int rwidth, int rheight,

                const gx_drawing_color * pdcolor, int depth,

                gs_logical_operation_t lop, const gx_clip_path * pcpath)

{

    gx_device_clist_writer * const cdev =

        &((gx_device_clist *)dev)->writer;

    const byte *orig_data = data;       /* for writing tile */

    int orig_data_x = data_x;   /* ditto */

    int orig_x = rx;            /* ditto */

    int orig_width = rwidth;    /* ditto */

    int orig_height = rheight;  /* ditto */

    int y0;

    byte copy_op =

        (depth > 1 ? cmd_op_copy_color_alpha :

         cmd_op_copy_mono_planes);  /* Plane not needed here */

    bool slow_rop =

        cmd_slow_rop(dev, lop_know_S_0(lop), pdcolor) ||

        cmd_slow_rop(dev, lop_know_S_1(lop), pdcolor);

    cmd_rects_enum_t re;

    /* If depth > 1, this call will be translated to a copy_alpha call. */

    /* if the target device can't perform copy_alpha, exit now. */

    if (depth > 1 && (cdev->disable_mask & clist_disable_copy_alpha) != 0)

        return_error(gs_error_unknownerror);

    crop_copy(cdev, data, data_x, raster, id, rx, ry, rwidth, rheight);

    if (rwidth <= 0 || rheight <= 0)

        return 0;

    y0 = ry;                    /* must do after fit_copy */

    /* If non-trivial clipping & complex clipping disabled, default */

    /* Also default for uncached bitmap or non-default lop; */

    /* We could handle more RasterOp cases here directly, but it */

    /* doesn't seem worth the trouble right now. */

    /* Lastly, the command list will translate calls with depth > 1 to */

    /* copy_alpha calls, so the device color must be pure */

    if (((cdev->disable_mask & clist_disable_complex_clip) &&

         !check_rect_for_trivial_clip(pcpath, rx, ry, rx + rwidth, ry + rheight)) ||

        gs_debug_c('`') || id == gx_no_bitmap_id || lop != lop_default ||

        (depth > 1 && !color_writes_pure(pdcolor, lop))

        )

  copy:

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

                                    rx, ry, rwidth, rheight, pdcolor, depth,

                                    lop, pcpath);

    if (cmd_check_clip_path(cdev, pcpath))

        cmd_clear_known(cdev, clip_path_known);

    if (cdev->permanent_error < 0)

      return (cdev->permanent_error);

    /* If needed, update the trans_bbox */

    if (cdev->pdf14_needed) {

        gs_int_rect bbox;

        bbox.p.x = rx;

        bbox.q.x = rx + rwidth - 1;

        bbox.p.y = ry;

        bbox.q.y = ry + rheight - 1;

        clist_update_trans_bbox(cdev, &bbox);

    }

    RECT_ENUM_INIT(re, ry, rheight);

    do {

        int code;

        ulong offset_temp;

        RECT_STEP_INIT(re);

        code = cmd_update_lop(cdev, re.pcls, lop);

        if (code < 0)

            return code;

        if (depth > 1 && !re.pcls->color_is_alpha) {

            byte *dp;

            code = set_cmd_put_op(&dp, cdev, re.pcls, cmd_opv_set_copy_alpha, 1);

            if (code < 0)

                return code;

            re.pcls->color_is_alpha = 1;

        }

        code = cmd_do_write_unknown(cdev, re.pcls, clip_path_known);

        if (code >= 0)

            code = cmd_do_enable_clip(cdev, re.pcls, pcpath != NULL);

        if (code < 0)

            return code;

        code = cmd_put_drawing_color(cdev, re.pcls, pdcolor, &re,

                                     devn_not_tile_fill);

        if (code == gs_error_unregistered)

            return code;

        if (depth > 1 && code >= 0)

            code = cmd_set_color1(cdev, re.pcls, pdcolor->colors.pure);

        if (code < 0)

            return code;

        re.pcls->color_usage.slow_rop |= slow_rop;

        /* Put it in the cache if possible. */

        if (!cls_has_tile_id(cdev, re.pcls, id, offset_temp)) {

            gx_strip_bitmap tile;

            tile.data = (byte *) orig_data;     /* actually const */

            tile.raster = raster;

            tile.size.x = tile.rep_width = orig_width;

            tile.size.y = tile.rep_height = orig_height;

            tile.rep_shift = tile.shift = 0;

            tile.id = id;

            tile.num_planes = 1;

            code = clist_change_bits(cdev, re.pcls, &tile, depth);

            if (code < 0) {

                /* Something went wrong; just copy the bits. */

                goto copy;

            }

        }

        {

            gx_cmd_rect rect;

            int rsize;

            byte op = copy_op + cmd_copy_use_tile;

            /* Output a command to copy the entire character. */

            /* It will be truncated properly per band. */

            rect.x = orig_x, rect.y = y0;

            rect.width = orig_width, rect.height = re.yend - y0;

            rsize = 1 + cmd_sizexy(rect);

            if (depth == 1) rsize = rsize + cmd_sizew(0);  /* need planar_height 0 setting */

            code = (orig_data_x ?

                    cmd_put_set_data_x(cdev, re.pcls, orig_data_x) : 0);

            if (code >= 0) {

                byte *dp;

                code = set_cmd_put_op(&dp, cdev, re.pcls, op, rsize);

                /*

                 * The following conditional is unnecessary: the two

                 * statements inside it should go outside the

                 * HANDLE_RECT.  They are here solely to pacify

                 * stupid compilers that don't understand that dp

                 * will always be set if control gets past the

                 * HANDLE_RECT.

                 */

                if (code >= 0) {

                    dp++;

                    if (depth == 1) {

                        cmd_putw(0, &dp);

                    }

                    cmd_putxy(rect, &dp);

                }

            }

            if (code < 0)

                return code;

            re.pcls->rect = rect;

        }

    } while ((re.y += re.height) < re.yend);

    return 0;

}

/* ------ Bitmap image driver procedures ------ */

/* Define the structure for keeping track of progress through an image. */

typedef struct clist_image_enum_s {

    gx_image_enum_common;

    /* Arguments of begin_image */

    gs_pixel_image_t image;     /* only uses Width, Height, Interpolate */

    gx_drawing_color dcolor;    /* only pure right now */

    gs_int_rect rect;

    const gx_clip_path *pcpath;

    /* Set at creation time */

    gs_image_format_t format;

    gs_int_point support;       /* extra source pixels for interpolation */

    int bits_per_plane;         /* bits per pixel per plane */

    gs_matrix matrix;           /* image space -> device space */

    bool uses_color;

    bool masked;

    clist_color_space_t color_space;

    int ymin, ymax;

    gx_color_usage_t color_usage;

    /* begin_image command prepared & ready to output */

    /****** SIZE COMPUTATION IS WRONG, TIED TO gximage.c, gsmatrix.c ******/

    byte begin_image_command[3 +

                            /* Width, Height */

                            2 * cmd_sizew_max +

                            /* ImageMatrix */

                            1 + 6 * sizeof(float) +

                            /* Decode */

                            (GS_IMAGE_MAX_COMPONENTS + 3) / 4 +

                              GS_IMAGE_MAX_COMPONENTS * 2 * sizeof(float) +

                            /* MaskColors */

                            GS_IMAGE_MAX_COMPONENTS * cmd_sizew_max +

                            /* rect */

                            4 * cmd_sizew_max];

    int begin_image_command_length;

    /* Updated dynamically */

    int y;

    bool color_map_is_known;

    bool monitor_color;

    image_decode_t decode;

    byte *buffer;  /* needed for unpacking during monitoring */

} clist_image_enum;

gs_private_st_suffix_add3(st_clist_image_enum, clist_image_enum,

                          "clist_image_enum", clist_image_enum_enum_ptrs,

                          clist_image_enum_reloc_ptrs, st_gx_image_enum_common,

                          pcpath, color_space.space, buffer);

static image_enum_proc_plane_data(clist_image_plane_data);

static image_enum_proc_end_image(clist_image_end_image);

static const gx_image_enum_procs_t clist_image_enum_procs =

{

    clist_image_plane_data, clist_image_end_image

};

/* data_size is number of bytes per component, width is number of pixels in the row. */

static bool

row_has_color(byte *data_ptr, clist_image_enum *pie_c, int data_size, int width)

{

    clist_color_space_t pclcs = pie_c->color_space;

    bool ((*is_neutral)(void*, int));

    int step_size = data_size * pie_c->decode.spp;

    byte *ptr;

    bool is_mono;

    int k;

    if (pclcs.icc_info.is_lab) {

        is_neutral = &gsicc_mcm_monitor_lab;

    } else {

        switch(pclcs.icc_info.icc_num_components) {

        case 3:

            is_neutral = &gsicc_mcm_monitor_rgb;

            break;

        case 4:

            is_neutral = &gsicc_mcm_monitor_cmyk;

            break;

        default:

            return true;

        }

    }

    /* Now go through the raster line and determine if we have any color. */

    ptr = data_ptr;

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

        is_mono = is_neutral(ptr, data_size);

        if (!is_mono) {

            return true;

        }

        ptr += step_size;

    }

    return false;

}

/* Forward declarations */

static bool image_band_box(gx_device * dev, const clist_image_enum * pie,

                            int y, int h, gs_int_rect * pbox);

static int begin_image_command(byte *buf, uint buf_size,

                                const gs_image_common_t *pic);

static int cmd_image_plane_data(gx_device_clist_writer * cldev,

                                 gx_clist_state * pcls,

                                 const gx_image_plane_t * planes,

                                 const gx_image_enum_common_t * pie,

                                 uint bytes_per_plane,

                                 const uint * offsets, int dx, int h);

static int cmd_image_plane_data_mon(gx_device_clist_writer * cldev,

                                 gx_clist_state * pcls,

                                 const gx_image_plane_t * planes,

                                 const gx_image_enum_common_t * pie,

                                 uint bytes_per_plane,

                                 const uint * offsets, int dx, int h,

                                 bool *found_color);

static uint clist_image_unknowns(gx_device *dev,

                                  const clist_image_enum *pie);

static int write_image_end_all(gx_device *dev,

                                const clist_image_enum *pie);

/*

 * Since currently we are limited to writing a single subrectangle of the

 * image for each band, images that are rotated by angles other than

 * multiples of 90 degrees may wind up writing many copies of the data.

 * Eventually we will fix this by breaking up the image into multiple

 * subrectangles, but for now, don't use the high-level approach if it would

 * cause the data to explode because of this.

 */

static bool

image_matrix_ok_to_band(const gs_matrix * pmat)

{

    double t;

    /* Detecting a downscale when it's really noscale upsets some

     * customers code, so we add a fudge factor in here. This may

     * cause us to allow the use of high level images for some downscales

     * that are *nearly* noscales, but our code will cope with that. */

    float one = (float)(1.0 - 1e-5);

    /* Don't band if the matrix is (nearly) singular. */

    if (fabs(pmat->xx * pmat->yy - pmat->xy * pmat->yx) < 0.001)

        return false;

    /* If it's portrait, then we encode it if not a downscale */

    if (is_xxyy(pmat))

        return (fabs(pmat->xx) >= one) && (fabs(pmat->yy) >= one);

    /* If it's landscape, then we encode it if not a downscale */

    if (is_xyyx(pmat))

        return (fabs(pmat->xy) >= one) && (fabs(pmat->yx) >= one);

    /* Skewed, so do more expensive downscale test */

    if ((pmat->xx * pmat->xx + pmat->xy * pmat->xy < one) ||

        (pmat->yx * pmat->yx + pmat->yy * pmat->yy < one))

        return false;

    /* Otherwise only encode it if it doesn't rotate too much */

    t = (fabs(pmat->xx) + fabs(pmat->yy)) /

        (fabs(pmat->xy) + fabs(pmat->yx));

    return (t < 0.2 || t > 5);

}

/* Start processing an image. */

int

clist_begin_typed_image(gx_device * dev, const gs_gstate * pgs,

                        const gs_matrix * pmat, const gs_image_common_t * pic,

                        const gs_int_rect * prect, const gx_drawing_color * pdcolor,

                        const gx_clip_path * pcpath, gs_memory_t * mem,

                        gx_image_enum_common_t ** pinfo)

{

    const gs_pixel_image_t * const pim = (const gs_pixel_image_t *)pic;

    gx_device_clist_writer * const cdev =

        &((gx_device_clist *)dev)->writer;

    clist_image_enum *pie = 0;

    int base_index;

    bool indexed;

    bool masked = false;

    bool has_alpha = false;

    int num_components;

    int bits_per_pixel;

    bool uses_color;

    bool varying_depths = false;

    gs_matrix mat;

    gs_rect sbox, dbox;

    gs_image_format_t format;

    gx_color_usage_bits color_usage = 0;

    int code;

    bool mask_use_hl;

    clist_icc_color_t icc_zero_init = { 0 };

    cmm_profile_t *src_profile;

    cmm_srcgtag_profile_t *srcgtag_profile;

    gsicc_rendering_intents_t renderingintent;

    gsicc_blackptcomp_t blackptcomp;

    gsicc_rendering_param_t stored_rendering_cond;

    gsicc_rendering_param_t dev_render_cond;

    gs_gstate *pgs_nonconst = (gs_gstate*) pgs;

    bool intent_changed = false;

    bool bp_changed = false;

    cmm_dev_profile_t *dev_profile = NULL;

    cmm_profile_t *gs_output_profile;

    bool is_planar_dev = !!dev->num_planar_planes;

    bool render_is_valid;

    int csi;

    gx_clip_path *lpcpath = NULL;

    if (pgs == NULL) {

        /* At this time, this cannot/should not ever happen,

           so it's fatal if it does.

         */

        return_error(gs_error_Fatal);

    }

    renderingintent = pgs->renderingintent;

    blackptcomp = pgs->blackptcomp;

    /* We can only handle a limited set of image types. */

    switch ((gs_debug_c('`') ? -1 : pic->type->index)) {

    case 1:

        masked = ((const gs_image1_t *)pim)->ImageMask;

        has_alpha = ((const gs_image1_t *)pim)->Alpha != 0;

        /* fall through */

    case 4:

        if (pmat == 0)

            break;

    default:

        goto use_default;

    }

    format = pim->format;

    /* See above for why we allocate the enumerator as immovable. */

    pie = gs_alloc_struct_immovable(mem, clist_image_enum,

                                    &st_clist_image_enum,

                                    "clist_begin_typed_image");

    if (pie == 0)

        return_error(gs_error_VMerror);

#ifdef PACIFY_VALGRIND

    /* The following memset is required to avoid a valgrind warning

     * in:

     *   gs -I./gs/lib -sOutputFile=out.pgm -dMaxBitmap=10000

     *      -sDEVICE=pgmraw -r300 -Z: -sDEFAULTPAPERSIZE=letter

     *      -dNOPAUSE -dBATCH -K2000000 -dClusterJob -dJOBSERVER

     *      tests_private/ps/ps3cet/11-14.PS

     * Setting the individual elements of the structure directly is

     * not enough, which leads me to believe that we are writing the

     * entire struct out, padding and all.

     */

    memset(&pie->color_space.icc_info, 0, sizeof(pie->color_space.icc_info));

#endif

    pie->memory = mem;

    pie->buffer = NULL;

    pie->masked = masked;

    *pinfo = (gx_image_enum_common_t *) pie;

    /* num_planes and plane_depths[] are set later, */

    /* by gx_image_enum_common_init. */

    if (masked) {

        base_index = gs_color_space_index_DeviceGray;   /* arbitrary */

        indexed = false;

        num_components = 1;

        uses_color = true;

        /* cmd_put_drawing_color handles color_usage */

    } else {

        const gs_color_space *pcs = pim->ColorSpace;

        base_index = gs_color_space_get_index(pcs);

        if (base_index == gs_color_space_index_Indexed) {

            const gs_color_space *pbcs =

                gs_color_space_indexed_base_space(pcs);

            indexed = true;

            base_index = gs_color_space_get_index(pbcs);

            num_components = 1;

        } else {

            indexed = false;

            num_components = gs_color_space_num_components(pcs);

        }

        uses_color = pim->CombineWithColor &&

                    (rop3_uses_T(pgs->log_op) || rop3_uses_S(pgs->log_op));

    }

    code = gx_image_enum_common_init((gx_image_enum_common_t *) pie,

                                     (const gs_data_image_t *) pim,

                                     &clist_image_enum_procs, dev,

                                     num_components, format);

    {

        int i;

        for (i = 1; i < pie->num_planes; ++i)

            varying_depths |= pie->plane_depths[i] != pie->plane_depths[0];

    }

    /* Now, check to see if we can't handle this as a high level image. */

    if (code < 0)

        goto use_default;

    if (!USE_HL_IMAGES) /* Always use the default. */

        goto use_default;

    if (cdev->disable_mask & clist_disable_hl_image)

        goto use_default;

    if (cdev->image_enum_id != gs_no_id) /* Can't handle nested images */

        goto use_default;

    if (base_index > gs_color_space_index_DeviceCMYK &&

        base_index != gs_color_space_index_ICC)

        /****** Can only handle Gray, RGB, CMYK and ICC ******/

        goto use_default;

    if (has_alpha)

        /****** CAN'T HANDLE IMAGES WITH ALPHA YET ******/

        goto use_default;

    if (varying_depths)

        /****** CAN'T HANDLE IMAGES WITH IRREGULAR DEPTHS ******/

        goto use_default;

    if ((code = gs_matrix_invert(&pim->ImageMatrix, &mat)) < 0 ||

        (code = gs_matrix_multiply(&mat, &ctm_only(pgs), &mat)) < 0 ||

        !(cdev->disable_mask & clist_disable_nonrect_hl_image ?

          (is_xxyy(&mat) || is_xyyx(&mat)) :

          image_matrix_ok_to_band(&mat)))

        goto use_default;

    mask_use_hl =

        masked && ( gx_dc_is_pattern1_color(pdcolor) || gx_dc_is_pure(pdcolor) );

    if (!mask_use_hl && uses_color && !gx_dc_is_pure(pdcolor) &&

             !gx_dc_is_pattern1_color_clist_based(pdcolor))

        /* Only add in masks that are pure or pattern or pattern trans types */

        goto use_default;

    /* We've passed the tests; code it as a high level image */

    {

        int bytes_per_plane, bytes_per_row;

        bits_per_pixel = pim->BitsPerComponent * num_components;

        pie->decode.bps = bits_per_pixel/num_components;

        pie->decode.spp = num_components;

        pie->image = *pim;

        pie->dcolor = *pdcolor;

        if (prect)

            pie->rect = *prect;

        else {

            pie->rect.p.x = 0, pie->rect.p.y = 0;

            pie->rect.q.x = pim->Width, pie->rect.q.y = pim->Height;

        }

        pie->pgs = pgs;

        pie->pgs_level = pgs->level;

        if (pcpath) {

            lpcpath = gx_cpath_alloc(mem, "clist_begin_typed_image(lpcpath)");

            if (!lpcpath) {

                goto use_default;

            }

            code = gx_cpath_copy(pcpath, lpcpath);

            if (code < 0) {

                goto use_default;

            }

        }

        pie->pcpath = lpcpath;

        pie->buffer = NULL;

        pie->format = format;

        pie->bits_per_plane = bits_per_pixel / pie->num_planes;

        pie->matrix = mat;

        pie->uses_color = uses_color;

        if (masked) {

            pie->color_space.byte1 = 0;  /* arbitrary */

            pie->color_space.icc_info = icc_zero_init;

            pie->color_space.space = 0;

            pie->color_space.id = gs_no_id;

        } else {

            /* Check for presence of ICC profiles in standard Device Color Spaces

               This can happen if a default space was initialized. It should

               typically have assigned to it one of the default ICC profiles */

            if (indexed) {

                if (pim->ColorSpace->base_space->cmm_icc_profile_data) {

                    base_index = gs_color_space_index_ICC;

                }

            } else {

                if (pim->ColorSpace->cmm_icc_profile_data) {

                    base_index = gs_color_space_index_ICC;

                }

            }

            pie->color_space.byte1 = (base_index << 4) |

                (indexed ? (pim->ColorSpace->params.indexed.use_proc ? 12 : 8) : 0);

            pie->color_space.id =

                (pie->color_space.space = pim->ColorSpace)->id;

            /* Get the hash code of the ICC space */

            if ( base_index == gs_color_space_index_ICC ) {

                code = dev_proc(dev, get_profile)(dev,  &dev_profile);

                gsicc_extract_profile(dev->graphics_type_tag, dev_profile,

                                      &(gs_output_profile),

                                      (&(dev_render_cond)));

                if (!indexed) {

                    src_profile = pim->ColorSpace->cmm_icc_profile_data;

                } else {

                    src_profile =

                        pim->ColorSpace->base_space->cmm_icc_profile_data;

                }

                /* Initialize the rendering conditions to what we currently

                   have before we may blow them away with what is set in

                   the srcgtag information */

                stored_rendering_cond.graphics_type_tag = GS_IMAGE_TAG;

                stored_rendering_cond.override_icc =

                                dev_render_cond.override_icc;

                stored_rendering_cond.preserve_black =

                                dev_render_cond.preserve_black;

                stored_rendering_cond.cmm = gsCMM_DEFAULT;  /* Unless spec. below */

                /* We may need to do some substitions for the source profile */

                if (pgs->icc_manager->srcgtag_profile != NULL) {

                    srcgtag_profile = pgs->icc_manager->srcgtag_profile;

                    if (src_profile->data_cs == gsRGB) {

                        if (srcgtag_profile->rgb_profiles[gsSRC_IMAGPRO] != NULL) {

                            /* We only do this replacement depending upon the

                               ICC override setting for this object and the

                               original color space of this object */

                            csi = gsicc_get_default_type(src_profile);

                            if (srcgtag_profile->rgb_rend_cond[gsSRC_IMAGPRO].override_icc ||

                                csi == gs_color_space_index_DeviceRGB) {

                                src_profile =

                                    srcgtag_profile->rgb_profiles[gsSRC_IMAGPRO];

                                pgs_nonconst->renderingintent =

                                    srcgtag_profile->rgb_rend_cond[gsSRC_IMAGPRO].rendering_intent;

                                pgs_nonconst->blackptcomp =

                                    srcgtag_profile->rgb_rend_cond[gsSRC_IMAGPRO].black_point_comp;

                                stored_rendering_cond =

                                    srcgtag_profile->rgb_rend_cond[gsSRC_IMAGPRO];

                            }

                        } else {

                            /* A possible do not use CM case */

                            stored_rendering_cond.cmm =

                                srcgtag_profile->rgb_rend_cond[gsSRC_IMAGPRO].cmm;

                        }

                    } else if (src_profile->data_cs == gsCMYK) {

                        if (srcgtag_profile->cmyk_profiles[gsSRC_IMAGPRO] != NULL) {

                            csi = gsicc_get_default_type(src_profile);

                            if (srcgtag_profile->cmyk_rend_cond[gsSRC_IMAGPRO].override_icc ||

                                csi == gs_color_space_index_DeviceCMYK) {

                                src_profile =

                                    srcgtag_profile->cmyk_profiles[gsSRC_IMAGPRO];

                                pgs_nonconst->renderingintent =

                                    srcgtag_profile->cmyk_rend_cond[gsSRC_IMAGPRO].rendering_intent;

                                pgs_nonconst->blackptcomp =

                                    srcgtag_profile->cmyk_rend_cond[gsSRC_IMAGPRO].black_point_comp;

                                stored_rendering_cond =

                                    srcgtag_profile->cmyk_rend_cond[gsSRC_IMAGPRO];

                            }

                        } else {

                            /* A possible do not use CM case */

                            stored_rendering_cond.cmm =

                                srcgtag_profile->cmyk_rend_cond[gsSRC_IMAGPRO].cmm;

                        }

                    }

                }

                /* If the device RI is set and we are not  setting the RI from

                   the source structure, then override any RI specified in the

                   document by the RI specified in the device */

                if (!(pgs_nonconst->renderingintent & gsRI_OVERRIDE)) {  /* was set by source? */

                    /* No it was not.  See if we should override with the

                       device setting */

                    if (dev_render_cond.rendering_intent != gsRINOTSPECIFIED) {

                        pgs_nonconst->renderingintent =

                                        dev_render_cond.rendering_intent;

                        }

                }

                /* We have a similar issue to deal with with respect to the

                   black point.  */

                if (!(pgs_nonconst->blackptcomp & gsBP_OVERRIDE)) {

                    if (dev_render_cond.black_point_comp != gsBPNOTSPECIFIED) {

                        pgs_nonconst->blackptcomp =

                                            dev_render_cond.black_point_comp;

                    }

                }

                if (renderingintent != pgs_nonconst->renderingintent)

                    intent_changed = true;

                if (blackptcomp != pgs_nonconst->blackptcomp)

                    bp_changed = true;

                /* Set for the rendering param structure also */

                stored_rendering_cond.rendering_intent =

                                                pgs_nonconst->renderingintent;

                stored_rendering_cond.black_point_comp =

                                                pgs_nonconst->blackptcomp;

                stored_rendering_cond.graphics_type_tag = GS_IMAGE_TAG;

                if (!(src_profile->hash_is_valid)) {

                    int64_t hash;

                    gsicc_get_icc_buff_hash(src_profile->buffer, &hash,

                                            src_profile->buffer_size);

                    src_profile->hashcode = hash;

                    src_profile->hash_is_valid = true;

                }

                pie->color_space.icc_info.icc_hash = src_profile->hashcode;

                pie->color_space.icc_info.icc_num_components =

                    src_profile->num_comps;

                pie->color_space.icc_info.is_lab = src_profile->islab;

                pie->color_space.icc_info.default_match = src_profile->default_match;

                pie->color_space.icc_info.data_cs = src_profile->data_cs;

                src_profile->rend_cond = stored_rendering_cond;

                render_is_valid = src_profile->rend_is_valid;

                src_profile->rend_is_valid = true;

                clist_icc_addentry(cdev, src_profile->hashcode, src_profile);

                src_profile->rend_is_valid = render_is_valid;

            } else {

                pie->color_space.icc_info = icc_zero_init;

            }

        }

        pie->y = pie->rect.p.y;

        /* Image row has to fit in cmd writer's buffer */

        bytes_per_plane =

            (pim->Width * pie->bits_per_plane + 7) >> 3;

        bytes_per_row = bytes_per_plane * pie->num_planes;

        bytes_per_row = max(bytes_per_row, 1);

        if (cmd_largest_size + bytes_per_row > cdev->cend - cdev->cbuf)

            goto use_default;

    }

    if (pim->Interpolate) {

        pie->support.x = pie->support.y = MAX_ISCALE_SUPPORT + 1;

    } else {

        pie->support.x = pie->support.y = 0;

    }

    sbox.p.x = pie->rect.p.x - pie->support.x;

    sbox.p.y = pie->rect.p.y - pie->support.y;

    sbox.q.x = pie->rect.q.x + pie->support.x;

    sbox.q.y = pie->rect.q.y + pie->support.y;

    gs_bbox_transform(&sbox, &mat, &dbox);

    if (cdev->disable_mask & clist_disable_complex_clip)

        if (!check_rect_for_trivial_clip(lpcpath,

                                (int)floor(dbox.p.x), (int)floor(dbox.p.y),

                                (int)ceil(dbox.q.x), (int)ceil(dbox.q.y)))

            goto use_default;

    /* If we are going out to a halftone device and the size of the stored

       image at device resolution and color space is going to be smaller,

       go ahead and do the default handler. This occurs only for planar

       devices where if we prerender we will end up doing the fast theshold

       halftone and going out as copy_planes commands into the clist.

       There is already a test above with regard to the posture so that

       we are only doing portrait or landscape cases if we are here.  Only

       question is penum->image_parent_type == gs_image_type1 */

    if (dev_profile == NULL) {

        gsicc_rendering_param_t temp_render_cond;

        code = dev_proc(dev, get_profile)(dev,  &dev_profile);

        if (code < 0)

            return code;

        gsicc_extract_profile(dev->graphics_type_tag, dev_profile,

                                              &(gs_output_profile),

                                              &(temp_render_cond));

    }

    /* Decide if we need to do any monitoring of the colors.  Note that multiple source

       (planes) is treated as color */

    pie->decode.unpack = NULL;

    if (dev_profile->pageneutralcolor && pie->color_space.icc_info.data_cs != gsGRAY) {

        /* If it is an index image, then check the pallete only */

        if (!indexed) {

            pie->monitor_color = true;

            /* Set up the unpacking proc for monitoring */

            get_unpack_proc((gx_image_enum_common_t*) pie, &(pie->decode),

                             pim->format, pim->Decode);

            get_map(&(pie->decode), pim->format, pim->Decode);

            if (pie->decode.unpack == NULL) {

                /* If we cant unpack, then end monitoring now. Treat as has color */

                dev_profile->pageneutralcolor = false;

                code = gsicc_mcm_end_monitor(pgs->icc_link_cache, dev);

                if (code < 0)

                    return code;

            } else {

                /* We need to allocate the buffer for unpacking during monitoring.

                    This is mainly for the 12bit case */

                int bsize = ((pie->decode.bps > 8 ? (pim->Width) * 2 : pim->Width) + 15) * num_components;

                pie->buffer = gs_alloc_bytes(mem, bsize, "image buffer");

                if (pie->buffer == 0) {

                    gs_free_object(mem, pie, "clist_begin_typed_image");

                    *pinfo = NULL;

                    return_error(gs_error_VMerror);

                }

            }

        } else {

            pie->monitor_color = false;

            /* Check the Palette here */

            if (palette_has_color(pim->ColorSpace, pim)) {

                /* Has color.  We are done monitoring */

                dev_profile->pageneutralcolor = false;

                code = gsicc_mcm_end_monitor(pgs->icc_link_cache, dev);

                if (code < 0)

                    return code;

            }

        }

    } else {

        pie->monitor_color = false;

    }

    if (gx_device_must_halftone(dev) && pim->BitsPerComponent == 8 && !masked &&

        (dev->color_info.num_components == 1 || is_planar_dev) &&

        dev_profile->prebandthreshold) {

        int dev_width = (int)(ceil(dbox.q.x) - floor(dbox.p.x));

        int dev_height = (int)(ceil(dbox.q.y) - floor(dbox.p.y));

        int src_size = pim->Height *

                       bitmap_raster(pim->Width * pim->BitsPerComponent *

                                     num_components);

        int des_size = dev_height * bitmap_raster(dev_width *

                                                  dev->color_info.depth);

        if (src_size > des_size)

            goto use_default;

    }

    /* Create the begin_image command. */

    if ((pie->begin_image_command_length =

         begin_image_command(pie->begin_image_command,

                             sizeof(pie->begin_image_command), pic)) < 0)

        goto use_default;

    if (!masked) {

        /*

         * Calculate (conservatively) the set of colors that this image

         * might generate.  For single-component images we can sample

         * this. We generate all the possible colors now; otherwise,

         * we assume that any color might be generated.  It is possible

         * to do better than this, but we won't bother unless there's

         * evidence that it's worthwhile.

         */

        gx_color_usage_bits all = gx_color_usage_all(cdev);

        if (num_components > 1)

            color_usage = all;

        else {

            const gs_color_space *pcs = pim->ColorSpace;

            cs_proc_remap_color((*remap_color)) = pcs->type->remap_color;

            gs_client_color cc;

            gx_drawing_color dcolor;

            int i;

            int max_value = indexed ? pcs->params.indexed.hival : 1;

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

                /* Enumerate the indexed colors, or just Black (DeviceGray = 0) */

                cc.paint.values[0] = (double)i;

                code = remap_color(&cc, pcs, &dcolor, pgs, dev,

                            gs_color_select_source);

                if (code < 0)

                    break;

                color_usage |= cmd_drawing_color_usage(cdev, &dcolor);

            }

            if (code < 0)

                goto use_default;

        }

    }

    pie->color_usage.or = color_usage;

    pie->color_usage.slow_rop =

        cmd_slow_rop(dev, pgs->log_op, (uses_color ? pdcolor : NULL));

    pie->color_map_is_known = false;

    /*

     * Calculate a (slightly conservative) Y bounding interval for the image

     * in device space.

     */

    {

        int y0 = (int)floor(dbox.p.y - 0.51);   /* adjust + rounding slop */

        int y1 = (int)ceil(dbox.q.y + 0.51);    /* ditto */

        if (lpcpath) {

            gs_fixed_rect obox;

            gx_cpath_outer_box(lpcpath, &obox);

            pie->ymin = max(0, max(y0, fixed2int(obox.p.y)));

            pie->ymax = min(min(y1, fixed2int(obox.q.y)), dev->height);

        } else {

            pie->ymin = max(y0, 0);

            pie->ymax = min(y1, dev->height);

        }

    }

    /*

     * Make sure the CTM, color space, and clipping region (and, for

     * masked images or images with CombineWithColor, the current color)

     * are known at the time of the begin_image command.

     */

    cmd_clear_known(cdev, clist_image_unknowns(dev, pie) | begin_image_known);

    /* Because the rendering intent may be driven by the source color

       settings we may have needed to overide the intent.  Need to break the const

       on the pgs here for this and reset back */

    if (intent_changed)

        pgs_nonconst->renderingintent = renderingintent;

    if (bp_changed)

        pgs_nonconst->blackptcomp = blackptcomp;

    cdev->image_enum_id = pie->id;

    return 0;

    /*

     * We couldn't handle the image.  It is up to the caller to use the default

     * algorithms, which break the image up into rectangles or small pixmaps.

     * If we are doing the PDF14 transparency device then we want to make sure we do

     * NOT use the target device.  In this case we return -1.

     */

use_default:

    if (pie != NULL)

        gs_free_object(mem, pie->buffer, "clist_begin_typed_image");

    gs_free_object(mem, pie, "clist_begin_typed_image");

    *pinfo = NULL;

    if (lpcpath != NULL)

        gx_cpath_free(lpcpath, "clist_begin_typed_image(lpcpath)");

    if (pgs->has_transparency){

        return -1;

    } else {

        return gx_default_begin_typed_image(dev, pgs, pmat, pic, prect,

                                            pdcolor, pcpath, mem, pinfo);

    }

}

/* Error cleanup for clist_image_plane_data. */

static inline int

clist_image_plane_data_retry_cleanup(gx_device *dev, clist_image_enum *pie, int yh_used, int code)

{

    gx_device_clist_writer * const cdev =

        &((gx_device_clist *)dev)->writer;

    ++cdev->ignore_lo_mem_warnings;

    {

        code = write_image_end_all(dev, pie);