/* Copyright (C) 2001-2013 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.,  7 Mt. Lassen Drive - Suite A-134, San Rafael,
   CA  94903, U.S.A., +1(415)492-9861, for further information.
*/

/* gsicc handling for monitoring colors.  Used for detecting gray only pages */


#include "std.h"
#include "stdpre.h"
#include "gstypes.h"
#include "gsmemory.h"
#include "gxdevcli.h"
#include "gxcspace.h"
#include "gsicc_cms.h"
#include "gsicc_cache.h"
#include "gxcvalue.h"
#include "gxdevsop.h"
#include "gdevp14.h"
#include "string_.h"
#include <stdlib.h> /* abs() */

static void gsicc_mcm_transform_general(gx_device *dev, gsicc_link_t *icclink,
                                         void *inputcolor, void *outputcolor,
                                         int num_bytes_in, int num_bytes_out);

/* 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_mcm_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_mcm_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;
        }
    }
}

/* This is not really used yet */
static void
gsicc_mcm_planar_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)
{


}

/* This is used with the fast thresholding code when doing -dUseFastColor
   and going out to a planar device */
static void
gsicc_mcm_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_mcm_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_mcm_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_mcm_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_mcm_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;
    }
}

/* Transform an entire buffer monitoring and transforming the colors */
static void
gsicc_mcm_transform_color_buffer(gx_device *dev, gsicc_link_t *icclink,
                                  gsicc_bufferdesc_t *input_buff_desc,
                                  gsicc_bufferdesc_t *output_buff_desc,
                                  void *inputbuffer, void *outputbuffer)
{
    if (input_buff_desc->is_planar) {
        if (output_buff_desc->is_planar) {
            gsicc_mcm_planar_to_planar(dev, icclink, input_buff_desc,
                                        output_buff_desc, inputbuffer,
                                        outputbuffer);
        } else {
            gsicc_mcm_planar_to_chunky(dev, icclink, input_buff_desc,
                                        output_buff_desc, inputbuffer,
                                        outputbuffer);
        }
    } else {
        if (output_buff_desc->is_planar) {
            gsicc_mcm_chunky_to_planar(dev, icclink, input_buff_desc,
                                        output_buff_desc, inputbuffer,
                                        outputbuffer);
        } else {
            gsicc_mcm_chunky_to_chunky(dev, icclink, input_buff_desc,
                                        output_buff_desc, inputbuffer,
                                        outputbuffer);
        }
    }
    return;
}

/* This is where we do the monitoring and the conversion if needed */
static void
gsicc_mcm_transform_general(gx_device *dev, gsicc_link_t *icclink,
                             void *inputcolor, void *outputcolor,
                             int num_bytes_in, int num_bytes_out)
{
    bool is_neutral = false;
    unsigned short outputcolor_cm[GX_DEVICE_COLOR_MAX_COMPONENTS];
    void *outputcolor_cm_ptr = (void*) outputcolor_cm;
    cmm_dev_profile_t *dev_profile;
    int code;
    int k;

    code = dev_proc(dev, get_profile)(dev, &dev_profile);

    /* Monitor only if gray detection is still true */
    if (dev_profile->pageneutralcolor)
        is_neutral = icclink->procs.is_color(inputcolor, num_bytes_in);

    /* Color found turn off gray detection */
    if (!is_neutral)
        dev_profile->pageneutralcolor = false;

    /* Reset all links so that they will no longer monitor.  This one will finish
       the buffer but we will not have any additional ones */
    if (!dev_profile->pageneutralcolor)
        gsicc_mcm_end_monitor(icclink->icc_link_cache, dev);

    /* Now apply the color transform using the original color procs, but don't
       do this if we had the identity.  We also have to worry about 8 and 16 bit
       depth */
    if (icclink->hashcode.des_hash == icclink->hashcode.src_hash) {
        if (num_bytes_in == num_bytes_out) {
            /* The easy case */
            memcpy(outputcolor, inputcolor, num_bytes_in * icclink->num_input);
            return;
        } else {
            if (num_bytes_in == 2) {
                unsigned short *in_ptr = (unsigned short*) inputcolor;
                byte *out_ptr = (byte*) outputcolor;
                for (k = 0; k < icclink->num_input; k++) {
                    out_ptr[k] = gx_color_value_to_byte(in_ptr[k]);
                }
            } else {
                byte *in_ptr = (byte*) inputcolor;
                unsigned short *out_ptr = (unsigned short*) outputcolor;
                for (k = 0; k < icclink->num_input; k++) {
                    out_ptr[k] = gx_color_value_to_byte(in_ptr[k]);
                }
            }
            return;
        }
    } else {
        if (num_bytes_in == num_bytes_out) {
            icclink->orig_procs.map_color(dev, icclink, inputcolor, outputcolor,
                                          num_bytes_in);
            return;
        } else {
            icclink->orig_procs.map_color(dev, icclink, inputcolor, outputcolor_cm_ptr,
                                          num_bytes_in);
            if (num_bytes_in == 2) {
                unsigned short *in_ptr = (unsigned short*) outputcolor_cm_ptr;
                byte *out_ptr = (byte*) outputcolor;
                for (k = 0; k < icclink->num_input; k++) {
                    out_ptr[k] = gx_color_value_to_byte(in_ptr[k]);
                }
            } else {
                byte *in_ptr = (byte*) outputcolor_cm_ptr;
                unsigned short *out_ptr = (unsigned short*) outputcolor;
                for (k = 0; k < icclink->num_input; k++) {
                    out_ptr[k] = gx_color_value_to_byte(in_ptr[k]);
                }
            }
            return;
        }
    }
}

