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