#include "trop.h"

// TnzCore includes

#include "tpixelgr.h"

#include "trandom.h"

#include "tpixelutils.h"

//******************************************************************

//    Conversion functions

//******************************************************************

static void do_convert(const TRaster64P &dst, const TRaster32P &src) {

  assert(dst->getSize() == src->getSize());

  int lx = src->getLx();

  for (int y = 0; y < src->getLy(); y++) {

    TPixel64 *outPix   = dst->pixels(y);

    TPixel32 *inPix    = src->pixels(y);

    TPixel32 *inEndPix = inPix + lx;

    for (; inPix < inEndPix; ++outPix, ++inPix) {

      outPix->r = ushortFromByte(inPix->r);

      outPix->g = ushortFromByte(inPix->g);

      outPix->b = ushortFromByte(inPix->b);

      outPix->m = ushortFromByte(inPix->m);

    }

  }

}

//-----------------------------------------------------------------------------

static void do_convert(const TRasterGR8P &dst, const TRaster32P &src) {

  assert(dst->getSize() == src->getSize());

  int lx = src->getLx();

  for (int y = 0; y < src->getLy(); ++y) {

    TPixelGR8 *outPix = dst->pixels(y);

    TPixel32 *inPix = src->pixels(y), *inEndPix = inPix + lx;

    for (; inPix < inEndPix; ++outPix, ++inPix)

      *outPix = TPixelGR8::from(overPix(TPixel32::White, *inPix));

  }

}

//-----------------------------------------------------------------------------

static void do_convert(const TRasterGR16P &dst, const TRaster32P &src) {

  assert(dst->getSize() == src->getSize());

  int lx = src->getLx();

  for (int y = 0; y < src->getLy(); ++y) {

    TPixelGR16 *outPix = dst->pixels(y);

    TPixel32 *inPix = src->pixels(y), *inEndPix = inPix + lx;

    for (; inPix < inEndPix; ++outPix, ++inPix)

      outPix->value =

          257 * (TPixelGR8::from(overPix(TPixel32::White, *inPix))).value;

  }

}

//-----------------------------------------------------------------------------

static void do_convert(const TRasterGR16P &dst, const TRaster64P &src) {

  assert(dst->getSize() == src->getSize());

  int lx = src->getLx();

  for (int y = 0; y < src->getLy(); y++) {

    TPixelGR16 *outPix = dst->pixels(y);

    TPixel64 *inPix    = src->pixels(y);

    TPixel64 *inEndPix = inPix + lx;

    while (inPix < inEndPix) {

      outPix->value = (inPix->r + 2 * inPix->g + inPix->b) >> 2;

      outPix++;

      inPix++;

    }

  }

}

//-----------------------------------------------------------------------------

static void do_convert(const TRaster32P &dst, const TRasterGR8P &src) {

  assert(dst->getSize() == src->getSize());

  int lx = src->getLx();

  for (int y = 0; y < src->getLy(); y++) {

    TPixel32 *outPix    = dst->pixels(y);

    TPixelGR8 *inPix    = src->pixels(y);

    TPixelGR8 *inEndPix = inPix + lx;

    while (inPix < inEndPix) {

      outPix->r = inPix->value;

      outPix->g = inPix->value;

      outPix->b = inPix->value;

      outPix->m = 0xff;

      outPix++;

      inPix++;

    }

  }

}

//-----------------------------------------------------------------------------

#define USHORT2BYTE_MAGICFAC (256U * 255U + 1U)

inline UCHAR ditherUcharFromUshort(USHORT in, UINT rndNum) {

  return ((((in * USHORT2BYTE_MAGICFAC) - ((in * USHORT2BYTE_MAGICFAC) >> 24)) +

           rndNum) >>

          24);

}

inline void ditherRgbmFromRgbm64(TPixel32 &out, const TPixel64 &in,

                                 TRandom &rnd) {

  UINT randomRound;

  randomRound = rnd.getUInt() & ((1U << 24) - 1);

  out.r = ditherUcharFromUshort(in.r, randomRound);

  out.g = ditherUcharFromUshort(in.g, randomRound);

  out.b = ditherUcharFromUshort(in.b, randomRound);

  out.m = ditherUcharFromUshort(in.m, randomRound);

}

//-----------------------------------------------------------------------------

