Subversion Repositories planix.SVN

/* Copyright (C) 2002 artofcode LLC.  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: gdevxcf.c,v 1.10 2005/06/20 08:59:23 igor Exp $ */

/* Gimp (XCF) export device, supporting DeviceN color models. */

#include "math_.h"

#include "gdevprn.h"

#include "gsparam.h"

#include "gscrd.h"

#include "gscrdp.h"

#include "gxlum.h"

#include "gdevdcrd.h"

#include "gstypes.h"

#include "icc.h"

#include "gxdcconv.h"

/* Define the device parameters. */

#ifndef X_DPI

#  define X_DPI 72

#endif

#ifndef Y_DPI

#  define Y_DPI 72

#endif

/* The device descriptor */

private dev_proc_get_params(xcf_get_params);

private dev_proc_put_params(xcf_put_params);

private dev_proc_print_page(xcf_print_page);

private dev_proc_map_color_rgb(xcf_map_color_rgb);

private dev_proc_get_color_mapping_procs(get_spotrgb_color_mapping_procs);

#if 0

private dev_proc_get_color_mapping_procs(get_spotcmyk_color_mapping_procs);

#endif

private dev_proc_get_color_mapping_procs(get_xcf_color_mapping_procs);

private dev_proc_get_color_comp_index(xcf_get_color_comp_index);

private dev_proc_encode_color(xcf_encode_color);

private dev_proc_decode_color(xcf_decode_color);

/*

 * Type definitions associated with the fixed color model names.

 */

typedef const char * fixed_colorant_name;

typedef fixed_colorant_name fixed_colorant_names_list[];

/*

 * Structure for holding SeparationNames and SeparationOrder elements.

 */

typedef struct gs_separation_names_s {

    int num_names;

    const gs_param_string * names[GX_DEVICE_COLOR_MAX_COMPONENTS];

} gs_separation_names;

/* This is redundant with color_info.cm_name. We may eliminate this

   typedef and use the latter string for everything. */

typedef enum {

    XCF_DEVICE_GRAY,

    XCF_DEVICE_RGB,

    XCF_DEVICE_CMYK,

    XCF_DEVICE_N

} xcf_color_model;

/*

 * A structure definition for a DeviceN type device

 */

typedef struct xcf_device_s {

    gx_device_common;

    gx_prn_device_common;

    /*        ... device-specific parameters ... */

    xcf_color_model color_model;

    /*

     * Bits per component (device colorant).  Currently only 1 and 8 are

     * supported.

     */

    int bitspercomponent;

    /*

     * Pointer to the colorant names for the color model.  This will be

     * null if we have DeviceN type device.  The actual possible colorant

     * names are those in this list plus those in the separation_names

     * list (below).

     */

    const fixed_colorant_names_list * std_colorant_names;

    int num_std_colorant_names;	/* Number of names in list */

    /*

    * Separation names (if any).

    */

    gs_separation_names separation_names;

    /*

     * Separation Order (if specified).

     */

    gs_separation_names separation_order;

    /* ICC color profile objects, for color conversion. */

    char profile_rgb_fn[256];

    icmLuBase *lu_rgb;

    int lu_rgb_outn;

    char profile_cmyk_fn[256];

    icmLuBase *lu_cmyk;

    int lu_cmyk_outn;

    char profile_out_fn[256];

    icmLuBase *lu_out;

} xcf_device;

/*

 * Macro definition for DeviceN procedures

 */

#define device_procs(get_color_mapping_procs)\

