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

*/

/* Graphics state management for pdfwrite driver */

#include "math_.h"

#include "string_.h"

#include "memory_.h"

#include "gx.h"

#include "gserrors.h"

#include "gsfunc0.h"

#include "gsstate.h"

#include "gxbitmap.h"   /* for gxhttile.h in gzht.h */

#include "gxdht.h"

#include "gxfarith.h"   /* for gs_sin/cos_degrees */

#include "gxfmap.h"

#include "gxht.h"

#include "gxgstate.h"

#include "gxdcolor.h"

#include "gxpcolor.h"

#include "gsptype2.h"

#include "gzht.h"

#include "gdevpdfx.h"

#include "gdevpdfg.h"

#include "gdevpdfo.h"

#include "gscspace.h"

#include "gsicc_manage.h"

#include "gsicc_cache.h"

#include "gsccolor.h"

#include "gxcdevn.h"

#include "gscie.h"

#include "gdevpdtx.h"

#include "gdevpdts.h"

/* ------ Exported by gdevpdfc.c for gdevpdfg.c ------ */

int pdf_make_sampled_base_space_function(gx_device_pdf *pdev, gs_function_t **pfn,

                                        int nSrcComp, int nDstComp, byte *data);

int pdf_delete_sampled_base_space_function(gx_device_pdf *pdev, gs_function_t *pfn);

int pdf_make_base_space_function(gx_device_pdf *pdev, gs_function_t **pfn,

                                        int ncomp, float *data_low, float *data_high);

int pdf_delete_base_space_function(gx_device_pdf *pdev, gs_function_t *pfn);

/* ---------------- Miscellaneous ---------------- */

/* Save the viewer's graphic state. */

int

pdf_save_viewer_state(gx_device_pdf *pdev, stream *s)

{

    const int i = pdev->vgstack_depth;

    int code = 0;

    if (pdev->vgstack_depth >= pdev->vgstack_size) {

        pdf_viewer_state *new_vgstack = (pdf_viewer_state *)gs_alloc_bytes(pdev->pdf_memory,

            (size_t)(pdev->vgstack_size + 5) * sizeof(pdf_viewer_state), "increase graphics state stack size");

        if (new_vgstack == 0)

            return_error(gs_error_VMerror);

        memset(new_vgstack, 0x00, (pdev->vgstack_size + 5) * sizeof(pdf_viewer_state));

        memcpy(new_vgstack, pdev->vgstack, pdev->vgstack_size * sizeof(pdf_viewer_state));

        gs_free_object(pdev->pdf_memory, pdev->vgstack, "resize graphics state stack, free old stack)");

        pdev->vgstack = new_vgstack;

        pdev->vgstack_size += 5;

    }

    pdev->vgstack[i].transfer_ids[0] = pdev->transfer_ids[0];

    pdev->vgstack[i].transfer_ids[1] = pdev->transfer_ids[1];

    pdev->vgstack[i].transfer_ids[2] = pdev->transfer_ids[2];

    pdev->vgstack[i].transfer_ids[3] = pdev->transfer_ids[3];

    pdev->vgstack[i].transfer_not_identity = pdev->transfer_not_identity;

    pdev->vgstack[i].strokeconstantalpha = pdev->state.strokeconstantalpha;

    pdev->vgstack[i].fillconstantalpha = pdev->state.fillconstantalpha;

    pdev->vgstack[i].alphaisshape = pdev->state.alphaisshape;

    pdev->vgstack[i].blend_mode = pdev->state.blend_mode;

    pdev->vgstack[i].halftone_id = pdev->halftone_id;

    pdev->vgstack[i].black_generation_id = pdev->black_generation_id;

    pdev->vgstack[i].undercolor_removal_id = pdev->undercolor_removal_id;

    pdev->vgstack[i].overprint_mode = pdev->state.overprint_mode;

    pdev->vgstack[i].smoothness = pdev->state.smoothness;

    pdev->vgstack[i].flatness = pdev->state.flatness;

    pdev->vgstack[i].text_knockout = pdev->state.text_knockout;

    pdev->vgstack[i].fill_overprint = pdev->fill_overprint;

    pdev->vgstack[i].stroke_overprint = pdev->stroke_overprint;

    pdev->vgstack[i].stroke_adjust = pdev->state.stroke_adjust;

    pdev->vgstack[i].fill_used_process_color = pdev->fill_used_process_color;

    pdev->vgstack[i].stroke_used_process_color = pdev->stroke_used_process_color;

    pdev->vgstack[i].saved_fill_color = pdev->saved_fill_color;

    pdev->vgstack[i].saved_stroke_color = pdev->saved_stroke_color;

    pdev->vgstack[i].line_params = pdev->state.line_params;

    pdev->vgstack[i].line_params.dash.pattern = 0; /* Use pdev->dash_pattern instead. */

    pdev->vgstack[i].soft_mask_id = pdev->state.soft_mask_id; /* Use pdev->dash_pattern instead. */

    if (pdev->dash_pattern) {

        if (pdev->vgstack[i].dash_pattern)

            gs_free_object(pdev->memory->non_gc_memory, pdev->vgstack[i].dash_pattern, "free gstate copy dash");

        pdev->vgstack[i].dash_pattern = (float *)gs_alloc_bytes(pdev->memory->non_gc_memory, (size_t)pdev->dash_pattern_size * sizeof(float), "gstate copy dash");

        if (pdev->vgstack[i].dash_pattern == NULL)

            return_error(gs_error_VMerror);

        memcpy(pdev->vgstack[i].dash_pattern, pdev->dash_pattern, pdev->dash_pattern_size * sizeof(float));

        pdev->vgstack[i].dash_pattern_size = pdev->dash_pattern_size;

    } else {

        if (pdev->vgstack[i].dash_pattern) {

            gs_free_object(pdev->memory->non_gc_memory, pdev->vgstack[i].dash_pattern, "free gstate copy dash");

            pdev->vgstack[i].dash_pattern = 0;

            pdev->vgstack[i].dash_pattern_size = 0;

        }

    }

    if (pdev->clip_path != 0) {

        if (pdev->vgstack[i].clip_path != 0)

            gx_path_free(pdev->vgstack[i].clip_path, "pdf clip path");

        pdev->vgstack[i].clip_path = gx_path_alloc(pdev->pdf_memory->non_gc_memory, "pdf clip path");

        if (pdev->vgstack[i].clip_path == 0)

            return_error(gs_error_VMerror);

        code = gx_path_copy(pdev->clip_path, pdev->vgstack[i].clip_path);

        if (code < 0)

            return code;

        pdev->vgstack[i].clip_path_id = pdev->clip_path_id;

    } else {

        if (pdev->vgstack[i].clip_path != 0) {

            gx_path_free(pdev->vgstack[i].clip_path, "pdf clip path");

            pdev->vgstack[i].clip_path = 0;

            pdev->vgstack[i].clip_path_id = 0;

        }

    }

    pdev->vgstack_depth++;

    if (s)

        stream_puts(s, "q\n");

    return 0;

}