inline void ditherConvert(TRaster64P inRas, TRaster32P outRas) {

  int inWrap  = inRas->getWrap();

  int outWrap = outRas->getWrap();

  TPixel64 *inPix = 0, *inRow = inRas->pixels();

  TPixel32 *outPix, *outRow   = outRas->pixels();

  TPixel64 *endPix;

  int inLx          = inRas->getLx();

  TPixel64 *lastPix = inRow + inWrap * (inRas->getLy() - 1) + inLx;

  TRandom rnd(130266);

  while (inPix < lastPix) {

    inPix  = inRow;

    outPix = outRow;

    endPix = inPix + inLx;

    while (inPix < endPix) {

      ditherRgbmFromRgbm64(*outPix, *inPix, rnd);

      inPix++;

      outPix++;

    }

    inRow += inWrap;

    outRow += outWrap;

  }

}

//******************************************************************

//    Obsolete conversion functions

//******************************************************************

static void do_convert(const TRasterCM32P &dst, const TRasterGR8P &src) {

  assert(dst->getSize() == src->getSize());

  TPixelCM32 bg = TPixelCM32(0, 0, TPixelCM32::getMaxTone());

  int lx = src->getLx();

  for (int y = 0; y < src->getLy(); y++) {

    TPixelCM32 *outPix  = dst->pixels(y);

    TPixelGR8 *inPix    = src->pixels(y);

    TPixelGR8 *inEndPix = inPix + lx;

    while (inPix < inEndPix) {

      *outPix = (inPix->value == 255) ? bg : TPixelCM32(1, 0, inPix->value);

      outPix++;

      inPix++;

    }

  }

}

//-----------------------------------------------------------------------------

static void do_convert(const TRasterCM32P &dst, const TRaster32P &src) {

  assert(dst->getSize() == src->getSize());

  TPixelCM32 bg = TPixelCM32(0, 0, TPixelCM32::getMaxTone());

  int lx = src->getLx();

  bool isOverlay = false;

  for (int y = 0; y < src->getLy(); y++)  // if it is an overlay, I use the

                                          // matte value for inks, otherwise I

                                          // use the brightness.

  {

    TPixel32 *inPix    = src->pixels(y);

    TPixel32 *inEndPix = inPix + lx;

    while (inPix < inEndPix) {

      if (inPix->m != 255) {

        isOverlay = true;

        break;

      }

      inPix++;

    }

    if (isOverlay) break;

  }

  if (isOverlay)

    for (int y = 0; y < src->getLy(); y++) {

      TPixelCM32 *outPix = dst->pixels(y);

      TPixel32 *inPix    = src->pixels(y);

      TPixel32 *inEndPix = inPix + lx;

      while (inPix < inEndPix) {

        *outPix = (inPix->m == 0) ? bg : TPixelCM32(1, 0, 255 - inPix->m);

        outPix++;

        inPix++;

      }

    }

  else

    for (int y = 0; y < src->getLy(); y++) {

      TPixelCM32 *outPix = dst->pixels(y);

      TPixel32 *inPix    = src->pixels(y);

      TPixel32 *inEndPix = inPix + lx;

      while (inPix < inEndPix) {

        UCHAR val = TPixelGR8::from(*inPix).value;

        *outPix   = (val == 255) ? bg : TPixelCM32(1, 0, val);

        outPix++;

        inPix++;

      }

    }

}

//-----------------------------------------------------------------------------

static void do_convert(const TRasterYUV422P &dst, const TRaster32P &src) {

  assert(src->getLx() & 0);

  long y1, y2, u, v, u1, u2, v1, v2;

  TPixel32 *pix     = (TPixel32 *)src->pixels();

  TPixel32 *lastPix = &(src->pixels(src->getLy() - 1)[src->getLx() - 1]);

  UCHAR *out = dst->getRawData();

  while (pix < lastPix) {

    /* first pixel gives Y and 0.5 of chroma */

    y1 = 16829 * pix->r + 33039 * pix->g + 6416 * pix->b;

    u1 = -4831 * pix->r + -9488 * pix->g + 14319 * pix->b;

    v1 = 14322 * pix->r + -11992 * pix->g + -2330 * pix->b;

    /* second pixel gives Y and 0.5 of chroma */

    ++pix;

    y2 = 16829 * pix->r + 33039 * pix->g + 6416 * pix->b;

    u2 = -4831 * pix->r + -9488 * pix->g + 14319 * pix->b;

    v2 = 14322 * pix->r + -11992 * pix->g + -2330 * pix->b;

    /* average the chroma */

    u = u1 + u2;

    v = v1 + v2;

    /* round the chroma */

    u1 = (u + 0x008000) >> 16;

    v1 = (v + 0x008000) >> 16;

    /* limit the chroma */

    if (u1 < -112) u1 = -112;

    if (u1 > 111) u1 = 111;

    if (v1 < -112) v1 = -112;

    if (v1 > 111) v1 = 111;

    /* limit the lum */

    if (y1 > 0x00dbffff) y1 = 0x00dbffff;

    if (y2 > 0x00dbffff) y2 = 0x00dbffff;

    /* save the results */

    *out++ = (UCHAR)(u1 + 128);

    *out++ = (UCHAR)((y1 >> 16) + 16);

    *out++ = (UCHAR)(v1 + 128);

    *out++ = (UCHAR)((y2 >> 16) + 16);

    ++pix;

  }

}

