// Copyright (c) 2005-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:

//

#include <ecam/ecamimageprocessingintf.h>

#include <ecam/implementationfactoryintf.h>

#include <ecamimageprocessing.h>

#include "ecamversion.h"

#include <ecam/ecamconstants.h>

const TInt KBaselinedEffects = 0x000001FF;

const TUint KBaselinedImageProcessing = KUidECamEventImageProcessingGlareRemovalUidValue;

/**

Factory function for creating the CCameraImageProcessing object.

The created object is supposed to be meant for image captures only.

@param aCamera 

	a reference to a CCamera object providing the settings.

@return a pointer to a fully constructed CCameraImageProcessing object.

@leave KErrNoMemory Out of memory Or any other system-wide error code.

@note  Clients using MCameraObserver are not recommended to use this extension class since they cannot handle events.

*/

EXPORT_C CCamera::CCameraImageProcessing* CCamera::CCameraImageProcessing::NewL(CCamera& aCamera)

	{

	CCamera::CCameraImageProcessing* self = new (ELeave)CCamera::CCameraImageProcessing(aCamera); 

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self; 

	}

/**

@internalComponent

Factory function for creating the CCameraImageProcessing object specifically for any one of the following:-

VideoCapture and Viewfinder. This may be used in 

other possible cases as well.

The other factory method CCamera::CCameraImageProcessing::NewL is assumed for being operated on image captures only.

@param aCamera 

	   A reference to a CCamera object providing the settings.

@param aImplFactory 

	   A reference to the MImplementationFactory derived object.

@return a pointer to a fully constructed CCameraImageProcessing object.

@leave KErrNoMemory Out of memory.

@leave KErrExtensionNotSupported When NewL/NewDuplicateL used instead of New2L/NewDuplicate2L.

@note This method is supposed to be used by internal ECAM components only.

*/	

EXPORT_C CCamera::CCameraImageProcessing* CCamera::CCameraImageProcessing::CreateL(CCamera& aCamera, MImplementationFactory& aImplFactory)

	{

 	if(aCamera.CameraVersion() == KCameraDefaultVersion)

 		{

 		User::Leave(KErrExtensionNotSupported);

 		}

	CCamera::CCameraImageProcessing* self = new (ELeave)CCamera::CCameraImageProcessing(aCamera); 

	CleanupStack::PushL(self);

	self->ConstructL(aImplFactory);

	CleanupStack::Pop(self);

	return self; 

	}	

/**	

CCameraImageProcessing Constructor.

@param aOwner

       a reference to a CCamera object providing the settings. 

*/	

EXPORT_C CCamera::CCameraImageProcessing::CCameraImageProcessing(CCamera& aOwner):iOwner(aOwner), iImpl(NULL), iImpl2(NULL), iImpl3(NULL)

	{

	}

/**

CCameraImageProcessing second phase constructor 

Function used to initialise internal state of the object. Uses reference to the camera to retrieve 

Camera image processing interface pointer.

@leave KErrNoMemory Out of memory.

*/ 

EXPORT_C void CCamera::CCameraImageProcessing::ConstructL() 

	{

	iImpl = static_cast<MCameraImageProcessing*>(iOwner.CustomInterface(KECamMCameraImageProcessingUid));

	if (iImpl == NULL)

		{

		User::Leave(KErrNotSupported);

		}

	iImpl2 = static_cast<MCameraImageProcessing2*>(iOwner.CustomInterface(KECamMCameraImageProcessing2Uid));

	iImpl3 = static_cast<MCameraImageProcessing3*>(iOwner.CustomInterface(KECamMCameraImageProcessing3Uid));

	}

/**

@internalComponent

CCameraImageProcessing second phase constructor 

Function used to initialise internal state of the object specifically for any one of the following:-

VideoCapture and Viewfinder. This may be used in other possible cases as well.

@param aImplFactory 

	   A constant reference to the MImplementationFactory derived object.

@leave KErrNoMemory Out of memory; or any other error code as well.

@note This method is supposed to be used by this class only.

*/ 

