/*

* 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 <e32math.h>

#include "CFilterCartoon.h"

const TInt KMaxColors = 10;

const TInt KColorBits = 8;

const TUint8 ByteMask[8] = {0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01};

/*

*

*   CLASS: CFilterCartoon

*

*/

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

EXPORT_C TInt CFilterCartoon::Create()

	{

	CFilterCartoon* ptr = NULL;

	TRAPD( error, ptr = NewL(); );

	if( error != KErrNone )

		{

		ptr = NULL;

		}

	return (TInt)((MImageFilter*)ptr);

	}

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

CFilterCartoon* CFilterCartoon::NewL()

	{

	CFilterCartoon* self = new( ELeave )CFilterCartoon();

	CleanupStack::PushL( self );

	self->ConstructL();

	CleanupStack::Pop( self );

	return self;

	}

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

CFilterCartoon::~CFilterCartoon()

{

	delete[] i16BitIndLut;

	delete[] iRGB;

}

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

CFilterCartoon::CFilterCartoon()

	{

	}

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

void CFilterCartoon::ConstructL()

	{

	}

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

TRect CFilterCartoon::Rect()

	{

	return iChild->Rect();

	}

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

TReal CFilterCartoon::Scale()

	{

	return iChild->Scale();

	}

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

TSize CFilterCartoon::ViewPortSize()

{

    return iChild->ViewPortSize();

}

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

TBlock * CFilterCartoon::GetBlockL ( const TRect & aRect )

{

    TBlock * pB = iChild->GetBlockL (aRect);

    if (!pB)

    {

        return NULL;

    }

    TUint32 * pD	= pB->iData;

    TUint32 c		= 0;

	TUint32	r,g,b;

    for (TInt i = pB->iDataLength; i != 0 ; --i)

    {

        c = *pD;

		b = c & 0xFF;

		c >>= 8;

		g = c & 0xFF;

		c >>= 8;

		r = c & 0xFF;

		c = ((r >> 3) << 11) | ((g >> 2) << 5) | (b >> 3);

		*pD++ = iRGB[i16BitIndLut[c]];

    }

    return pB;

}

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

void CFilterCartoon::SetParent( MImageFilter* aParent )

	{

	iParent = aParent;

	}

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

void CFilterCartoon::SetChild( MImageFilter* aChild )

	{

	iChild = aChild;

	}

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

TInt CFilterCartoon::CmdL( const TDesC16& aCmd )

{

	TLex lex (aCmd);

	while ( !lex.Eos() )

	{

		TPtrC token = lex.NextToken();

		if( token.Compare( _L("quantcolors") ) == 0 )

		{

            CreateOctreePaletteL();

		}

    }

	return 0;

}

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

const char* CFilterCartoon::Type()

	{

	return "cartoon";

	}

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

void CFilterCartoon::CreateOctreePaletteL()

{

    //  Create new quantizer

    COTreeQuant * quant = new (ELeave) COTreeQuant;

    CleanupStack::PushL( quant );

    //  Octree quantize colors

    TRect rect = iChild->Rect();

    TBlock * pB = iChild->GetBlockL(rect);

    TUint32 * pD = pB->iData;

    TInt i;

    for (i = 0; i < pB->iDataLength; ++i, pD++) 

    {

        quant->AddColorL (*pD);

        while ( quant->iLeaves > KMaxColors )

        {

            quant->ReduceTree ();

        }

    }

    delete pB;

    pB = NULL;

    //  Create palette

    quant->GetColorTable();

    //  Get new iCount

    iCount = quant->iPalette.Count();

    //  Create 16 bit indexing array

	delete[] i16BitIndLut;

	i16BitIndLut = NULL;

    i16BitIndLut = new (ELeave) TInt [65536];

	delete[] iRGB;

	iRGB = NULL;

    iRGB = new (ELeave) TUint32 [iCount];

    //  Enumerate indexing array

    for (i = 0; i < 65536; ++i)

    {

		TUint32 c = i;

		TUint32 b = c & 0x1F;

		c >>= 5;

		TUint32 g = c & 0x3F;

		c >>= 6;

		TUint32 r = c & 0x1F;

		TInt md = 99999999;

		for (TInt j = 0; j < iCount; ++j)

		{

			c = quant->iPalette[j];

			TUint32 bb = c & 0xFF;

			bb >>= 3;

			c >>= 8;

			TUint32 gg = c & 0xFF;

			gg >>= 2;

			c >>= 8;

			TUint32 rr = c & 0xFF;

			rr >>= 3;

			TInt d = (b-bb) * (b-bb) + (g-gg) * (g-gg) + (r-rr) * (r-rr);

			if (d < md)

			{

				md = d;

				i16BitIndLut[i] = j;

			}

			else if (d == md)

			{

/*

				// compute i in 24 bit coordinates

				c = i;

				b = (c & 0x1F) << 3;

				c >>= 5;

				g = (c & 0x3F) << 2;

				c >>= 6;

				r = (c & 0x1F) << 3;

				//	compute distance of old min to i

				c = iRGB[i16BitIndLut[i]];

				bb = (c & 0xFF);

				c >>= 8;

				gg = (c & 0xFF);

				c >>= 8;

				rr = (c & 0xFF);

				d = (b-bb) * (b-bb) + (g-gg) * (g-gg) + (r-rr) * (r-rr);

				//	compute distance of the new min to i

				c = iRGB[j];

				bb = (c & 0xFF);

				c >>= 8;

				gg = (c & 0xFF);

				c >>= 8;

				rr = (c & 0xFF);

				TInt d2 = (b-bb) * (b-bb) + (g-gg) * (g-gg) + (r-rr) * (r-rr);

				if (d2 < d)

				{

					i16BitIndLut[i] = j;

				}

*/				

			}

		}

    }

	for (TInt j = 0; j < iCount; ++j)

	{

		iRGB[j] = quant->iPalette[j];

	}

    CleanupStack::PopAndDestroy( quant );

}