//-----------------------------------------------------------------------------

static void do_convert(const TRaster32P &dst, const TRasterYUV422P &src) {

  int long r, g, b, y1, y2, u, v;

  TPixel32 *buf     = dst->pixels();

  const UCHAR *in   = src->getRawData();

  const UCHAR *last = in + src->getRowSize() * src->getLy() - 1;

  while (in < last) {

    u = *in;

    u -= 128;

    in++;

    y1 = *in;

    y1 -= 16;

    in++;

    v = *in;

    v -= 128;

    in++;

    y2 = *in;

    y2 -= 16;

    in++;

    r = 76310 * y1 + 104635 * v;

    if (r > 0xFFFFFF) r = 0xFFFFFF;

    if (r <= 0xFFFF) r = 0;

    g = 76310 * y1 + -25690 * u + -53294 * v;

    if (g > 0xFFFFFF) g = 0xFFFFFF;

    if (g <= 0xFFFF) g = 0;

    b = 76310 * y1 + 132278 * u;

    if (b > 0xFFFFFF) b = 0xFFFFFF;

    if (b <= 0xFFFF) b = 0;

    buf->r = (UCHAR)(r >> 16);

    buf->g = (UCHAR)(g >> 16);

    buf->b = (UCHAR)(b >> 16);

    buf->m = (UCHAR)255;

    buf++;

    r = 76310 * y2 + 104635 * v;

    if (r > 0xFFFFFF) r = 0xFFFFFF;

    if (r <= 0xFFFF) r = 0;

    g = 76310 * y2 + -25690 * u + -53294 * v;

    if (g > 0xFFFFFF) g = 0xFFFFFF;

    if (g <= 0xFFFF) g = 0;

    b = 76310 * y2 + 132278 * u;

    if (b > 0xFFFFFF) b = 0xFFFFFF;

    if (b <= 0xFFFF) b = 0;

    buf->r = (UCHAR)(r >> 16);

    buf->g = (UCHAR)(g >> 16);

    buf->b = (UCHAR)(b >> 16);

    buf->m = (UCHAR)255;

    buf++;

  }

}

//******************************************************************

//    Conversion from/to double raster

//******************************************************************

static void do_convert(const TRasterFP &dst, const TRaster32P &src) {

  assert(dst->getSize() == src->getSize());

  int lx = src->getLx();

  for (int y = 0; y < src->getLy(); y++) {

    TPixelF *outPix    = dst->pixels(y);

    TPixel32 *inPix    = src->pixels(y);

    TPixel32 *inEndPix = inPix + lx;

    for (; inPix < inEndPix; ++outPix, ++inPix) {

      outPix->r = (float)inPix->r / (float)TPixel32::maxChannelValue;

      outPix->g = (float)inPix->g / (float)TPixel32::maxChannelValue;

      outPix->b = (float)inPix->b / (float)TPixel32::maxChannelValue;

      outPix->m = (float)inPix->m / (float)TPixel32::maxChannelValue;

    }

  }

}

//-----------------------------------------------------------------------------

static void do_convert(const TRasterFP &dst, const TRaster64P &src) {

  assert(dst->getSize() == src->getSize());

  int lx = src->getLx();

  for (int y = 0; y < src->getLy(); y++) {

    TPixelF *outPix    = dst->pixels(y);

    TPixel64 *inPix    = src->pixels(y);

    TPixel64 *inEndPix = inPix + lx;

    for (; inPix < inEndPix; ++outPix, ++inPix) {

      outPix->r = (float)inPix->r / (float)TPixel64::maxChannelValue;

      outPix->g = (float)inPix->g / (float)TPixel64::maxChannelValue;

      outPix->b = (float)inPix->b / (float)TPixel64::maxChannelValue;

      outPix->m = (float)inPix->m / (float)TPixel64::maxChannelValue;

    }

  }

}

