/*
 * Copyright (C) 2009 GraphicsMagick Group
 *
 * American Society of Cinematographers Color Decision List (ASC-CDL)
 * implementation.
 *
 * Original implementation by Clément Follet.  Additional work by Bob
 * Friesenhahn.
 */

/*
  Include declarations.
*/
#include "magick/studio.h"
#include "magick/cdl.h"
#include "magick/pixel_iterator.h"
#include "magick/utility.h"

/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%                                                                             %
%                                                                             %
%     C d l I m a g e                                                         %
%                                                                             %
%                                                                             %
%                                                                             %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%  The CdlImage() method applies ("bakes in") the ASC-CDL which is a format
%  for the exchange of basic primary color grading information between
%  equipment and software from different manufacturers. The format defines
%  the math for three functions: slope, offset and power. Each function uses
%  a number for the red, green, and blue color channels for a total of nine
%  numbers comprising a single color decision. A tenth number for chrominance
%  (saturation) has been proposed but is not yet standardized.
%
%  The cdl argument string is comma delimited and is in the form (but
%  without invervening spaces or line breaks):
%
%    redslope, redoffset, redpower :
%    greenslope, greenoffset, greenpower :
%    blueslope, blueoffset, bluepower :
%    saturation
%
%  with the unity (no change) specification being:
%
%    "1.0,0.0,1.0:1.0,0.0,1.0:1.0,0.0,1.0:0.0"
%
%  See http://en.wikipedia.org/wiki/ASC_CDL for more information.
%
%  The format of the CdlImage method is:
%
%      MagickPassFail CdlImage(Image *image,const char *cdl)
%
%  A description of each parameter follows:
%
%    o image: The image.
%
%    o cdl: Define the coefficients for slope offset and power in the
%      red green and blue channels, plus saturation.
%
*/

typedef struct _CdlImageParameters_t
{
  double
    redslope,
    redoffset,
    redpower,
    greenslope,
    greenoffset,
    greenpower,
    blueslope,
    blueoffset,
    bluepower,
    saturation;

  const PixelPacket
    *lut;

} CdlImageParameters_t;

static Quantum
CdlQuantum(const Quantum quantum, const double slope, const double offset,
           const double power, const double saturation)
{
  double
    v,
    t;

  t=(((double) quantum)/MaxRGBDouble)*slope+offset;
  if (t < 0.0)
    t = 0.0;
  else if (t > 1.0)
    t = 1.0;
  v = (pow(t,power)+saturation)*MaxRGBDouble;
  return RoundDoubleToQuantum(v);
}

static MagickPassFail
CdlImagePixels(void *mutable_data,         /* User provided mutable data */
               const void *immutable_data, /* User provided immutable data */
               Image * restrict image,               /* Modify image */
               PixelPacket * restrict pixels,        /* Pixel row */
               IndexPacket * restrict indexes,       /* Pixel row indexes */
               const long npixels,         /* Number of pixels in row */
               ExceptionInfo *exception)   /* Exception report */
{
  const CdlImageParameters_t
    param = *(const CdlImageParameters_t *) immutable_data;

  register long
    i;

  ARG_NOT_USED(mutable_data);
  ARG_NOT_USED(image);
  ARG_NOT_USED(indexes);
  ARG_NOT_USED(exception);

  if (param.lut != (PixelPacket *) NULL)
    {
      for(i = 0; i < npixels; i++)
        {
          pixels[i].red=param.lut[pixels[i].red].red;
          pixels[i].green=param.lut[pixels[i].green].green;
          pixels[i].blue=param.lut[pixels[i].blue].blue;
        }
    }
  else
    {
      for(i = 0; i < npixels; i++)
        {
          pixels[i].red=CdlQuantum(pixels[i].red,param.redslope,param.redoffset,
                                   param.redpower,param.saturation);
          pixels[i].green=CdlQuantum(pixels[i].green,param.greenslope,param.greenoffset,
                                     param.greenpower,param.saturation);
          pixels[i].blue=CdlQuantum(pixels[i].blue,param.blueslope,param.blueoffset,
                                    param.bluepower,param.saturation);
        }
    }

  return MagickPass;
}