/* Monitor for color */
static void
gsicc_mcm_transform_color(gx_device *dev, gsicc_link_t *icclink, void *inputcolor,
                           void *outputcolor, int num_bytes)
{
    gsicc_mcm_transform_general(dev, icclink, inputcolor, outputcolor,
                                 num_bytes, num_bytes);
}

bool gsicc_mcm_monitor_rgb(void *inputcolor, int num_bytes)
{
    if (num_bytes == 1) {
        byte *rgb_val = (byte*) inputcolor;
        int rg_diff = (int) abs((int) rgb_val[0] - (int) rgb_val[1]);
        int rb_diff = (int) abs((int) rgb_val[0] - (int) rgb_val[2]);
        int bg_diff = (int) abs((int) rgb_val[1] - (int) rgb_val[2]);
        return (rg_diff < DEV_NEUTRAL_8 && rb_diff < DEV_NEUTRAL_8
                && bg_diff < DEV_NEUTRAL_8);
    } else {
        unsigned short *rgb_val = (unsigned short*) inputcolor;
        int rg_diff = (int) abs((int) rgb_val[0] - (int) rgb_val[1]);
        int rb_diff = (int) abs((int) rgb_val[0] - (int) rgb_val[2]);
        int bg_diff = (int) abs((int) rgb_val[1] - (int) rgb_val[2]);
        return (rg_diff < DEV_NEUTRAL_16 && rb_diff < DEV_NEUTRAL_16
                && bg_diff < DEV_NEUTRAL_16);
    }
}

bool gsicc_mcm_monitor_cmyk(void *inputcolor, int num_bytes)
{
#ifdef PESSIMISTIC_CMYK_NEUTRAL
    if (num_bytes == 1) {
        byte *cmyk = (byte*) inputcolor;
        return (cmyk[0] < DEV_NEUTRAL_8 && cmyk[1] < DEV_NEUTRAL_8
                && cmyk[2] < DEV_NEUTRAL_8);
    } else {
        unsigned short *cmyk = (unsigned short*) inputcolor;
        return (cmyk[0] < DEV_NEUTRAL_16 && cmyk[1] < DEV_NEUTRAL_16
                && cmyk[2] < DEV_NEUTRAL_16);
    }
#else /* The code below is more similar to RGB in that C = M = Y (or close) */
      /* will be treated as neutral.                                        */
    if (num_bytes == 1) {
        byte *cmyk = (byte*) inputcolor;
        int cm_diff = (int) abs((int) cmyk[0] - (int) cmyk[1]);
        int cy_diff = (int) abs((int) cmyk[0] - (int) cmyk[2]);
        int my_diff = (int) abs((int) cmyk[1] - (int) cmyk[2]);
        return (cm_diff < DEV_NEUTRAL_8 && cy_diff < DEV_NEUTRAL_8
                && my_diff < DEV_NEUTRAL_8);
    } else {
        unsigned short *cmyk = (unsigned short*) inputcolor;
        int cm_diff = (int) abs((int) cmyk[0] - (int) cmyk[1]);
        int cy_diff = (int) abs((int) cmyk[0] - (int) cmyk[2]);
        int my_diff = (int) abs((int) cmyk[1] - (int) cmyk[2]);
        return (cm_diff < DEV_NEUTRAL_16 && cy_diff < DEV_NEUTRAL_16
                && my_diff < DEV_NEUTRAL_16);
    }
#endif
}