/* Load the viewer's graphic state. */

static int

pdf_load_viewer_state(gx_device_pdf *pdev, pdf_viewer_state *s)

{

    int code = 0;

    pdev->transfer_ids[0] = s->transfer_ids[0];

    pdev->transfer_ids[1] = s->transfer_ids[1];

    pdev->transfer_ids[2] = s->transfer_ids[2];

    pdev->transfer_ids[3] = s->transfer_ids[3];

    pdev->transfer_not_identity = s->transfer_not_identity;

    pdev->state.strokeconstantalpha = s->strokeconstantalpha;

    pdev->state.fillconstantalpha = s->fillconstantalpha;

    pdev->state.alphaisshape = s->alphaisshape;

    pdev->state.blend_mode = s->blend_mode;

    pdev->halftone_id = s->halftone_id;

    pdev->black_generation_id = s->black_generation_id;

    pdev->undercolor_removal_id = s->undercolor_removal_id;

    pdev->state.overprint_mode = s->overprint_mode;

    pdev->state.smoothness = s->smoothness;

    pdev->state.flatness = s->flatness;

    pdev->state.text_knockout = s->text_knockout;

    pdev->fill_overprint = s->fill_overprint;

    pdev->stroke_overprint = s->stroke_overprint;

    pdev->state.stroke_adjust = s->stroke_adjust;

    pdev->fill_used_process_color = s->fill_used_process_color;

    pdev->stroke_used_process_color = s->stroke_used_process_color;

    pdev->saved_fill_color = s->saved_fill_color;

    pdev->saved_stroke_color = s->saved_stroke_color;

    pdev->state.line_params = s->line_params;

    pdev->state.soft_mask_id = s->soft_mask_id;

    if (s->dash_pattern) {

        if (pdev->dash_pattern)

            gs_free_object(pdev->memory->stable_memory, pdev->dash_pattern, "vector free dash pattern");

        pdev->dash_pattern = (float *)gs_alloc_bytes(pdev->memory->stable_memory, (size_t)s->dash_pattern_size * sizeof(float), "vector allocate dash pattern");

        if (pdev->dash_pattern == NULL)

            return_error(gs_error_VMerror);

        memcpy(pdev->dash_pattern, s->dash_pattern, sizeof(float)*s->dash_pattern_size);

        pdev->dash_pattern_size  = s->dash_pattern_size;

    } else {

        if (pdev->dash_pattern) {

            gs_free_object(pdev->memory->stable_memory, pdev->dash_pattern, "vector free dash pattern");

            pdev->dash_pattern = 0;

            pdev->dash_pattern_size = 0;

        }

    }

    if (pdev->clip_path != 0) {

        gx_path_free(pdev->clip_path, "pdf clip path");

        pdev->clip_path = 0;

        pdev->clip_path_id = 0;

    }

    if (s->clip_path != 0) {

        pdev->clip_path = gx_path_alloc(pdev->pdf_memory, "pdf clip path");

        if (pdev->clip_path == 0)

            return_error(gs_error_VMerror);

        code = gx_path_copy(s->clip_path, pdev->clip_path);

        if (code < 0)

            return code;

        pdev->clip_path_id = s->clip_path_id;

    }

    return 0;

}

/* Restore the viewer's graphic state. */

int

pdf_restore_viewer_state(gx_device_pdf *pdev, stream *s)

{

    int i;

    if (pdev->vgstack_depth == 0)

        return 0;

    i = --pdev->vgstack_depth;

    if (i < pdev->vgstack_bottom) {

        if ((pdev->ObjectFilter & FILTERIMAGE) == 0) {

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

        }

        else

            return 0;

    }

    if (s)

        stream_puts(s, "Q\n");

    return pdf_load_viewer_state(pdev, pdev->vgstack + i);

}

