// Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "Symbian Foundation License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// testimageprocessing.cpp

// 

//

#include "test_image_processing.h"

#include <ecamerrors.h>

#include <ecam/ecamversion.h>

CTestCamImgProc::CTestCamImgProc(CTestCamera& aOwner): iOwner(aOwner)

	{}

CTestCamImgProc::~CTestCamImgProc()

	{

	iSupportedTranformations.Close();

	iActiveTransformations.Close();

	iActiveTransformSequence.Close();

	CDataGlobal* globalData = static_cast <CDataGlobal*> (Dll::Tls());	

	if(globalData != NULL)

		{

		if(!globalData->iTestCamAdvSet && !globalData->iTestCamPresets && !globalData->iTestCamSnapshot)

			{

			delete globalData;

			Dll::FreeTls();

			}	

		else

			{

			globalData->iTestCamImgProc = NULL;	

			Dll::SetTls(globalData);

			}

		}

	}

CTestCamImgProc* CTestCamImgProc::NewL(CTestCamera& aOwner)

	{

	CDataGlobal* globalData = static_cast <CDataGlobal*> (Dll::Tls());

	if(globalData == NULL)

		{

		globalData = new (ELeave) CDataGlobal;

		CleanupStack::PushL(globalData);

		globalData->iImgProcReferenceCount = 0;

		globalData->iTestCamImgProc = new (ELeave) CTestCamImgProc(aOwner);

		CleanupStack::PushL(globalData->iTestCamImgProc);

		globalData->iTestCamImgProc->ConstructL();

		globalData->iTestCamImgProc->iRefCount = 1;

		User::LeaveIfError(Dll::SetTls(globalData));

		CleanupStack::Pop(globalData->iTestCamImgProc);

		CleanupStack::Pop(globalData);

		return globalData->iTestCamImgProc;

		}

	else

		{

		if(globalData->iTestCamImgProc == NULL)

			{

			globalData->iImgProcReferenceCount = 0;

			globalData->iTestCamImgProc = new (ELeave) CTestCamImgProc(aOwner);

			CleanupStack::PushL(globalData->iTestCamImgProc);

			globalData->iTestCamImgProc->ConstructL();

			globalData->iTestCamImgProc->iRefCount = 1;

			User::LeaveIfError(Dll::SetTls(globalData));

			CleanupStack::Pop(globalData->iTestCamImgProc);

			return globalData->iTestCamImgProc;

			}

		CTestCamImgProc* self = globalData->iTestCamImgProc;

		globalData->iImgProcReferenceCount++;

		self->iRefCount = globalData->iImgProcReferenceCount + 1;

		if (globalData->iImgProcReferenceCount == KNumOfImgProcExtensions-1)

			{

			globalData->iTestCamImgProc = NULL;

			if(!globalData->iTestCamAdvSet && !globalData->iTestCamPresets && !globalData->iTestCamSnapshot)

				{

				delete globalData;

				Dll::FreeTls();

				}

			else

				{

				User::LeaveIfError(Dll::SetTls(globalData));	

				}

			}

		else

			{

			User::LeaveIfError(Dll::SetTls(globalData));	

			}

		return self;		

		}

	}

void CTestCamImgProc::Release()

	{

	iRefCount--; 

	if(iRefCount == 0)

		{

		iOwner.iImgProcImpl = NULL;

		delete this;

		}

	}	

void CTestCamImgProc::ConstructL()

	{

	iSupportedTranformations.Reset();

	iSupportedTranformations.AppendL(KUidECamEventImageProcessingAdjustBrightness);

	iSupportedTranformations.AppendL(KUidECamEventImageProcessingAdjustContrast);

	iActiveTransformations.Reset();

	iActiveTransformSequence.Reset();

	}

void CTestCamImgProc::GetSupportedTransformationsL(RArray<TUid>& aTransformations) const

	{

	aTransformations.Reset();

	for(TInt index=0; index < iSupportedTranformations.Count(); index++)

		{

		aTransformations.AppendL(iSupportedTranformations[index]);

		}

	}

void CTestCamImgProc::GetActiveTransformationsL(RArray<TUid>& aTransformations) const

	{

	aTransformations.Reset();

	for(TInt index=0; index < iActiveTransformations.Count(); index++)

		{

		aTransformations.AppendL(iActiveTransformations[index]);

		}	

	}