//-----------------------------------------------------------------------------

static void do_convert(const TRaster32P &dst, const TRasterFP &src) {

  auto clamp01 = [](float val) {

    return (val < 0.f) ? 0.f : (val > 1.f) ? 1.f : val;

  };

  assert(dst->getSize() == src->getSize());

  int lx = src->getLx();

  for (int y = 0; y < src->getLy(); y++) {

    TPixel32 *outPix  = dst->pixels(y);

    TPixelF *inPix    = src->pixels(y);

    TPixelF *inEndPix = inPix + lx;

    for (; inPix < inEndPix; ++outPix, ++inPix) {

      outPix->r = (TPixel32::Channel)(

          clamp01(inPix->r) * (float)TPixel32::maxChannelValue + 0.5f);

      outPix->g = (TPixel32::Channel)(

          clamp01(inPix->g) * (float)TPixel32::maxChannelValue + 0.5f);

      outPix->b = (TPixel32::Channel)(

          clamp01(inPix->b) * (float)TPixel32::maxChannelValue + 0.5f);

      outPix->m = (TPixel32::Channel)(

          clamp01(inPix->m) * (float)TPixel32::maxChannelValue + 0.5f);

    }

  }

}

//-----------------------------------------------------------------------------

static void do_convert(const TRaster64P &dst, const TRasterFP &src) {

  auto clamp01 = [](float val) {

    return (val < 0.f) ? 0.f : (val > 1.f) ? 1.f : val;

  };

  assert(dst->getSize() == src->getSize());

  int lx = src->getLx();

  for (int y = 0; y < src->getLy(); y++) {

    TPixel64 *outPix  = dst->pixels(y);

    TPixelF *inPix    = src->pixels(y);

    TPixelF *inEndPix = inPix + lx;

    for (; inPix < inEndPix; ++outPix, ++inPix) {

      outPix->r = (TPixel64::Channel)(

          clamp01(inPix->r) * (float)TPixel64::maxChannelValue + 0.5f);

      outPix->g = (TPixel64::Channel)(

          clamp01(inPix->g) * (float)TPixel64::maxChannelValue + 0.5f);

      outPix->b = (TPixel64::Channel)(

          clamp01(inPix->b) * (float)TPixel64::maxChannelValue + 0.5f);

      outPix->m = (TPixel64::Channel)(

          clamp01(inPix->m) * (float)TPixel64::maxChannelValue + 0.5f);

    }

  }

}

//******************************************************************

//    Main conversion function

//******************************************************************

void TRop::convert(TRasterP dst, const TRasterP &src) {

  if (dst->getSize() != src->getSize())

    throw TRopException("convert: size mismatch");

  TRaster32P dst32      = dst;

  TRasterGR8P dst8      = dst;

  TRasterGR16P dst16    = dst;

  TRaster64P dst64      = dst;

  TRasterCM32P dstCm    = dst;

  TRasterYUV422P dstYUV = dst;

  TRasterFP dstF        = dst;

  TRaster32P src32      = src;

  TRasterGR8P src8      = src;

  TRaster64P src64      = src;

  TRasterYUV422P srcYUV = src;

  TRasterFP srcF        = src;

  src->lock();

  dst->lock();

  if (dst64 && src32)

    do_convert(dst64, src32);

  else if (dst8 && src32)

    do_convert(dst8, src32);

  else if (dst16 && src32)

    do_convert(dst16, src32);

  else if (dst32 && src64)

    ditherConvert(src64, dst32);

  else if (dst16 && src64)

    do_convert(dst16, src64);

  else if (dst32 && src8)

    do_convert(dst32, src8);

  else if (dstYUV && src32)

    do_convert(dstYUV, src32);  // Obsolete conversions

  else if (dst32 && srcYUV)

    do_convert(dst32, srcYUV);  //

  else if (dstCm && src32)

    do_convert(dstCm, src32);  //

  else if (dstCm && src8)

    do_convert(dstCm, src8);  //

  // conversion from/to double

  else if (dstF && src32)

    do_convert(dstF, src32);

  else if (dstF && src64)

    do_convert(dstF, src64);

  else if (dst32 && srcF)

    do_convert(dst32, srcF);

  else if (dst64 && srcF)

    do_convert(dst64, srcF);

  else {

    dst->unlock();

    src->unlock();

    throw TRopException("unsupported pixel type");

  }

  dst->setLinear(src->isLinear());

  dst->unlock();

  src->unlock();

}