/* Set initial color. */

void

pdf_set_initial_color(gx_device_pdf * pdev, gx_hl_saved_color *saved_fill_color,

                    gx_hl_saved_color *saved_stroke_color,

                    bool *fill_used_process_color, bool *stroke_used_process_color)

{

    gx_device_color black;

    pdev->black = gx_device_black((gx_device *)pdev);

    pdev->white = gx_device_white((gx_device *)pdev);

    set_nonclient_dev_color(&black, pdev->black);

    gx_hld_save_color(NULL, &black, saved_fill_color);

    gx_hld_save_color(NULL, &black, saved_stroke_color);

    *fill_used_process_color = true;

    *stroke_used_process_color = true;

}

/* Prepare intitial values for viewer's graphics state parameters. */

static void

pdf_viewer_state_from_gs_gstate_aux(pdf_viewer_state *pvs, const gs_gstate *pgs)

{

    pvs->transfer_not_identity =

            (pgs->set_transfer.red   != NULL ? pgs->set_transfer.red->proc   != gs_identity_transfer : 0) * 1 +

            (pgs->set_transfer.green != NULL ? pgs->set_transfer.green->proc != gs_identity_transfer : 0) * 2 +

            (pgs->set_transfer.blue  != NULL ? pgs->set_transfer.blue->proc  != gs_identity_transfer : 0) * 4 +

            (pgs->set_transfer.gray  != NULL ? pgs->set_transfer.gray->proc  != gs_identity_transfer : 0) * 8;

    pvs->transfer_ids[0] = (pgs->set_transfer.red != NULL ? pgs->set_transfer.red->id : 0);

    pvs->transfer_ids[1] = (pgs->set_transfer.green != NULL ? pgs->set_transfer.green->id : 0);

    pvs->transfer_ids[2] = (pgs->set_transfer.blue != NULL ? pgs->set_transfer.blue->id : 0);

    pvs->transfer_ids[3] = (pgs->set_transfer.gray != NULL ? pgs->set_transfer.gray->id : 0);

    pvs->fillconstantalpha = pgs->fillconstantalpha;

    pvs->strokeconstantalpha = pgs->strokeconstantalpha;

    pvs->alphaisshape = pgs->alphaisshape;

    pvs->blend_mode = pgs->blend_mode;

    pvs->halftone_id = (pgs->dev_ht[HT_OBJTYPE_DEFAULT] != NULL ? pgs->dev_ht[HT_OBJTYPE_DEFAULT]->id : 0);

    pvs->black_generation_id = (pgs->black_generation != NULL ? pgs->black_generation->id : 0);

    pvs->undercolor_removal_id = (pgs->undercolor_removal != NULL ? pgs->undercolor_removal->id : 0);

    pvs->overprint_mode = 0;

    pvs->flatness = pgs->flatness;

    pvs->smoothness = pgs->smoothness;

    pvs->text_knockout = pgs->text_knockout;

    pvs->fill_overprint = false;

    pvs->stroke_overprint = false;

    /* The PDF Reference says that the default is 'false' but experiments show (bug #706407)

     * that Acrobat defaults to true. Also Ghostscript, at low resolution at least, defaults

     * to true as well. By setting the initial value to neither true nor false we can ensure

     * that any input file which sets it, whether true or false, will cause it not to match

     * the initial value, so we will write it out, thus preserving the value, no matter what

     * the default.

     */

    pvs->stroke_adjust = -1;

    pvs->line_params.half_width = 0.5;

    pvs->line_params.start_cap = 0;

    pvs->line_params.end_cap = 0;

    pvs->line_params.dash_cap = 0;

    pvs->line_params.join = 0;

    pvs->line_params.curve_join = 0;

    pvs->line_params.miter_limit = 10.0;

    pvs->line_params.miter_check = 0;

    pvs->line_params.dot_length = pgs->line_params.dot_length;

    pvs->line_params.dot_length_absolute = pgs->line_params.dot_length_absolute;

    pvs->line_params.dot_orientation = pgs->line_params.dot_orientation;

    memset(&pvs->line_params.dash, 0 , sizeof(pvs->line_params.dash));

    pvs->dash_pattern = 0;

    pvs->dash_pattern_size = 0;

    pvs->soft_mask_id = pgs->soft_mask_id;

}

/* Copy viewer state from images state. */

void

pdf_viewer_state_from_gs_gstate(gx_device_pdf * pdev,

        const gs_gstate *pgs, const gx_device_color *pdevc)

{

    pdf_viewer_state vs;

    pdf_viewer_state_from_gs_gstate_aux(&vs, pgs);

    /* pdf_viewer_state_from_gs_gstate_aux always returns

     * vs with a NULL dash pattern. */

    gx_hld_save_color(pgs, pdevc, &vs.saved_fill_color);

    gx_hld_save_color(pgs, pdevc, &vs.saved_stroke_color);

    vs.fill_used_process_color = 0;

    vs.stroke_used_process_color = 0;

    vs.clip_path = 0;

    vs.clip_path_id = 0;

    /* pdf_load_viewer_state should never fail, as vs has a NULL

     * dash pattern, and therefore will not allocate. */

    (void)pdf_load_viewer_state(pdev, &vs);

}

