Subversion Repositories planix.SVN

/* Copyright (C) 1989, 2000 Aladdin Enterprises.  All rights reserved.

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

  implied.

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

  modified or distributed except as expressly authorized under the terms

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

  For more information about licensing, please refer to

  http://www.ghostscript.com/licensing/. For information on

  commercial licensing, go to http://www.artifex.com/licensing/ or

  contact Artifex Software, Inc., 101 Lucas Valley Road #110,

  San Rafael, CA  94903, U.S.A., +1(415)492-9861.

*/

/* $Id: zcolor.c,v 1.21 2004/10/01 23:35:02 ghostgum Exp $ */

/* Color operators */

#include "memory_.h"

#include "ghost.h"

#include "oper.h"

#include "estack.h"

#include "ialloc.h"

#include "igstate.h"

#include "iutil.h"

#include "store.h"

#include "gxfixed.h"

#include "gxmatrix.h"

#include "gzstate.h"

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

#include "gxdevice.h"

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

#include "gxcmap.h"

#include "gxcspace.h"

#include "gxcolor2.h"

#include "gxpcolor.h"

#include "idict.h"

#include "icolor.h"

#include "idparam.h"

#include "iname.h"

/* imported from gsht.c */

extern  void    gx_set_effective_transfer(gs_state *);

/* define the number of stack slots needed for zcolor_remap_one */

const int   zcolor_remap_one_ostack = 4;

const int   zcolor_remap_one_estack = 3;

/* utility to test whether a Pattern instance uses a base space */

private inline bool

pattern_instance_uses_base_space(const gs_pattern_instance_t * pinst)

{

    return pinst->type->procs.uses_base_space(

                   pinst->type->procs.get_pattern(pinst) );

}

/*

 *  -   currentcolor   <param1>  ...  <paramN>

 *

 * Return the current color. <paramN> may be a dictionary or a null

 * object, if the current color space is a pattern color space. The

 * other parameters will be numeric.

 *

 * Note that the results of this operator differ slightly from those of

 * most currentcolor implementations. If a color component value is 

 * integral (e.g.: 0, 1), it will be pushed on the stack as an integer.

 * Most currentcolor implementations, including the earlier

 * implementation in Ghostscript, would push real objects for all

 * color spaces except indexed color space. The approach taken here is

 * equally legitimate, and avoids special handling of indexed color

 * spaces.

 */

private int

zcurrentcolor(i_ctx_t * i_ctx_p)

{

    os_ptr                  op = osp;

    const gs_color_space *  pcs = gs_currentcolorspace(igs);

    const gs_client_color * pcc = gs_currentcolor(igs);

    int                     i, n = cs_num_components(pcs);

    bool                    push_pattern = n < 0;

    /* check for pattern */

    if (push_pattern) {

        gs_pattern_instance_t * pinst = pcc->pattern;

        if (pinst == 0 || !pattern_instance_uses_base_space(pinst))

            n = 1;

        else

            n = -n;

    }

    /* check for sufficient space on the stack */

    push(n);

    op -= n - 1;

    /* push the numeric operands, if any */

    if (push_pattern)

        --n;

    for (i = 0; i < n; i++, op++) {

        float   rval = pcc->paint.values[i];

        int     ival = (int)rval;

        /* the following handles indexed color spaces */

        if (rval == ival)

            make_int(op, ival);

        else

            make_real(op, rval);

    }

    /* push the pattern dictionary or null object, if appropriate */

    if (push_pattern)

        *op = istate->pattern;

    return 0;

}

/*

 *  -   .currentcolorspace   <array>

 *

 * Return the current color space. Unlike the prior implementation, the

 * istate->color_space.array field will now always have a legitimate

 * (array) value.

 */

private int

zcurrentcolorspace(i_ctx_t * i_ctx_p)

{

    os_ptr  op = osp;   /* required by "push" macro */

    push(1);

    if ( gs_color_space_get_index(igs->color_space) == gs_color_space_index_DeviceGray ) {

        ref gray, graystr;

        ref csa = istate->colorspace.array; 

        if (array_get(imemory, &csa, 0, &gray) >= 0 && 

            r_has_type(&gray, t_name) && 

	    (name_string_ref(imemory, &gray, &graystr),

	    r_size(&graystr) == 10 &&

	    !memcmp(graystr.value.bytes, "DeviceGray", 10))) {

            *op = istate->colorspace.array;

        } else {

	    int code = ialloc_ref_array(op, a_all, 1, "currentcolorspace");

	    if (code < 0)

	        return code;

	    return name_enter_string(imemory, "DeviceGray", op->value.refs);

        }

    } else

        *op = istate->colorspace.array;

    return 0;

}

