// 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 the License "Symbian Foundation License v1.0" to Symbian Foundation members and "Symbian Foundation End User License Agreement v1.0" to non-members
// which accompanies this distribution, and is available
// at the URL "http://www.symbianfoundation.org/legal/licencesv10.html".
//
// Initial Contributors:
// Nokia Corporation - initial contribution.
//
// Contributors:
//
// Description:
//



/**
 @file	
 @publishedAll
 @released
*/
#ifndef  ECAMIMAGEPROCESSING_H
#define  ECAMIMAGEPROCESSING_H

#include <e32base.h>
#include <gdi.h>
#include <ecam.h>
#include <ecamadvsettingsuids.hrh>
#include <ecam/ecamconstants.h>

class MCameraImageProcessing;
class MCameraImageProcessing2;
class MCameraImageProcessing3;

class MImplementationFactory;

/** 
The current Version of the TColorOperationCapabilities class.

*/
static const TUint KECamColorOperationCapabilitiesCurrentVersion = 1;

/** 
The current Version of the TBitsIgnore class.

*/
static const TUint KECamBitsIgnoreCurrentVersion = 1;

/** 
The current Version of the TColorOperationEntry class.

*/
static const TUint KECamColorOperationEntryCurrentVersion = 1;


/* General purpose constants */

/** 
	Uid used to identify the CCamera Post Processing API.
	Such image operations are performed on the acquired image by the camera itself. 
	@see CCamera::CCameraPresets
*/
static const TUid  KECamImageProcessingUid 	= {KECamImageProcessingUidValue};

/** Transformations */
/* Adjustments */
/** Brightness adjustment - recognized range [-100:100] */
static const TUid  KUidECamEventImageProcessingAdjustBrightness 	= {KUidECamEventImageProcessingAdjustBrightnessUidValue};
/** Contrast adjustment  - recognized range [-100:100] */
static const TUid  KUidECamEventImageProcessingAdjustContrast 		= {KUidECamEventImageProcessingAdjustContrastUidValue};
/** Gamma adjustment  - recognized range [0:1000] */
static const TUid  KUidECamEventImageProcessingAdjustGamma 			= {KUidECamEventImageProcessingAdjustGammaUidValue};
/** Sharpness adjustment - recognized range [-100:100] */
static const TUid  KUidECamEventImageProcessingAdjustSharpness 		= {KUidECamEventImageProcessingAdjustSharpnessUidValue};
/** Saturation adjustment  - recognized range [-100:100] */
static const TUid  KUidECamEventtImageProcessingAdjustSaturation 	= {KUidECamEventtImageProcessingAdjustSaturationUidValue};
static const TUid  KUidECamEventImageProcessingAdjustSaturation 	= {KUidECamEventtImageProcessingAdjustSaturationUidValue};
/** Hue adjustment  - recognized range [-100:100] */
static const TUid  KUidECamEventtImageProcessingAdjustHue 			= {KUidECamEventtImageProcessingAdjustHueUidValue};
static const TUid  KUidECamEventImageProcessingAdjustHue 			= {KUidECamEventtImageProcessingAdjustHueUidValue};
/** Contrast Enhancement

This uid value is available from the 'supported' or 'getter' methods only to the API clients using CCamera::New2L() or 
CCamera::NewDuplicate2L().

@internalTechnology
*/
static const TUid  KUidECamEventCIPAdjustContrastEnhancement 		= {KUidECamEventCIPAdjustContrastEnhancementUidValue};
/** Software based Red Eye Reduction

This uid value is available from the 'supported' or 'getter' methods only to the API clients using CCamera::New2L() or 
CCamera::NewDuplicate2L()

@internalTechnology
*/
static const TUid  KUidECamEventCIPAdjustRedEyeReduction 		    = {KUidECamEventCIPAdjustRedEyeReductionUidValue};