{	gdev_prn_open,\

	gx_default_get_initial_matrix,\

	NULL,				/* sync_output */\

	gdev_prn_output_page,		/* output_page */\

	gdev_prn_close,			/* close */\

	NULL,				/* map_rgb_color - not used */\

	xcf_map_color_rgb,		/* map_color_rgb */\

	NULL,				/* fill_rectangle */\

	NULL,				/* tile_rectangle */\

	NULL,				/* copy_mono */\

	NULL,				/* copy_color */\

	NULL,				/* draw_line */\

	NULL,				/* get_bits */\

	xcf_get_params,		/* get_params */\

	xcf_put_params,		/* put_params */\

	NULL,				/* map_cmyk_color - not used */\

	NULL,				/* get_xfont_procs */\

	NULL,				/* get_xfont_device */\

	NULL,				/* map_rgb_alpha_color */\

	gx_page_device_get_page_device,	/* get_page_device */\

	NULL,				/* get_alpha_bits */\

	NULL,				/* copy_alpha */\

	NULL,				/* get_band */\

	NULL,				/* copy_rop */\

	NULL,				/* fill_path */\

	NULL,				/* stroke_path */\

	NULL,				/* fill_mask */\

	NULL,				/* fill_trapezoid */\

	NULL,				/* fill_parallelogram */\

	NULL,				/* fill_triangle */\

	NULL,				/* draw_thin_line */\

	NULL,				/* begin_image */\

	NULL,				/* image_data */\

	NULL,				/* end_image */\

	NULL,				/* strip_tile_rectangle */\

	NULL,				/* strip_copy_rop */\

	NULL,				/* get_clipping_box */\

	NULL,				/* begin_typed_image */\

	NULL,				/* get_bits_rectangle */\

	NULL,				/* map_color_rgb_alpha */\

	NULL,				/* create_compositor */\

	NULL,				/* get_hardware_params */\

	NULL,				/* text_begin */\

	NULL,				/* finish_copydevice */\

	NULL,				/* begin_transparency_group */\

	NULL,				/* end_transparency_group */\

	NULL,				/* begin_transparency_mask */\

	NULL,				/* end_transparency_mask */\

	NULL,				/* discard_transparency_layer */\

	get_color_mapping_procs,	/* get_color_mapping_procs */\

	xcf_get_color_comp_index,	/* get_color_comp_index */\

	xcf_encode_color,		/* encode_color */\

	xcf_decode_color		/* decode_color */\

}

private const fixed_colorant_names_list DeviceGrayComponents = {

	"Gray",

};

private const fixed_colorant_names_list DeviceRGBComponents = {

	"Red",

	"Green",

	"Blue",

};

private const fixed_colorant_names_list DeviceCMYKComponents = {

	"Cyan",

	"Magenta",

	"Yellow",

	"Black",

};

/*

 * Example device with RGB and spot color support

 */

private const gx_device_procs spot_rgb_procs = device_procs(get_spotrgb_color_mapping_procs);

const xcf_device gs_xcf_device =

{   

    prn_device_body_extended(xcf_device, spot_rgb_procs, "xcf",

	 DEFAULT_WIDTH_10THS, DEFAULT_HEIGHT_10THS,

	 X_DPI, Y_DPI,		/* X and Y hardware resolution */

	 0, 0, 0, 0,		/* margins */

    	 GX_DEVICE_COLOR_MAX_COMPONENTS, 3,	/* MaxComponents, NumComp */

	 GX_CINFO_POLARITY_ADDITIVE,		/* Polarity */

	 24, 0,			/* Depth, Gray_index, */

	 255, 255, 256, 256,	/* MaxGray, MaxColor, DitherGray, DitherColor */

	 GX_CINFO_UNKNOWN_SEP_LIN, /* Let check_device_separable set up values */

	 "DeviceN",		/* Process color model name */

	 xcf_print_page),	/* Printer page print routine */

    /* DeviceN device specific parameters */

    XCF_DEVICE_RGB,		/* Color model */

    8,				/* Bits per color - must match ncomp, depth, etc. above */

    (&DeviceRGBComponents),	/* Names of color model colorants */

    3,				/* Number colorants for RGB */

    {0},			/* SeparationNames */

    {0}				/* SeparationOrder names */

};

private const gx_device_procs spot_cmyk_procs = device_procs(get_xcf_color_mapping_procs);

const xcf_device gs_xcfcmyk_device =

{   

    prn_device_body_extended(xcf_device, spot_cmyk_procs, "xcfcmyk",

	 DEFAULT_WIDTH_10THS, DEFAULT_HEIGHT_10THS,

	 X_DPI, Y_DPI,		/* X and Y hardware resolution */

	 0, 0, 0, 0,		/* margins */

    	 GX_DEVICE_COLOR_MAX_COMPONENTS, 4,	/* MaxComponents, NumComp */

	 GX_CINFO_POLARITY_SUBTRACTIVE,		/* Polarity */

	 32, 0,			/* Depth, Gray_index, */

	 255, 255, 256, 256,	/* MaxGray, MaxColor, DitherGray, DitherColor */

	 GX_CINFO_UNKNOWN_SEP_LIN, /* Let check_device_separable set up values */

	 "DeviceN",		/* Process color model name */

	 xcf_print_page),	/* Printer page print routine */

    /* DeviceN device specific parameters */

    XCF_DEVICE_CMYK,		/* Color model */

    8,				/* Bits per color - must match ncomp, depth, etc. above */

    (&DeviceCMYKComponents),	/* Names of color model colorants */

    4,				/* Number colorants for RGB */

    {0},			/* SeparationNames */

    {0}				/* SeparationOrder names */

};