EXPORT_C void CCamera::CCameraImageProcessing::ConstructL(const MImplementationFactory& aImplFactory) 

	{

	TInt err = KErrNone;

	TAny* implPtr = NULL;

	err = aImplFactory.GetImpl(implPtr, KECamMCameraImageProcessingUid);

	if (err != KErrNone)

		{

		User::Leave(err);

		}

	iImpl = static_cast<MCameraImageProcessing*>(implPtr);

	implPtr = NULL;	

	err = aImplFactory.GetImpl(implPtr, KECamMCameraImageProcessing2Uid);

	if (err != KErrNone && err != KErrNotSupported)

		{

		User::Leave(err);

		}

	iImpl2 = static_cast<MCameraImageProcessing2*>(implPtr);

	implPtr = NULL;	

	err = aImplFactory.GetImpl(implPtr, KECamMCameraImageProcessing3Uid);

	if (err != KErrNone && err != KErrNotSupported)

		{

		User::Leave(err);

		}

	iImpl3 = static_cast<MCameraImageProcessing3*>(implPtr);

	}

/**

Destructor

*/	

EXPORT_C CCamera::CCameraImageProcessing::~CCameraImageProcessing()

	{

	if (iImpl != NULL)

		{

		iImpl->Release();	

		}

	if (iImpl2 != NULL)

		{

		iImpl2->Release();	

		}

	if (iImpl3 != NULL)

		{

		iImpl3->Release();	

		}

	}

/** Get all transformations supported on the camera. 

@param  aTransformations

		An empty RArray of TUids to store the UIDs of the supported transformations.

@leave KErrNoMemory Out of memory. 

*/

EXPORT_C void CCamera::CCameraImageProcessing::GetSupportedTransformationsL(RArray<TUid>& aTransformations) const

	{

	iImpl->GetSupportedTransformationsL(aTransformations);

	/* if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that 

    application is not prepared to receive extra added uid values (new settings added). So, any extra uid value passed 

    from the implementation will be filtered at this point.

    To receive extra added uid values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L() 

    to create camera object. In this case, application is assumed to be prepared to receive unrecognised uid values */

	if(iOwner.CameraVersion() == KCameraDefaultVersion)

		{

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

			{

			/** KBaselinedImageProcessing is the baseline. Any image processing attribute with greater uid value means that

			it has been added in later versions */

			if(aTransformations[index].iUid > KBaselinedImageProcessing)

				{

				aTransformations.Remove(index);

				index--;

				}

			}

		}

	}

/** Get currently active transformations on the camera. 

@param  aTransformations

		An empty RArray of TUids to store the UIDs of the supported transformations.

@leave KErrNoMemory Out of memory.  

*/

EXPORT_C void CCamera::CCameraImageProcessing::GetActiveTransformationsL(RArray<TUid>& aTransformations) const

	{

	iImpl->GetActiveTransformationsL(aTransformations);

	/* if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that 

    application is not prepared to receive extra added uid values (new settings added). So, any extra uid value passed 

    from the implementation will be filtered at this point.

    To receive extra added uid values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L() 

    to create camera object. In this case, application is assumed to be prepared to receive unrecognised uid values */

	if(iOwner.CameraVersion() == KCameraDefaultVersion)

		{

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

			{

			/** KBaselinedImageProcessing is the baseline. Any image processing attribute with greater uid value means that

			it has been added in later versions */

			if(aTransformations[index].iUid > KBaselinedImageProcessing)

				{

				aTransformations.Remove(index);

				index--;

				}

			}

		}

	}

/** Get all values supported by an active transformation.

@param  aTransformation

		The UID of active transform for which values are requested.

@param  aValues 

        An array of integers to represent the values for the requested transformation.

@param  aInfo

        Additional information describing the returned array of values.

@note   Depending on the value of aInfo parameter, same array of values may describe 

        different set of values.

        When camera device doesn't support this, empty array may be returned and TValueInfo may be ENotActive; 

        corresponding getter/setters for this feature should not be used in such a case.

@note   If CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that 

	    application is not prepared to receive extra added enum values for Effects. So, any extra enum value(unrecognised) passed 

	    from the implementation will be filtered at this point.

	    To receive extra added enum values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L() 

	    to create camera object. In this case, application is assumed to be prepared to receive unrecognised enum values

@leave  KErrNoMemory Out of memory.  

*/

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

	{

	iImpl->GetTransformationSupportedValuesL(aTransformation, aValues, aInfo);

	/* if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that 

	   application is not prepared to receive extra added enum values for Effects. So, any extra enum value(unrecognised) passed 

	   from the implementation will be filtered at this point.

	   To receive extra added enum values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L() 

	   to create camera object. In this case, application is assumed to be prepared to receive unrecognised enum values */

	if(aTransformation == KUidECamEventImageProcessingEffect)

		{

		if(iOwner.CameraVersion() == KCameraDefaultVersion)

			{

			/** it is assumed that implementation will use EBitField to pack all supported effects */

			if(aInfo == EBitField)

				{

				aValues[0] &= KBaselinedEffects;

				}

			}

		}

	}