/**
Image distortion correction.

This uid value is available from the 'supported' or 'getter' methods only to the API clients using CCamera::New2L() or 
CCamera::NewDuplicate2L()

@internalTechnology
*/
static const TUid KUidECamEventCIPImageDistortionCorrection         = {KUidECamEventCIPImageDistortionCorrectionUidValue};


/** Effect value */
static const TUid  KUidECamEventImageProcessingEffect 				= {KUidECamEventImageProcessingEffectUidValue};

/* Transforms */
/** Crop */
static const TUid  KUidECamEventImageProcessingTransformCrop 		= {KUidECamEventImageProcessingTransformCropUidValue};
/** Rotation */
static const TUid  KUidECamEventImageProcessingTransformRotate 		= {KUidECamEventImageProcessingTransformRotateUidValue};
/** Mirroring */
static const TUid  KUidECamEventImageProcessingTransformMirror		= {KUidECamEventImageProcessingTransformMirrorUidValue};
/** Rescale */
static const TUid  KUidECamEventImageProcessingTransformScale		= {KUidECamEventImageProcessingTransformScaleUidValue};
/** origin subset */
static const TUid  KUidECamEventImageProcessingSourceRect 			= {KUidECamEventImageProcessingSourceRectUidValue};
/** Noise reduction */
static const TUid  KUidECamEventImageProcessingNoiseReduction		= {KUidECamEventImageProcessingNoiseReductionUidValue};
/** Glare removal */
static const TUid  KUidECamEventImageProcessingGlareRemoval			= {KUidECamEventImageProcessingGlareRemovalUidValue};
/** Relative Orientation 

This uid value is available from the 'supported' or 'getter' methods only to the API clients using CCamera::New2L() or 
CCamera::NewDuplicate2L().

@publishedPartner
@prototype
*/
static const TUid  KUidECamEventImageProcessingTransformRelativeOrientation = {KUidECamEventImageProcessingTransformRelativeOrientationUidValue};

/** Default value for image processing */
static const TInt  KECamImageProcessingDefaultValue  = 0;

/**
Uid used to indicate completion of StartColorSwap

*/
static const TUid  KUidECamEventCIPStartColorSwap					= {KUidECamEventCIPStartColorSwapUidValue};

/**
Uid used to indicate completion of StartColorAccent

*/
static const TUid  KUidECamEventCIPStartColorAccent					= {KUidECamEventCIPStartColorAccentUidValue};

/**
Uid used to notify that the current picture orientation is unachievable after setting the relative custom orientation.

@see CCamera::CCameraImageProcessing::SetRelativeCustomOrientationL(TOrientationReference aOrientationReference, 
												TRelativeCustomOrientation aRelativeCustomOrientation);

@publishedPartner
@prototype
*/
static const TUid  KUidECamEventPictureOrientationUnachievable		= {KUidECamEventPictureOrientationUnachievableUidValue};