/*

 * The following procedures are used to map the standard color spaces into

 * the color components for the spotrgb device.

 */

private void

gray_cs_to_spotrgb_cm(gx_device * dev, frac gray, frac out[])

{

/* TO_DO_DEVICEN  This routine needs to include the effects of the SeparationOrder array */

    int i = ((xcf_device *)dev)->separation_names.num_names;

    out[0] = out[1] = out[2] = gray;

    for(; i>0; i--)			/* Clear spot colors */

        out[2 + i] = 0;

}

private void

rgb_cs_to_spotrgb_cm(gx_device * dev, const gs_imager_state *pis,

				  frac r, frac g, frac b, frac out[])

{

/* TO_DO_DEVICEN  This routine needs to include the effects of the SeparationOrder array */

    int i = ((xcf_device *)dev)->separation_names.num_names;

    out[0] = r;

    out[1] = g;

    out[2] = b;

    for(; i>0; i--)			/* Clear spot colors */

        out[2 + i] = 0;

}

private void

cmyk_cs_to_spotrgb_cm(gx_device * dev, frac c, frac m, frac y, frac k, frac out[])

{

/* TO_DO_DEVICEN  This routine needs to include the effects of the SeparationOrder array */

    int i = ((xcf_device *)dev)->separation_names.num_names;

    color_cmyk_to_rgb(c, m, y, k, NULL, out);

    for(; i>0; i--)			/* Clear spot colors */

        out[2 + i] = 0;

}

private void

gray_cs_to_spotcmyk_cm(gx_device * dev, frac gray, frac out[])

{

/* TO_DO_DEVICEN  This routine needs to include the effects of the SeparationOrder array */

    int i = ((xcf_device *)dev)->separation_names.num_names;

    out[0] = out[1] = out[2] = 0;

    out[3] = frac_1 - gray;

    for(; i>0; i--)			/* Clear spot colors */

        out[3 + i] = 0;

}

private void

rgb_cs_to_spotcmyk_cm(gx_device * dev, const gs_imager_state *pis,

				   frac r, frac g, frac b, frac out[])

{

/* TO_DO_DEVICEN  This routine needs to include the effects of the SeparationOrder array */

    xcf_device *xdev = (xcf_device *)dev;

    int n = xdev->separation_names.num_names;

    int i;

    color_rgb_to_cmyk(r, g, b, pis, out);

    for(i = 0; i < n; i++)			/* Clear spot colors */

	out[4 + i] = 0;

}

private void

cmyk_cs_to_spotcmyk_cm(gx_device * dev, frac c, frac m, frac y, frac k, frac out[])

{

/* TO_DO_DEVICEN  This routine needs to include the effects of the SeparationOrder array */

    xcf_device *xdev = (xcf_device *)dev;

    int n = xdev->separation_names.num_names;

    int i;

    out[0] = c;

    out[1] = m;

    out[2] = y;

    out[3] = k;

    for(i = 0; i < n; i++)			/* Clear spot colors */

	out[4 + i] = 0;

}

private void

cmyk_cs_to_spotn_cm(gx_device * dev, frac c, frac m, frac y, frac k, frac out[])

{

/* TO_DO_DEVICEN  This routine needs to include the effects of the SeparationOrder array */

    xcf_device *xdev = (xcf_device *)dev;

    int n = xdev->separation_names.num_names;

    icmLuBase *luo = xdev->lu_cmyk;

    int i;

    if (luo != NULL) {

	double in[3];

	double tmp[MAX_CHAN];

	int outn = xdev->lu_cmyk_outn;

	in[0] = frac2float(c);

	in[1] = frac2float(m);

	in[2] = frac2float(y);

	in[3] = frac2float(k);

	luo->lookup(luo, tmp, in);

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

	    out[i] = float2frac(tmp[i]);

	for (; i < n + 4; i++)

	    out[i] = 0;

    } else {

	/* If no profile given, assume CMYK */

	out[0] = c;

	out[1] = m;

	out[2] = y;

	out[3] = k;

	for(i = 0; i < n; i++)			/* Clear spot colors */

	    out[4 + i] = 0;

    }

}