/* Prepare intitial values for viewer's graphics state parameters. */

void

pdf_prepare_initial_viewer_state(gx_device_pdf * pdev, const gs_gstate *pgs)

{

    /* Parameter values, which are specified in PDF spec, are set here.

     * Parameter values, which are specified in PDF spec as "installation dependent",

     * are set here to intial values used with PS interpreter.

     * This allows to write differences to the output file

     * and skip initial values.

     */

    pdf_set_initial_color(pdev, &pdev->vg_initial.saved_fill_color, &pdev->vg_initial.saved_stroke_color,

            &pdev->vg_initial.fill_used_process_color, &pdev->vg_initial.stroke_used_process_color);

    pdf_viewer_state_from_gs_gstate_aux(&pdev->vg_initial, pgs);

    pdev->vg_initial_set = true;

    /*

     * Some parameters listed in PDF spec are missed here :

     * text state - it is initialized per page.

     * rendering intent - not sure why, fixme.

     */

}

/* Reset the graphics state parameters to initial values. */

/* Used if pdf_prepare_initial_viewer_state was not callad. */

static void

pdf_reset_graphics_old(gx_device_pdf * pdev)

{

    pdf_set_initial_color(pdev, &pdev->saved_fill_color, &pdev->saved_stroke_color,

                                &pdev->fill_used_process_color, &pdev->stroke_used_process_color);

    pdev->state.flatness = -1;

    {

        static const gx_line_params lp_initial = {

            gx_line_params_initial

        };

        pdev->state.line_params = lp_initial;

    }

    pdev->fill_overprint = false;

    pdev->stroke_overprint = false;

    pdev->remap_fill_color = false;

    pdev->remap_stroke_color = false;

    pdf_reset_text(pdev);

}

/* Reset the graphics state parameters to initial values. */

void

pdf_reset_graphics(gx_device_pdf * pdev)

{

    int soft_mask_id = pdev->state.soft_mask_id;

    if (pdev->vg_initial_set)

        /* The following call cannot fail as vg_initial has no

         * dash pattern, and so no allocations are required. */

        (void)pdf_load_viewer_state(pdev, &pdev->vg_initial);

    else

        pdf_reset_graphics_old(pdev);

    pdf_reset_text(pdev);

    /* Not obvious, we want to preserve any extant soft mask, not reset it */

    pdev->state.soft_mask_id = soft_mask_id;

}

/* Write client color. */

static int

pdf_write_ccolor(gx_device_pdf * pdev, const gs_gstate * pgs,

                const gs_client_color *pcc)

{

    int i, n = gx_hld_get_number_color_components(pgs);

    pprintg1(pdev->strm, "%g", psdf_round(pcc->paint.values[0], 255, 8));

    for (i = 1; i < n; i++) {

        pprintg1(pdev->strm, " %g", psdf_round(pcc->paint.values[i], 255, 8));

    }

    return 0;

}

static inline bool

is_cspace_allowed_in_strategy(gx_device_pdf * pdev, gs_color_space_index csi)

{

    if (pdev->params.ColorConversionStrategy == ccs_CMYK &&

            csi != gs_color_space_index_DeviceCMYK &&

            csi != gs_color_space_index_DeviceGray)

        return false;

    if (pdev->params.ColorConversionStrategy == ccs_sRGB &&

            csi != gs_color_space_index_DeviceRGB &&

            csi != gs_color_space_index_DeviceGray)

        return false;

    if (pdev->params.ColorConversionStrategy == ccs_RGB &&

            csi != gs_color_space_index_DeviceRGB &&

            csi != gs_color_space_index_DeviceGray)

        return false;

    if (pdev->params.ColorConversionStrategy == ccs_Gray &&

            csi != gs_color_space_index_DeviceGray)

        return false;

    return true;

}

static inline bool

is_pattern2_allowed_in_strategy(gx_device_pdf * pdev, const gx_drawing_color *pdc)

{

    const gs_color_space *pcs2 = gx_dc_pattern2_get_color_space(pdc);

    gs_color_space_index csi = gs_color_space_get_index(pcs2);

    if (csi == gs_color_space_index_ICC)

        csi = gsicc_get_default_type(pcs2->cmm_icc_profile_data);

    return is_cspace_allowed_in_strategy(pdev, csi);

}

static int apply_transfer_gray(gx_device_pdf * pdev, const gs_gstate * pgs, gs_client_color *pcc, gs_client_color *cc)

{

    unsigned short psrc[GS_CLIENT_COLOR_MAX_COMPONENTS];

    frac conc[GS_CLIENT_COLOR_MAX_COMPONENTS];

    gx_device_color dc;

    const gs_color_space *pcs = gs_currentcolorspace_inline(pgs);

    int code, color_index;

    color_index = pdev->pcm_color_info_index;

    pdf_set_process_color_model(pdev, 0);

    psrc[0] = (unsigned short) (pcc->paint.values[0]*65535.0);;

    conc[0] = ushort2frac(psrc[0]);

    code = gx_remap_concrete_DGray(pcs, (const frac *)&conc, &dc, pgs, (gx_device *)pdev, gs_color_select_texture, NULL);

    if (code < 0)

        return code;

    cc->paint.values[0] = (dc.colors.pure & 0xff) / 255.0;

    pdf_set_process_color_model(pdev, color_index);

    return 0;

}