void CTestCamImgProc::GetTransformationSupportedValuesL(TUid aTransformation, RArray<TInt>& aValues, TValueInfo& aInfo) const

	{

	TInt err = iActiveTransformations.Find(aTransformation);

	if(err == KErrNotFound)

		{

		User::Leave(err);

		}

	switch(aTransformation.iUid)

		{

		case KUidECamEventImageProcessingAdjustBrightnessUidValue:

			{

			aInfo = EContinuousRangeMinMax;

			aValues.Reset();

			aValues.AppendL(KMinBrightness);

			aValues.AppendL(KMaxBrightness);	

			break;

			}

		case KUidECamEventImageProcessingAdjustContrastUidValue:

			{

			aInfo = EContinuousRangeMinMax;

			aValues.Reset();

			aValues.AppendL(KMinContrast);

			aValues.AppendL(KMaxContrast);	

			break;

			}

		default:

			User::Leave(KErrNotSupported);

		}

	}

TInt CTestCamImgProc::TransformationValue(TUid aTransformation) const

	{

	switch(aTransformation.iUid)

		{

		case KUidECamEventImageProcessingAdjustBrightnessUidValue:

			{

			return iOwner.iImgProcBrightness;

			}

		case KUidECamEventImageProcessingAdjustContrastUidValue:

			{

			return iOwner.iImgProcContrast;

			}

		default:

			return 0;

		}	

	}

TInt CTestCamImgProc::GetTransformationValue(TUid aTransformation, TInt& aTransformationValue) const

	{

	switch(aTransformation.iUid)

		{

		case KUidECamEventImageProcessingAdjustBrightnessUidValue:

			{

			aTransformationValue = iOwner.iImgProcBrightness;

			return KErrNone;

			}

		case KUidECamEventImageProcessingAdjustContrastUidValue:

			{

			aTransformationValue = iOwner.iImgProcContrast;

			return KErrNone;

			}

		default:

			return KErrNotSupported;

		}	

	}

void CTestCamImgProc::SetTransformationValue(TUid aTransformation, TInt aValue)

	{

	TInt eventError = iOwner.CheckReserveAndPower();

	if(eventError == KErrNone)

		{

		switch(aTransformation.iUid)

			{

			case KUidECamEventImageProcessingAdjustBrightnessUidValue:

				{

				if(aValue < KMinBrightness)

					{

					iOwner.iImgProcBrightness = KMinBrightness;

					}

				else

					{

					if(aValue > KMaxBrightness)	

						{

						iOwner.iImgProcBrightness = KMaxBrightness;

						}

					else

						{

						iOwner.iImgProcBrightness = aValue;	

						}

					}

				break;

				}

			case KUidECamEventImageProcessingAdjustContrastUidValue:

				{

				if(aValue < KMinContrast)

					{

					iOwner.iImgProcContrast = KMinContrast;

					}

				else

					{

					if(aValue > KMaxContrast)	

						{

						iOwner.iImgProcContrast = KMaxContrast;

						}

					else

						{

						iOwner.iImgProcContrast = aValue;	

						}

					}

				break;

				}

			default:

				eventError = KErrNotSupported;

			}	

		}

	if(eventError == KErrNone)	

		{

		eventError = iActiveTransformations.Find(aTransformation);

		if(eventError == KErrNotFound)

			{

			eventError = iActiveTransformations.Append(aTransformation);

			if(eventError == KErrNone)

				{

				if(IsTransform(aTransformation))

					{

					eventError = iActiveTransformSequence.Append(aTransformation);

					}

				}

			}

		else

			{

			eventError = KErrNone;	

			}	

		}

	TECAMEvent ecamevent(aTransformation, eventError);

	iOwner.iECamEvent = ecamevent;

	iOwner.iHandleEventAsync.CallBack();

	}

void CTestCamImgProc::GetActiveTransformSequenceL(RArray<TUid>& aTransformSequence) const

	{

	aTransformSequence.Reset();

	for(TInt index=0; index < iActiveTransformSequence.Count(); index++)

		{

		aTransformSequence.AppendL(iActiveTransformSequence[index]);

		}	

	}

void CTestCamImgProc::SetActiveTransformSequenceL(RArray<TUid>& aTransformSequence)

	{

	TInt err = KErrNone;

	for(TInt index=0; index < aTransformSequence.Count(); index++)

		{

		err = iActiveTransformations.Find(aTransformSequence[index]);

		if(err == KErrNotFound)

			{

			User::Leave(err);

			}

		}

	iActiveTransformSequence.Reset();

	for(TInt index=0; index < aTransformSequence.Count(); index++)

		{

		iActiveTransformSequence.AppendL(aTransformSequence[index]);

		}

	}

void CTestCamImgProc::SetSourceRect(const TRect& /*aRect*/)

	{

	return;

	}