private void

gray_cs_to_spotn_cm(gx_device * dev, frac gray, frac out[])

{

/* TO_DO_DEVICEN  This routine needs to include the effects of the SeparationOrder array */

    cmyk_cs_to_spotn_cm(dev, 0, 0, 0, frac_1 - gray, out);

}

private void

rgb_cs_to_spotn_cm(gx_device * dev, const gs_imager_state *pis,

				   frac r, frac g, frac b, frac out[])

{

/* TO_DO_DEVICEN  This routine needs to include the effects of the SeparationOrder array */

    xcf_device *xdev = (xcf_device *)dev;

    int n = xdev->separation_names.num_names;

    icmLuBase *luo = xdev->lu_rgb;

    int i;

    if (luo != NULL) {

	double in[3];

	double tmp[MAX_CHAN];

	int outn = xdev->lu_rgb_outn;

	in[0] = frac2float(r);

	in[1] = frac2float(g);

	in[2] = frac2float(b);

	luo->lookup(luo, tmp, in);

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

	    out[i] = float2frac(tmp[i]);

	for (; i < n + 4; i++)

	    out[i] = 0;

    } else {

	frac cmyk[4];

	color_rgb_to_cmyk(r, g, b, pis, cmyk);

	cmyk_cs_to_spotn_cm(dev, cmyk[0], cmyk[1], cmyk[2], cmyk[3],

			    out);

    }

}

private const gx_cm_color_map_procs spotRGB_procs = {

    gray_cs_to_spotrgb_cm, rgb_cs_to_spotrgb_cm, cmyk_cs_to_spotrgb_cm

};

private const gx_cm_color_map_procs spotCMYK_procs = {

    gray_cs_to_spotcmyk_cm, rgb_cs_to_spotcmyk_cm, cmyk_cs_to_spotcmyk_cm

};

private const gx_cm_color_map_procs spotN_procs = {

    gray_cs_to_spotn_cm, rgb_cs_to_spotn_cm, cmyk_cs_to_spotn_cm

};

/*

 * These are the handlers for returning the list of color space

 * to color model conversion routines.

 */

private const gx_cm_color_map_procs *

get_spotrgb_color_mapping_procs(const gx_device * dev)

{

    return &spotRGB_procs;

}

#if 0

private const gx_cm_color_map_procs *

get_spotcmyk_color_mapping_procs(const gx_device * dev)

{

    return &spotCMYK_procs;

}

#endif

private const gx_cm_color_map_procs *

get_xcf_color_mapping_procs(const gx_device * dev)

{

    const xcf_device *xdev = (const xcf_device *)dev;

    if (xdev->color_model == XCF_DEVICE_RGB)

	return &spotRGB_procs;

    else if (xdev->color_model == XCF_DEVICE_CMYK)

	return &spotCMYK_procs;

    else if (xdev->color_model == XCF_DEVICE_N)

	return &spotN_procs;

    else

	return NULL;

}

/*

 * Encode a list of colorant values into a gx_color_index_value.

 */

private gx_color_index

xcf_encode_color(gx_device *dev, const gx_color_value colors[])

{

    int bpc = ((xcf_device *)dev)->bitspercomponent;

    int drop = sizeof(gx_color_value) * 8 - bpc;

    gx_color_index color = 0;

    int i = 0;

    int ncomp = dev->color_info.num_components;

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

	color <<= bpc;

        color |= (colors[i] >> drop);

    }

    return (color == gx_no_color_index ? color ^ 1 : color);

}

/*

 * Decode a gx_color_index value back to a list of colorant values.

 */

private int

xcf_decode_color(gx_device * dev, gx_color_index color, gx_color_value * out)

{

    int bpc = ((xcf_device *)dev)->bitspercomponent;

    int drop = sizeof(gx_color_value) * 8 - bpc;

    int mask = (1 << bpc) - 1;

    int i = 0;

    int ncomp = dev->color_info.num_components;

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

        out[ncomp - i - 1] = (color & mask) << drop;

	color >>= bpc;

    }

    return 0;

}

/*

 * Convert a gx_color_index to RGB.

 */

private int

