#include "stdfx.h"

#include "tfxparam.h"

#include "tpixelutils.h"

#include "tparamset.h"

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

//    Local namespace

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

namespace

{

enum PixelOp { OVER = 0,

			   ADD,

			   SUBTRACT,

			   MULTIPLY,

			   LIGHTEN,

			   DARKEN };

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

template <typename pixel=""></typename>

int doBlurValue(PIXEL *SRC, int SRC_WRAP, int BLUR)

{

	unsigned int count = 0;

	int h, k;

	int blur_val;

	PIXEL *pix, *line;

	pix = line = (SRC) + (-(BLUR) + 1) * (SRC_WRAP);

	for (h = -(BLUR) + 1; h < (BLUR); h++) {

		for (k = -(BLUR) + 1; k < (BLUR); k++)

			count += pix[k].m;

		line += SRC_WRAP;

		pix = line;

	}

	blur_val = (int)(count / (4 * (float)(BLUR) * (float)((BLUR)-1) + 1));

	return blur_val;

}

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

template <typename channel_type="" pixel,="" typename=""></typename>

void doBlur(CHANNEL_TYPE *greymap, const TRasterPT<pixel> &rin, int blur)</pixel>

{

	//Perform a flat mean-convolution filter

	//NOTE: This is improved due to separability of convolution kernel, plus

	// - since its elements are all the same, only pixels entering and quitting

	//the convolution area are added/subtracted from the sums.

	//As a result, this yields an O(row*columns) complexity, independently

	//from the blur factor.

	int i, j;

	int blurDiameter = 2 * blur + 1;

	unsigned long sum;

	int wrapSrc = rin->getWrap();

	int wrapOut = rin->getLx();

	//First, blur each column independently

	//We'll need a temporary col for storing sums

	unsigned long *tempCol = new unsigned long[rin->getLy()];

	int edge = tmin(blur + 1, rin->getLy());

	for (i = 0; i < rin->getLx(); ++i) {

		PIXEL *lineSrcPix = rin->pixels(0) + i;

		CHANNEL_TYPE *lineOutPix = greymap + i;

		PIXEL *pixin = lineSrcPix;

		unsigned long *pixsum = tempCol;

		memset(tempCol, 0, rin->getLy() * sizeof(unsigned long));

		//Build up to blur with retro-sums

		sum = 0;

		for (j = 0; j < edge; ++j, pixin += wrapSrc, ++pixsum) {

			sum += pixin->m;

			*pixsum = sum;

		}

		//Fill in after blur

		PIXEL *queuepix = lineSrcPix;

		for (j = edge; j < rin->getLy(); ++j, pixin += wrapSrc, queuepix += wrapSrc, ++pixsum) {

			sum += (pixin->m - queuepix->m);

			*pixsum = sum;

		}

		//Now, the same in reverse

		lineSrcPix = lineSrcPix + (rin->getLy() - 1) * wrapSrc;

		pixin = lineSrcPix;

		pixsum = tempCol + rin->getLy() - 1;

		sum = 0;

		for (j = 0; j < edge; ++j, pixin -= wrapSrc, --pixsum) {

			*pixsum += sum;

			sum += pixin->m;

		}

		queuepix = lineSrcPix;

		for (j = edge; j < rin->getLy(); ++j, pixin -= wrapSrc, queuepix -= wrapSrc, --pixsum) {

			sum -= queuepix->m;

			*pixsum += sum;

			sum += pixin->m;

		}

		//Finally, transfer sums to the output greymap, divided by the blur.

		pixsum = tempCol;

		CHANNEL_TYPE *pixout = lineOutPix;

		for (j = 0; j < rin->getLy(); ++j, pixout += wrapOut, ++pixsum)

			*pixout = (*pixsum) / blurDiameter;

	}

	delete[] tempCol;

	//Then, the same for all greymap rows

	//We'll need a temporary row for sums

	unsigned long *tempRow = new unsigned long[rin->getLx()];

	edge = tmin(blur + 1, rin->getLx());

	for (j = 0; j < rin->getLy(); ++j) {

		CHANNEL_TYPE *lineSrcPix = greymap + j * wrapOut;

		CHANNEL_TYPE *lineOutPix = lineSrcPix;

		unsigned long *pixsum = tempRow;

		CHANNEL_TYPE *pixin = lineSrcPix;

		memset(tempRow, 0, rin->getLx() * sizeof(unsigned long));

		//Build up to blur with retro-sums

		sum = 0;

		for (i = 0; i < edge; ++i, ++pixin, ++pixsum) {

			sum += *pixin;

			*pixsum = sum;

		}

		//Fill in after blur

		CHANNEL_TYPE *queuepix = lineSrcPix;

		for (i = edge; i < rin->getLx(); ++i, ++pixin, ++pixsum, ++queuepix) {

			sum += *pixin;

			sum -= *queuepix;

			*pixsum = sum;

		}

		//Now, the same in reverse

		lineSrcPix = lineSrcPix + rin->getLx() - 1;

		pixin = lineSrcPix;

		pixsum = tempRow + rin->getLx() - 1;

		sum = 0;

		for (i = 0; i < edge; ++i, --pixin, --pixsum) {

			*pixsum += sum;

			sum += *pixin;

		}

		queuepix = lineSrcPix;

		for (i = edge; i < rin->getLx(); ++i, --pixin, --pixsum, --queuepix) {

			sum -= *queuepix;

			*pixsum += sum;

			sum += *pixin;

		}

		//Finally, transfer sums to the output greymap, divided by the blur.

		CHANNEL_TYPE *pixout = lineOutPix;

		pixsum = tempRow;

		for (i = 0; i < rin->getLx(); ++i, ++pixout, ++pixsum)

			*pixout = (*pixsum) / blurDiameter;

	}

	delete[] tempRow;

}

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

template <typename pixel=""></typename>

void myOver(PIXEL &pixout, const PIXEL &pixin, const PIXEL &color)

{

	pixout = color;

}

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

template <typename pixel=""></typename>

void myAdd(PIXEL &pixout, const PIXEL &pixin, const PIXEL &color)

{

	pixout.r = tmin(pixin.r + color.r, PIXEL::maxChannelValue);

	pixout.g = tmin(pixin.g + color.g, PIXEL::maxChannelValue);

	pixout.b = tmin(pixin.b + color.b, PIXEL::maxChannelValue);

}

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

template <typename pixel=""></typename>

void mySub(PIXEL &pixout, const PIXEL &pixin, const PIXEL &color)

{

	pixout.r = tmax(pixin.r - color.r, 0);

	pixout.g = tmax(pixin.g - color.g, 0);

	pixout.b = tmax(pixin.b - color.b, 0);

}

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

template <typename pixel=""></typename>

void myMult(PIXEL &pixout, const PIXEL &pixin, const PIXEL &color)

{

	static const double den = PIXEL::maxChannelValue;

	pixout.r = pixin.r * (color.r / den);

	pixout.g = pixin.g * (color.g / den);

	pixout.b = pixin.b * (color.b / den);

}

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

template <typename pixel=""></typename>

void myLighten(PIXEL &pixout, const PIXEL &pixin, const PIXEL &color)

{

	pixout.r = pixin.r > color.r ? pixin.r : color.r;

	pixout.g = pixin.g > color.g ? pixin.g : color.g;

	pixout.b = pixin.b > color.b ? pixin.b : color.b;

}

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

template <typename pixel=""></typename>

void myDarken(PIXEL &pixout, const PIXEL &pixin, const PIXEL &color)

{

	pixout.r = pixin.r < color.r ? pixin.r : color.r;

	pixout.g = pixin.g < color.g ? pixin.g : color.g;

	pixout.b = pixin.b < color.b ? pixin.b : color.b;

}

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

template <typename channel="" pixel,="" typename=""></typename>

void doLayerBlending(PIXEL *pixin, PIXEL *pixout, CHANNEL *pixmatte,

					 int inLx, int outLx, int outLy, int wrapIn, int wrapOut, int dx, int dy,

					 double transp, PIXEL color,

					 void (*pixelOp)(PIXEL &, const PIXEL &, const PIXEL &))

{

	double CROP_VAL = PIXEL::maxChannelValue;

	CHANNEL U_CROP_VAL = PIXEL::maxChannelValue;

	int const_transp = CROP_VAL * transp + 0.5;

	double val_r, val_g, val_b, val_m;

	int blur_val;

	PIXEL opColor;

	double k, matte;

	CHANNEL shadow_matte;

	int x, y;

	for (y = 0; y < outLy; ++y, pixin += wrapIn - outLx, pixout += wrapOut - outLx, pixmatte += inLx - outLx)

		for (x = 0; x < outLx; ++x, ++pixin, ++pixout, ++pixmatte) {

			if (pixin->m != 0) // where the image is transparent, no shadow

			{

				blur_val = *(pixmatte + dy * inLx + dx);

				shadow_matte = (blur_val) ? (int)((CROP_VAL - blur_val) * transp + 0.5) : const_transp;

				k = (double)(CROP_VAL - shadow_matte) / CROP_VAL;

				val_r = pixin->r * k + 0.5;

				val_g = pixin->g * k + 0.5;

				val_b = pixin->b * k + 0.5;

				val_m = pixin->m;

				pixelOp(opColor, *pixin, color);

				matte = (1 - k) * (val_m / CROP_VAL);

				val_r += matte * opColor.r;

				val_g += matte * opColor.g;

				val_b += matte * opColor.b;

				pixout->r = (val_r > CROP_VAL) ? U_CROP_VAL : ((val_r < 0) ? 0 : (CHANNEL)val_r);

				pixout->g = (val_g > CROP_VAL) ? U_CROP_VAL : ((val_g < 0) ? 0 : (CHANNEL)val_g);

				pixout->b = (val_b > CROP_VAL) ? U_CROP_VAL : ((val_b < 0) ? 0 : (CHANNEL)val_b);

				pixout->m = (val_m > CROP_VAL) ? U_CROP_VAL : ((val_m < 0) ? 0 : (CHANNEL)val_m);

			} else

				*pixout = PIXEL::Transparent;

		}

}

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

template <typename pixel=""></typename>

void doBodyHighlight(const TRasterPT<pixel> rout, const TRasterPT<pixel> rin,</pixel></pixel>

					 TRectD rectIn, int rasInLx, int rasInLy, double frame, int blur,

					 double transp, PIXEL color, TPointD point, bool invert,

					 void (*pixelOp)(PIXEL &, const PIXEL &, const PIXEL &),

					 TRasterFxPort &m_input, const TRenderSettings &ri)

{

	typedef typename PIXEL::Channel CHANNEL_TYPE;

	rin->lock();

	rout->lock();

	int inLx = rin->getLx(), inLy = rin->getLy(), inWrap = rin->getWrap();

	int outLx = rout->getLx(), outLy = rout->getLy(), outWrap = rout->getWrap();

	int dx = point.x, dy = point.y;

	transp = 1.0 - transp;

	PIXEL *src_buf, *dst_buf;

	dst_buf = rout->pixels(0);

	src_buf = rin->pixels(0) + blur + blur * inWrap;

	if (dy < 0)

		src_buf -= dy * inWrap;

	if (dx < 0)

		src_buf -= dx;

	//First, perform an optimized mean-convolution of the interesting part of image's matte

	int matteLxLy = inLx * inLy;

	CHANNEL_TYPE *matteGreymap = (CHANNEL_TYPE *)malloc(matteLxLy * sizeof(CHANNEL_TYPE));

	if (!matteGreymap)

		return;

	memset(matteGreymap, 0, matteLxLy * sizeof(CHANNEL_TYPE));

	doBlur<pixel, channel_type="">(matteGreymap, rin, blur);</pixel,>

	CHANNEL_TYPE U_CROP_VAL = PIXEL::maxChannelValue;

	//If specified, invert the matte

	if (invert) {

		CHANNEL_TYPE *mpix, *end = matteGreymap + matteLxLy;

		for (mpix = matteGreymap; mpix < end; ++mpix)

			*mpix = U_CROP_VAL - *mpix;

	}

	CHANNEL_TYPE *mattepix = matteGreymap + blur + blur * inLx;

	if (dy < 0)

		mattepix -= dy * inLx;

	if (dx < 0)

		mattepix -= dx;

	doLayerBlending(src_buf, dst_buf, mattepix, inLx, outLx, outLy,

					inWrap, outWrap, dx, dy, transp, color, pixelOp);

	free(matteGreymap);

	rin->unlock();

	rout->unlock();

}

} //namespace

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

