/*
* Copyright (c) 2010 Ixonos Plc.
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - Initial contribution
*
* Contributors:
* Ixonos Plc
*
* Description:  
*
*/


#include "CFilterRedEye.h"


const TInt KHueRedLimitLow	= 15;
const TInt KHueRedLimitHigh = 245;
const TInt KSatLimitLow		= 80; 

//=============================================================================
EXPORT_C TInt CFilterRedEye::Create()
	{
	CFilterRedEye * ptr = NULL;
	TRAPD( error, ptr = NewL(); );
	if( error != KErrNone )
		{
		ptr = NULL;
		}
	return (TInt)((MImageFilter*)ptr);
	}

//=============================================================================
CFilterRedEye* CFilterRedEye::NewL()
	{
	CFilterRedEye* self = new( ELeave )CFilterRedEye();
	CleanupStack::PushL( self );
	self->ConstructL();
	CleanupStack::Pop( self );
	return self;
	}

//=============================================================================
CFilterRedEye::~CFilterRedEye()
	{
	}


//=============================================================================
CFilterRedEye::CFilterRedEye()
	{

	}

//=============================================================================
void CFilterRedEye::ConstructL()
	{

	}

//=============================================================================
TRect CFilterRedEye::Rect()
	{
	return iChild->Rect();
	}

//=============================================================================
TReal CFilterRedEye::Scale()
	{
	return iChild->Scale();
	}

//=============================================================================
TSize CFilterRedEye::ViewPortSize()
{
    return iChild->ViewPortSize();
}

//=============================================================================
TBlock * CFilterRedEye::GetBlockL ( const TRect & aRect )
{
    TBlock * pB = iChild->GetBlockL(aRect);
    if (!pB) return NULL;
    if ( iRedEyeRectSc.Intersects (aRect) )
    {
        TUint32 * pD = pB->iData;
        TInt column = 0;
        TInt rows = 0;
        for (TInt i = 0; i < pB->iDataLength; ++i, ++pD)
        {        
		    TUint8 hue = Hue (*pD);
		    TUint8 sat = Saturation (*pD);
		    if ( ((hue < KHueRedLimitLow) || (hue > KHueRedLimitHigh)) && (sat > KSatLimitLow) )
		    {
				// Check if the pixel is inside the intersection of 
				// the requested block and the red eye rect
		        if (aRect.iTl.iX + column >= iRedEyeRectSc.iTl.iX &&
		            aRect.iTl.iY + rows >= iRedEyeRectSc.iTl.iY &&
                    aRect.iTl.iX + column < iRedEyeRectSc.iBr.iX &&
                    aRect.iTl.iY + rows < iRedEyeRectSc.iBr.iY)
		        {
					// Check if the pixel is inside the cirle that fits 
					// into the red eye rect (assuming it is square).
					TInt r = static_cast<TInt> ( (TReal)(iRedEyeRectSc.iBr.iX - iRedEyeRectSc.iTl.iX) / 2 + 0.5);
					TInt a = (iRedEyeRectSc.iTl.iX + r) - (aRect.iTl.iX + column);
					TInt b = (iRedEyeRectSc.iTl.iY + r) - (aRect.iTl.iY + rows);
					if ( (a*a + b*b) <= r*r )
					{
						TUint32 c = *pD;
						TUint8 cb = (TUint8)(c & 0xFF);
						c >>= 8;
						TUint8 cg = (TUint8)(c & 0xFF);
						c >>= 8;
						TUint8 cr = (TUint8)(c & 0xFF);
						TUint8 y = (TUint8)((306 * cr + 587 * cg + 117 * cb) >> 10);
						*pD = (y | (y << 8) | (y << 16));
					}
		        }
		    }

		    ++column;
		    if (column >= pB->iWidth)
		    {
		        column = 0;
		        ++rows;
		    }
        }
    }
    return pB;
}


//=============================================================================
void CFilterRedEye::SetParent( MImageFilter* aParent )
	{
	iParent = aParent;
	}

//=============================================================================
void CFilterRedEye::SetChild( MImageFilter* aChild )
	{
	iChild = aChild;
	}