/** 

@deprecated Use TInt GetTransformationValue(TUid aTransformation, TInt& aTransformationValue); 

Get the current value of a transformation

@param aTransformation

	   The UID of the transformation

@return The integer value of the tranformation. 	 

@note 	If CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that 

	    application is not prepared to receive extra added enum values for Effects. So, any extra enum value (unrecognised) received 

	    from the implementation will be dropped and EEffectNone would be passed instead.

	    To receive extra added enum values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L() 

	    to create camera object. In this case, application is assumed to be prepared to receive unrecognised enum values 

*/

EXPORT_C TInt CCamera::CCameraImageProcessing::TransformationValue(TUid aTransformation) const

	{

	TInt value = iImpl->TransformationValue(aTransformation);

	/* if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that 

    application is not prepared to receive extra added enum values for Effects. So, any extra enum value (unrecognised) received 

    from the implementation will be dropped and EEffectNone would be passed instead.

    To receive extra added enum values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L() 

    to create camera object. In this case, application is assumed to be prepared to receive unrecognised enum values */

	if(aTransformation == KUidECamEventImageProcessingEffect)

		{

		if(iOwner.CameraVersion() == KCameraDefaultVersion)

			{

			if(value > KBaselinedEffects)

				{

				value = CCamera::CCameraImageProcessing::EEffectNone;

				}

			}

		}

	return value;

	}

/** Get the current value of a transformation

@param aTransformation

	   The UID of the transformation

@param  aTransformationValue

		Reference to the integer value of the tranformation.

@return system wide error code. 	 

@note 	If CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that 

	    application is not prepared to receive extra added enum values for Effects. So, any extra enum value (unrecognised) received 

	    from the implementation will be dropped and EEffectNone would be passed instead.

	    To receive extra added enum values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L() 

	    to create camera object. In this case, application is assumed to be prepared to receive unrecognised enum values 

@note	Use this method instead of deprecated TInt TransformationValue(TUid aTransformation) 

*/

EXPORT_C TInt CCamera::CCameraImageProcessing::GetTransformationValue(TUid aTransformation, TInt& aTransformationValue) const

	{

	TInt error = iImpl->GetTransformationValue(aTransformation, aTransformationValue);

	/* if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that 

    application is not prepared to receive extra added enum values for Effects. So, any extra enum value (unrecognised) received 

    from the implementation will be dropped and EEffectNone would be passed instead.

    To receive extra added enum values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L() 

    to create camera object. In this case, application is assumed to be prepared to receive unrecognised enum values */

	if(aTransformation == KUidECamEventImageProcessingEffect)

		{

		if(iOwner.CameraVersion() == KCameraDefaultVersion)

			{

			if(aTransformationValue > KBaselinedEffects)

				{

				aTransformationValue = CCamera::CCameraImageProcessing::EEffectNone;

				}

			}

		}

	return error;

	}

/** Set new value for a transformation. 

 A notification event with the transformation UID is sent to 

 all clients. UIDs are in the form KUidECamEventImageProcessingXXXX.

@param aTransformation

	   The UID of the transformation

@param aValue

	   The integer value of the tranformation. 	   

*/

EXPORT_C void CCamera::CCameraImageProcessing::SetTransformationValue(TUid aTransformation, TInt aValue)

	{

	iImpl->SetTransformationValue(aTransformation, aValue);

	}

/** Get the sequence of all active transforms, ordered in order of execution.

@param aTransformSequence

	   an empty array to be populated with sequence of transform UIDs, 

	   where transform entries with smaller index are executed earlier. 

@leave KErrNoMemory Out of memory.  

*/

EXPORT_C void CCamera::CCameraImageProcessing::GetActiveTransformSequenceL(RArray<TUid>& aTransformSequence) const

	{

	iImpl->GetActiveTransformSequenceL(aTransformSequence);

	/* if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that 

    application is not prepared to receive extra added uid values (new settings added). So, any extra uid value passed 

    from the implementation will be filtered at this point.

    To receive extra added uid values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L() 

    to create camera object. In this case, application is assumed to be prepared to receive unrecognised uid values */

	if(iOwner.CameraVersion() == KCameraDefaultVersion)

		{

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

			{

			/** KBaselinedImageProcessing is the baseline. Any image processing attribute with greater uid value means that

			it has been added in later versions */

			if(aTransformSequence[index].iUid > KBaselinedImageProcessing)

				{

				aTransformSequence.Remove(index);

				index--;

				}

			}

		}

	}