void CTestCamImgProc::GetSourceRect(TRect& /*aRect*/) const

	{

	return;	

	}

void CTestCamImgProc::GetConcurrentColorSwappingsSupportedL(TInt& /*aConcurrentColorSwappingSupported*/) const

	{

	User::Leave(KErrNotSupported);

	}

void CTestCamImgProc::GetColorSwapCapabilitiesL(TInt /*aIndex*/, CCamera::CCameraImageProcessing::TColorOperationCapabilities& /*aColorSwapCapabilities*/) const

	{

	User::Leave(KErrNotSupported);	

	}

void CTestCamImgProc::SetColorSwapEntry(TInt aIndex, const CCamera::CCameraImageProcessing::TColorOperationEntry& /*aColorSwapParameters*/)

	{

	TECAMEvent2 ecamevent2(KUidECamEventCIPSetColorSwapEntry, KErrNotSupported, aIndex);

	iOwner.iECamEvent2 = ecamevent2;

	iOwner.iHandleEvent2Async.CallBack();

	}

void CTestCamImgProc::RemoveColorSwapEntry(TInt aIndex)

	{

	TECAMEvent2 ecamevent2(KUidECamEventCIPRemoveColorSwapEntry, KErrNotSupported, aIndex);

	iOwner.iECamEvent2 = ecamevent2;

	iOwner.iHandleEvent2Async.CallBack();

	}

void CTestCamImgProc::GetColorSwapEntryL(TInt /*aIndex*/, CCamera::CCameraImageProcessing::TColorOperationEntry& /*aColorSwapParameters*/) const

	{

	User::Leave(KErrNotSupported);	

	}

void CTestCamImgProc::StartColorSwapping()

	{

	TECAMEvent ecamevent(KUidECamEventCIPStartColorSwap, KErrNotSupported);

	iOwner.iECamEvent = ecamevent;

	iOwner.iHandleEventAsync.CallBack();

	}

void CTestCamImgProc::CancelColorSwappingL()

	{

	User::Leave(KErrNotSupported);

	}

void CTestCamImgProc::GetConcurrentColorAccentSupportedL(TInt& /*aConcurrentColorAccentSupported*/) const

	{

	User::Leave(KErrNotSupported);	

	}

void CTestCamImgProc::GetColorAccentCapabilitiesL(TInt /*aIndex*/, CCamera::CCameraImageProcessing::TColorOperationCapabilities& /*aColorAccentCapabilities*/) const

	{

	User::Leave(KErrNotSupported);	

	}

void CTestCamImgProc::SetColorAccentEntry(TInt aIndex, const CCamera::CCameraImageProcessing::TColorOperationEntry& /*aColorAccentParameters*/)

	{

	TECAMEvent2 ecamevent2(KUidECamEventCIPSetColorAccentEntry, KErrNotSupported, aIndex);

	iOwner.iECamEvent2 = ecamevent2;

	iOwner.iHandleEvent2Async.CallBack();

	}

void CTestCamImgProc::RemoveColorAccentEntry(TInt aIndex)

	{

	TECAMEvent2 ecamevent2(KUidECamEventCIPRemoveColorAccentEntry, KErrNotSupported, aIndex);

	iOwner.iECamEvent2 = ecamevent2;

	iOwner.iHandleEvent2Async.CallBack();

	}

void CTestCamImgProc::GetColorAccentEntryL(TInt /*aIndex*/, CCamera::CCameraImageProcessing::TColorOperationEntry& /*aColorAccentParameters*/) const

	{

	User::Leave(KErrNotSupported);	

	}

void CTestCamImgProc::StartColorAccent()

	{

	TECAMEvent ecamevent(KUidECamEventCIPStartColorAccent, KErrNotSupported);

	iOwner.iECamEvent = ecamevent;

	iOwner.iHandleEventAsync.CallBack();

	}

void CTestCamImgProc::CancelColorAccentL()

	{

	User::Leave(KErrNotSupported);

	}

TBool CTestCamImgProc::IsTransform(TUid aTransformation)

	{

	switch(aTransformation.iUid)

		{

		//fall through

		case KUidECamEventImageProcessingTransformCropUidValue:

		case KUidECamEventImageProcessingTransformRotateUidValue:

		case KUidECamEventImageProcessingTransformMirrorUidValue:

		case KUidECamEventImageProcessingTransformScaleUidValue:

		case KUidECamEventImageProcessingSourceRectUidValue:

		case KUidECamEventImageProcessingNoiseReductionUidValue:

		case KUidECamEventImageProcessingGlareRemovalUidValue:

			{

			return ETrue;	

			}

		default:

			return EFalse;

		}

	}