//=============================================================================
TInt CFilterRedEye::CmdL( const TDesC16& aCmd )
	{

	TLex lex (aCmd);

	while ( !lex.Eos() )
	{
		TPtrC token = lex.NextToken();
		if( token.Compare( _L("ulc") ) == 0 )
			{
			TReal relscale = iChild->Scale();
			TInt param = 0;
			lex.Inc();
			lex.Val( param );
			iRedEyeRect.iTl.iX = (TInt)((param / relscale) + 0.5);
			}
		else if( token.Compare( _L("ulr") ) == 0 )
			{
			TReal relscale = iChild->Scale();
			TInt param = 0;
			lex.Inc();
			lex.Val( param );
			iRedEyeRect.iTl.iY = (TInt)((param / relscale) + 0.5);
			}
		else if( token.Compare( _L("lrc") ) == 0 )
			{
			TReal relscale = iChild->Scale();
			TInt param = 0;
			lex.Inc();
			lex.Val( param );
			iRedEyeRect.iBr.iX = (TInt)((param / relscale) + 0.5);
			}
		else if( token.Compare( _L("lrr") ) == 0 )
			{
			TReal relscale = iChild->Scale();
			TInt param = 0;
			lex.Inc();
			lex.Val( param );
			iRedEyeRect.iBr.iY = (TInt)((param / relscale) + 0.5);
			}
		}

    TReal relscale = iChild->Scale();
    iRedEyeRectSc.iTl.iX = (TInt)(iRedEyeRect.iTl.iX * relscale + 0.5);
    iRedEyeRectSc.iTl.iY = (TInt)(iRedEyeRect.iTl.iY * relscale + 0.5);
    iRedEyeRectSc.iBr.iX = (TInt)(iRedEyeRect.iBr.iX * relscale + 0.5);
    iRedEyeRectSc.iBr.iY = (TInt)(iRedEyeRect.iBr.iY * relscale + 0.5);

    return 0;

	}

//=============================================================================
const char* CFilterRedEye::Type()
	{
	return "negate";
	}
	
//=============================================================================
TUint8 CFilterRedEye::Hue ( TUint32 aPixel ) const
{

	TUint8 g = (TUint8)(aPixel & 0xFF); 
	aPixel >>= 8;
	TUint8 b = (TUint8)(aPixel & 0xFF); 
	aPixel >>= 8;
	TUint8 r = (TUint8)(aPixel & 0xFF);

	const TInt t1 = (1 << 10);
	const TInt t3 = (3 << 10);
	const TInt t5 = (5 << 10);
	const TInt t6 = (6 << 10);
	
	TInt h = 0;
	TInt v = ( r > g ) ? ( (r > b) ? (r) : (b) ) : ( (g > b) ? (g) : (b) );
	TInt m = ( r < g ) ? ( (r < b) ? (r) : (b) ) : ( (g < b) ? (g) : (b) );

	if (v != m) 
	{

		TInt vm = v - m;

		if (r == v) 
		{
			TInt g2 = ((v - g) << 10) / vm;
			TInt b2 = ((v - b) << 10) / vm;
			h = (g == m) ? (t5 + b2) : (t1 - g2);
		}

		else if (g == v) 
		{
			TInt r2 = ((v - r) << 10) / vm;
			TInt b2 = ((v - b) << 10) / vm;
			h = (b == m) ? (t1 + r2) : (t3 - b2);
		}

		else 
		{
			TInt r2 = ((v - r) << 10) / vm;
			TInt g2 = ((v - g) << 10) / vm;
			h = (r == m) ? (t3 + g2) : (t5 - r2);
		}

		h *= 255;
		h /= t6;
	}

	return (TUint8)h;
}

//=============================================================================
TUint8 CFilterRedEye::Saturation ( TUint32 aPixel ) const
{
	TUint8 g = (TUint8)(aPixel & 0xFF); 
	aPixel >>= 8;
	TUint8 b = (TUint8)(aPixel & 0xFF); 
	aPixel >>= 8;
	TUint8 r = (TUint8)(aPixel & 0xFF);

	TInt v = ( r > g ) ? ( (r > b) ? (r) : (b) ) : ( (g > b) ? (g) : (b) );
	TInt m = ( r < g ) ? ( (r < b) ? (r) : (b) ) : ( (g < b) ? (g) : (b) );
	TInt l = ((m + v) >> 1);
	TInt s = 0;

	if (l > 0) 
	{
		s = v - m;

		if (s > 0) {

			s *= 255;

			if (l <= 127)
			{
				s /= (v + m);
			}
			else 
			{
				s /= (512 - v - m);
			}
		}
	}
	else {
		s = 0;
	}	
	return (TUint8)s;
}

//=============================================================================
#if !defined(EKA2)
GLDEF_C TInt E32Dll( TDllReason )
    {
    return KErrNone;
    }	
#endif