//    BodyHighLightFx implementation

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

class BodyHighLightFx : public TStandardRasterFx

{

	FX_PLUGIN_DECLARATION(BodyHighLightFx)

	TRasterFxPort m_input;

	TIntEnumParamP m_mode;

	TPointParamP m_point;

	TDoubleParamP m_transparency;

	TDoubleParamP m_blur;

	TPixelParamP m_color;

	TBoolParamP m_invert;

public:

	BodyHighLightFx()

		: m_point(TPointD(10.0, 10.0)), m_mode(new TIntEnumParam(OVER, "Over")), m_transparency(0.5), m_blur(2.0), m_color(TPixel32::White), m_invert(false)

	{

		m_point->getX()->setMeasureName("fxLength");

		m_point->getY()->setMeasureName("fxLength");

		m_blur->setMeasureName("fxLength");

		bindParam(this, "mode", m_mode);

		bindParam(this, "point", m_point);

		bindParam(this, "transparency", m_transparency);

		bindParam(this, "blur", m_blur);

		bindParam(this, "color", m_color);

		bindParam(this, "invert", m_invert);

		addInputPort("Source", m_input);

		m_transparency->setValueRange(0.0, 1.0);

		m_blur->setValueRange(0, (std::numeric_limits<double>::max)());</double>

		m_color->enableMatte(false);

		m_mode->addItem(ADD, "Add");

		m_mode->addItem(SUBTRACT, "Subtract");

		m_mode->addItem(MULTIPLY, "Multiply");

		m_mode->addItem(LIGHTEN, "Lighten");

		m_mode->addItem(DARKEN, "Darken");

	}