xcf_map_color_rgb(gx_device *dev, gx_color_index color, gx_color_value rgb[3])

{

    xcf_device *xdev = (xcf_device *)dev;

    if (xdev->color_model == XCF_DEVICE_RGB)

	return xcf_decode_color(dev, color, rgb);

    /* TODO: return reasonable values. */

    rgb[0] = 0;

    rgb[1] = 0;

    rgb[2] = 0;

    return 0;

}

/*

 * This routine will extract a specified set of bits from a buffer and pack

 * them into a given buffer.

 *

 * Parameters:

 *   source - The source of the data

 *   dest - The destination for the data

 *   depth - The size of the bits per pixel - must be a multiple of 8

 *   first_bit - The location of the first data bit (LSB).

 *   bit_width - The number of bits to be extracted.

 *   npixel - The number of pixels.

 *

 * Returns:

 *   Length of the output line (in bytes)

 *   Data in dest.

 */

#if 0

private int

repack_data(byte * source, byte * dest, int depth, int first_bit,

		int bit_width, int npixel)

{

    int in_nbyte = depth >> 3;		/* Number of bytes per input pixel */

    int out_nbyte = bit_width >> 3;	/* Number of bytes per output pixel */

    gx_color_index mask = 1;

    gx_color_index data;

    int i, j, length = 0;

    int in_byte_loc = 0, out_byte_loc = 0;

    byte temp;

    byte * out = dest;

    int max_bit_byte = 8 - bit_width;

    mask = (mask << bit_width) - 1;

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

        /* Get the pixel data */

	if (!in_nbyte) {		/* Multiple pixels per byte */

	    data = *source;

	    data >>= in_byte_loc;

	    in_byte_loc += depth;

	    if (in_byte_loc >= 8) {	/* If finished with byte */

	        in_byte_loc = 0;

		source++;

	    }

	}

	else {				/* One or more bytes per pixel */

	    data = *source++;

	    for (j=1; j<in_nbyte; j++)

	        data = (data << 8) + *source++;

	}

	data >>= first_bit;

	data &= mask;

	/* Put the output data */

	if (!out_nbyte) {		/* Multiple pixels per byte */

	    temp = *out & ~(mask << out_byte_loc);

	    *out = temp | (data << out_byte_loc);

	    out_byte_loc += bit_width;

	    if (out_byte_loc > max_bit_byte) {	/* If finished with byte */

	        out_byte_loc = 0;

		out++;

	    }

	}

	else {				/* One or more bytes per pixel */

	    *out++ = data >> ((out_nbyte - 1) * 8);

	    for (j=1; j<out_nbyte; j++) {

	        *out++ = data >> ((out_nbyte - 1 - j) * 8);

	    }

	}

    }

    /* Return the number of bytes in the destination buffer. */

    length = out - dest;

    if (out_byte_loc)		 	/* If partially filled last byte */

	length++;

    return length;

}

#endif /* 0 */

private int

xcf_open_profile(xcf_device *xdev, char *profile_fn, icmLuBase **pluo,

		 int *poutn)

{

    icmFile *fp;

    icc *icco;

    icmLuBase *luo;

    dlprintf1("xcf_open_profile %s\n", profile_fn);

    fp = new_icmFileStd_name(profile_fn, (char *)"r");

    if (fp == NULL)

	return_error(gs_error_undefinedfilename);

    icco = new_icc();

    if (icco == NULL)

	return_error(gs_error_VMerror);

    if (icco->read(icco, fp, 0))

	return_error(gs_error_rangecheck);

    luo = icco->get_luobj(icco, icmFwd, icmDefaultIntent, icmSigDefaultData, icmLuOrdNorm);

    if (luo == NULL)

	return_error(gs_error_rangecheck);

    *pluo = luo;

    luo->spaces(luo, NULL, NULL, NULL, poutn, NULL, NULL, NULL, NULL);

    return 0;

}

private int

xcf_open_profiles(xcf_device *xdev)

{

    int code = 0;

    if (xdev->lu_out == NULL && xdev->profile_out_fn[0]) {

	code = xcf_open_profile(xdev, xdev->profile_out_fn,

				    &xdev->lu_out, NULL);

    }

    if (code >= 0 && xdev->lu_rgb == NULL && xdev->profile_rgb_fn[0]) {

	code = xcf_open_profile(xdev, xdev->profile_rgb_fn,

				&xdev->lu_rgb, &xdev->lu_rgb_outn);

    }

    if (code >= 0 && xdev->lu_cmyk == NULL && xdev->profile_cmyk_fn[0]) {

	code = xcf_open_profile(xdev, xdev->profile_cmyk_fn,

				&xdev->lu_cmyk, &xdev->lu_cmyk_outn);

    }

    return code;

}