static int apply_transfer_rgb(gx_device_pdf * pdev, const gs_gstate * pgs, gs_client_color *pcc, gs_client_color *cc)

{

    unsigned short psrc[GS_CLIENT_COLOR_MAX_COMPONENTS];

    frac conc[GS_CLIENT_COLOR_MAX_COMPONENTS];

    gx_device_color dc;

    const gs_color_space *pcs = gs_currentcolorspace_inline(pgs);

    int code, i, color_index;

    color_index = pdev->pcm_color_info_index;

    pdf_set_process_color_model(pdev, 1);

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

        psrc[i] = (unsigned short) (pcc->paint.values[i]*65535.0);;

        conc[i] = ushort2frac(psrc[i]);

    }

    code = gx_remap_concrete_DRGB(pcs, (const frac *)&conc, &dc, pgs, (gx_device *)pdev, gs_color_select_texture, NULL);

    if (code < 0)

        return code;

    cc->paint.values[0] = ((dc.colors.pure & 0xff0000) >> 16) / 255.0;

    cc->paint.values[1] = ((dc.colors.pure & 0xff00) >> 8) / 255.0;

    cc->paint.values[2] = (dc.colors.pure & 0xff) / 255.0;

    pdf_set_process_color_model(pdev, color_index);

    return 0;

}

static int apply_transfer_cmyk(gx_device_pdf * pdev, const gs_gstate * pgs, gs_client_color *pcc, gs_client_color *cc)

{

    unsigned short psrc[GS_CLIENT_COLOR_MAX_COMPONENTS];

    frac conc[GS_CLIENT_COLOR_MAX_COMPONENTS];

    gx_device_color dc;

    const gs_color_space *pcs = gs_currentcolorspace_inline(pgs);

    int code, i, color_index;

    color_index = pdev->pcm_color_info_index;

    pdf_set_process_color_model(pdev, 2);

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

        psrc[i] = (unsigned short) (pcc->paint.values[i]*65535.0);;

        conc[i] = ushort2frac(psrc[i]);

    }

    code = gx_remap_concrete_DCMYK(pcs, (const frac *)&conc, &dc, pgs, (gx_device *)pdev, gs_color_select_texture, NULL);

    if (code < 0)

        return code;

    cc->paint.values[0] = ((dc.colors.pure & 0xff000000) >> 24) / 255.0;

    cc->paint.values[1] = ((dc.colors.pure & 0xff0000) >> 16) / 255.0;

    cc->paint.values[2] = ((dc.colors.pure & 0xff00) >> 8) / 255.0;

    cc->paint.values[3] = (dc.colors.pure & 0xff) / 255.0;

    pdf_set_process_color_model(pdev, color_index);

    return 0;

}

static int write_color_as_process(gx_device_pdf * pdev, const gs_gstate * pgs, const gs_color_space *pcs,

                        const gx_drawing_color *pdc, bool *used_process_color,

                        const psdf_set_color_commands_t *ppscc, gs_client_color *pcc)

