// 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. 

*/		 
EXPORT_C void CCamera::CCameraImageProcessing::SetColorSwapEntryL(TInt aIndex, const CCamera::CCameraImageProcessing::TColorOperationEntry& aColorSwapParameters)
	{
	if(iImpl2 != NULL)
		{
		iImpl2->SetColorSwapEntry(aIndex, aColorSwapParameters);	
		}
	else
		{
		User::Leave(KErrNotSupported);	
		}	
	}
	
/**
Removes the color swap entry corresponding to the given index

@param aIndex
	   This gives the color swapping entry to be removed. 
	   
@leave KErrNotSupported if implementation is not present.
	   
@note  Triggers KUidECamEventCIPRemoveColorSwapEntry 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 removed. 

*/
EXPORT_C void CCamera::CCameraImageProcessing::RemoveColorSwapEntryL(TInt aIndex)
	{
	if(iImpl2 != NULL)
		{
		iImpl2->RemoveColorSwapEntry(aIndex);	
		}
	else
		{
		User::Leave(KErrNotSupported);	
		}	
	}

/**
Get the details of the color swap entry corresponding to the given index

@param aIndex
	   This gives the color swapping entry whose information has to be retrieved.

@param aColorSwapParameters
	   This contains the parameters currently being used by the color swapping operation for the given entry.

@leave May leave as a result of some error. 

*/			   
EXPORT_C void CCamera::CCameraImageProcessing::GetColorSwapEntryL(TInt aIndex, CCamera::CCameraImageProcessing::TColorOperationEntry& aColorSwapParameters) const
	 {
	if(iImpl2 != NULL)
		{
		iImpl2->GetColorSwapEntryL(aIndex, aColorSwapParameters);	
		}
	else
		{
		User::Leave(KErrNotSupported);	
		}	
	}

/**
Starts the color swapping process after taking into account the color swap entries updated up to this point.

@leave KErrNotSupported if implementation is not present.

@note Triggers KUidECamEventCIPStartColorSwap to all MCameraObserver2 clients of the camera. 
	  HandleEvent is used to report the result or any possible error. 
	  One possible error case is when more than one entry describe the same color source. 
	  New ecam error KErrECamColorOperationConflict used in such a case.

*/		 
EXPORT_C void CCamera::CCameraImageProcessing::StartColorSwappingL()
	{
	if(iImpl2 != NULL)
		{
		iImpl2->StartColorSwapping();	
		}
	else
		{
		User::Leave(KErrNotSupported);	
		}	
	}

/**
Cancel the color swapping process.

@leave May leave as a result of some error.

@note  Used to cancel the color swapping process which might have been just started. 
	   If the issued StartColorSwappingL() gets cancelled, its event should report KErrCancel.

*/
EXPORT_C void CCamera::CCameraImageProcessing::CancelColorSwappingL()
	{
	if(iImpl2 != NULL)
		{
		iImpl2->CancelColorSwappingL();	
		}
	else
		{
		User::Leave(KErrNotSupported);	
		}	
	}

/**
Retrieves the maximum number of color entries on which simultaneous color accent process is possible.

@param aConcurrentColorAccentSupported
	   Retrieves the number of color entries on which simultaneous color accent process is possible. 
	   Retrieves 0 when color accent process is not supported.

@leave May leave as a result of some error. 

*/    
EXPORT_C void CCamera::CCameraImageProcessing::GetConcurrentColorAccentSupportedL(TInt& aConcurrentColorAccentSupported) const
	{
	if(iImpl2 != NULL)
		{
		iImpl2->GetConcurrentColorAccentSupportedL(aConcurrentColorAccentSupported);	
		}
	else
		{
		User::Leave(KErrNotSupported);	
		}	
	}

/**
Retrieves the color accent 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 numOfSimultaneousColorAccent -1. Color accent 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 aColorAccentCapabilities
	   This retrieves the color accent capabilities.
	   
@leave May leave as a result of some error.

*/       
EXPORT_C void CCamera::CCameraImageProcessing::GetColorAccentCapabilitiesL(TInt aIndex, CCamera::CCameraImageProcessing::TColorOperationCapabilities& aColorAccentCapabilities) const
	{
	if(iImpl2 != NULL)
		{
		iImpl2->GetColorAccentCapabilitiesL(aIndex, aColorAccentCapabilities);	
		}
	else
		{
		User::Leave(KErrNotSupported);	
		}	
	}