/** 

Set the order of all active transform in terms of execution. The transforms with 

smaller index are executed earlier.

@param aTransformSequence

	   The list of ordered transforms, where transforms with smaller 

	   index are executed earlier.

@leave KErrNoMemory Out of memory.

*/

EXPORT_C void CCamera::CCameraImageProcessing::SetActiveTransformSequenceL(RArray<TUid>& aTransformSequence)

	{

	iImpl->SetActiveTransformSequenceL(aTransformSequence);

	}

/**

Set the source rectangle for KUidECamEventImageProcessingTransformScale or 

KUidECamEventImageProcessingTransformCrop.

The coordinates should fall within the current image rectangle. The result 

is always a logical AND operation between the two rectangles.

@param aRect

	   a reference to TRect object which describes the coordinates of the 

	   area of interest. 

*/

EXPORT_C void CCamera::CCameraImageProcessing::SetSourceRect(const TRect& aRect)

	{

	iImpl->SetSourceRect(aRect);

	}

/**

Get the source rectangle for KUidECamEventImageProcessingTransformScale or 

KUidECamEventImageProcessingTransformCrop.

The coordinates should fall within the current image rectangle. The result 

is always a logical AND operation between the two rectangles.

@param aRect

		a reference to TRect object to hold the current source rectangle 

		coordinates. If it has not been set, the coordinates match these of 

		the whole image.      

*/

EXPORT_C void CCamera::CCameraImageProcessing::GetSourceRect(TRect& aRect) const

	{

	iImpl->GetSourceRect(aRect);

	}

/**

Retrieves the maximum number of simultaneous color swapping possible.

@param aConcurrentColorSwappingSupported

	   Retrieves the number of simultaneous color swapping supported. 

	   Retrieves 0 when swapping feature is not supported.

@leave May leave as a result of some error.

*/       

EXPORT_C void CCamera::CCameraImageProcessing::GetConcurrentColorSwappingsSupportedL(TInt& aConcurrentColorSwappingSupported) const

	{

	if(iImpl2 != NULL)

		{

		iImpl2->GetConcurrentColorSwappingsSupportedL(aConcurrentColorSwappingSupported);	

		}

	else

		{

		User::Leave(KErrNotSupported);	

		}	

	}

/**

Retrieves the color swapping capabilites per entry, if different entries have different capabilities 

otherwise the same capabilities retrieved for a particular entry can be assumed to be valid for every entry

@param aIndex 

	   This is a value from 0 to numOfSimultaneousColorSwappings -1. Color swapping capabilities specific to 

	   a particular entry are retrieved. If uniform capability exists for every entry, then this method need not 

	   be called per entry.	

@param aColorSwapCapabilities

	   This retrieves the color swap capabilities.

@leave May leave as a result of some error.

*/

EXPORT_C void CCamera::CCameraImageProcessing::GetColorSwapCapabilitiesL(TInt aIndex, CCamera::CCameraImageProcessing::TColorOperationCapabilities& aColorSwapCapabilities) const

	{

	if(iImpl2 != NULL)

		{

		iImpl2->GetColorSwapCapabilitiesL(aIndex, aColorSwapCapabilities);	

		}

	else

		{

		User::Leave(KErrNotSupported);	

		}	

	}

/**

Set the color swap entries

@param aIndex

	   This is a value from 0 to numOfSimultaneousColorSwappings -1. This helps in managing the limited no. of 

	   simultaneous color swaps. If parameters are already set for the given entry, then it's up to the implementation

	   to replace the existing one or discard it. 

@param aColorSwapParameters

	   The parameters necessary to define clearly the color swapping operation for the given entry. 

	   iEntryStatus has to be updated by the implementation as per the result of the setting operation. 

	   So, iEntryStatus value is redundant at this point.

@leave KErrNotSupported if implementation is not present.

@note  Triggers KUidECamEventCIPSetColorSwapEntry to all MCameraObserver2 clients of the camera. 

	   HandleEvent is used to report the result or any possible error. TECAMEvent2 class should 

	   be used in order to provide the entry no. of the color being set.