MagickExport MagickPassFail CdlImage(Image *image,const char *cdl)
{
  char
    progress_message[MaxTextExtent];

  CdlImageParameters_t
    param;

  PixelPacket
    *lut = (PixelPacket *) NULL;

  register long
    i;

  MagickPassFail
    status=MagickPass;

  assert(image != (Image *) NULL);
  assert(image->signature == MagickSignature);
  if (cdl == (char *) NULL)
    return(MagickFail);

  param.redslope=1.0;
  param.redoffset=0.0;
  param.redpower=1.0;
  param.greenslope=1.0;
  param.greenoffset=0.0;
  param.greenpower=1.0;
  param.blueslope=1.0;
  param.blueoffset=0.0;
  param.bluepower=1.0;
  param.saturation=0.0;
  param.lut=(PixelPacket *) NULL;

  (void) sscanf(cdl,
                "%lf%*[,/]%lf%*[,/]%lf%*[:/]%lf%*[,/]%lf%*[,/]%lf%*"
                "[:/]%lf%*[,/]%lf%*[,/]%lf%*[:/]%lf",
                &param.redslope,&param.redoffset,&param.redpower,
                &param.greenslope,&param.greenoffset,&param.greenpower
                ,&param.blueslope,&param.blueoffset,&param.bluepower,
                &param.saturation);

  param.redslope=AbsoluteValue(param.redslope);
  param.redpower=AbsoluteValue(param.redpower);
  param.greenslope=AbsoluteValue(param.greenslope);
  param.greenpower=AbsoluteValue(param.greenpower);
  param.blueslope=AbsoluteValue(param.blueslope);
  param.bluepower=AbsoluteValue(param.bluepower);

  FormatString(progress_message,
               "[%%s] cdl %g/%g/%g/%g/%g/%g/%g/%g/%g/%g image...",
               param.redslope,param.redoffset,param.redpower,
               param.greenslope,param.greenoffset,param.greenpower,
               param.blueslope,param.blueoffset,param.bluepower,
               param.saturation);

  if (!IsRGBCompatibleColorspace(image->colorspace))
    TransformColorspace(image,RGBColorspace);

  /*
    Build a LUT if it is beneficial to do so.
  */
  if ((MaxMap == MaxRGB) && (image->columns*image->rows > MaxMap*3))
    {
      lut=MagickAllocateMemory(PixelPacket *,(MaxMap+1)*sizeof(PixelPacket));
      if (lut != (PixelPacket *) NULL)
        {
#if (MaxMap > 256) && defined(HAVE_OPENMP)
#  if defined(USE_STATIC_SCHEDULING_ONLY)
#    pragma omp parallel for schedule(static,4)
#  else
#    pragma omp parallel for schedule(guided)
#  endif
#endif
          for (i=0; i <= (long) MaxMap; i++)
            {
              lut[i].red=CdlQuantum((Quantum) i,param.redslope,param.redoffset,
                                       param.redpower,param.saturation);
              lut[i].green=CdlQuantum((Quantum) i,param.greenslope,param.greenoffset,
                                         param.greenpower,param.saturation);
              lut[i].blue=CdlQuantum((Quantum) i,param.blueslope,param.blueoffset,
                                        param.bluepower,param.saturation);
            }
          param.lut=lut;
        }
    }

  if (image->storage_class == PseudoClass)
    {
      (void) CdlImagePixels(NULL,&param,image,image->colormap,
                            (IndexPacket *) NULL,image->colors,
                            &image->exception);
      status=SyncImage(image);
    }
  else
    {
      status=PixelIterateMonoModify(CdlImagePixels,NULL,progress_message,
                                    NULL,&param,0,0,image->columns,image->rows,
                                    image,&image->exception);
    }

  MagickFreeMemory(lut);

  return(status);
}