/**
Set the color accent entries

@param aIndex
	   This is a value from 0 to numOfSimultaneousColorAccent -1. This helps in managing the limited no. of 
	   simultaneous color accent. 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 aColorAccentParameters
	   The parameters necessary to define clearly the color accent 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. The parameters defined for target colors in 
	   TColorOperationEntry are redundant for color accent.
	   
@leave KErrNotSupported if implementation is not present.
	   
@note  Triggers KUidECamEventCIPSetColorAccentEntry 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. 

*/		 
EXPORT_C void CCamera::CCameraImageProcessing::SetColorAccentEntryL(TInt aIndex, const CCamera::CCameraImageProcessing::TColorOperationEntry& aColorAccentParameters)
	{
	if(iImpl2 != NULL)
		{
		iImpl2->SetColorAccentEntry(aIndex, aColorAccentParameters);	
		}
	else
		{
		User::Leave(KErrNotSupported);	
		}	
	}

/**
Removes the color accent entry corresponding to the given index

@param aIndex
	   This gives the color accent entry to be removed. 
	   
@leave KErrNotSupported if implementation is not present.
	   
@note  Triggers KUidECamEventCIPRemoveColorAccentEntry 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 removed. 

*/		 
EXPORT_C void CCamera::CCameraImageProcessing::RemoveColorAccentEntryL(TInt aIndex)
	{
	if(iImpl2 != NULL)
		{
		iImpl2->RemoveColorAccentEntry(aIndex);	
		}
	else
		{
		User::Leave(KErrNotSupported);	
		}	
	}

/**
Get the details of the color accent entry corresponding to the given index

@param aIndex
	   This gives the color accent entry whose information has to be retrieved.

@param aColorAccentParameters
	   This contains the parameters currently being used by the color accent operation for the given entry.
	   The parameters defined for target colors in TColorOperationEntry are redundant for color accent.

@leave May leave as a result of some error. 

*/		  
EXPORT_C void CCamera::CCameraImageProcessing::GetColorAccentEntryL(TInt aIndex, CCamera::CCameraImageProcessing::TColorOperationEntry& aColorAccentParameters) const
	{
	if(iImpl2 != NULL)
		{
		iImpl2->GetColorAccentEntryL(aIndex, aColorAccentParameters);	
		}
	else
		{
		User::Leave(KErrNotSupported);	
		}	
	} 

/**
Starts the color accent process after taking into account the color accent entries updated up to this point.

@leave KErrNotSupported if implementation is not present.

@note  Triggers KUidECamEventCIPStartColorAccent to all MCameraObserver2 clients of the camera. 
	   HandleEvent is used to report the result or any possible error. 

*/
EXPORT_C void CCamera::CCameraImageProcessing::StartColorAccentL()
	{
	if(iImpl2 != NULL)
		{
		iImpl2->StartColorAccent();	
		}
	else
		{
		User::Leave(KErrNotSupported);	
		}	
	}

/**
Cancel the color accent process.

@leave May leave as a result of some error.

@note  Used to cancel the color accent process which might have been just started. 
	   If the issued StartColorAccentL() gets cancelled, its event should report KErrCancel.

*/
EXPORT_C void CCamera::CCameraImageProcessing::CancelColorAccentL()
	{
	if(iImpl2 != NULL)
		{
		iImpl2->CancelColorAccentL();	
		}
	else
		{
		User::Leave(KErrNotSupported);	
		}	
	}