/*

 *  -   .getuseciecolor   <bool>

 *

 * Return the current setting of the use_cie_color graphic state parameter,

 * which tracks the UseCIEColor page device parameter. This parameter may be

 * read (via this operator) at all language leves, but may only be set (via

 * the .setuseciecolor operator; see zcolor3.c) only in language level 3.

 *

 * We handle this parameter separately from the page device primarily for

 * performance reasons (the parameter may be queried frequently), but as a

 * side effect achieve proper behavior relative to the language level. The

 * interpreter is always initialized with this parameter set to false, and

 * it can only be updated (via setpagedevice) in language level 3.

 */

private int

zgetuseciecolor(i_ctx_t * i_ctx_p)

{

    os_ptr  op = osp;

    push(1);

    *op = istate->use_cie_color;

    return 0;

}

/*

 *  <param1>  ...  <paramN>   setcolor   -

 *

 * Set the current color. All of the parameters except the topmost (paramN) are

 * numbers; the topmost (and possibly only) entry may be pattern dictionary or

 * a null object.

 *

 * The use of one operator to set both patterns and "normal" colors is

 * consistent with Adobe's documentation, but primarily reflects the use of

 * gs_setcolor for both purposes in the graphic library. An alternate

 * implementation would use a .setpattern operator, which would interface with

 * gs_setpattern.

 *

 * This operator is hidden by a pseudo-operator of the same name, so it will

 * only be invoked under controlled situations. Hence, it does no operand

 * checking.

 */

private int

zsetcolor(i_ctx_t * i_ctx_p)

{

    os_ptr                  op = osp;

    const gs_color_space *  pcs = gs_currentcolorspace(igs);

    gs_client_color         cc;

    int                     n_comps, n_numeric_comps, num_offset = 0, code;

    bool                    is_ptype2 = 0;

    /* initialize the client color pattern pointer for GC */

    cc.pattern = 0;

    /* check for a pattern color space */

    if ((n_comps = cs_num_components(pcs)) < 0) {

        n_comps = -n_comps;

        if (r_has_type(op, t_dictionary)) {

            ref *   pImpl;

            int     ptype;

            dict_find_string(op, "Implementation", &pImpl);

            cc.pattern = r_ptr(pImpl, gs_pattern_instance_t);

            n_numeric_comps = ( pattern_instance_uses_base_space(cc.pattern)

                                  ? n_comps - 1

                                  : 0 );

            (void)dict_int_param(op, "PatternType", 1, 2, 1, &ptype);

            is_ptype2 = ptype == 2;

        } else

            n_numeric_comps = 0;

        num_offset = 1;

    } else

        n_numeric_comps = n_comps;

    /* gather the numeric operands */

    float_params(op - num_offset, n_numeric_comps, cc.paint.values);

    /* pass the color to the graphic library */

    if ((code = gs_setcolor(igs, &cc)) >= 0) {

        if (n_comps > n_numeric_comps) {

            istate->pattern = *op;      /* save pattern dict or null */

            n_comps = n_numeric_comps + 1;

        }

        pop(n_comps);

    }

    return code;

}

/*

 *  <array>   setcolorspace   -

 *

 * Set the nominal color space. This color space will be pushd by the

 * currentcolorspace operator, but is not directly used to pass color

 * space information to the graphic library.

 *

 * This operator can only be called from within the setcolorspace

 * pseudo-operator; the definition of the latter will override this

 * definition. Because error cheching is performed by the pseudo-

 * operator, it need not be repeated here.

 */

private int

zsetcolorspace(i_ctx_t * i_ctx_p)

{

    os_ptr  op = osp;

    istate->colorspace.array = *op;

    pop(1);

    return 0;

}

/*

 *  <name> .includecolorspace -

 *

 * See the comment for gs_includecolorspace in gscolor2.c .

 */

private int

zincludecolorspace(i_ctx_t * i_ctx_p)

{

    os_ptr  op = osp;

    ref nsref;

    int code;

    check_type(*op, t_name);

    name_string_ref(imemory, op, &nsref);

    code =  gs_includecolorspace(igs, nsref.value.const_bytes, r_size(&nsref));

    if (!code)

	pop(1);

    return code;

}

