--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/mmplugins/cameraplugins/source/testcamera/test_image_processing.cpp Tue Feb 02 01:56:55 2010 +0200
@@ -0,0 +1,441 @@
+// 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 "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:
+//
+// Description:
+// testimageprocessing.cpp
+//
+//
+
+#include "test_image_processing.h"
+#include <ecamerrors.h>
+#include "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;
+ }
+ }