#include "trop.h"

// TnzCore includes

#include "tpixelgr.h"

#include "trandom.h"

#include "tpixelutils.h"

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

//    Conversion functions

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

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);

		}

	}

}

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

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));

	}

}

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

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;

	}

}

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

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++;

		}

	}

}

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

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

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

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++;

		}

	}

}

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

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++;

			}

		}

}

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

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;

	}

}

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

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++;

	}

}

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

//    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;

	TRaster32P src32 = src;

	TRasterGR8P src8 = src;

	TRaster64P src64 = src;

	TRasterYUV422P srcYUV = src;

	TRasterYUV422P dstYUV = dst;

	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); //

	else {

		dst->unlock();

		src->unlock();

		throw TRopException("unsupported pixel type");

	}

	dst->unlock();

	src->unlock();

}