{

    int code, i;

    unsigned char j;

    frac conc[GS_CLIENT_COLOR_MAX_COMPONENTS];

    gs_color_space_index csi, csi2;

    gs_color_space *pcs2 = (gs_color_space *)pcs;

    gx_drawing_color dc;

    int num_des_comps;

    cmm_dev_profile_t *dev_profile;

    dc.type = gx_dc_type_pure;

    dc.colors.pure = 0;

    csi = gs_color_space_get_index(pcs);

    if (csi == gs_color_space_index_ICC) {

        csi = gsicc_get_default_type(pcs->cmm_icc_profile_data);

    }

    if (csi == gs_color_space_index_Indexed ||

        csi == gs_color_space_index_DeviceN ||

        csi == gs_color_space_index_Separation) {

        const char *command = NULL;

        *used_process_color = true;

        memset (&conc, 0x00, sizeof(frac) * GS_CLIENT_COLOR_MAX_COMPONENTS);

        pcs->type->concretize_color(pcc, pcs, conc, pgs, (gx_device *)pdev);

        do{

            pcs2 = pcs2->base_space;

            csi2 = gs_color_space_get_index(pcs2);

        } while(csi2 != gs_color_space_index_ICC && pcs2->base_space);

        csi2 = gs_color_space_get_index(pcs2);

        switch (csi2) {

            case gs_color_space_index_DeviceGray:

            case gs_color_space_index_DeviceRGB:

            case gs_color_space_index_DeviceCMYK:

                switch (pdev->color_info.num_components) {

                    case 1:

                        command = ppscc->setgray;

                        break;

                    case 3:

                        command = ppscc->setrgbcolor;

                        break;

                    case 4:

                        command = ppscc->setcmykcolor;

                        break;

                    default:

                        /* Can't happen since we already check the colour space */

          return_error(gs_error_rangecheck);

                }

                pprintg1(pdev->strm, "%g", psdf_round(frac2float(conc[0]), 255, 8));

                for (j = 1; j < pdev->color_info.num_components; j++) {

                    pprintg1(pdev->strm, " %g", psdf_round(frac2float(conc[j]), 255, 8));

                }

                pprints1(pdev->strm, " %s\n", command);

                return 0;

                break;

            case gs_color_space_index_CIEDEFG:

            case gs_color_space_index_CIEDEF:

            case gs_color_space_index_CIEABC:

            case gs_color_space_index_CIEA:

            case gs_color_space_index_ICC:

                code = dev_proc((gx_device *)pdev, get_profile)((gx_device *)pdev, &dev_profile);

                if (code < 0)

                    return code;

                num_des_comps = gsicc_get_device_profile_comps(dev_profile);

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

                    dc.colors.pure = (dc.colors.pure << 8) + (int)(frac2float(conc[i]) * 255);

                code = psdf_set_color((gx_device_vector *)pdev, &dc, ppscc);

                return code;

                break;

            default:    /* can't happen, simply silences compiler warnings */

                break;

        }

    } else {

        if (csi >= gs_color_space_index_CIEDEFG &&

            csi <= gs_color_space_index_CIEA) {

                memset (&conc, 0x00, sizeof(frac) * GS_CLIENT_COLOR_MAX_COMPONENTS);

                pcs->type->concretize_color(pcc, pcs, conc, pgs, (gx_device *)pdev);

                code = dev_proc((gx_device *)pdev, get_profile)((gx_device *)pdev, &dev_profile);

                if (code < 0)

                    return code;

                num_des_comps = gsicc_get_device_profile_comps(dev_profile);

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

                    dc.colors.pure = (dc.colors.pure << 8) + (int)(frac2float(conc[i]) * 255);

                code = psdf_set_color((gx_device_vector *)pdev, &dc, ppscc);

                *used_process_color = true;

                return code;

        } else {

            memset (&conc, 0x00, sizeof(frac) * GS_CLIENT_COLOR_MAX_COMPONENTS);

            /* Special case handling for Lab spaces */

            if (pcs->cmm_icc_profile_data->data_cs == gsCIELAB || pcs->cmm_icc_profile_data->islab) {

                gs_client_color cc;

                /* Get the data in a form that is concrete for the CMM */

                cc.paint.values[0] = pcc->paint.values[0] / 100.0;

                cc.paint.values[1] = (pcc->paint.values[1]+128)/255.0;

                cc.paint.values[2] = (pcc->paint.values[2]+128)/255.0;

                pcs->type->concretize_color((const gs_client_color *)&cc, pcs, conc, pgs, (gx_device *)pdev);

            } else {

                if (pdev->params.TransferFunctionInfo == tfi_Apply) {

                    /* Apply transfer functions */

                    switch(csi) {

                        case gs_color_space_index_DeviceGray:

                        case gs_color_space_index_DeviceRGB:

                        case gs_color_space_index_DeviceCMYK:

                            (*pcs->type->remap_color)((const gs_client_color *)pcc, pcs, (gx_drawing_color *)pdc, pgs, (gx_device *)pdev, 0);

                            code = psdf_set_color((gx_device_vector *)pdev, pdc, ppscc);

                            return code;

                            break;

                        default:

                            pcs->type->concretize_color(pcc, pcs, conc, pgs, (gx_device *)pdev);

                            break;

                    }

                } else {

                    pcs->type->concretize_color(pcc, pcs, conc, pgs, (gx_device *)pdev);

                }

            }

            code = dev_proc((gx_device *)pdev, get_profile)((gx_device *)pdev, &dev_profile);

            if (code < 0)

                return code;

            num_des_comps = gsicc_get_device_profile_comps(dev_profile);

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

                dc.colors.pure = (dc.colors.pure << 8) + (int)(frac2float(conc[i]) * 255);

            code = psdf_set_color((gx_device_vector *)pdev, &dc, ppscc);

            return code;

        }

    }

    return_error(gs_error_unknownerror);

}

static int write_color_unchanged(gx_device_pdf * pdev, const gs_gstate * pgs,

                          gs_client_color *pcc, gx_hl_saved_color *current,

                          gx_hl_saved_color * psc, const psdf_set_color_commands_t *ppscc,

                          bool *used_process_color, const gs_color_space *pcs,

                          const gx_drawing_color *pdc)