	~BodyHighLightFx(){};

	bool doGetBBox(double frame, TRectD &bBox, const TRenderSettings &info)

	{

		if (m_input.isConnected())

			return m_input->doGetBBox(frame, bBox, info);

		else {

			bBox = TRectD();

			return false;

		}

	}

	bool canHandle(const TRenderSettings &info, double frame) { return true; }

	void doDryCompute(TRectD &rect, double frame, const TRenderSettings &info);

	void doCompute(TTile &tile, double frame, const TRenderSettings &);

	int getMemoryRequirement(const TRectD &rect, double frame, const TRenderSettings &info);

};

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

void BodyHighLightFx::doDryCompute(TRectD &rect, double frame, const TRenderSettings &info)

{

	m_input->dryCompute(rect, frame, info);

	double fac = sqrt(fabs(info.m_affine.det()));

	int blur = (int)(fac * fabs(m_blur->getValue(frame)));

	TPoint point = convert(fac * m_point->getValue(frame));

	TRectD rectIn = rect.enlarge(blur);

	int rasInLx = tround(rectIn.getLx() + abs(point.x)) + 1;

	int rasInLy = tround(rectIn.getLy() + abs(point.y)) + 1;

	if (point.x < 0) {

		rectIn.x0 += point.x;

	}

	if (point.y < 0) {

		rectIn.y0 += point.y;

	}

	rectIn = TRectD(rectIn.getP00(), TDimensionD(rasInLx, rasInLy));

	m_input->dryCompute(rectIn, frame, info);

}

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

