diff options
Diffstat (limited to 'cupsfilters/rgb.c')
| -rw-r--r-- | cupsfilters/rgb.c | 551 |
1 files changed, 551 insertions, 0 deletions
diff --git a/cupsfilters/rgb.c b/cupsfilters/rgb.c new file mode 100644 index 000000000..70a29153e --- /dev/null +++ b/cupsfilters/rgb.c @@ -0,0 +1,551 @@ +/* + * RGB color separation code for CUPS. + * + * Copyright 2007 by Apple Inc. + * Copyright 1993-2005 by Easy Software Products. + * + * These coded instructions, statements, and computer programs are the + * property of Apple Inc. and are protected by Federal copyright + * law. Distribution and use rights are outlined in the file "COPYING" + * which should have been included with this file. + * + * Contents: + * + * cupsRGBDelete() - Delete a color separation. + * cupsRGBDoGray() - Do a grayscale separation... + * cupsRGBDoRGB() - Do a RGB separation... + * cupsRGBLoad() - Load a RGB color profile from a PPD file. + * cupsRGBNew() - Create a new RGB color separation. + */ + +/* + * Include necessary headers. + */ + +#include "driver.h" + + +/* + * 'cupsRGBDelete()' - Delete a color separation. + */ + +void +cupsRGBDelete(cups_rgb_t *rgbptr) /* I - Color separation */ +{ + if (rgbptr == NULL) + return; + + free(rgbptr->colors[0][0][0]); + free(rgbptr->colors[0][0]); + free(rgbptr->colors[0]); + free(rgbptr->colors); + free(rgbptr); +} + + +/* + * 'cupsRGBDoGray()' - Do a grayscale separation... + */ + +void +cupsRGBDoGray(cups_rgb_t *rgbptr, + /* I - Color separation */ + const unsigned char *input, + /* I - Input grayscale pixels */ + unsigned char *output, + /* O - Output Device-N pixels */ + int num_pixels) + /* I - Number of pixels */ +{ + int i; /* Looping var */ + int lastgray; /* Previous grayscale */ + int xs, ys, zs, /* Current RGB row offsets */ + g, gi, gm0, gm1;/* Current gray index and multipliers ... */ + const unsigned char *color; /* Current color data */ + int tempg; /* Current separation color */ + int rgbsize; /* Separation data size */ + + + /* + * Range check input... + */ + + if (!rgbptr || !input || !output || num_pixels <= 0) + return; + + /* + * Initialize variables used for the duration of the separation... + */ + + lastgray = -1; + rgbsize = rgbptr->num_channels; + xs = rgbptr->cube_size * rgbptr->cube_size * rgbptr->num_channels; + ys = rgbptr->cube_size * rgbptr->num_channels; + zs = rgbptr->num_channels; + + /* + * Loop through it all... + */ + + while (num_pixels > 0) + { + /* + * See if the next pixel is a cached value... + */ + + num_pixels --; + + g = cups_srgb_lut[*input++]; + + if (g == lastgray) + { + /* + * Copy previous color and continue... + */ + + memcpy(output, output - rgbptr->num_channels, rgbsize); + + output += rgbptr->num_channels; + continue; + } + else if (g == 0x00 && rgbptr->cache_init) + { + /* + * Copy black color and continue... + */ + + memcpy(output, rgbptr->black, rgbsize); + + output += rgbptr->num_channels; + continue; + } + else if (g == 0xff && rgbptr->cache_init) + { + /* + * Copy white color and continue... + */ + + memcpy(output, rgbptr->white, rgbsize); + + output += rgbptr->num_channels; + continue; + } + + /* + * Nope, figure this one out on our own... + */ + + gi = rgbptr->cube_index[g]; + gm0 = rgbptr->cube_mult[g]; + gm1 = 256 - gm0; + + color = rgbptr->colors[gi][gi][gi]; + + for (i = 0; i < rgbptr->num_channels; i ++, color ++) + { + tempg = (color[0] * gm0 + color[xs + ys + zs] * gm1) / 256; + + if (tempg > 255) + *output++ = 255; + else if (tempg < 0) + *output++ = 0; + else + *output++ = tempg; + } + } +} + + +/* + * 'cupsRGBDoRGB()' - Do a RGB separation... + */ + +void +cupsRGBDoRGB(cups_rgb_t *rgbptr, + /* I - Color separation */ + const unsigned char *input, + /* I - Input RGB pixels */ + unsigned char *output, + /* O - Output Device-N pixels */ + int num_pixels) + /* I - Number of pixels */ +{ + int i; /* Looping var */ + int rgb, /* Current RGB color */ + lastrgb; /* Previous RGB color */ + int r, ri, rm0, rm1, rs, + /* Current red index, multipliexs, and row offset */ + g, gi, gm0, gm1, gs, + /* Current green ... */ + b, bi, bm0, bm1, bs; + /* Current blue ... */ + const unsigned char *color; /* Current color data */ + int tempr, /* Current separation colors */ + tempg, /* ... */ + tempb ; /* ... */ + int rgbsize; /* Separation data size */ + + + /* + * Range check input... + */ + + if (!rgbptr || !input || !output || num_pixels <= 0) + return; + + /* + * Initialize variables used for the duration of the separation... + */ + + lastrgb = -1; + rgbsize = rgbptr->num_channels; + rs = rgbptr->cube_size * rgbptr->cube_size * rgbptr->num_channels; + gs = rgbptr->cube_size * rgbptr->num_channels; + bs = rgbptr->num_channels; + + /* + * Loop through it all... + */ + + while (num_pixels > 0) + { + /* + * See if the next pixel is a cached value... + */ + + num_pixels --; + + r = cups_srgb_lut[*input++]; + g = cups_srgb_lut[*input++]; + b = cups_srgb_lut[*input++]; + rgb = (((r << 8) | g) << 8) | b; + + if (rgb == lastrgb) + { + /* + * Copy previous color and continue... + */ + + memcpy(output, output - rgbptr->num_channels, rgbsize); + + output += rgbptr->num_channels; + continue; + } + else if (rgb == 0x000000 && rgbptr->cache_init) + { + /* + * Copy black color and continue... + */ + + memcpy(output, rgbptr->black, rgbsize); + + output += rgbptr->num_channels; + continue; + } + else if (rgb == 0xffffff && rgbptr->cache_init) + { + /* + * Copy white color and continue... + */ + + memcpy(output, rgbptr->white, rgbsize); + + output += rgbptr->num_channels; + continue; + } + + /* + * Nope, figure this one out on our own... + */ + + ri = rgbptr->cube_index[r]; + rm0 = rgbptr->cube_mult[r]; + rm1 = 256 - rm0; + + gi = rgbptr->cube_index[g]; + gm0 = rgbptr->cube_mult[g]; + gm1 = 256 - gm0; + + bi = rgbptr->cube_index[b]; + bm0 = rgbptr->cube_mult[b]; + bm1 = 256 - bm0; + + color = rgbptr->colors[ri][gi][bi]; + + for (i = rgbptr->num_channels; i > 0; i --, color ++) + { + tempb = (color[0] * bm0 + color[bs] * bm1) / 256; + tempg = tempb * gm0; + tempb = (color[gs] * gm0 + color[gs + bs] * bm1) / 256; + tempg = (tempg + tempb * gm1) / 256; + + tempr = tempg * rm0; + + tempb = (color[rs] * bm0 + color[rs + bs] * bm1) / 256; + tempg = tempb * gm0; + tempb = (color[rs + gs] * bm0 + color[rs + gs + bs] * bm1) / 256; + tempg = (tempg + tempb * gm1) / 256; + + tempr = (tempr + tempg * rm1) / 256; + + if (tempr > 255) + *output++ = 255; + else if (tempr < 0) + *output++ = 0; + else + *output++ = tempr; + } + } +} + + +/* + * 'cupsRGBLoad()' - Load a RGB color profile from a PPD file. + */ + +cups_rgb_t * /* O - New color profile */ +cupsRGBLoad(ppd_file_t *ppd, /* I - PPD file */ + const char *colormodel, /* I - Color model */ + const char *media, /* I - Media type */ + const char *resolution) /* I - Resolution */ +{ + int i, /* Looping var */ + cube_size, /* Size of color lookup cube */ + num_channels, /* Number of color channels */ + num_samples; /* Number of color samples */ + cups_sample_t *samples; /* Color samples */ + float values[7]; /* Color sample values */ + char spec[PPD_MAX_NAME]; /* Profile name */ + ppd_attr_t *attr; /* Attribute from PPD file */ + cups_rgb_t *rgbptr; /* RGB color profile */ + + + /* + * Find the following attributes: + * + * cupsRGBProfile - Specifies the cube size, number of channels, and + * number of samples + * cupsRGBSample - Specifies an RGB to CMYK color sample + */ + + if ((attr = cupsFindAttr(ppd, "cupsRGBProfile", colormodel, media, + resolution, spec, sizeof(spec))) == NULL) + { + fputs("DEBUG2: No cupsRGBProfile attribute found for the current settings!\n", stderr); + return (NULL); + } + + if (!attr->value || sscanf(attr->value, "%d%d%d", &cube_size, &num_channels, + &num_samples) != 3) + { + fprintf(stderr, "ERROR: Bad cupsRGBProfile attribute \'%s\'!\n", + attr->value ? attr->value : "(null)"); + return (NULL); + } + + if (cube_size < 2 || cube_size > 16 || + num_channels < 1 || num_channels > CUPS_MAX_RGB || + num_samples != (cube_size * cube_size * cube_size)) + { + fprintf(stderr, "ERROR: Bad cupsRGBProfile attribute \'%s\'!\n", + attr->value); + return (NULL); + } + + /* + * Allocate memory for the samples and read them... + */ + + if ((samples = calloc(num_samples, sizeof(cups_sample_t))) == NULL) + { + fputs("ERROR: Unable to allocate memory for RGB profile!\n", stderr); + return (NULL); + } + + /* + * Read all of the samples... + */ + + for (i = 0; i < num_samples; i ++) + if ((attr = ppdFindNextAttr(ppd, "cupsRGBSample", spec)) == NULL) + break; + else if (!attr->value) + { + fputs("ERROR: Bad cupsRGBSample value!\n", stderr); + break; + } + else if (sscanf(attr->value, "%f%f%f%f%f%f%f", values + 0, + values + 1, values + 2, values + 3, values + 4, values + 5, + values + 6) != (3 + num_channels)) + { + fputs("ERROR: Bad cupsRGBSample value!\n", stderr); + break; + } + else + { + samples[i].rgb[0] = (int)(255.0 * values[0] + 0.5); + samples[i].rgb[1] = (int)(255.0 * values[1] + 0.5); + samples[i].rgb[2] = (int)(255.0 * values[2] + 0.5); + samples[i].colors[0] = (int)(255.0 * values[3] + 0.5); + if (num_channels > 1) + samples[i].colors[1] = (int)(255.0 * values[4] + 0.5); + if (num_channels > 2) + samples[i].colors[2] = (int)(255.0 * values[5] + 0.5); + if (num_channels > 3) + samples[i].colors[3] = (int)(255.0 * values[6] + 0.5); + } + + /* + * If everything went OK, create the color profile... + */ + + if (i == num_samples) + rgbptr = cupsRGBNew(num_samples, samples, cube_size, num_channels); + else + rgbptr = NULL; + + /* + * Free the temporary sample array and return... + */ + + free(samples); + + return (rgbptr); +} + + +/* + * 'cupsRGBNew()' - Create a new RGB color separation. + */ + +cups_rgb_t * /* O - New color separation or NULL */ +cupsRGBNew(int num_samples, /* I - Number of samples */ + cups_sample_t *samples, /* I - Samples */ + int cube_size, /* I - Size of LUT cube */ + int num_channels) /* I - Number of color components */ +{ + cups_rgb_t *rgbptr; /* New color separation */ + int i; /* Looping var */ + int r, g, b; /* Current RGB */ + int tempsize; /* Sibe of main arrays */ + unsigned char *tempc; /* Pointer for C arrays */ + unsigned char **tempb ; /* Pointer for Z arrays */ + unsigned char ***tempg; /* Pointer for Y arrays */ + unsigned char ****tempr; /* Pointer for X array */ + unsigned char rgb[3]; /* Temporary RGB value */ + + + /* + * Range-check the input... + */ + + if (!samples || num_samples != (cube_size * cube_size * cube_size) || + num_channels <= 0 || num_channels > CUPS_MAX_RGB) + return (NULL); + + /* + * Allocate memory for the separation... + */ + + if ((rgbptr = calloc(1, sizeof(cups_rgb_t))) == NULL) + return (NULL); + + /* + * Allocate memory for the samples and the LUT cube... + */ + + tempsize = cube_size * cube_size * cube_size; /* FUTURE: num_samples < cs^3 */ + + tempc = calloc(tempsize, num_channels); + tempb = calloc(tempsize, sizeof(unsigned char *)); + tempg = calloc(cube_size * cube_size, sizeof(unsigned char **)); + tempr = calloc(cube_size, sizeof(unsigned char ***)); + + if (tempc == NULL || tempb == NULL || tempg == NULL || tempr == NULL) + { + free(rgbptr); + + if (tempc) + free(tempc); + + if (tempb) + free(tempb); + + if (tempg) + free(tempg); + + if (tempr) + free(tempr); + + return (NULL); + } + + /* + * Fill in the arrays... + */ + + for (i = 0, r = 0; r < cube_size; r ++) + { + tempr[r] = tempg + r * cube_size; + + for (g = 0; g < cube_size; g ++) + { + tempr[r][g] = tempb + i; + + for (b = 0; b < cube_size; b ++, i ++) + tempr[r][g][b] = tempc + i * num_channels; + } + } + + for (i = 0; i < num_samples; i ++) + { + r = samples[i].rgb[0] * (cube_size - 1) / 255; + g = samples[i].rgb[1] * (cube_size - 1) / 255; + b = samples[i].rgb[2] * (cube_size - 1) / 255; + + memcpy(tempr[r][g][b], samples[i].colors, num_channels); + } + + rgbptr->cube_size = cube_size; + rgbptr->num_channels = num_channels; + rgbptr->colors = tempr; + + /* + * Generate the lookup tables for the cube indices and multipliers... + */ + + for (i = 0; i < 256; i ++) + { + rgbptr->cube_index[i] = i * (cube_size - 1) / 256; + + if (i == 0) + rgbptr->cube_mult[i] = 256; + else + rgbptr->cube_mult[i] = 255 - ((i * (cube_size - 1)) & 255); + } + + /* + * Generate the black and white cache values for the separation... + */ + + rgb[0] = 0; + rgb[1] = 0; + rgb[2] = 0; + + cupsRGBDoRGB(rgbptr, rgb, rgbptr->black, 1); + + rgb[0] = 255; + rgb[1] = 255; + rgb[2] = 255; + + cupsRGBDoRGB(rgbptr, rgb, rgbptr->white, 1); + + rgbptr->cache_init = 1; + + /* + * Return the separation... + */ + + return (rgbptr); +} + |