/** 
This class is used to perform image processing operations on the camera.
These include brightness, contrast, gamma, hue, sharpness and saturation adjustments. The client is also 
able to perform simple image transformations like cropping, rotation, mirroring, scaling, noise reduction and glare reduction. .  
When an operation selection is complete, all clients are notified with the respective event UID.

As often cameras may support only a subset of discrete values of the allowed range, 
the API allows the client to retrieve those and use them explicitly.   

@note This class is not intended for sub-classing and used to standardise existing
	  varieties of implementations.

@note it is assumed that setting a new value for a transformations(transform, adjust, effect) effectively
	  activates the transformations. Whilst for effects and adjustments there is always a value, transforms 
	  may have a dependency on other parameters and 
	  crop 	- requires setting of source rectangle.
	  scale - will use setting of source rectangle, and the magnification factor is 
	  		  determined by the source rectangle and the output size. This is always magnification.
	  		  if a value is set, it is assumed to be a scaling factor multiplied by KECamFineResolutionFactor
	  		  and set to integer.
	  mirror - values of TMirror type.
	  rotation - the angle in degrees.
	  noise reduction - TNoiseReduction.
	  glare removal - TGlareReduction.

	  	Example 
		
		@code
		// Lets assume that an application would need to check whether gamma correction is 
		// supported on a particular platform. After obtaining a valid pointer to the interface, 
		// it would call GetSupportedTransformationsL() to obtain the list of the supported 
		// transformations and check whether KUidECamEventImageProcessingAdjustGamma
		// is in the list. If it is then call SetTranformationValue(KUidECamEventImageProcessingAdjustGamma, 200);
		// to set the new value. A notification will be generated to the client to indicate success.

		RArray<TUid> suppTransforms; // array of supported transformations
		CleanupClosePushL(suppTransforms);

		imageProcess->GetSupportedTransformationsL(suppTransfUids);
		 ...
		// if the gamma is supported 
		TInt gammaCorrection = 200; // gamma correction of 2.0
		imageProcess->SetTranformationValue(KUidECamEventImageProcessingAdjustGamma, gammaCorrection);
		...
		// pop stack to close the RArray
		@endcode
		
@note   If the class methods leave, the output type parameter value is not guaranteed to be valid.

@publishedAll
@released	
*/
class CCamera::CCameraImageProcessing : public CBase
	{
	
	// so can use internal factory functions etc.
	friend class CCamera;
	
public: 
	
	/** Gamma settings */		
   	enum TGamma
	   	{
   		/** Sets the gamma adjustment automatically. */
	   	EGammaAuto						= KMinTInt
	   	};
	/** Sharpness Settings */	   	
	enum TSharpness
	   	{
   		/** Sets the sharpness adjustment automatically. */
	   	ESharpnessAuto					= KMinTInt
	   	};   	
	/** Saturation Settings */	 
	enum TSaturation
	   	{
   		/** Sets the saturation adjustment automatically. */
	   	ESaturationAuto					= KMinTInt
	   	};
	/** Hue Settings */	 
	enum THue
	   	{
   		/** Sets the hue adjustment automatically. */
	   	EHueAuto						= KMinTInt
	   	};	   	
	   	     	
	/** Settings for the supported effects */
	enum TEffect
	  	{
		/** Effects off is default, always supported */
		EEffectNone			     	= 0x00000000,
		/** Negative visual effect. */
		EEffectNegative		   		= 0x00000001,
		/** Black and white visual effect. */
		EEffectMonochrome 			= 0x00000002,
		/** Solarization visual effect. */
		EEffectSolarize		 		= 0x00000004,
		/** Sepia visual effect. */
		EEffectSepia		     	= 0x00000008,
		/** Emboss visual effect. */
		EEffectEmboss 				= 0x00000010,
		/** Red eye glare reduction visual effect. */
		EEffectRedEyeReduction 		= 0x00000020,
		/** Vivid colour visual effect. */ 
		EEffectVivid 				= 0x00000040,
		/** Neutral colour visual effect. */ 
		EEffectNeutral 				= 0x00000080,
		/** Selective sharpening visual effect. */ 
		EEffectLowSharpening		= 0x00000100,
		/** 
		Natural visual effect. 
		
		This enum value is available from the 'supported' or 'getter' methods only to the API clients using CCamera::New2L() or 
		CCamera::NewDuplicate2L().
		
		*/
		EEffectNatural 				= 0x00000200, 
		/** 
		Cine visual effect. 
		
		This enum value is available from the 'supported' or 'getter' methods only to the API clients using CCamera::New2L() or 
		CCamera::NewDuplicate2L().
		
		*/
		EEffectCine 				= 0x00000400, 
		/** 
		Old film visual effect. 
		
		This enum value is available from the 'supported' or 'getter' methods only to the API clients using CCamera::New2L() or 
		CCamera::NewDuplicate2L().
		
		*/
		EEffectOldFilm 				= 0x00000800,  
		/** 
		Color swap visual effect. 
		
		This enum value is available from the 'supported' or 'getter' methods only to the API clients using CCamera::New2L() or 
		CCamera::NewDuplicate2L().
		
		*/
		EEffectColorSwap 			= 0x00001000, 
		/** 
		Where a list of color can be kept as they are and the rest converted to gray. 
	
		This enum value is available from the 'supported' or 'getter' methods only to the API clients using CCamera::New2L() or 
		CCamera::NewDuplicate2L().
	
		*/
		EEffectColorAccent			= 0x00002000
 		};
		
	/** Mirror settings */		
	enum TMirror
		{
		/** Default value. Mirroring is disabled. */
		EMirrorNone			= 0x00000000, 
		/** Mirror along horizontal axis. */
		EMirrorHorizontal	= 0x00000001,
		/** Mirror along vertical axis. */
		EMirrorVertical		= 0x00000002,
		/** Mirror along horizontal and vertical axis. */
		EMirrorBoth			= 0x00000003
		};
	
	/** Noise filter settings */		
	enum TNoiseReduction
		{
		/** Default value. Noise reduction disabled. */
		ENoiseReductionNone			= 0x0000, 
		/** most basic noise reduction. */
		ENoiseReductionBasic		= 0x0001
		};
	
	/** Glare reduction settings */		
	enum TGlareReduction
		{
		/** Default value. Glare reduction disabled. */
		EGlareReductionNone			= 0x0000, 
		/** most basic glare reduction. */
		EGlareReductionBasic		= 0x0001
		};
	
	/** 
	Used for color swap and color accent feature in TEffect. It describes whether the given source 
	or target color represents itself or a group of color.
	
	*/
	enum TColorOperationRepresentation
		{
		/** Feature is not supported */
		ERepresentationNone         = 0x00,
		/** The given color is uniquely represented */
		ERepresentationSingle	    = 0x01,
		/** The given color represents a group of colors */
		ERepresentationMultiple     = 0x02
		};

	/**
	Used for color swap and color accent feature in TEffect. It describes the type of grouping for 
	source and target colors when they represent a group of color.
	
	*/
	enum TColorOperationRgbGroupingMode
		{
		/** Feature is not supported */
		ERgbGroupingNone			= 0x00,
		/** This means no neighbourhood colors are considered */
		ERgbGroupingFixed			= 0x01,
		/** This means neighbourhood colors are to be automatically decided by the implementation or hardware */
		ERgbGroupingAutomatic		= 0x02,
		/** This means neighbourhood colors for source have to be decided by ignoring few starting bits. Used for source only */
		ERgbGroupingSignificantBits = 0x04,
		/** This means colors in target are obtained as some uniform proportion using source. Used for target only */
		ERgbGroupingUniform			= 0x08
		};
	
	/**
	Used to provide different types of references for orientation of images retrieved. These references are the various 
	means by the orientation of an image can be defined. Client needs to choose a particular TOrientationReference and 
	specify any relative rotation, mirroring and flipping on top of it.	
	
	This enumeration has nothing to do with absolute rotation. Uid KUidECamEventImageProcessingTransformRotate is used 
	for absolute rotation purposes.
	
	The enumeration list may be extended in future.	
	
	@publishedPartner
	@prototype
	*/
	enum TOrientationReference
		{
		/** The retrieved images will follow the camera sensor orientation. This orientation would be relative 
		to the current screen mode as given by the reference screen. */
		EOrientationReferenceCameraSensorOrientation,
	
		/** The retrieved images will get oriented as per the tilt sensor information. 
		So,the orientation would be relative to the current screen mode as given by the reference screen. */
		EOrientationReferenceTiltOrientation
		};
	
	/**
	Used to describe the various relative rotation. The term 'relative' means that the rotation is applied after the 
	image undergoes orientation as given by TOrientationReference.
	
	The enumeration list may be extended in future.	
	
	@publishedPartner
	@prototype
	*/
	enum TRelativeRotation
		{
		/** Zero degree Rotation applied on top of orientation reference and is relative to current reference screen. */
		ERelativeRotation0Degrees				= 0x00,
		/** 90 degree clockwise Rotation applied on top of orientation reference and is relative to current reference screen. */
		ERelativeRotation90DegreesClockwise 	= 0x01,
		/** 180 degree clockwise Rotation applied on top of orientation reference and is relative to current reference screen. */
		ERelativeRotation180DegreesClockwise	= 0x02,
		/** 270 degree clockwise Rotation applied on top of orientation reference and is relative to current reference screen. */
		ERelativeRotation270DegreesClockwise 	= 0x04
		};
		
	/**
	Used to describe the various relative mirroring. The term 'relative' means that the mirroring is applied after the 
	image undergoes orientation as given by TOrientationReference.
		
	The enumeration list may be extended in future.	
	
	@publishedPartner
	@prototype
	*/
	enum TRelativeMirror
		{
		/** No mirroring. */
		ERelativeMirrorNone				= 0x00,
		/** Used to mirror an image about the horizontal axis. This is applied on top of orientation reference and is 
		relative to current reference screen. */
		ERelativeMirrorHorizontalAxis	= 0x10,
		/** Used to mirror an image about the vertical axis. This is applied on top of orientation reference and is 
		relative to current reference screen. */
		ERelativeMirrorVerticalAxis 	= 0x20 
		};
		
	/**
	Used to describe the various relative flipping. The term 'relative' means that the flipping is applied after the 
	image undergoes orientation as given by TOrientationReference.
	
	The enumeration list may be extended in future.
	
	@publishedPartner
	@prototype
	*/
	enum TRelativeFlipping
		{
		/** No flipping. */
		ERelativeFlippingNone			= 0x00,
		/** Used to flip an image horizontally. This is applied on top of orientation reference and is relative to current
		reference screen. */
		ERelativeFlippingHorizontal		= 0x10,
		/** Used to flip an image vertically. This is applied on top of orientation reference and is relative to current
		reference screen. */
		ERelativeFlippingVertical 		= 0x20 
		};
		
	/**
	Different types of contrast enhancement options.
	The enumeration list may be extended in future.
	
	@publishedPartner
	@prototype
	*/	
	enum TContrastEnhancement
		{
		/** Not Supported. */
		EContrastEnhancementNone				=0x00,
		/** Contrast Enhancement switched off. */
		EContrastEnhancementSwitchOff			=0x01,
		/** Contrast Enhacement switched On manually. */
		EContrastEnhancementManualSwitchOn		=0x02,
		/** Contrast Enhancement in auto mode. */
		EContrastEnhancementSwitchAuto			=0x04
		};
		
	/**
	Different types of software-based red eye reduction options.
	The enumeration list may be extended in future.
	
	@publishedPartner
	@prototype
	*/
	enum TRedEyeReduction
		{
		/** Not Supported. */
		ERedEyeReductionNone				=0x00,
		/** Software based Red Eye Reduction can be switched off(disabled). */
		ERedEyeReductionSwitchOff			=0x01,
		/** Software based Red Eye Reduction can be switched on (enabled). */
		ERedEyeReductionManualSwitchOn		=0x02,
		/** Software based Red Eye Reduction can be put to auto mode. */
		ERedEyeReductionSwitchAuto			=0x04
		};

	/** 
	Color operation capabilities characterizing both color swap and color accent feature 
	
	*/
	class TColorOperationCapabilities
		{
	public:
		/**
		Constructor.
		Sets the size of this class in iSize.
		*/
		IMPORT_C TColorOperationCapabilities();
		
		IMPORT_C TInt Size() const;
		IMPORT_C TUint Version() const;
	
	private:
		//for future expansion
		TUint iSize:24;
		TUint iVersion:8;
		
		// reserved for future expansion
		TInt    iReserved;
		
	public:
		/** The source color representation that the server supports.
	    The supported representations are held as a bitwise logical OR of the relevant individual modes
	    defined in CCamera::CCameraImageProcessing:: TColorOperationRepresentation. */
		TUint	iSupportedSourceRepresentation;
		
		/** The target color representation that the server supports.
	    The supported representations are held as a bitwise logical OR of the relevant individual modes
	    defined in CCamera::CCameraImageProcessing:: TColorOperationRepresentation.
	    Not applicable for color accent */
		TUint	iSupportedTargetRepresentation;

		/** The source color Rgb grouping modes that the server supports.
	    The modes are held as a bitwise logical OR of the relevant individual modes
	    defined in CCamera::CCameraImageProcessing:: TColorOperationRgbGroupingMode. */
		TUint   iSupportedSourceRgbGroupingMode;

		/** The target color Rgb grouping modes that the server supports.
	    The modes are held as a bitwise logical OR of the relevant individual modes
	    defined in CCamera::CCameraImageProcessing:: TColorOperationRgbGroupingMode. 
	    Not applicable for color accent */
		TUint   iSupportedTargetRgbGroupingMode;
		
		/** This indicates whether the mapping mode and Rgb grouping mode uniform for every color entry */
		TBool   iIsCapabilityUniform;
		};

	/** 
	Class used to control the number of bits to ignore for Red, Green, Blue or Alpha.
	This may be used when deciding for neighbourhood for source color in case of color swap and color accent feature

	*/
	class TBitsIgnore
		{
	public:
		/**
		Constructor.
		Sets the size of this class in iSize.
		*/
		IMPORT_C TBitsIgnore();
		
		IMPORT_C TInt Size() const;
		IMPORT_C TUint Version() const;
	
	private:
		//for future expansion
		TUint iSize:24;
		TUint iVersion:8;
		
		// for future use
		TUint iReservedBits:16;
			
	public:
		/** This gives the no. of bits to ignore for Red color. Varies from 0 to 8. 
		Any other value should be an error */
		TUint iRedBitsIgnore:4;
		
		/** This gives the no. of bits to ignore for Green color. Varies from 0 to 8. 
		Any other value should be an error */
		TUint iGreenBitsIgnore:4;
		
		/** This gives the no. of bits to ignore for Blue color. Varies from 0 to 8. 
		Any other value should be an error */
		TUint iBlueBitsIgnore:4;

		/** This gives the no. of bits to ignore for Alpha. Varies from 0 to 8. 
		Any other value should be an error */
		TUint iAlphaBitsIgnore:4;
		};

	/** 
	Color operation parameters characterizing both color swap and color accent feature; and for a particular entry.
	 
	*/
	class TColorOperationEntry
		{
	public:
		/**
		Constructor.
		Sets the size of this class in iSize.
		*/
		IMPORT_C TColorOperationEntry();
				
		IMPORT_C TInt Size() const;
		IMPORT_C TUint Version() const;

	private:
		//for future expansion
		TUint iSize:24;
		TUint iVersion:8;
		
		// reserved for future expansion
		TInt iReserved;
		
	public:
		/** The source color (rgb triplet) which is changed to target color in case of Color Swap operation 
		and remains unaffected in case of Color Accent operation */
		TRgb iSourceColor;

		/** The target color (rgb triplet) which replaces the source color in case of Color Swap operation. 
		Redundant for Color Accent operation */
		TRgb iTargetColor;

		/** This defines whether the given source color represents itself or a group of colors */
		TColorOperationRepresentation iSourceColorRepresentation;

		/** This defines whether the given target color represents itself or a group of colors in case of 
		Color Swap operation. Redundant for Color Accent operation */
		TColorOperationRepresentation iTargetColorRepresentation;

		/** This defines the type of grouping for multiple representation of source color */
		TColorOperationRgbGroupingMode iColorOperationSourceRgbGroupingMode;

		/** This defines the type of grouping for multiple representation of target color in case of 
		Color Swap operation. Redundant for Color Accent operation */
		TColorOperationRgbGroupingMode iColorOperationTargetRgbGroupingMode;  

		/** This gives the number of bits to ignore in case ERgbGroupingSignificantBits is used for 
		multiple representation of source color. For any other case, no. of bits ignored for red, green, 
		blue or alpha should be 0 */
		TBitsIgnore iNumBitsIgnored;

		/** This gives the entry status of every color operation entry. If entry is not set or removed, 
		this is ENotActive. And if entry is set, then this is EDiscreteSteps */
		TValueInfo iEntryStatus;
		};

public:
	
    IMPORT_C static CCameraImageProcessing* NewL(CCamera& aCamera);
    
    IMPORT_C static CCameraImageProcessing* CreateL(CCamera& aCamera, MImplementationFactory& aImplFactory);
    
	IMPORT_C void GetSupportedTransformationsL(RArray<TUid>& aTransformations) const;

	IMPORT_C void GetActiveTransformationsL(RArray<TUid>& aTransformations) const;

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

	IMPORT_C TInt TransformationValue(TUid aTransformation) const;
	
	IMPORT_C TInt GetTransformationValue(TUid aTransformation, TInt& aTransformationValue) const;

	IMPORT_C void SetTransformationValue(TUid aTransformation, TInt aValue);

	IMPORT_C void GetActiveTransformSequenceL(RArray<TUid>& aTransformSequence) const;

	IMPORT_C void SetActiveTransformSequenceL(RArray<TUid>& aTransformSequence);

	IMPORT_C void SetSourceRect(const TRect& aRect);

	IMPORT_C void GetSourceRect(TRect& aRect) const;

	IMPORT_C ~CCameraImageProcessing();
	
	IMPORT_C void GetConcurrentColorSwappingsSupportedL(TInt& aConcurrentColorSwappingSupported) const; 
	
	IMPORT_C void GetColorSwapCapabilitiesL(TInt aIndex, TColorOperationCapabilities& aColorSwapCapabilities) const;
	
	IMPORT_C void SetColorSwapEntryL(TInt aIndex, const TColorOperationEntry& aColorSwapParameters); 
	
	IMPORT_C void RemoveColorSwapEntryL(TInt aIndex);
	
	IMPORT_C void GetColorSwapEntryL(TInt aIndex, TColorOperationEntry& aColorSwapParameters) const; 
	
	IMPORT_C void StartColorSwappingL();
	
	IMPORT_C void CancelColorSwappingL();
	
	IMPORT_C void GetConcurrentColorAccentSupportedL(TInt& aConcurrentColorAccentSupported) const; 
	
	IMPORT_C void GetColorAccentCapabilitiesL(TInt aIndex, TColorOperationCapabilities& aColorAccentCapabilities) const;
	
	IMPORT_C void SetColorAccentEntryL(TInt aIndex, const TColorOperationEntry& aColorAccentParameters); 
	
	IMPORT_C void RemoveColorAccentEntryL(TInt aIndex);
	
	IMPORT_C void GetColorAccentEntryL(TInt aIndex, TColorOperationEntry& aColorAccentParameters) const; 
	
	IMPORT_C void StartColorAccentL();
	
	IMPORT_C void CancelColorAccentL();
	
	IMPORT_C void GetSupportedRelativeOrientationOptionsL(TOrientationReference aOrientationReference, 
		TUint& aSupportedRelativeRotation, TUint& aSupportedRelativeMirroring, TUint& aSupportedRelativeFlipping) const;
																
	IMPORT_C void GetCurrentRelativeOrientationOptionsL(TOrientationReference& aOrientationReference, 
		TRelativeRotation& aRelativeRotation, TRelativeMirror& aRelativeMirror, TRelativeFlipping& aRelativeFlipping) const;
												
	IMPORT_C void SetRelativeOrientationOptionsL(TOrientationReference aOrientationReference, 
		TRelativeRotation aRelativeRotation, TRelativeMirror aRelativeMirror, TRelativeFlipping aRelativeFlipping);
	
private:
	CCameraImageProcessing(CCamera& aOwner);
	void ConstructL();
	void ConstructL(const MImplementationFactory& aImplFactory);
	
private:
	CCamera& iOwner;
	MCameraImageProcessing* iImpl;  // not owned
	MCameraImageProcessing2* iImpl2;   //not owned
	MCameraImageProcessing3* iImpl3;   //not owned
	};
#endif//ECAMIMAGEPROCESSING_H