void BodyHighLightFx::doCompute(TTile &tile, double frame, const TRenderSettings &ri)

{

	double fac = sqrt(fabs(ri.m_affine.det()));

	if (!m_input.isConnected())

		return;

	//Compute the effective input tile

	m_input->compute(tile, frame, ri);

	double transp = m_transparency->getValue(frame);

	int blur = (int)(fac * fabs(m_blur->getValue(frame)));

	TPoint point = convert(fac * m_point->getValue(frame));

	bool invert = m_invert->getValue();

	//Build the shadow, blurred tile

	TDimension rectSize(tile.getRaster()->getSize());

	TRectD rectIn(tile.m_pos, TDimensionD(rectSize.lx, rectSize.ly));

	rectIn = rectIn.enlarge(blur);

	//Shift rectIn by the input 'point'

	int rasInLx = tround(rectIn.getLx() + abs(point.x)) + 1;

	int rasInLy = tround(rectIn.getLy() + abs(point.y)) + 1;

	if (point.x < 0) {

		rectIn.x0 += point.x;

	} else {

		rectIn.x1 += point.x;

	}

	if (point.y < 0) {

		rectIn.y0 += point.y;

	} else {

		rectIn.y1 += point.y;

	}

	const TPixel32 color = m_color->getPremultipliedValue(frame);

	TRaster32P raster32 = tile.getRaster();

	TRaster64P raster64 = tile.getRaster();

	TTile tileIn;

	m_input->allocateAndCompute(tileIn, rectIn.getP00(),

								TDimension(rasInLx, rasInLy),

								tile.getRaster(), frame, ri);

	//Select the specified pixel operation

	void (*pixelOp32)(TPixel32 &, const TPixel32 &, const TPixel32 &);

	void (*pixelOp64)(TPixel64 &, const TPixel64 &, const TPixel64 &);

	switch (m_mode->getValue()) {

	case OVER: {

		pixelOp32 = ::myOver<tpixel32>;</tpixel32>

		pixelOp64 = ::myOver<tpixel64>;</tpixel64>

		break;

	}

	case ADD: {

		pixelOp32 = ::myAdd<tpixel32>;</tpixel32>

		pixelOp64 = ::myAdd<tpixel64>;</tpixel64>

		break;

	}

	case SUBTRACT: {

		pixelOp32 = ::mySub<tpixel32>;</tpixel32>

		pixelOp64 = ::mySub<tpixel64>;</tpixel64>

		break;

	}

	case MULTIPLY: {

		pixelOp32 = ::myMult<tpixel32>;</tpixel32>

		pixelOp64 = ::myMult<tpixel64>;</tpixel64>

		break;

	}

	case LIGHTEN: {

		pixelOp32 = ::myLighten<tpixel32>;</tpixel32>

		pixelOp64 = ::myLighten<tpixel64>;</tpixel64>

		break;

	}

	case DARKEN: {

		pixelOp32 = ::myDarken<tpixel32>;</tpixel32>

		pixelOp64 = ::myDarken<tpixel64>;</tpixel64>

		break;

	}

	}

	TRaster32P rin = tileIn.getRaster();

	if (raster32)

		doBodyHighlight<tpixel32>(</tpixel32>

			raster32, rin, rectIn, rasInLx, rasInLy, frame, blur,

			transp, color, convert(point), invert, pixelOp32, m_input, ri);

	else {

		TRaster64P rin = tileIn.getRaster();

		if (raster64)

			doBodyHighlight<tpixel64>(</tpixel64>

				raster64, rin, rectIn, rasInLx, rasInLy, frame, blur,

				transp, toPixel64(color), convert(point), invert, pixelOp64, m_input, ri);

		else

			throw TException("Brightness&Contrast: unsupported Pixel Type");

	}

}

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

int BodyHighLightFx::getMemoryRequirement(const TRectD &rect, double frame, const TRenderSettings &info)

{

	int blur = (int)(sqrt(fabs(info.m_affine.det())) * fabs(m_blur->getValue(frame)));

	return TRasterFx::memorySize(rect.enlarge(blur), info.m_bpp);

}

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

FX_PLUGIN_IDENTIFIER(BodyHighLightFx, "bodyHighLightFx")