bool gsicc_mcm_monitor_lab(void *inputcolor, int num_bytes)
{
    if (num_bytes == 1) {
        byte *lab = (byte*) inputcolor;
        int diffa = (int) abs((int) lab[1] - (int) 0x80);
        int diffb = (int) abs((int) lab[2] - (int) 0x80);
        return (diffa < AB_NEUTRAL_8 && diffb < AB_NEUTRAL_8);
    } else {
        unsigned short *lab = (unsigned short*) inputcolor;
        int diffa = (int) abs((int) lab[1] - (int) 0x8000);
        int diffb = (int) abs((int) lab[2] - (int) 0x8000);
        return (diffa < AB_NEUTRAL_16 && diffb < AB_NEUTRAL_16);
    }
}

/* Set the link up to monitor */
void
gsicc_mcm_set_link(gsicc_link_t* link)
{
    link->orig_procs = link->procs;
    link->is_monitored = true;
    link->is_identity = false;

    link->procs.map_buffer = gsicc_mcm_transform_color_buffer;
    link->procs.map_color = gsicc_mcm_transform_color;

    switch (link->data_cs) {
        case gsRGB:
            link->procs.is_color = gsicc_mcm_monitor_rgb;
            break;
        case gsCIELAB:
            link->procs.is_color = gsicc_mcm_monitor_lab;
            break;
        case gsCMYK:
            link->procs.is_color = gsicc_mcm_monitor_cmyk;
            break;
        default:
            break;
    }
}

/* This gets rid of the monitoring */
void
gsicc_mcm_end_monitor(gsicc_link_cache_t *cache, gx_device *dev)
{
    gx_monitor_t *lock = cache->lock;
    gsicc_link_t *curr;
    int code;
    cmm_dev_profile_t *dev_profile;

    /* Lock the cache as we remove monitoring from the links */
    gx_monitor_enter(lock);

    /* Get the device profile */
    code = dev_proc(dev, get_profile)(dev, &dev_profile);
    dev_profile->pageneutralcolor = false;
    /* If this device is a pdf14 device, then we may need to take care of the
       profile in the target device also.  This is a special case since the
       pdf14 device has its own profile different from the target device */
    if (dev_proc(dev, dev_spec_op)(dev, gxdso_is_pdf14_device, NULL, 0) > 0) {
        gs_pdf14_device_color_mon_set(dev, false);
    }

    curr = cache->head;
    while (curr != NULL ) {
        if (curr->is_monitored) {
            curr->procs = curr->orig_procs;
            if (curr->hashcode.des_hash == curr->hashcode.src_hash)
                curr->is_identity = true;
            curr->is_monitored = false;
        }
        /* Now release any tasks/threads waiting for these contents */
        while (curr->num_waiting > 0) {
            gx_semaphore_signal(curr->wait);
            curr->num_waiting--;
        }
        curr = curr->next;
    }
    gx_monitor_leave(lock);	/* done with updating, let everyone run */
}

/* Conversely to the above, this gets restores monitoring, needed after
 * monitoring was turned off above (for the next page)
*/
void
gsicc_mcm_begin_monitor(gsicc_link_cache_t *cache, gx_device *dev)
{
    gx_monitor_t *lock = cache->lock;
    gsicc_link_t *curr;
    int code;
    cmm_dev_profile_t *dev_profile;

    /* Lock the cache as we remove monitoring from the links */
    gx_monitor_enter(lock);

    /* Get the device profile */
    code = dev_proc(dev, get_profile)(dev, &dev_profile);
    dev_profile->pageneutralcolor = true;
    /* If this device is a pdf14 device, then we may need to take care of the
       profile in the target device also.  This is a special case since the
       pdf14 device has its own profile different from the target device */
    if (dev_proc(dev, dev_spec_op)(dev, gxdso_is_pdf14_device, NULL, 0) > 0) {
        gs_pdf14_device_color_mon_set(dev, true);
    }

    curr = cache->head;
    while (curr != NULL ) {
        if (curr->data_cs != gsGRAY)
            gsicc_mcm_set_link(curr);
        /* Now release any tasks/threads waiting for these contents */
        while (curr->num_waiting > 0) {
            gx_semaphore_signal(curr->wait);
            curr->num_waiting--;
        }
        curr = curr->next;
    }
    gx_monitor_leave(lock);	/* done with updating, let everyone run */
}