/*

 *  <int>   .setdevcspace   -

 *

 * Set a parameterless color space. This is now used to set the

 * DeviceGray, DeviceRGB, and DeviceCMYK color spaces, rather than

 * the setgray/setrgbcolor/setcmykcolor operators. All PostScript-based

 * color space substitution will have been accomplished before this

 * operator is called.

 *

 * The use of an integer to indicate the specific color space is 

 * historical and on the whole not particularly desirable, as it ties

 * the PostScript code to a specific enumeration. This may be modified

 * in the future.

 *

 * As with setcolorspace, this operator is called only under controlled

 * circumstances, hence it does no operand error checking.

 */

private int

zsetdevcspace(i_ctx_t * i_ctx_p)

{

    gs_color_space  cs;

    int             code;

    switch((gs_color_space_index)osp->value.intval) {

      default:  /* can't happen */

      case gs_color_space_index_DeviceGray:

	gs_cspace_init_DeviceGray(imemory, &cs);

        break;

      case gs_color_space_index_DeviceRGB:

        gs_cspace_init_DeviceRGB(imemory, &cs);

        break;

      case gs_color_space_index_DeviceCMYK:

        gs_cspace_init_DeviceCMYK(imemory, &cs);

        break;

    }

    if ((code = gs_setcolorspace(igs, &cs)) >= 0)

        pop(1);

    return code;

}

/*  -   currenttransfer   <proc> */

private int

zcurrenttransfer(i_ctx_t *i_ctx_p)

{

    os_ptr  op = osp;

    push(1);

    *op = istate->transfer_procs.gray;

    return 0;

}

/*

 *  -   processcolors   <int>  -

 *

 * Note: this is an undocumented operator that is not supported

 * in Level 2.

 */

private int

zprocesscolors(i_ctx_t * i_ctx_p)

{

    os_ptr  op = osp;

    push(1);

    make_int(op, gs_currentdevice(igs)->color_info.num_components);

    return 0;

}

/* <proc> settransfer - */

private int

zsettransfer(i_ctx_t * i_ctx_p)

{

    os_ptr  op = osp;

    int     code;

    check_proc(*op);

    check_ostack(zcolor_remap_one_ostack - 1);

    check_estack(1 + zcolor_remap_one_estack);

    istate->transfer_procs.red =

        istate->transfer_procs.green =

        istate->transfer_procs.blue =

        istate->transfer_procs.gray = *op;

    if ((code = gs_settransfer_remap(igs, gs_mapped_transfer, false)) < 0)

        return code;

    push_op_estack(zcolor_reset_transfer);

    pop(1);

    return zcolor_remap_one( i_ctx_p,

                             &istate->transfer_procs.gray,

                             igs->set_transfer.gray,

                             igs,

                             zcolor_remap_one_finish );

}

/*

 * Internal routines

 */

/*

 * Prepare to remap one color component (also used for black generation

 * and undercolor removal). Use the 'for' operator to gather the values.

 * The caller must have done the necessary check_ostack and check_estack.

 */

int

zcolor_remap_one(

    i_ctx_t *           i_ctx_p,

    const ref *         pproc,

    gx_transfer_map *   pmap,

    const gs_state *    pgs,

    op_proc_t           finish_proc )

{

    os_ptr              op;

    /*

     * Detect the identity function, which is a common value for one or

     * more of these functions.

     */

    if (r_size(pproc) == 0) {

	gx_set_identity_transfer(pmap);

	/*

	 * Even though we don't actually push anything on the e-stack, all

	 * clients do, so we return o_push_estack in this case.  This is

	 * needed so that clients' finishing procedures will get run.

	 */

	return o_push_estack;

    }

    op = osp += 4;

    make_real(op - 3, 0);

    make_int(op - 2, transfer_map_size - 1);

    make_real(op - 1, 1);

    *op = *pproc;

    ++esp;

    make_struct(esp, imemory_space((gs_ref_memory_t *) pgs->memory),

		pmap);

    push_op_estack(finish_proc);

    push_op_estack(zfor_samples);

    return o_push_estack;

}

/* Store the result of remapping a component. */

private int

zcolor_remap_one_store(i_ctx_t *i_ctx_p, floatp min_value)

{

    int i;

    gx_transfer_map *pmap = r_ptr(esp, gx_transfer_map);

    if (ref_stack_count(&o_stack) < transfer_map_size)

	return_error(e_stackunderflow);

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

	double v;

	int code =

	    real_param(ref_stack_index(&o_stack, transfer_map_size - 1 - i),

		       &v);

	if (code < 0)

	    return code;

	pmap->values[i] =

	    (v < min_value ? float2frac(min_value) :

	     v >= 1.0 ? frac_1 :

	     float2frac(v));

    }

    ref_stack_pop(&o_stack, transfer_map_size);

    esp--;			/* pop pointer to transfer map */

    return o_pop_estack;

}