{

    gs_color_space_index csi, csi2;

    int code, i;

    const char *command = NULL;

    gs_range_t *ranges = 0;

    gs_client_color cc;

    csi = csi2 = gs_color_space_get_index(pcs);

    if (csi == gs_color_space_index_ICC) {

        csi2 = gsicc_get_default_type(pcs->cmm_icc_profile_data);

    }

    switch (csi2) {

        case gs_color_space_index_DeviceGray:

            command = ppscc->setgray;

            if (pdev->params.TransferFunctionInfo == tfi_Apply) {

                code = apply_transfer_gray(pdev, pgs, pcc, &cc);

                if (code < 0)

                    return_error(code);

            } else {

                cc.paint.values[0] = pcc->paint.values[0];

            }

            code = pdf_write_ccolor(pdev, pgs, &cc);

            if (code < 0)

                return code;

            pprints1(pdev->strm, " %s\n", command);

            break;

        case gs_color_space_index_DeviceRGB:

            command = ppscc->setrgbcolor;

            if (pdev->params.TransferFunctionInfo == tfi_Apply) {

                code = apply_transfer_rgb(pdev, pgs, pcc, &cc);

                if (code < 0)

                    return_error(code);

            } else {

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

                    cc.paint.values[i] = pcc->paint.values[i];

            }

            code = pdf_write_ccolor(pdev, pgs, &cc);

            if (code < 0)

                return code;

            pprints1(pdev->strm, " %s\n", command);

            break;

        case gs_color_space_index_DeviceCMYK:

            command = ppscc->setcmykcolor;

            if (pdev->params.TransferFunctionInfo == tfi_Apply) {

                code = apply_transfer_cmyk(pdev, pgs, pcc, &cc);

                if (code < 0)

                    return_error(code);

            } else {

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

                    cc.paint.values[i] = pcc->paint.values[i];

            }

            code = pdf_write_ccolor(pdev, pgs, &cc);

            if (code < 0)

                return code;

            pprints1(pdev->strm, " %s\n", command);

            break;

        default:

            if (!gx_hld_saved_color_same_cspace(current, psc) || (csi2 >= gs_color_space_index_CIEDEFG && csi2 <= gs_color_space_index_CIEA)) {

                cos_value_t cs_value;

                code = pdf_color_space_named(pdev, pgs, &cs_value, (const gs_range_t **)&ranges, pcs,

                                &pdf_color_space_names, true, NULL, 0, false);

                /* fixme : creates redundant PDF objects. */

                if (code == gs_error_rangecheck) {

                    *used_process_color = true;

                    if (pdev->ForOPDFRead) {

                    /* The color space can't write to PDF. This should never happen */

                    code = psdf_set_color((gx_device_vector *)pdev, pdc, ppscc);

                    } else {

                    code = write_color_as_process(pdev, pgs, pcs, pdc, used_process_color, ppscc, pcc);

                    }

                    return code;

                }

                if (code < 0)

                    return code;

                code = cos_value_write(&cs_value, pdev);

                if (code < 0)

                    return code;

                pprints1(pdev->strm, " %s\n", ppscc->setcolorspace);

                if (ranges && (csi2 >= gs_color_space_index_CIEDEFG && csi2 <= gs_color_space_index_CIEA)) {

                    gs_client_color dcc = *pcc;

                    switch (csi2) {

                        case gs_color_space_index_CIEDEFG:

                            rescale_cie_color(ranges, 4, pcc, &dcc);

                            break;

                        case gs_color_space_index_CIEDEF:

                            rescale_cie_color(ranges, 3, pcc, &dcc);

                            break;

                        case gs_color_space_index_CIEABC:

                            rescale_cie_color(ranges, 3, pcc, &dcc);

                            break;

                        case gs_color_space_index_CIEA:

                            rescale_cie_color(ranges, 1, pcc, &dcc);

                            break;

                        default:

                            /* can't happen but silences compiler warnings */

                            break;

                    }

                    code = pdf_write_ccolor(pdev, pgs, &dcc);

                } else {

                    code = pdf_write_ccolor(pdev, pgs, pcc);

                }

                *used_process_color = false;

                if (code < 0)

                    return code;

                pprints1(pdev->strm, " %s\n", ppscc->setcolorn);

            } else if (*used_process_color) {

                    *used_process_color = true;

                    if (pdev->ForOPDFRead) {

                    /* The color space can't write to PDF. This should never happen */

                    code = psdf_set_color((gx_device_vector *)pdev, pdc, ppscc);

                    } else {

                    code = write_color_as_process(pdev, pgs, pcs, pdc, used_process_color, ppscc, pcc);

                    }

                    return code;

            }

            else {

                code = pdf_write_ccolor(pdev, pgs, pcc);

                if (code < 0)

                    return code;

                pprints1(pdev->strm, " %s\n", ppscc->setcolorn);

            }

            break;

    }

    *used_process_color = false;

    return 0;

}

static int write_color_as_process_ICC(gx_device_pdf * pdev, const gs_gstate * pgs, const gs_color_space *pcs,

                        const gx_drawing_color *pdc, gx_hl_saved_color * psc, bool *used_process_color,

                        const psdf_set_color_commands_t *ppscc, gs_client_color *pcc,

                        gx_hl_saved_color *current)

{

    int i, code;

    cos_value_t cs_value;

    if (!gx_hld_saved_color_same_cspace(current, psc)) {

        code = pdf_color_space_named(pdev, pgs, &cs_value, NULL, pcs,

                        &pdf_color_space_names, true, NULL, 0, true);

        /* fixme : creates redundant PDF objects. */

        if (code == gs_error_rangecheck) {

            /* The color space can't write to PDF. This should never happen */

            return write_color_as_process(pdev, pgs, pcs, pdc, used_process_color, ppscc, pcc);

        }

        if (code < 0)

            return code;

        code = cos_value_write(&cs_value, pdev);

        if (code < 0)

            return code;

        pprints1(pdev->strm, " %s\n", ppscc->setcolorspace);

        *used_process_color = false;

        pprintg1(pdev->strm, "%g", psdf_round(pcc->paint.values[0], 255, 8));

        for (i = 1; i < pcs->type->num_components(pcs); i++) {

            pprintg1(pdev->strm, " %g", psdf_round(pcc->paint.values[i], 255, 8));

        }

        pprints1(pdev->strm, " %s\n", ppscc->setcolorn);

    } else {

        *used_process_color = false;

        pprintg1(pdev->strm, "%g", psdf_round(pcc->paint.values[0], 255, 8));

        for (i = 1; i < pcs->type->num_components(pcs); i++) {

            pprintg1(pdev->strm, " %g", psdf_round(pcc->paint.values[i], 255, 8));

        }

        pprints1(pdev->strm, " %s\n", ppscc->setcolorn);

    }

    return 0;

}

