#include "stdfx.h"

#include "tfxparam.h"

//#include "trop.h"

#include <math.h></math.h>

#include "tpixelutils.h"

//==================================================================

class ChannelMixerFx : public TStandardRasterFx

{

	FX_PLUGIN_DECLARATION(ChannelMixerFx)

	TRasterFxPort m_input;

	TDoubleParamP m_r_r;

	TDoubleParamP m_g_r;

	TDoubleParamP m_b_r;

	TDoubleParamP m_m_r;

	TDoubleParamP m_r_g;

	TDoubleParamP m_g_g;

	TDoubleParamP m_b_g;

	TDoubleParamP m_m_g;

	TDoubleParamP m_r_b;

	TDoubleParamP m_g_b;

	TDoubleParamP m_b_b;

	TDoubleParamP m_m_b;

	TDoubleParamP m_r_m;

	TDoubleParamP m_g_m;

	TDoubleParamP m_b_m;

	TDoubleParamP m_m_m;

public:

	ChannelMixerFx()

		: m_r_r(1.0), m_g_r(0.0), m_b_r(0.0), m_m_r(0.0), m_r_g(0.0), m_g_g(1.0), m_b_g(0.0), m_m_g(0.0), m_r_b(0.0), m_g_b(0.0), m_b_b(1.0), m_m_b(0.0), m_r_m(0.0), m_g_m(0.0), m_b_m(0.0), m_m_m(1.0)

	{

		addInputPort("Source", m_input);

		bindParam(this, "red_to_red", m_r_r);

		bindParam(this, "green_to_red", m_g_r);

		bindParam(this, "blue_to_red", m_b_r);

		bindParam(this, "matte_to_red", m_m_r);

		bindParam(this, "red_to_green", m_r_g);

		bindParam(this, "green_to_green", m_g_g);

		bindParam(this, "blue_to_green", m_b_g);

		bindParam(this, "matte_to_green", m_m_g);

		bindParam(this, "red_to_blue", m_r_b);

		bindParam(this, "green_to_blue", m_g_b);

		bindParam(this, "blue_to_blue", m_b_b);

		bindParam(this, "matte_to_blue", m_m_b);

		bindParam(this, "red_to_matte", m_r_m);

		bindParam(this, "green_to_matte", m_g_m);

		bindParam(this, "blue_to_matte", m_b_m);

		bindParam(this, "matte_to_matte", m_m_m);

		m_r_r->setValueRange(0, 1);

		m_r_g->setValueRange(0, 1);

		m_r_b->setValueRange(0, 1);

		m_r_m->setValueRange(0, 1);

		m_g_r->setValueRange(0, 1);

		m_g_g->setValueRange(0, 1);

		m_g_b->setValueRange(0, 1);

		m_g_m->setValueRange(0, 1);

		m_b_r->setValueRange(0, 1);

		m_b_g->setValueRange(0, 1);

		m_b_b->setValueRange(0, 1);

		m_b_m->setValueRange(0, 1);

		m_m_r->setValueRange(0, 1);

		m_m_g->setValueRange(0, 1);

		m_m_b->setValueRange(0, 1);

		m_m_m->setValueRange(0, 1);

	}

	~ChannelMixerFx(){};

	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;

		}

	};

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

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

};

namespace

{

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

void depremult(PIXEL *pix)

{

	if (!pix->m)

		return;

	double depremult = (double)PIXEL::maxChannelValue / pix->m;

	pix->r = (CHANNEL_TYPE)(pix->r * depremult);

	pix->g = (CHANNEL_TYPE)(pix->g * depremult);

	pix->b = (CHANNEL_TYPE)(pix->b * depremult);

}

}

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

void doChannelMixer(TRasterPT<pixel> ras, double r_r, double r_g, double r_b, double r_m, double g_r, double g_g, double g_b,</pixel>

					double g_m, double b_r, double b_g, double b_b, double b_m, double m_r,

					double m_g, double m_b, double m_m)

{

	double aux = (double)PIXEL::maxChannelValue;

	int j;

	ras->lock();

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

		PIXEL *pix = ras->pixels(j);

		PIXEL *endPix = pix + ras->getLx();

		while (pix < endPix) {

			depremult<pixel, channel_type="">(pix); //if removed, a black line appears in the edge of a level (default values, not black lines)</pixel,>

			double red = pix->r * r_r + pix->g * g_r + pix->b * b_r + pix->m * m_r;

			double green = pix->r * r_g + pix->g * g_g + pix->b * b_g + pix->m * m_g;

			double blue = pix->r * r_b + pix->g * g_b + pix->b * b_b + pix->m * m_b;

			double matte = pix->r * r_m + pix->g * g_m + pix->b * b_m + pix->m * m_m;

			red = tcrop(red, 0.0, aux);

			green = tcrop(green, 0.0, aux);

			blue = tcrop(blue, 0.0, aux);

			matte = tcrop(matte, 0.0, aux);

			pix->r = (CHANNEL_TYPE)red;

			pix->g = (CHANNEL_TYPE)green;

			pix->b = (CHANNEL_TYPE)blue;

			pix->m = (CHANNEL_TYPE)matte;

			*pix = premultiply(*pix); //if removed, a white edged line appears in the edge of a level (if m>r, g, b)

			pix++;

		}

	}

	ras->unlock();

}

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

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

{

	if (!m_input.isConnected())

		return;

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

	double r_r = m_r_r->getValue(frame);

	double r_g = m_r_g->getValue(frame);

	double r_b = m_r_b->getValue(frame);

	double r_m = m_r_m->getValue(frame);

	double g_r = m_g_r->getValue(frame);

	double g_g = m_g_g->getValue(frame);

	double g_b = m_g_b->getValue(frame);

	double g_m = m_g_m->getValue(frame);

	double b_r = m_b_r->getValue(frame);

	double b_g = m_b_g->getValue(frame);

	double b_b = m_b_b->getValue(frame);

	double b_m = m_b_m->getValue(frame);

	double m_r = m_m_r->getValue(frame);

	double m_g = m_m_g->getValue(frame);

	double m_b = m_m_b->getValue(frame);

	double m_m = m_m_m->getValue(frame);

	TRaster32P raster32 = tile.getRaster();

	if (raster32)

		doChannelMixer<tpixel32, uchar="">(raster32, r_r, r_g, r_b, r_m, g_r, g_g, g_b, g_m, b_r, b_g, b_b, b_m, m_r, m_g, m_b, m_m);</tpixel32,>

	else {

		TRaster64P raster64 = tile.getRaster();

		if (raster64)

			doChannelMixer<tpixel64, ushort="">(raster64, r_r, r_g, r_b, r_m, g_r, g_g, g_b, g_m, b_r, b_g, b_b, b_m, m_r, m_g, m_b, m_m);</tpixel64,>

		else

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

	}

}

FX_PLUGIN_IDENTIFIER(ChannelMixerFx, "channelMixerFx")