int

zcolor_remap_one_finish(i_ctx_t *i_ctx_p)

{

    return zcolor_remap_one_store(i_ctx_p, 0.0);

}

int

zcolor_remap_one_signed_finish(i_ctx_t *i_ctx_p)

{

    return zcolor_remap_one_store(i_ctx_p, -1.0);

}

/* Finally, reset the effective transfer functions and */

/* invalidate the current color. */

int

zcolor_reset_transfer(i_ctx_t *i_ctx_p)

{

    gx_set_effective_transfer(igs);

    return zcolor_remap_color(i_ctx_p);

}

int

zcolor_remap_color(i_ctx_t *i_ctx_p)

{

    gx_unset_dev_color(igs);

    return 0;

}

/* 

 * <param1> ... <paramN> .color_test <param1> ... <paramN>

 *

 * encode and decode color to allow mapping to be tested.

 */

private int

zcolor_test(i_ctx_t *i_ctx_p)

{

    gx_color_value cv[GX_DEVICE_COLOR_MAX_COMPONENTS];

    gx_device *dev = gs_currentdevice(igs);

    int ncomp = dev->color_info.num_components;

    gx_color_index color;

    os_ptr op = osp - (ncomp-1);

    int i;

    if (ref_stack_count(&o_stack) < ncomp)

	return_error(e_stackunderflow);

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

	if (r_has_type(op+i, t_real))

	    cv[i] = (gx_color_value)

		(op[i].value.realval * gx_max_color_value);

	else if (r_has_type(op+i, t_integer))

	    cv[i] = (gx_color_value)

		(op[i].value.intval * gx_max_color_value);

	else

	    return_error(e_typecheck);

    }

    color = (*dev_proc(dev, encode_color)) (dev, cv);

    (*dev_proc(dev, decode_color)) (dev, color, cv);

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

        make_real(op+i, (float)cv[i] / (float)gx_max_color_value);

    return 0;

}

/* 

 * <levels> .color_test_all <value0> ... <valueN>

 *

 * Test encode/decode color procedures for a range of values.

 * Return value with the worst error in a single component.

 */

private int

zcolor_test_all(i_ctx_t *i_ctx_p)