/*

*

*   CLASS: CNode

*

*/

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

CNode::CNode()

{

}

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

CNode::~CNode()

{

   for (TInt i = 0; i < 8; i++) 

    {

        delete iChild[i];

        iChild[i] = NULL;

    }

    iNext = NULL;

}

/*

*

*   CLASS: COTreeQuant

*

*/

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

COTreeQuant::COTreeQuant() 

{

}

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

COTreeQuant::~COTreeQuant()

{

    delete iTree;

    iTree = NULL;

    Mem::FillZ(iReducibleNodes, 9 * sizeof(CNode *));

    iPalette.Reset();

}

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

void COTreeQuant::AddColorL (TUint32 aRgb)

{

    DoAddColorL (&iTree, aRgb, 0);

}

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

void COTreeQuant::ReduceTree ()

{ 

    //  Find the deepest level with at least 1 reducible node

    TInt i=0;

    for (i = KColorBits - 1; (i > 0) && (!iReducibleNodes[i]); i--) {};

    //  Reduce most recent node at level i

    CNode * pNode = iReducibleNodes[i];

    iReducibleNodes[i] = pNode->iNext;

    TInt reds = 0;

    TInt greens = 0;

    TInt blues = 0;

    TInt children = 0;

    for ( i = 0; i < 8; i++) 

    {

        if ( pNode->iChild[i] ) 

        {

            reds += pNode->iChild[i]->iRedSum;

            greens += pNode->iChild[i]->iGreenSum;

            blues += pNode->iChild[i]->iBlueSum;

            pNode->iPixels += pNode->iChild[i]->iPixels;

            delete pNode->iChild[i];

            pNode->iChild[i] = NULL;

            children++;

        }

    }

    pNode->iIsLeaf = ETrue;

    pNode->iRedSum = reds;

    pNode->iGreenSum = greens;

    pNode->iBlueSum = blues;

    iLeaves -= (children - 1);

}

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

void COTreeQuant::GetColorTable ()

{

    GetPaletteColors ( *iTree );

}

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

TInt COTreeQuant::GetColorCount() const

{

    return iLeaves;

}

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

void COTreeQuant::DoAddColorL (CNode ** apNode, TUint32 aRgb, TInt aLevel)

{

    //  If node does not exist, create new

    if (!*apNode)

    {

        *apNode = new (ELeave) CNode;

        (*apNode)->iIsLeaf = (aLevel == KColorBits) ? ETrue : EFalse;

        if ((*apNode)->iIsLeaf)

        {

            iLeaves++;

        }

        else 

        {

            (*apNode)->iNext = iReducibleNodes[aLevel];

            iReducibleNodes[aLevel] = *apNode;

        }

    }

    TUint32 c = aRgb;

    TUint8 b = (TUint8)(c & 0xFF);

    c >>= 8;

    TUint8 g = (TUint8)(c & 0xFF);

    c >>= 8;

    TUint8 r = (TUint8)(c & 0xFF);

    //  Update colors if leaf

    if ( (*apNode)->iIsLeaf ) 

    {

        (*apNode)->iPixels++;

        (*apNode)->iRedSum += r;

        (*apNode)->iGreenSum += g;

        (*apNode)->iBlueSum += b;

    }

    //  Recurse deeper if not a leaf

    else 

    {

        TInt shift = 7 - aLevel;

        TInt index =    (((r & ByteMask[aLevel]) >> shift) << 2) |

                        (((g & ByteMask[aLevel]) >> shift) << 1) |

                        ((b & ByteMask[aLevel]) >> shift);

        DoAddColorL (&((*apNode)->iChild[index]), aRgb, aLevel + 1);

    }

}

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

void COTreeQuant::GetPaletteColors ( const CNode & aNode )

{

    if ( aNode.iIsLeaf ) 

    {

        TUint8 r = (TUint8) (aNode.iRedSum / aNode.iPixels);

        TUint8 g = (TUint8) (aNode.iGreenSum / aNode.iPixels);

        TUint8 b = (TUint8) (aNode.iBlueSum / aNode.iPixels);

        iPalette.Append ( ((r << 16) | (g << 8) | b) );

    }

    else 

    {

        for (TInt i = 0; i < 8; i++) 

        {

            if ( aNode.iChild[i] )

            {

                GetPaletteColors ( *aNode.iChild[i] );

            }

        }

    }

}

/*

*

*   ENTRY POINT

*

*/

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

#if !defined(EKA2)

GLDEF_C TInt E32Dll( TDllReason )

    {

    return KErrNone;

    }	

#endif