/**
Retrieves the supported options for a particular orientation reference.

@param  aOrientationReference
		A TOrientationReference for which supported relative custom orientation have to retrieved.
		
@param  aSupportedRelativeRotation
		A bitfield which retrieves the supported TRelativeRotation for 'aOrientationReference'
		
@param  aSupportedRelativeMirroring
		A bitfield which retrieves the supported TRelativeMirror for 'aOrientationReference'
		
@param  aSupportedRelativeFlipping
		A bitfield which retrieves the supported TRelativeFlipping for 'aOrientationReference'

@leave  May leave with any error code.

@publishedPartner
@prototype
*/
EXPORT_C void CCamera::CCameraImageProcessing::GetSupportedRelativeOrientationOptionsL(CCamera::CCameraImageProcessing::TOrientationReference aOrientationReference, 
		TUint& aSupportedRelativeRotation, TUint& aSupportedRelativeMirroring, TUint& aSupportedRelativeFlipping) const
	{
	if(iImpl3 != NULL)
		{
		iImpl3->GetSupportedRelativeOrientationOptionsL(aOrientationReference, aSupportedRelativeRotation, 
									aSupportedRelativeMirroring, aSupportedRelativeFlipping);	
		}
	else
		{
		User::Leave(KErrNotSupported);	
		}		
	}										

/**
Retrieves the options which is being used for the current orientation reference.

@param  aOrientationReference
		A TOrientationReference which is the current orientation reference being used.
		
@param  aRelativeRotation
		A TRelativeRotation which is the current relative rotation being used with aOrientationReference.
		
@param  aRelativeMirror
		A TRelativeMirror which is the current relative mirroring being used with aOrientationReference.
		
@param  aRelativeFlipping
		A TRelativeFlipping which is the current relative flipping being used with aOrientationReference.
		
@leave  May leave with any error code.

@publishedPartner
@prototype
*/															
EXPORT_C void CCamera::CCameraImageProcessing::GetCurrentRelativeOrientationOptionsL(CCamera::CCameraImageProcessing::TOrientationReference& aOrientationReference, 
											CCamera::CCameraImageProcessing::TRelativeRotation& aRelativeRotation, 
											CCamera::CCameraImageProcessing::TRelativeMirror& aRelativeMirror, 
											CCamera::CCameraImageProcessing::TRelativeFlipping& aRelativeFlipping) const
	{
	if(iImpl3 != NULL)
		{
		iImpl3->GetCurrentRelativeOrientationOptionsL(aOrientationReference, aRelativeRotation, aRelativeMirror, aRelativeFlipping);	
		}
	else
		{
		User::Leave(KErrNotSupported);	
		}	
	}

/**
Sets the options which would be used with the desired orientation reference.

@param  aOrientationReference
		The desired TOrientationReference.
		
@param  aRelativeRotation
		The desired TRelativeRotation which would be used with 'aOrientationReference'.
		
@param  TRelativeMirror
		The desired TRelativeMirror which would be used with 'aOrientationReference'

@param  TRelativeFlipping
		The desired TRelativeFlipping which would be used with 'aOrientationReference'
		
@leave  KErrNotSupported if the implementation of this method is not present.
		
@note   Event KUidECamEventImageProcessingTransformRelativeOrientation is used to notify clients about relative 
		custom orientation setting operation.
		
@note   If the current picture orientation (Refer CCamera::CCameraAdvancedSettings::TPictureOrientation) is not possible
		to be achieved with the relative custom orientation, event KUidECamEventPictureOrientationUnachievable will be
		notified to the client.
		
@note   If the dimension of the image gets changed by the desired relative orientation options, notification 
		KUidECamEventCameraSettingImageSize will be notified to the client.
		
@publishedPartner
@prototype
*/												
EXPORT_C void CCamera::CCameraImageProcessing::SetRelativeOrientationOptionsL(CCamera::CCameraImageProcessing::TOrientationReference aOrientationReference, 
											CCamera::CCameraImageProcessing::TRelativeRotation aRelativeRotation, 
											CCamera::CCameraImageProcessing::TRelativeMirror aRelativeMirror, 
											CCamera::CCameraImageProcessing::TRelativeFlipping aRelativeFlipping)
	{
	if(iImpl3 != NULL)
		{
		iImpl3->SetRelativeOrientationOptions(aOrientationReference, aRelativeRotation, aRelativeMirror, aRelativeFlipping);	
		}
	else
		{
		User::Leave(KErrNotSupported);	
		}
	}

/**
Constructor for the TColorOperationCapabilities class.
Sets the size and version of this class.
*/
EXPORT_C CCamera::CCameraImageProcessing::TColorOperationCapabilities::TColorOperationCapabilities()
	{
	iSize = sizeof(CCamera::CCameraImageProcessing::TColorOperationCapabilities);
	iVersion = KECamColorOperationCapabilitiesCurrentVersion;
	}
	