#define set_param_array(a, d, s)\

  (a.data = d, a.size = s, a.persistent = false);

/* Get parameters.  We provide a default CRD. */

private int

xcf_get_params(gx_device * pdev, gs_param_list * plist)

{

    xcf_device *xdev = (xcf_device *)pdev;

    int code;

    bool seprs = false;

    gs_param_string_array scna;

    gs_param_string pos;

    gs_param_string prgbs;

    gs_param_string pcmyks;

    set_param_array(scna, NULL, 0);

    if ( (code = gdev_prn_get_params(pdev, plist)) < 0 ||

         (code = sample_device_crd_get_params(pdev, plist, "CRDDefault")) < 0 ||

	 (code = param_write_name_array(plist, "SeparationColorNames", &scna)) < 0 ||

	 (code = param_write_bool(plist, "Separations", &seprs)) < 0)

	return code;

    pos.data = (const byte *)xdev->profile_out_fn,

	pos.size = strlen(xdev->profile_out_fn),

	pos.persistent = false;

    code = param_write_string(plist, "ProfileOut", &pos);

    if (code < 0)

	return code;

    prgbs.data = (const byte *)xdev->profile_rgb_fn,

	prgbs.size = strlen(xdev->profile_rgb_fn),

	prgbs.persistent = false;

    code = param_write_string(plist, "ProfileRgb", &prgbs);

    pcmyks.data = (const byte *)xdev->profile_cmyk_fn,

	pcmyks.size = strlen(xdev->profile_cmyk_fn),

	pcmyks.persistent = false;

    code = param_write_string(plist, "ProfileCmyk", &prgbs);

    return code;

}

#undef set_param_array

#define compare_color_names(name, name_size, str, str_size) \

    (name_size == str_size && \

	(strncmp((const char *)name, (const char *)str, name_size) == 0))

/*

 * This routine will check if a name matches any item in a list of process model

 * color component names.

 */

private bool

check_process_color_names(const fixed_colorant_names_list * pcomp_list,

			  const gs_param_string * pstring)

{

    if (pcomp_list) {

        const fixed_colorant_name * plist = *pcomp_list;

        uint size = pstring->size;

	while( *plist) {

	    if (compare_color_names(*plist, strlen(*plist), pstring->data, size)) {

		return true;

	    }

	    plist++;

	}

    }

    return false;

}

/*

 * This utility routine calculates the number of bits required to store

 * color information.  In general the values are rounded up to an even

 * byte boundary except those cases in which mulitple pixels can evenly

 * into a single byte.

 *

 * The parameter are:

 *   ncomp - The number of components (colorants) for the device.  Valid

 * 	values are 1 to GX_DEVICE_COLOR_MAX_COMPONENTS

 *   bpc - The number of bits per component.  Valid values are 1, 2, 4, 5,

 *	and 8.

 * Input values are not tested for validity.

 */

static int

bpc_to_depth(int ncomp, int bpc)

{

    static const byte depths[4][8] = {

	{1, 2, 0, 4, 8, 0, 0, 8},

	{2, 4, 0, 8, 16, 0, 0, 16},

	{4, 8, 0, 16, 16, 0, 0, 24},

	{4, 8, 0, 16, 32, 0, 0, 32}

    };

    if (ncomp <=4 && bpc <= 8)

        return depths[ncomp -1][bpc-1];

    else

    	return (ncomp * bpc + 7) & 0xf8;

}

#define BEGIN_ARRAY_PARAM(pread, pname, pa, psize, e)\

    BEGIN\

    switch (code = pread(plist, (param_name = pname), &(pa))) {\

      case 0:\

	if ((pa).size != psize) {\

	  ecode = gs_note_error(gs_error_rangecheck);\

	  (pa).data = 0;	/* mark as not filled */\

	} else

#define END_ARRAY_PARAM(pa, e)\

	goto e;\

      default:\

	ecode = code;\

e:	param_signal_error(plist, param_name, ecode);\

      case 1:\

	(pa).data = 0;		/* mark as not filled */\

    }\

    END