{

    os_ptr                  op = osp;

    gx_color_value cv[GX_DEVICE_COLOR_MAX_COMPONENTS];

    gx_color_value cvout[GX_DEVICE_COLOR_MAX_COMPONENTS];

    gx_color_value cvbad[GX_DEVICE_COLOR_MAX_COMPONENTS];

    int counter[GX_DEVICE_COLOR_MAX_COMPONENTS];

    gx_device *dev = gs_currentdevice(igs);

    int ncomp = dev->color_info.num_components;

    int steps;

    int maxerror = 0;

    int err;

    int acceptable_error;

    int linsep = dev->color_info.separable_and_linear == GX_CINFO_SEP_LIN;

    int linsepfailed = 0;

    int lsmaxerror = 0;

    gx_color_index color, lscolor;

    int i, j, k;

    int finished = 0;

    if (ncomp == 1) 

	acceptable_error = gx_max_color_value / dev->color_info.max_gray + 1;

    else

	acceptable_error = gx_max_color_value / dev->color_info.max_color + 1;

    if (ref_stack_count(&o_stack) < 1)

	return_error(e_stackunderflow);

    if (!r_has_type(&osp[0], t_integer))

        return_error(e_typecheck);

    steps = osp[0].value.intval;

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

        counter[i] = 0; 

	cvbad[i] = 0;

    }

    dprintf1("Number of components = %d\n", ncomp);

    dprintf1("Depth = %d\n", dev->color_info.depth);

    dprintf2("max_gray = %d   dither_grays = %d\n", 

	dev->color_info.max_gray, dev->color_info.dither_grays);

    dprintf2("max_color = %d   dither_colors = %d\n", 

 	dev->color_info.max_color, dev->color_info.dither_colors);

    dprintf1("polarity = %s\n", 

      dev->color_info.polarity == GX_CINFO_POLARITY_ADDITIVE ? "Additive" :

      dev->color_info.polarity == GX_CINFO_POLARITY_SUBTRACTIVE ?"Subtractive":

      "Unknown");

    /* Indicate color index value with all colorants = zero */

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

	cv[i] = 0;

    color = (*dev_proc(dev, encode_color)) (dev, cv);

    dprintf1("Zero color index:  %8x\n", color);

    dprintf1("separable_and_linear = %s\n", 

      linsep == GX_CINFO_SEP_LIN_NONE ? "No" :

      linsep == GX_CINFO_SEP_LIN ? "Yes" :

      "Unknown");

    if (dev->color_info.gray_index == GX_CINFO_COMP_INDEX_UNKNOWN)

        dprintf("gray_index is unknown\n");

    else

        dprintf1("gray_index = %d\n", dev->color_info.gray_index);

    if (linsep) {

        dprintf(" Shift     Mask  Bits\n");

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

            dprintf3(" %5d %8x  %4d\n",

		(int)(dev->color_info.comp_shift[i]),

		(int)(dev->color_info.comp_mask[i]),

		(int)(dev->color_info.comp_bits[i]));

        }

    }

    while (!finished) {

	for (j = 0; j <= steps; j++) {

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

		cv[i] = counter[i] * gx_max_color_value / steps;

	    color = (*dev_proc(dev, encode_color)) (dev, cv);

	    if (linsep) {

		/* Derive it the other way */

		lscolor = gx_default_encode_color(dev, cv);

		if ((color != lscolor) && (linsepfailed < 5)) {

		    linsepfailed++;

		    dprintf("Failed separable_and_linear for");

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

			dprintf1(" %d", cv[i]);

		    dprintf("\n");

		    dprintf2("encode_color=%x  gx_default_encode_color=%x\n",

			(int)color, (int)lscolor);

		}

	    }

	    (*dev_proc(dev, decode_color)) (dev, color, cvout);

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

		err = (int)cvout[i] - (int)cv[i];

		if (err < 0)

		    err = -err;

		if (err > maxerror) {

		    maxerror = err;

		    for (k=0; k < ncomp; k++)

			cvbad[k] = cv[k];

		}

	    }

	    if (linsep) {

	        gx_default_decode_color(dev, color, cvout);

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

		    err = (int)cvout[i] - (int)cv[i];

		    if (err < 0)

			err = -err;

		    if (err > lsmaxerror) {

			lsmaxerror = err;

		    }

		}

	    }

	    counter[0] += 1;

	}

	counter[0] = 0;

	i = 1;

	while (i < ncomp) {

	    counter[i] += 1;

	    if (counter[i] > steps) {

		counter[i] = 0;

		i++;

	    }

	    else

		break;

	}

	if (i >= ncomp)

	    finished = 1;

    }

    dprintf2("Maximum error %g %s\n", 

	(float)maxerror / (float)gx_max_color_value,

	maxerror <= acceptable_error ? "is Ok" :

	maxerror <= 3*acceptable_error/2 ? "is POOR" : "FAILED");

    if (linsep)

      dprintf2("Maximum linear_and_separable error %g %s\n", 

	(float)lsmaxerror / (float)gx_max_color_value,

	lsmaxerror <= acceptable_error ? "is Ok" :

	lsmaxerror <= 3*acceptable_error/2 ? "is POOR" : "FAILED");

    /* push worst value */

    push(ncomp-1);

    op -= ncomp - 1;

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

        make_real(op+i, (float)cvbad[i] / (float)gx_max_color_value);

    return 0;

}

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

const op_def    zcolor_op_defs[] = 

{

    { "0currentcolor", zcurrentcolor },

    { "0currentcolorspace", zcurrentcolorspace },

    { "0.getuseciecolor", zgetuseciecolor },

    { "1setcolor", zsetcolor },

    { "1setcolorspace", zsetcolorspace },

    { "1.setdevcspace", zsetdevcspace },

    /* basic transfer operators */

    { "0currenttransfer", zcurrenttransfer },

    { "0processcolors", zprocesscolors },

    { "1settransfer", zsettransfer },

    /* internal operators */

    { "1%zcolor_remap_one_finish", zcolor_remap_one_finish },

    { "1%zcolor_remap_one_signed_finish", zcolor_remap_one_signed_finish },

    { "0%zcolor_reset_transfer", zcolor_reset_transfer },

    { "0%zcolor_remap_color", zcolor_remap_color },

    { "0.color_test", zcolor_test },

    { "1.color_test_all", zcolor_test_all },

    /* high level device support */

    { "0.includecolorspace", zincludecolorspace },

    op_def_end(0)

};