/**	
Returns the size of the class. Used for extensibility by deriving from this base class and adding new member variables.
Intended to be used for implementation of methods where this class reference is passed as function arguments. 
Implementation of such methods can find out the whether the actual class passed is base or the derived one. So, if a new application 
is made to run on an old implementation, an error may occur in such cases after the old implementation detects this by getting 
the size information of the T class passed. Also, if old application is made to run on a new implementation, this could be 
properly handled if the derived class variables handling is done in a proper 'if-else' statement.

@return The size of the class.

@note The size will be modified when the T-class gets updated.
*/
EXPORT_C TInt CCamera::CCameraImageProcessing::TColorOperationCapabilities::Size() const
	{
	return static_cast<TInt>(iSize);
	}
	
/**	
Returns the version of the class. Used for extensibility specially when the class members are not added but the Reserved 
members get used at a later stage.

@return The version of this class.

@note The version will be modified when the T-class gets updated.
*/
EXPORT_C TUint CCamera::CCameraImageProcessing::TColorOperationCapabilities::Version() const
	{
	return iVersion;	
	}
	
/**
Constructor for the TBitsIgnore class.
Sets the size and version of this class.
*/
EXPORT_C CCamera::CCameraImageProcessing::TBitsIgnore::TBitsIgnore()
	{
	iSize = sizeof(CCamera::CCameraImageProcessing::TBitsIgnore);
	iVersion = KECamBitsIgnoreCurrentVersion;
	iRedBitsIgnore = 0;
	iGreenBitsIgnore = 0;
	iBlueBitsIgnore = 0;
	iAlphaBitsIgnore = 0;
	}
	
/**	
Returns the size of the class. Used for extensibility by deriving from this base class and adding new member variables.
Intended to be used for implementation of methods where this class reference is passed as function arguments. 
Implementation of such methods can find out the whether the actual class passed is base or the derived one. So, if a new application 
is made to run on an old implementation, an error may occur in such cases after the old implementation detects this by getting 
the size information of the T class passed. Also, if old application is made to run on a new implementation, this could be 
properly handled if the derived class variables handling is done in a proper 'if-else' statement.

@return The size of the class.

@note The size will be modified when the T-class gets updated.
*/	
EXPORT_C TInt CCamera::CCameraImageProcessing::TBitsIgnore::Size() const
	{
	return static_cast<TInt>(iSize);
	}
	
/**	
Returns the version of the class. Used for extensibility specially when the class members are not added but the Reserved 
members get used at a later stage.

@return The version of this class.

@note The version will be modified when the T-class gets updated.
*/
EXPORT_C TUint CCamera::CCameraImageProcessing::TBitsIgnore::Version() const
	{
	return iVersion;	
	}
	
/**
Constructor for the TColorOperationEntry class.
Sets the size and version of this class.
*/
EXPORT_C CCamera::CCameraImageProcessing::TColorOperationEntry::TColorOperationEntry()
	{
	iSize = sizeof(CCamera::CCameraImageProcessing::TColorOperationEntry);
	iVersion = KECamColorOperationEntryCurrentVersion;
	}
	
/**	
Returns the size of the class. Used for extensibility by deriving from this base class and adding new member variables.
Intended to be used for implementation of methods where this class reference is passed as function arguments. 
Implementation of such methods can find out the whether the actual class passed is base or the derived one. So, if a new application 
is made to run on an old implementation, an error may occur in such cases after the old implementation detects this by getting 
the size information of the T class passed. Also, if old application is made to run on a new implementation, this could be 
properly handled if the derived class variables handling is done in a proper 'if-else' statement.

@return The size of the class.

@note The size will be modified when the T-class gets updated.
*/	
EXPORT_C TInt CCamera::CCameraImageProcessing::TColorOperationEntry::Size() const
	{
	return static_cast<TInt>(iSize);
	}
	
/**	
Returns the version of the class. Used for extensibility specially when the class members are not added but the Reserved 
members get used at a later stage.

@return The version of this class.

@note The version will be modified when the T-class gets updated.
*/
EXPORT_C TUint CCamera::CCameraImageProcessing::TColorOperationEntry::Version() const
	{
	return iVersion;	
	}