private int

xcf_param_read_fn(gs_param_list *plist, const char *name,

		  gs_param_string *pstr, int max_len)

{

    int code = param_read_string(plist, name, pstr);

    if (code == 0) {

	if (pstr->size >= max_len)

	    param_signal_error(plist, name, code = gs_error_rangecheck);

    } else {

	pstr->data = 0;

    }

    return code;

}

/* Compare a C string and a gs_param_string. */

static bool

param_string_eq(const gs_param_string *pcs, const char *str)

{

    return (strlen(str) == pcs->size &&

	    !strncmp(str, (const char *)pcs->data, pcs->size));

}

private int

xcf_set_color_model(xcf_device *xdev, xcf_color_model color_model)

{

    xdev->color_model = color_model;

    if (color_model == XCF_DEVICE_GRAY) {

	xdev->std_colorant_names = &DeviceGrayComponents;

	xdev->num_std_colorant_names = 1;

	xdev->color_info.cm_name = "DeviceGray";

	xdev->color_info.polarity = GX_CINFO_POLARITY_ADDITIVE;

    } else if (color_model == XCF_DEVICE_RGB) {

	xdev->std_colorant_names = &DeviceRGBComponents;

	xdev->num_std_colorant_names = 3;

	xdev->color_info.cm_name = "DeviceRGB";

	xdev->color_info.polarity = GX_CINFO_POLARITY_ADDITIVE;

    } else if (color_model == XCF_DEVICE_CMYK) {

	xdev->std_colorant_names = &DeviceCMYKComponents;

	xdev->num_std_colorant_names = 4;

	xdev->color_info.cm_name = "DeviceCMYK";

	xdev->color_info.polarity = GX_CINFO_POLARITY_SUBTRACTIVE;

    } else if (color_model == XCF_DEVICE_N) {

	xdev->std_colorant_names = &DeviceCMYKComponents;

	xdev->num_std_colorant_names = 4;

	xdev->color_info.cm_name = "DeviceN";

	xdev->color_info.polarity = GX_CINFO_POLARITY_SUBTRACTIVE;

    } else {

	return -1;

    }

    return 0;

}

/* Set parameters.  We allow setting the number of bits per component. */

private int

xcf_put_params(gx_device * pdev, gs_param_list * plist)

{

    xcf_device * const pdevn = (xcf_device *) pdev;

    gx_device_color_info save_info;

    gs_param_name param_name;

    int npcmcolors;

    int num_spot = pdevn->separation_names.num_names;

    int ecode = 0;

    int code;

    gs_param_string_array scna;

    gs_param_string po;

    gs_param_string prgb;

    gs_param_string pcmyk;

    gs_param_string pcm;

    xcf_color_model color_model = pdevn->color_model;

    BEGIN_ARRAY_PARAM(param_read_name_array, "SeparationColorNames", scna, scna.size, scne) {

	break;

    } END_ARRAY_PARAM(scna, scne);

    if (code >= 0)

	code = xcf_param_read_fn(plist, "ProfileOut", &po,

				 sizeof(pdevn->profile_out_fn));

    if (code >= 0)

	code = xcf_param_read_fn(plist, "ProfileRgb", &prgb,

				 sizeof(pdevn->profile_rgb_fn));

    if (code >= 0)

	code = xcf_param_read_fn(plist, "ProfileCmyk", &pcmyk,

				 sizeof(pdevn->profile_cmyk_fn));

    if (code >= 0)

	code = param_read_name(plist, "ProcessColorModel", &pcm);

    if (code == 0) {

	if (param_string_eq (&pcm, "DeviceGray"))

	    color_model = XCF_DEVICE_GRAY;

	else if (param_string_eq (&pcm, "DeviceRGB"))

	    color_model = XCF_DEVICE_RGB;

	else if (param_string_eq (&pcm, "DeviceCMYK"))

	    color_model = XCF_DEVICE_CMYK;

	else if (param_string_eq (&pcm, "DeviceN"))

	    color_model = XCF_DEVICE_N;

	else {

	    param_signal_error(plist, "ProcessColorModel",

			       code = gs_error_rangecheck);

	}

    }

    if (code < 0)

	ecode = code;

    /*

     * Save the color_info in case gdev_prn_put_params fails, and for

     * comparison.