int convert_DeviceN_alternate(gx_device_pdf * pdev, const gs_gstate * pgs, const gs_color_space *pcs,

                        const gx_drawing_color *pdc, bool *used_process_color,

                        const psdf_set_color_commands_t *ppscc, gs_client_color *pcc, cos_value_t *pvalue, bool by_name)

{

    gs_color_space_index csi;

    gs_function_t *new_pfn = 0;

    int code, i, samples=0, loop;

    cos_array_t *pca, *pca1;

    cos_value_t v;

    byte *data_buff;

    pdf_resource_t *pres = NULL;

    gs_color_space *pcs_save = NULL;

    csi = gs_color_space_get_index(pcs);

    if (csi == gs_color_space_index_Indexed) {

        pcs_save = (gs_color_space *)pcs;

        pcs = pcs->base_space;

    }

    if (pdev->PDFA != 0) {

        for (i = 0; i < pcs->params.device_n.num_components; ++i) {

            if (utf8_check((unsigned char *)pcs->params.device_n.names[i]) != NULL) {

                switch(pdev->PDFACompatibilityPolicy) {

                    case 0:

                        emprintf(pdev->memory,

                             "Ink name in Separation space not valid UTF-8, reverting to normal PDF output.\n");

                        pdev->AbortPDFAX = true;

                        pdev->PDFA = 0;

                        break;

                    case 1:

                        emprintf(pdev->memory,

                             "Ink name in Separation space not valid UTF-8, reverting to normal PDF output.\n");

                        pdev->AbortPDFAX = true;

                        pdev->PDFA = 0;

                        break;

                    default:

                    case 2:

                        emprintf(pdev->memory,

                             "Ink name in Separation space not valid UTF-8, aborting.\n");

                        return_error(gs_error_limitcheck);

                        break;

                }

                break;

            }

        }

    }

    pca = cos_array_alloc(pdev, "pdf_color_space");

    if (pca == 0)

        return_error(gs_error_VMerror);

    samples = (unsigned int)pow(2, pcs->params.device_n.num_components);

    data_buff = gs_alloc_bytes(pdev->memory, (unsigned int)pdev->color_info.num_components * (size_t)samples, "Convert DeviceN");

    if (data_buff == 0) {

        COS_FREE(pca, "convert DeviceN");

        return_error(gs_error_VMerror);

    }

    memset(data_buff, 0x00, (unsigned int)pdev->color_info.num_components * samples);

    {

        frac conc[GS_CLIENT_COLOR_MAX_COMPONENTS];

        gs_client_color cc, cc1;

        unsigned char j;

        gs_color_space *icc_space = (gs_color_space *)pcs;

        gs_color_space *devicen_space = (gs_color_space *)pcs;

        gs_color_space_index csi2;

        csi = gs_color_space_get_index(pcs);

        if (csi == gs_color_space_index_Indexed)

            devicen_space = pcs->base_space;

        do{

            icc_space = icc_space->base_space;

            csi2 = gs_color_space_get_index(icc_space);

        } while(csi2 != gs_color_space_index_ICC && icc_space->base_space);

        memset(&cc.paint.values, 0x00, GS_CLIENT_COLOR_MAX_COMPONENTS);

        devicen_space->params.device_n.use_alt_cspace = true;

        for (loop=0;loop < samples;loop++) {

            if (loop > 0) {

                if (cc.paint.values[0] == 0)

                    cc.paint.values[0] = 1;

                else {

                    int cascade = 0;

                    while (cascade < pcs->params.device_n.num_components && cc.paint.values[cascade] == 1) {

                        cc.paint.values[cascade++] = 0;

                    }

                    cc.paint.values[cascade] = 1;

                }

            }

            memset (&conc, 0x00, sizeof(frac) * GS_CLIENT_COLOR_MAX_COMPONENTS);

            devicen_space->type->concretize_color(&cc, devicen_space, conc, pgs, (gx_device *)pdev);

            for (i = 0;i < pdev->color_info.num_components;i++)

                cc1.paint.values[i] = frac2float(conc[i]);

            if (pdev->params.TransferFunctionInfo == tfi_Apply) {

                switch (pdev->params.ColorConversionStrategy) {

                    case ccs_Gray:

                        code = apply_transfer_gray(pdev, pgs, &cc1, &cc1);

                        break;

                    case ccs_sRGB:

                    case ccs_RGB:

                        code = apply_transfer_rgb(pdev, pgs, &cc1, &cc1);

                        break;

                    case ccs_CMYK:

                        code = apply_transfer_cmyk(pdev, pgs, &cc1, &cc1);

                        break;

                    default:

                        code = gs_error_rangecheck;

                        break;

                }

                if (code < 0) {

                    COS_FREE(pca, "pdf_color_space");

                    return code;

                }

            }

            for (j = 0;j < pdev->color_info.num_components;j++)

                data_buff[(loop * pdev->color_info.num_components) + j] = (int)(cc1.paint.values[j] * 255);

        }

    }

    switch(pdev->params.ColorConversionStrategy) {

        case ccs_Gray: