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

//

/**

 @file	

 @publishedAll

 @released

*/

#ifndef  ECAMADVSETTINGS_H

#define  ECAMADVSETTINGS_H

#include <e32base.h>

#include <ecam.h>

#include <ecamadvsettingsuids.hrh>

#include <gdi.h>

#include <s32strm.h>

#include <ecam/ecamconstants.h>

#include <ecamimageprocessing.h>

#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <ecamadvsettingsconst.h>

#include <ecamadvsettingsdef.h>

#endif

class MCameraPresets;

class MCameraAdvancedSettings;

class MCameraAdvancedSettings2;

class MCameraAdvancedSettings3;

class MCameraAdvancedSettings4;

class MCameraPresets2;

class MCameraContinuousZoom;

/* General purpose constants */

/**

	UID used to identify the CCamera Advanced Settings API.

	This API is used to control specific individual advanced settings of camera hardware.

	These settings directly relate to the image acquisition phase.

	@see CCamera::CCameraAdvancedSettings

*/

static const TUid KECamAdvancedSettingUid 	= {KECamAdvancedSettingUidValue};

/**

	UID used to identify the CCamera Presets API.

	This API is used to simplify user - camera interaction by allowing simultaneous 

	setting of various advanced camera hardware settings using a single predefined parameter. 

	@see CCamera::CCameraPresets

*/

static const TUid  KECamPresetsUid 			= {KECamPresetsUidValue};

/** All clients receive these events, irrespective of camera index.  */

/** Camera slots in for 8 cameras. */

/** Camera with index 0 Plugged-in */

static const TUid  KUidECamEventGlobalCamera00PluggedIn = {KUidECamEventGlobalCamera00PluggedInUidValue};

/** Camera with index 1 Plugged-in */

static const TUid  KUidECamEventGlobalCamera01PluggedIn = {KUidECamEventGlobalCamera01PluggedInUidValue};

/** Camera with index 2 Plugged-in */

static const TUid  KUidECamEventGlobalCamera02PluggedIn = {KUidECamEventGlobalCamera02PluggedInUidValue};

/** Camera with index 3 Plugged-in */

static const TUid  KUidECamEventGlobalCamera03PluggedIn = {KUidECamEventGlobalCamera03PluggedInUidValue};

/** Camera with index 4 Plugged-in */

static const TUid  KUidECamEventGlobalCamera04PluggedIn = {KUidECamEventGlobalCamera04PluggedInUidValue};

/** Camera with index 5 Plugged-in */

static const TUid  KUidECamEventGlobalCamera05PluggedIn = {KUidECamEventGlobalCamera05PluggedInUidValue};

/** Camera with index 6 Plugged-in */

static const TUid  KUidECamEventGlobalCamera06PluggedIn = {KUidECamEventGlobalCamera06PluggedInUidValue};

/** Camera with index 7 Plugged-in */

static const TUid  KUidECamEventGlobalCamera07PluggedIn = {KUidECamEventGlobalCamera07PluggedInUidValue};

/** Camera slots plugged out for 8 cameras. */

/** Camera with index 0 Plugged-out */

static const TUid  KUidECamEventGlobalCamera00PluggedOut = {KUidECamEventGlobalCamera00PluggedOutUidValue};

/** Camera with index 1 Plugged-out */

static const TUid  KUidECamEventGlobalCamera01PluggedOut = {KUidECamEventGlobalCamera01PluggedOutUidValue};

/** Camera with index 2 Plugged-out */

static const TUid  KUidECamEventGlobalCamera02PluggedOut = {KUidECamEventGlobalCamera02PluggedOutUidValue};

/** Camera with index 3 Plugged-out */

static const TUid  KUidECamEventGlobalCamera03PluggedOut = {KUidECamEventGlobalCamera03PluggedOutUidValue};

/** Camera with index 4 Plugged-out */

static const TUid  KUidECamEventGlobalCamera04PluggedOut = {KUidECamEventGlobalCamera04PluggedOutUidValue};

/** Camera with index 5 Plugged-out */

static const TUid  KUidECamEventGlobalCamera05PluggedOut = {KUidECamEventGlobalCamera05PluggedOutUidValue};

/** Camera with index 6 Plugged-out */

static const TUid  KUidECamEventGlobalCamera06PluggedOut = {KUidECamEventGlobalCamera06PluggedOutUidValue};

/** Camera with index 7 Plugged-out */

static const TUid  KUidECamEventGlobalCamera07PluggedOut = {KUidECamEventGlobalCamera07PluggedOutUidValue};

/** Camera slots available for 8 cameras. */

/** Signals a camera previously has been reserved and then released again. 

    In this way available clients may attempt to reserve the camera */

/** Camera with index 0 Available. */

static const TUid  KUidECamEventGlobalCamera00Available  = {KUidECamEventGlobalCamera00AvailableUidValue};

/** Camera with index 1 Available. */

static const TUid  KUidECamEventGlobalCamera01Available  = {KUidECamEventGlobalCamera01AvailableUidValue};

/** Camera with index 2 Available. */

static const TUid  KUidECamEventGlobalCamera02Available  = {KUidECamEventGlobalCamera02AvailableUidValue};

/** Camera with index 3 Available. */

static const TUid  KUidECamEventGlobalCamera03Available  = {KUidECamEventGlobalCamera03AvailableUidValue};

/** Camera with index 4 Available. */

static const TUid  KUidECamEventGlobalCamera04Available  = {KUidECamEventGlobalCamera04AvailableUidValue};

/** Camera with index 5 Available. */

static const TUid  KUidECamEventGlobalCamera05Available  = {KUidECamEventGlobalCamera05AvailableUidValue};

/** Camera with index 6 Available. */

static const TUid  KUidECamEventGlobalCamera06Available  = {KUidECamEventGlobalCamera06AvailableUidValue};

/** Camera with index 7 Available. */

static const TUid  KUidECamEventGlobalCamera07Available  = {KUidECamEventGlobalCamera07AvailableUidValue};

/** Individual camera events. These are used by the camera to signal its observers. */

/** Lens changed. */

static const TUid  KUidECamEventLensChanged 			= {KUidECamEventLensChangedUidValue};

/** Flash source added. */

static const TUid  KUidECamEventFlashSourceAdded 		= {KUidECamEventFlashSourceAddedUidValue};

/** Flash source removed. */

static const TUid  KUidECamEventFlashSourceRemoved		= {KUidECamEventFlashSourceRemovedUidValue};

/** Image resolution changed. */

static const TUid  KUidECamEventCameraSettingImageSize 	= {KUidECamEventCameraSettingImageSizeUidValue};

/** Image Format changed. */

static const TUid  KUidECamEventCameraSettingImageFormat 		= {KUidECamEventCameraSettingImageFormatUidValue};

/** Camera orientation changed. */

static const TUid  KUidECamEventCameraSettingCameraOrientation  = {KUidECamEventCameraSettingCameraOrientationUidValue};

/** Optimal focus */

static const TUid KUidECamEventCameraSettingsOptimalFocus 		= {KUidECamEventCameraSettingsOptimalFocusUidValue};

/** Advanced settings. */

/** Stabilization mode.  */

static const TUid  KUidECamEventCameraSettingStabilizationMode 	= {KUidECamEventCameraSettingStabilizationModeUidValue};

/** Focus mode. */

static const TUid  KUidECamEventCameraSettingFocusMode 			= {KUidECamEventCameraSettingFocusModeUidValue};

/** Focus range. 

@deprecated

Replaced by KUidECamEventCameraSettingFocusRange2

In the first release of this event, KUidECamEventCameraSettingFocusRange was incorrectly given an already existing uid. 

In order to preserve compatibility this event is marked as deprecated and has been replaced by KUidECamEventCameraSettingFocusRange2.

Camera servers predating this API change will continue to send the original event which is indistinguishable by value. 

Caching the old value and comparing it with the current value, will allow the client to determine that the value has changed.

Camera servers which have been updated should send both KUidECamEventCameraSettingFocusRange and KUidECamEventCameraSettingFocusRange2 on a focus range change. 

Camera clients should therefore process both events(old and new). 

@see KUidECamEventCameraSettingFocusRange2

*/

static const TUid  KUidECamEventCameraSettingFocusRange 		= {KUidECamEventCameraSettingFocusRangeUidValue};

/** Autofocus type.

@deprecated

Replaced by KUidECamEventCameraSettingAutoFocusType2

In the first release of this event, KUidECamEventCameraSettingAutoFocusType was incorrectly given an already existing uid. 

In order to preserve compatibility this event is marked as deprecated and has been replaced by KUidECamEventCameraSettingAutoFocusType2.

Camera servers predating this API change will continue to send the original event which is indistinguishable by value. 

Caching the old value and comparing it with the current value, will allow the client to determine that the value has changed.

Camera servers which have been updated should send both KUidECamEventCameraSettingAutoFocusType and KUidECamEventCameraSettingAutoFocusType2 on a focus range change. 

Camera clients should therefore process both events(old and new). 

@see KUidECamEventCameraSettingAutoFocusType2*/

static const TUid  KUidECamEventCameraSettingAutoFocusType 		= {KUidECamEventCameraSettingAutoFocusTypeUidValue};

/** Autofocus area. */

static const TUid  KUidECamEventCameraSettingAutoFocusArea 		= {KUidECamEventCameraSettingAutoFocusAreaUidValue};

/** Autofocus lock state.  */

static const TUid  KUidECamEventCameraSettingAutoFocusLock		= {KUidECamEventCameraSettingAutoFocusLockUidValue};

/** Focus distance */

static const TUid  KUidECamEventCameraSettingFocusDistance 		= {KUidECamEventCameraSettingFocusDistanceUidValue};

/** Sensitivity - ISO rate. */

static const TUid  KUidECamEventCameraSettingIsoRate 			= {KUidECamEventCameraSettingIsoRateUidValue};

/** Aperture. */

static const TUid  KUidECamEventCameraSettingAperture 			= {KUidECamEventCameraSettingApertureUidValue};

/** Aperture range. */

static const TUid  KUidECamEventCameraSettingApertureRange 		= {KUidECamEventCameraSettingApertureRangeUidValue};

/** Shutter speed. */

static const TUid  KUidECamEventCameraSettingShutterSpeed 		= {KUidECamEventCameraSettingShutterSpeedUidValue};

/** Shutter speed range.  */

static const TUid  KUidECamEventCameraSettingShutterSpeedRange 	= {KUidECamEventCameraSettingShutterSpeedRangeUidValue};

/**  Metering mode. */

static const TUid  KUidECamEventCameraSettingMeteringMode 		= {KUidECamEventCameraSettingMeteringModeUidValue};

/** Drive mode. */

static const TUid  KUidECamEventCameraSettingDriveMode 			= {KUidECamEventCameraSettingDriveModeUidValue};

/** Braket mode. */

static const TUid  KUidECamEventCameraSettingBracketMode 		= {KUidECamEventCameraSettingBracketModeUidValue};

/** Bracket step. */

static const TUid  KUidECamEventCameraSettingBracketStep 		= {KUidECamEventCameraSettingBracketStepUidValue};

/** Bracket parameter. */

static const TUid  KUidECamEventCameraSettingBracketParameter 	= {KUidECamEventCameraSettingBracketParameterUidValue};

/** Bracket merge. */

static const TUid  KUidECamEventBracketMerge					= {KUidECamEventBracketMergeUidValue};

/** Picture orientation.  */

static const TUid  KUidECamEventCameraSettingPictureOrientation = {KUidECamEventCameraSettingPictureOrientationUidValue};

/** Automatic size selection option */

static const TUid  KUidECamEventCameraSettingAutomaticSizeSelection = {KUidECamEventCameraSettingAutomaticSizeSelectionUidValue};

/** Flash setting. */

static const TUid  KUidECamEventCameraSettingFlashMode 			= {KUidECamEventCameraSettingFlashModeUidValue};

/** Flash compensation step. */

static const TUid  KUidECamEventCameraSettingFlashCompensationStep 		= {KUidECamEventCameraSettingFlashCompensationStepUidValue};

/** Flash compensation. */

static const TUid  KUidECamEventCameraSettingFlashCompensation 	= {KUidECamEventCameraSettingFlashCompensationUidValue};

/** Manual flash power. */

static const TUid  KUidECamEventCameraSettingFlashManualPower 	= {KUidECamEventCameraSettingFlashManualPowerUidValue};

/** Red eye reduce mode. */

static const TUid  KUidECamEventCameraSettingFlashRedEyeReduce 	= {KUidECamEventCameraSettingFlashRedEyeReduceUidValue};

/** Exposure mode setting. */

static const TUid  KUidECamEventCameraSettingExposureMode 		= {KUidECamEventCameraSettingExposureModeUidValue};

/** Exposure compensation step. */

static const TUid  KUidECamEventCameraSettingExposureCompensationStep 	= {KUidECamEventCameraSettingExposureCompensationStepUidValue};

/** Exposure compensation. */

static const TUid  KUidECamEventCameraSettingExposureCompensation 		= {KUidECamEventCameraSettingExposureCompensationUidValue};

/** Exposure lock state. */

static const TUid  KUidECamEventCameraSettingExposureLock 		= {KUidECamEventCameraSettingExposureLockUidValue};

/** AE lock option. */

static const TUid  KUidECamEventAELock 							= {KUidECamEventAELockUidValue};

/** White balance.  */

static const TUid  KUidECamEventCameraSettingWhiteBalanceMode 	= {KUidECamEventCameraSettingWhiteBalanceModeUidValue};

/** Timer changed. */

static const TUid  KUidECamEventCameraSettingTimerInterval 		= {KUidECamEventCameraSettingTimerIntervalUidValue};

/** Timer lapse period.  */

static const TUid  KUidECamEventCameraSettingTimeLapse			= {KUidECamEventCameraSettingTimeLapseUidValue};

/** Optical zoom. */

static const TUid  KUidECamEventCameraSettingOpticalZoom 		= {KUidECamEventCameraSettingOpticalZoomUidValue};

/** Optical zoom range.  */

static const TUid  KUidECamEventCameraSettingOpticalZoomRange 	= {KUidECamEventCameraSettingOpticalZoomRangeUidValue};

/** Digital zoom. */

static const TUid  KUidECamEventCameraSettingDigitalZoom 		= {KUidECamEventCameraSettingDigitalZoomUidValue};

/** Digital zoom range.  */

static const TUid  KUidECamEventCameraSettingDigitalZoomRange 	= {KUidECamEventCameraSettingDigitalZoomRangeUidValue};

/** Clicking sound state.  */

static const TUid  KUidECamEventSoundClick 						= {KUidECamEventSoundClickUidValue};

/** Pixel aspect ratio. */

static const TUid  KUidECamEventPixelAspectRatio 				= {KUidECamEventPixelAspectRatioUidValue};

/** Yuv range. */

static const TUid  KUidECamEventYuvRange 						= {KUidECamEventYuvRangeUidValue};

/** Burst images. */

static const TUid  KUidECamEventBurstImages						= {KUidECamEventBurstImagesUidValue};

/** Stabilization effect - magnitude of stabilization */

static const TUid KUidECamEventCameraSettingsStabilizationEffect 		= {KUidECamEventCameraSettingsStabilizationEffectUidValue};

/** Stabilization algorithm */

static const TUid KUidECamEventSettingsStabilizationAlgorithmComplexity = {KUidECamEventSettingsStabilizationAlgorithmComplexityUidValue};

/** Continuous Autofocus timeout */

static const TUid KUidECamEventCameraSettingsContinuousAutoFocusTimeout = {KUidECamEventCameraSettingsContinuousAutoFocusTimeoutUidValue};

/** White Balance manual setting */

static const TUid KUidECamEventCameraSettingsWBValue 					= {KUidECamEventCameraSettingsWBValueUidValue};	

/** Flash ready */

static const TUid KUidECamEventFlashReady 						= {KUidECamEventFlashReadyUidValue};	

/** Flash not ready */

static const TUid KUidECamEventFlashNotReady 					= {KUidECamEventFlashNotReadyUidValue};

/** Focus range. 

This is the new UID value to notify change on focus range and takes immediate effect as previous UID KUidECamEventCameraSettingFocusRange has been deprecated.

@see KUidECamEventCameraSettingFocusRange */

static const TUid  KUidECamEventCameraSettingFocusRange2 		= {KUidECamEventCameraSettingFocusRange2UidValue};

/** Autofocus type.

This is the new UID value to notify change on autofocus type and takes immediate effect as previous UID KUidECamEventCameraSettingAutoFocusType has been deprecated.

@see KUidECamEventCameraSettingAutoFocusType */

static const TUid  KUidECamEventCameraSettingAutoFocusType2 		= {KUidECamEventCameraSettingAutoFocusType2UidValue};

/** 

ISO Rate type. 

This TUid is available from the following methods only to the API clients using CCamera::New2L() or CCamera::NewDuplicate2L():

void CCamera::CCameraAdvancedSettings::GetSupportedSettingsL(RArray<TUid>& aSettings) const;

void CCamera::CCameraAdvancedSettings::GetActiveSettingsL(RArray<TUid>& aActiveSettings) const;

void CCamera::CCameraAdvancedSettings::GetDisabledSettingsL(RArray<TUid>& aDisabledSettings) const;

*/

static const TUid  KUidECamEventCameraSettingIsoRateType 		= {KUidECamEventCameraSettingIsoRateTypeUidValue};

/** 

Reference Screen setting. 

This TUid is available from the following methods only to the API clients using CCamera::New2L() or CCamera::NewDuplicate2L():

void CCamera::CCameraAdvancedSettings::GetSupportedSettingsL(RArray<TUid>& aSettings) const;

void CCamera::CCameraAdvancedSettings::GetActiveSettingsL(RArray<TUid>& aActiveSettings) const;

void CCamera::CCameraAdvancedSettings::GetDisabledSettingsL(RArray<TUid>& aDisabledSettings) const;

*/

static const TUid  KUidECamEventCameraSettingReferenceScreen    = {KUidECamEventCameraSettingReferenceScreenUidValue};

/** 

Pre Capture Warning indication.

This TUid is available from the following methods only to the API clients using CCamera::New2L() or CCamera::NewDuplicate2L():

void CCamera::CCameraAdvancedSettings::GetSupportedSettingsL(RArray<TUid>& aSettings) const;

void CCamera::CCameraAdvancedSettings::GetActiveSettingsL(RArray<TUid>& aActiveSettings) const;

void CCamera::CCameraAdvancedSettings::GetDisabledSettingsL(RArray<TUid>& aDisabledSettings) const;

*/

static const TUid  KUidECamEventCameraSettingAFAssistantLight	= {KUidECamEventCameraSettingAFAssistantLightUidValue};

class CCameraContinuousZoom;

/**	

A mixin class to be implemented by the client in order to use the Continuous Zoom API. The callbacks are invoked by the implementation

whenever the continuous zoom operations are ready to be notified.

@see CCameraContinuousZoom

@internalTechnology

@prototype

*/	

class MContinuousZoomObserver

	{	

public:

	/**

	This callback is sent when a new zoom factor is achieved. Client may not receive a callback for every new zoom factor as it is up

	to the implementation to choose the zoom factors for which it will issue this callback. Should an error occur, this implies that the

	continuous zoom operation has been stopped.

	@param  aContinuousZoomHandle

			Reference to CCameraContinuousZoom class object which was used to start the continuous zoom operation.

	@param  aZoomFactor

		    The new zoom factor value, multiplied by KECamFineResolutionFactor, which has been achieved.

	@param  aError

			Appropriate error code.

	*/

	virtual void ContinuousZoomProgress(CCamera::CCameraContinuousZoom& aContinuousZoomHandle, TInt aZoomFactor, TInt aError)=0;

	/**

	Implementation sends this callback when the Continuous Zoom operation has been completed. This callback will be sent when

	target zoom factor is achieved. This zoom factor may in some cases be less than the target zoom factor due to the complexity

	of the continuous zoom operation. Once this callback is received, client need not issue StopContinuousZoom() and can call

	StartContinuousZoom() again.

	@param  aContinuousZoomHandle

			Reference to CCameraContinuousZoom class object which was used to start the continuous zoom operation.

	@param  aFinalZoomFactor

			The final zoom factor value once the continuous zoom operation has completed. This zoom factor may in some cases be

			less than the target zoom factor due to the complexity of the continuous zoom operation.

	@param  aErrorCode

			Appropriate error code.

	*/

	virtual void ContinuousZoomCompleted(CCamera::CCameraContinuousZoom& aContinuousZoomHandle, TInt aFinalZoomFactor, TInt aError)=0;

	/**

	Gets a custom interface for future callbacks. This method will be called by the implementation to get a new interface

	which would support future callbacks.

	@param  aInterface

		    The Uid of the particular interface function required for callbacks.

	@param  aPtrInterface

		    The implementation has to type-cast the retrieved custom interface pointer to the appropriate type.	

	@return The error code.

	*/

	virtual TInt CustomInterface(TUid aInterface, TAny*& aPtrInterface)=0;

	};

/** 

CCamera advanced settings class exposes an API for controlling individually 

digital camera advanced settings. These settings directly relate to the 

image acquisition phase both for still images and video.

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

       varieties of implementations.

@note   If the class methods leave, the output type parameter value is not guaranteed to be valid.

@publishedAll

@released

*/

class CCamera::CCameraAdvancedSettings : public CBase

	{

	/* so can use internal factory functions etc. */

	friend class CCamera;

public:

	/** Specifies camera type. */ 

	enum TCameraType

		{

		/** Unable to identify. */  

		ECameraUnknown 		= 0x00, 

		/** Camera is non-detachable from device. Camera is always present. */

		ECameraOnBoard	 	= 0x01,

		/** Camera is detachable from device. Camera is not always present. */

		ECameraPluggable 	= 0x02

		};

	/** Specifies stabilization mode of the camera. */

	enum TStabilizationMode

		{

		/** Not present or switched off, default */

		EStabilizationModeOff			= 0x00,

		/** Stabilization only in horizontal direction. */

		EStabilizationModeHorizontal	= 0x01,

		/** Stabilization only in vertical direction. */

		EStabilizationModeVertical		= 0x02,

		/** Rotational stabilization. */

		EStabilizationModeRotation		= 0x04,

		/** Automatic stabilization. */

		EStabilizationModeAuto			= 0x08,

		/** Manual stabilization. */

		EStabilizationModeManual		= 0x10   

		};

	/** Supported magnitudes of stabilization effect when in manual mode. */	

	enum TStabilizationEffect

		{

		/** Stabilization effect is off. */ 

		EStabilizationOff		= 0x00, 

		/** Stabilization effect is automatic, default. */

		EStabilizationAuto		= 0x01,

		/** Stabilization effect is very small in magnitude. */

		EStabilizationFine 		= 0x02,

		/** Stabilization effect is average in magnitude. */

		EStabilizationMedium	= 0x04,

		/** Stabilization effect is large in magnitude. */

		EStabilizationStrong	= 0x08

		};

	/** Supported stabilization algorithms, graded on complexity. */	

	enum TStabilizationAlgorithmComplexity

		{

		/** Stabilization algorithm selection is automatic, default. */ 

		EStabilizationComplexityAuto	= 0x00, 

		/** Stabilization algorithm is simple - less precise but fast. */

		EStabilizationComplexityLow		= 0x01,

		/** Stabilization algorithm is of medium complexity. */

		EStabilizationComplexityMedium	= 0x02,

		/** Stabilization algorithm is of high complexity. */

		EStabilizationComplexityHigh	= 0x04

		};

	/** Supported focus modes. */	

	enum TFocusMode

		{

		/** Focus mode is unknown. */ 

		EFocusModeUnknown	= 0x00, 

		/** Focus is automatic, default. */

		EFocusModeAuto		= 0x01,

		/** Focus is fixed. */

		EFocusModeFixed 	= 0x02,

		/** Focus is manually set. */

		EFocusModeManual	= 0x04

		};

	/** Supported focus ranges. */	

	enum TFocusRange

		{

		/** Auto. Default */

		EFocusRangeAuto 		= 0x00,

		/** Focus operates in close range (macro). */

		EFocusRangeMacro		= 0x01,

		/** Normal operation. */

		EFocusRangeNormal		= 0x02,

		/** Extended (tele) operation. */

		EFocusRangeTele			= 0x04,

		/** Focus at larger areas at short to medium distance. */

		EFocusRangePortrait		= 0x08,

		/** Optimised macro operation, 

		where depth of field is very shallow and observation area changes quickly. */

		EFocusRangeSuperMacro	= 0x10,

		/** 

		All objects at distances from half of the hyperfocal distance out to infinity will be in focus.

		This gives gives maximum depth of field.

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

		CCamera::NewDuplicate2L().

		*/ 

		EFocusRangeHyperfocal 	= 0x20,

		/** 

		When there is a near obstacle or better focus wanted for far away objects.

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

		CCamera::NewDuplicate2L().

		*/ 

		EFocusRangeInfinite		= 0x40

		};	

	/** Specifies the supported autofocus types. */

	enum TAutoFocusType

		{

		/** Autofocus is switched off. */

		EAutoFocusTypeOff	 		= 0x00,

		/** Operates on a single shot, consumes less power. */

		EAutoFocusTypeSingle	 	= 0x01,

		/** Continious autofocus, more precise but consumes more power. 

		    also known as AF Servo. */

		EAutoFocusTypeContinuous	= 0x02

		};

	/** Specifies the autofocus area. */

	enum TAutoFocusArea

		{

		/** Automatic. Default value */

		EAutoFocusTypeAuto				= 0x00,

		/** Single area, suitable for relatively flat surfaces and portrait. */

		EAutoFocusTypeSingleArea		= 0x01,

		/** Multiple points of an object, more weighting for centre points. */

		EAutoFocusTypeMultiAreaCentered	= 0x02

		};

	/** Specifies the Metering mode for the camera. 

	EMeteringModeAuto is the default value. */	

	enum TMeteringMode

		{

		/** Automatic mode, default. */	

		EMeteringModeAuto				= 0x0000, 

		/** Metering in which the center is given a weighted priority. */	

		EMeteringModeCenterWeighted		= 0x0001,

		/** Metering of a central area/spot only, also known as partial. */	

		EMeteringModeSpot				= 0x0002, 

		/** Metering is evaluated over a matrix(several spots) and calculated 

		    as a function of that. Usually best but with increased 

		    power consumption. Alternative name multi-metering mode. */	

		EMeteringModeEvaluative			= 0x0004

		};	

	/** Specifies the drive mode for the camera. This determines how and in what sucession are images 

    shot. EDriveModeSingleShot is the default.*/				

	enum TDriveMode

		{

		/** Automatic. Default */

		EDriveModeAuto				= 0x0000,

		/** Camera takes a single image/shot. */	

		EDriveModeSingleShot		= 0x0001,

		/** Camera continuously captures images (as fast as it can) until stopped or out of storage medium. */	

		EDriveModeContinuous		= 0x0002,

		/** Camera is in bracketing mode, producing individual frames. @see TBracketMode */	

		EDriveModeBracket			= 0x0004,

		/** Camera is in bracketing mode, but producing a single image. @see TBracketMode */	

		EDriveModeBracketMerge		= 0x0008,

		/** camera captures a single shot after specified time period. @see Timer() */	

		EDriveModeTimed				= 0x0010,

		/** Camera captures a set of images with an uniform interval between them. @see TimeLapse() */	

		EDriveModeTimeLapse			= 0x0020,

		/** Camera captures a set of images as fast as it can, but in batches(bursts). */	

		EDriveModeBurst				= 0x0040,

		/** Camera captures a set of images before and after camera capture key press event. Client can specify

		the amount of pre-capture and post-capture images to be saved via TDriveModeDependentAttributes.

		The total amount of images to be saved will be pre-capture images + 1 + post-capture images.

		@note This drive mode is only available to clients using the CCamera::New2L() or CCamera::NewDuplicate2L()

			  in addition to the new image capture APIs ie. CCameraPreImageCaptureControl, CCameraImageCapture and

			  CCameraPostImageCaptureControl.

		@publishedPartner

		@prototype

		*/

		EDriveModeTimeNudgeCapture	= 0x0080

		};

	/** Specifies Bracket mode. */				

	enum TBracketMode

		{

		/** Bracket mode is switched off. Default value. */	

		EBracketModeOff			= 0x0000,

		/** Bracket mode on. Three consecutive pictures are taken in order

			under (-1), on (0), over (+1), where correction magnitude 

			is defined by bracket step size and by TBracketParameter 

			@see TBracketStep

			@see TBracketParameter */	

		EBracketMode3Image		= 0x0001, 

		/** Bracket mode on. Five consecutive pictures are taken in order

			under (-2),under (-1), on (0), over (+1), over (+2), where correction magnitude 

			is defined by bracket step size and by TBracketParameter

			@see TBracketStep 

			@see TBracketParameter */	

		EBracketMode5Image		= 0x0002  

		};	

	/** Supported parameters used for bracketing.

	@note Bracket mode parameter value changes by 

	a selected uniform step between successive image shots. 

	@see TBracketStep 

	@see TBracketMode.	*/			

	enum TBracketParameter

		{

		/** None. */	

		EBracketParameterNone			= 0x0000,

		/** Exposure settings change. */	

		EBracketParameterExposure		= 0x0001,

		/** Flash power change. */		

		EBracketParameterFlashPower	    = 0x0002,

		/** Colour balance settings change. */		

		EBracketParameterColourBalance	= 0x0004,

		/** Aperture settings change. */

		BracketParameterAperture		= 0x0008, 

		/** Autofocus settings change. */ 

		BracketParameterAutoFocus		= 0x0010

		};

	/** Specifies the magnitude of bracketing step. 

	The actual value and availability is parameter dependent.

	@see TBracketParameter 

	*/				

	enum TBracketStep

		{

		/** Not supported. */

		EBracketStepNonConfig	= 0x00, 

		/** Small value. */	

		EBracketStepSmall		= 0x01,

		/** Medium value. */	

		EBracketStepMedium 	    = 0x02,

		/** Large value. */	

		EBracketStepLarge		= 0x04

		};

	/** Specifies the orientation of the picture. */		

	enum TPictureOrientation

		{

		/** No information about picture orientation. */	

		EPictureOrientationUnknown		= 0x00,

		/** Portrait - height larger than width. */	

		EPictureOrientationPortrait		= 0x01,

		/** Landscape width larger than height. */	

		EPictureOrientationLandscape	= 0x02,

		/** Square width equals the height. */	

		EPictureOrientationSquare		= 0x04

		};	

	/** Specifies the pixel aspect ratio  

	@note It is specified as a fraction of  

	(x) horizontal pixel size divided by vertical (y) pixel size. 

	The pixel aspect ratio for square pixels is 1/1. 

	*/		

	enum TPixelAspectRatio

		{

		/** Pixel ratio undetermined */

		EPixelAspectUnknown		= 0x00,

		/** Pixel Ratio 1:1. */	

		EPixelAspect1To1		= 0x01,

		/** Pixel Ratio 12:11 */	

		EPixelAspect12To11		= 0x02,

		/** Pixel Ratio 11:10. */	

		EEPixelAspect11To10		= 0x04,

		/** Pixel Ratio 59:54. */	

		EEPixelAspect59To54		= 0x08,

		/** Pixel Ratio 16:11.

		    @note This value is available only to the API clients using CCamera::New2L() or CCamera::NewDuplicate2L()

		*/	

		EEPixelAspect16To11		= 0x10,

		/** Pixel Ratio 10:11.

		    @note This value is available only to the API clients using CCamera::New2L() or CCamera::NewDuplicate2L()

		*/	

		EEPixelAspect10To11		= 0x20,		

		/** Pixel Ratio 40:33. 

		    @note This value is available only to the API clients using CCamera::New2L() or CCamera::NewDuplicate2L()

		*/	

		EEPixelAspect40To33		= 0x40

		};

	/** Specifies YUV colour space dynamic range. 

	@note video compressors often use narrower than the default range.

	The nominal Y range is [16:235] and the U and V ranges [16:240]. 

	*/		

	enum TYuvRange

		{

		/** Yuv range undetermined */

		EYuvRangeUnknown		= 0x00,

		/** Yuv Full Range. The nominal Y,U and V colours range is [0:255].  */	

		EYuvRangeFull			= 0x01,

		/** Yuv Cropped Range. The nominal Y range is [16:235] and the U and V ranges [16:240]. */	

		EYuvRangeVideoCropped	= 0x02

		};

	/** Specifies the units supported by the camera for manual white balance setting. 

	 */				

	enum TWBUnits

		{

		/** The units type is undetermined or not supported. */ 

		EWBUnknown,

		/** The white balance is represented as temperature degrees in Kelvin. */   	

		EWBColorTemperature,

		/** The white balance is represented as RGB triples.  */ 

		EWBRgb

		};

	/** 

	Specifies the ISO type supported by the camera. ISO refers to the sensivity of the 

	image sensor and is one of the factors influencing the exposure.

	*/		

	enum TISORateType

		{

		/** ISO Not supported. Camera uses a fixed ISO rate internally and never reveals this information. */

		EISONone						 = 0x00,

		/** Camera gives a list of manual ISO rates to the user to set. Recommendation is to start camera in the manual ISO mode, by default. */

		EISOManual 						 = 0x01,

		/** Camera chooses the ISO on its own without prioritising any particular exposure parameters. */

		EISOAutoUnPrioritised 			 = 0x02,	

		/** Camera chooses the ISO on its own by prioritising ISO. */

		EISOAutoISOPrioritised 		 	 = 0x04,	

		/** Camera chooses the ISO on its own after prioritising shutter speed. */

		EISOAutoShutterSpeedPrioritised  = 0x08,

		/** Camera chooses the ISO on its own after prioritising aperture opening. */	

		EISOAutoAperturePrioritised 	 = 0x10	

		};

	/** 

	Specifies the unfavourable circumstances as pre capture warnings which may be issued before image/video capture. 

	*/	

	enum TPreCaptureWarning

		{

		/** No warnings */

		EPCWNone 						= 0x0000,

		/** warning to indicate that camera sensor is over exposed */

		EPCWOverExposure 				= 0x0001,

		/** warning to indicate that camera sensor is under exposed */

		EPCWUnderExposure 				= 0x0002,

		/** warning to indicate that camera operates under insufficient lightning conditions */

		EPCWLowLight 					= 0x0004,

		/** warning to indicate that focussing is not optimum. This is valid for manual/fixed focus only */

		EPCWBadFocus 					= 0x0008, 

		/** warning to indicate that camera might not be firmly gripped (Tripod required). This is same as long exposure */ 

		EPCWHandShakePossible 			= 0x0010,  

		/** warning to indicate that camera has not enough power to survive the flash operations (battery discharged) */

		EPCWNotEnoughPowerForFlash 		= 0x0020,

		/** warning to indicate that the current white balance is not the desired one */

		EPCWWrongWhiteBalanceValue 		= 0x0040,

		/** warning to indicate that the current flash value is not the desired one */

		EPCWWrongFlashValue 			= 0x0080,

		/** warning to indicate that the current digital zoom value is not the desired one */

		EPCWWrongDigiZoomValue 			= 0x0100,

		/** warning to indicate that the desired digital zoom affects the quality of image */

		EPCWDigiZoomBadQuality        	= 0x0200, 

		/** warning to indicate that flash is not ready. Recommendation: user may subscribe for this warning or issue 

		IsFlashReady() also. Using both options is not encouraged */

		EPCWFlashNotReady				= 0x0400,

		/** unknown reason */

		EPCWGeneralWarning 				= 0x0800,

		/** warning to indicate that flash has been overheated.

		@note This value is available only to the API clients using CCamera::New2L() or CCamera::NewDuplicate2L()

		@publishedPartner

		@prototype

		*/

		EPCWFlashOverheated				= 0x1000,

		/** warning to indicate that flash will not be fired because of enough ambient light.

		@note This value is available only to the API clients using CCamera::New2L() or CCamera::NewDuplicate2L()

		@publishedPartner

		@prototype

		*/

		EPCWFlashNotNeeded				= 0x2000

		};

	/**

	Describes the camera mode.

	*/	

	enum TCameraMode

		{

		/** Camera is Idle */

		EModeIdle				= 0x00,

		/** DSA based Viewfinder runs */

		EModeDSAViewFinder		= 0x01,

		/** Client based Viewfinder runs */

		EModeClientViewFinder	= 0x02		

		};

	/** 

	Specifies the different types of auto focus assistant light	

	*/

	enum TAFAssistantLight

		{

		/** switch off the AF assistant light from either of 'manual on' or 'auto' mode */

		EAFAssistantLightOff 			= 0x00, 

		/** switch on the AF assistant light manually */

		EAFAssistantLightManualOn 		= 0x01,

		/** Put the AF assistant light in auto mode. It will be automatically decided when to switch on or off. */

		EAFAssistantLightAuto 			= 0x02

		};

	/**

	Specifies the different types of continuous zoom supported.

	The enumeration list may be extended in future.

	@publishedPartner

	@prototype

	*/

	enum TContinuousZoomType

		{

		/** Continuous zoom not supported */

		EContinuousZoomNotSupported		= 0x00,

		/** Continuous zoom 'Optical' only, No 'Digital' */

		EContinuousZoomOpticalOnly		= 0x01,

		/** Continuous zoom 'Optical' and 'Digital' */

		EContinuousZoomMixed			= 0x02,

		/** Continuous zoom 'Digital' only, No 'Optical' */

		EContinuousZoomDigitalOnly		= 0x04

		};

	/**

	Specifies the zoom direction for continuous zoom operation. 

	The enumeration list may be extended in future.

	@publishedPartner

	@prototype

	*/	

	enum TZoomDirection

		{

		/** Implies that feature not supported. */

		EZoomDirectionNone		=0x00,

		/** Implies zooming out. */

		EZoomDirectionWide		=0x01,

		/** Implies zooming in. */

		EZoomDirectionTele		=0x02

		};

	/**

	Different levels for performance vectors like speed, quality, low memory consumption and low power consumption.

	The enumeration list may be extended in future.

	@publishedPartner

	@prototype

	*/	

	enum TPerformanceLevel

		{

		/** High level preference. */

		ELevelHigh			= 1,

		/** Medium level preference. */

		ELevelMedium		= 2,

		/** Low level preference. */

		ELevelLow			= 3,

		/** Dont care (No preference). */

		ELevelDontCare		= 4

		};

	/**

	Specifies flicker removal options.

	The enumeration list may be extended in future. 

	@internalTechnology

	*/

	enum TFlickerRemoval

		{

		/** Not Supported. */

		EFlickerRemovalNone  		= 0x00,

		/** Flicker removal for Field frequency of 50Hz. */

		EFlickerRemoval50Hz 		= 0x01,

		/** Flicker removal for Field frequency of 60Hz. */

		EFlickerRemoval60Hz			= 0x02,

		/** Auto flicker removal. */

		EFlickerRemovalAuto 		= 0x04,

		/** Switch Off flicker removal. */

		EFlickerRemovalSwitchOff   	= 0x08

		};

	/**

	Specifes the type of neutral density filters available. 

	The enumeration list may be extended in future.

	@internalTechnology

	*/

	enum TNDFilter

		{

		/** Not Supported. */

		ENDFilterNone  			= 0x00,

		/** Auto ND Filter. */

		ENDFilterAuto	  		= 0x01,

		/** Switched off ND Filter. */

		ENDFilterSwitchedOff	= 0x02,

		/** High level ND Filter. */

		ENDFilterHigh	 		= 0x04,

		/** Medium level ND Filter. */

		ENDFilterMedium	   		= 0x08,

		/** Low level ND Filter. */

		ENDFilterLow			= 0x10,

		/** General ND Filter. */

		ENDFilterGeneral		= 0x20

		};

	/**

	Specifies the various events for which the LED effects could be used.

	The enumeration list may be extended in future.

	@internalTechnology

	*/

	enum TLEDEvent

		{

		/** Not supported. */

		ELEDEventNone 				= 0x00,

		/** LED effect needed for self timer. */

		ELEDEventSelfTimer 			= 0x01,

		/** LED effect needed for starting of viewfinder. */

		ELEDEventViewfinderStart 	= 0x02,

		/** LED effect needed for stoping of viewfinder. */

		ELEDEventViewfinderStop		= 0x04,

		/** LED effect needed for still image capture. */

		ELEDEventStillImageCapture	= 0x08,

		/** LED effect needed for video recording. */

		ELEDEventVideoRecording		= 0x10

		};

	/**

	Specifes the type of LED effects available. 

	The enumeration list may be extended in future.

	@internalTechnology

	*/

	enum TLEDEffect

		{

		/** Not supported. */

		ELEDEffectNone				=0x00,

		/** LED always on. */

		ELEDEffectHardwired			=0x01,

		/** LED auto. */

		ELEDEffectAuto				=0x02,

		/** LED Effect manually switched on. */

		ELEDEffectManualSwitchOn	=0x04,

		/** LED Effect switched off. */

		ELEDEffectSwitchOff			=0x08,

		/** LED Custom Effect. */

		ELEDEffectCustom			=0x10

		};

	/**

	Color channels on which manual gain can be selectively applied.

	The enumeration list may be extended in future.

	@internalTechnology

	*/	

	enum TColorChannel

		{

		/** Red Color Channel (RGB model). */

		EColorChannelRed,

		/** Green Color Channel (RGB model). */

		EColorChannelGreen,

		/** Blue Color Channel (RGB model). */

		EColorChannelBlue,

		/** Luminance Y component (YUV model). */ 

		EChannelLumaY,

		/** Chrominance U component (YUV model). */ 

		EChannelChromaU,

		/** Chrominance V component (YUV model). */ 

		EChannelChromaV

		};

	/**

	Class used to provide a particular custom LED effect.

	@internalTechnology

	*/

	class TECamLEDSpecialEffectStep

	{

	public:

		TECamLEDSpecialEffectStep();

		TUint Size() const;

		TUint Version() const;

	private:

		//for future expansion

		TUint iSize:24;

		TUint iVersion:8;

		// reserved for future expansion.

		TInt iReserved1;

		TInt iReserved2;

		TInt iReserved3;

	public:

		/** Blinking frequency of LED in Hertz. */

		TUint iBlinkingFrequency;

		/** Represents the intensity of LED in millicandela. */

		TUint iIntensity;

		/** Frequency step with which the blinking frequency changes with time. May be positive as well as negative. */

		TInt iFrequencyStep;

		/** Time duration for which the particular LED special effect step would be valid. */

		TTimeIntervalMicroSeconds32 iDuration;

	};

	/**

	Class used to provide supported continuous zoom information.

	@internalTechnology

	@prototype

	*/

	class TContinuousZoomSupportInfo

		{