/* This is used with the fast thresholding code when doing -dUseFastColor
and going out to a planar device */
static void
gsicc_rcm_chunky_to_planar(gx_device *dev, gsicc_link_t *icclink,
gsicc_bufferdesc_t *input_buff_desc,
gsicc_bufferdesc_t *output_buff_desc,
void *inputbuffer, void *outputbuffer)
{
int k, j, m;
byte *inputpos = (byte *) inputbuffer;
byte *outputpos = (byte *) outputbuffer;
byte *output_loc;
byte *inputcolor;
byte outputcolor[8]; /* 8 since we have max 4 colorants and 2 bytes/colorant */
unsigned short *pos_in_short, *pos_out_short;
int num_bytes_in = input_buff_desc->bytes_per_chan;
int num_bytes_out = output_buff_desc->bytes_per_chan;
int pixel_in_step = num_bytes_in * input_buff_desc->num_chan;
int plane_stride = output_buff_desc->plane_stride;
/* Do row by row. */
for (k = 0; k < input_buff_desc->num_rows ; k++) {
inputcolor = inputpos;
output_loc = outputpos;
/* split the 2 byte 1 byte case here to avoid decision in inner loop */
if (output_buff_desc->bytes_per_chan == 1) {
for (j = 0; j < input_buff_desc->pixels_per_row; j++) {
gsicc_rcm_transform_general(dev, icclink, (void*) inputcolor,
(void*) &(outputcolor[0]), num_bytes_in,
num_bytes_out);
/* Stuff the output in the proper planar location */
for (m = 0; m < output_buff_desc->num_chan; m++) {
*(output_loc + m * plane_stride + j) = outputcolor[m];
}
inputcolor += pixel_in_step;
}
inputpos += input_buff_desc->row_stride;
outputpos += output_buff_desc->row_stride;
} else {
for (j = 0; j < input_buff_desc->pixels_per_row; j++) {
gsicc_rcm_transform_general(dev, icclink, (void*) inputcolor,
(void*) &(outputcolor[0]), num_bytes_in,
num_bytes_out);
/* Stuff the output in the proper planar location */
pos_in_short = (unsigned short*) &(outputcolor[0]);
pos_out_short = (unsigned short*) (output_loc);
for (m = 0; m < output_buff_desc->num_chan; m++) {
*(pos_out_short + m * plane_stride + j) = pos_in_short[m];
}
inputcolor += pixel_in_step;
}
inputpos += input_buff_desc->row_stride;
outputpos += output_buff_desc->row_stride;
}
}
}
static void
gsicc_rcm_chunky_to_chunky(gx_device *dev, gsicc_link_t *icclink,
gsicc_bufferdesc_t *input_buff_desc,
gsicc_bufferdesc_t *output_buff_desc,
void *inputbuffer, void *outputbuffer)
{
int k, j;
byte *inputpos = (byte *) inputbuffer;
byte *outputpos = (byte *) outputbuffer;
byte *inputcolor, *outputcolor;
int num_bytes_in = input_buff_desc->bytes_per_chan;
int num_bytes_out = output_buff_desc->bytes_per_chan;
int pixel_in_step = num_bytes_in * input_buff_desc->num_chan;
int pixel_out_step = num_bytes_out * output_buff_desc->num_chan;
/* Do row by row. */
for (k = 0; k < input_buff_desc->num_rows ; k++) {
inputcolor = inputpos;
outputcolor = outputpos;
for (j = 0; j < input_buff_desc->pixels_per_row; j++) {
gsicc_rcm_transform_general(dev, icclink, (void*) inputcolor,
(void*) outputcolor, num_bytes_in,
num_bytes_out);
inputcolor += pixel_in_step;
outputcolor += pixel_out_step;
}
inputpos += input_buff_desc->row_stride;
outputpos += output_buff_desc->row_stride;
}
}
/* Functions that should be optimized later to do planar/chunky with
color conversions. Just putting in something that should work
right now */
static void
gsicc_rcm_planar_to_planar(gx_device *dev, gsicc_link_t *icclink,
gsicc_bufferdesc_t *input_buff_desc,
gsicc_bufferdesc_t *output_buff_desc,
void *inputbuffer, void *outputbuffer)
{
int k, j;
byte *inputpos[4];
byte *outputpos[4];
byte *in_buffer_ptr = (byte *) inputbuffer;
byte *out_buffer_ptr = (byte *) outputbuffer;
byte in_color[4], out_color[4];
for (k = 0; k < input_buff_desc->num_chan; k++) {
inputpos[k] = in_buffer_ptr + k * input_buff_desc->plane_stride;
}
for (k = 0; k < output_buff_desc->num_chan; k++) {
outputpos[k] = out_buffer_ptr + k * input_buff_desc->plane_stride;
}
/* Note to self. We currently only do this in the transparency buffer
case which has byte representation so just stepping through
plane_stride is ok at this time. */
for (k = 0; k < input_buff_desc->plane_stride ; k++) {
for (j = 0; j < input_buff_desc->num_chan; j++) {
in_color[j] = *(inputpos[j]);
inputpos[j] += input_buff_desc->bytes_per_chan;
}
gsicc_rcm_transform_general(dev, icclink, (void*) &(in_color[0]),
(void*) &(out_color[0]), 1, 1);
for (j = 0; j < output_buff_desc->num_chan; j++) {
*(outputpos[j]) = out_color[j];
outputpos[j] += output_buff_desc->bytes_per_chan;
}
}
}
/* Transform a single color using the generic (non color managed)
transformations */
static void
gsicc_rcm_transform_color(gx_device *dev, gsicc_link_t *icclink, void *inputcolor,
void *outputcolor, int num_bytes)
{
gsicc_rcm_transform_general(dev, icclink, inputcolor, outputcolor,
num_bytes, num_bytes);
}
