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

 @publishedPartner

 @released

*/

#ifndef  ECAMCAPTURECONTROLINTF_H

#define  ECAMCAPTURECONTROLINTF_H

#include <ecamcapturecontrol.h>

#include <ecam/ecamadvsettingsintfuids.hrh>

class MImplementationFactory;

/** 

This is the UID which is used to obtain the interface MCameraPreImageCaptureControl, via the 

CCamera::CustomInterface() call, which provides implementation of the M-class interface.

@publishedPartner

@prototype

*/   

static const TUid KECamMCameraPreImageCaptureControlUid		=  {KECamMCameraPreImageCaptureControlUidValue};

/** 

This is the UID which is used to obtain the interface MCameraImageCapture, via the 

CCamera::CustomInterface() call, which provides implementation of the M-class interface.

@publishedPartner

@prototype

*/   

static const TUid KECamMCameraImageCaptureUid		=  {KECamMCameraImageCaptureUidValue};

/** 

This is the UID which is used to obtain the interface MCameraPostImageCaptureControl, via the 

CCamera::CustomInterface() call, which provides implementation of the M-class interface.

@publishedPartner

@prototype 

*/   

static const TUid KECamMCameraPostImageCaptureControlUid	=  {KECamMCameraPostImageCaptureControlUidValue};

/** 

This is the UID which is used to obtain the interface MCameraVideoCaptureControl, via the 

CCamera::CustomInterface() call, which provides implementation of the M-class interface. 

@publishedPartner

@prototype

*/   

static const TUid KECamMCameraVideoCaptureControlUid 	=  {KECamMCameraVideoCaptureControlUidValue};

/** 

Mixin class for implementation by providers of the PreImageCaptureControl Camera Extension API.

PreImageCaptureControl class exposes an API for controlling advanced still image related settings and control prior

to capturing the images.

@publishedPartner

@prototype 

*/	

class MCameraPreImageCaptureControl

	{

public:

	/** 

	Releases the interface. 

	*/

	virtual void Release()=0;

	/**

	The observer for the pre image capture control is passed to the implementation for passing callbacks on it.

	@param  aPreImageCaptureControlObserver

			The reference to the pre image capture control observer.

	*/

	virtual void SetPreImageCaptureControlObserver(MPreImageCaptureControlObserver& aPreImageCaptureControlObserver)=0;

	/**

	Retrieves information regarding the direct snapshot feature support. Direct Snapshot, if supported, can be created

	out of version2 direct viewfinder object only.

	@param  aDirectSnapshotSupportInfo

			This is a bit field providing supported direct snapshot of type TDirectSnapshotType

	@leave  May leave with any error code.

	*/

	virtual void GetDirectSnapshotSupportInfoL(TUint& aDirectSnapshotSupportInfo) const=0;

	/**

	Retrieves the settings supported for embedded still captures. Possibilty exists that not all the settings supported for

	normal still image captures are supported for embedded still captures as well.

	@param  aSupportedEmbeddedStillCaptureSettings

			Array of TUid which retrieves the supported embedded still captures. Empty list indicated that no settings are

			supported for embedded still captures.

	@leave  May leave with any error code.

	*/

	virtual void GetSupportedEmbeddedStillCaptureSettingsL(RArray<TUid>& aSupportedEmbeddedStillCaptureSettings) const=0;

	/**

	Retrieves information regarding the supported direct saving state. If used, still images are saved in files rather than 

	providing clients the MCameraImageBuffer. Direct saving to file will continue even if the client application gets closed

	for any reasons.

	@param  aSupportedDirectSavingType

			Retrieves the enum specifying supported TDirectSavingType.

			If EDirectSavingNotUsed, direct saving not supported. Images will be received in buffer MCameraImageBuffer.

			If EDirectSavingHighResolutionFileOnly, direct saving to file is supported. But no cut down version of the image 

			will be saved to file. Callback used is MCaptureImageObserver::ImageDirectSavingCompleted().

			If EDirectSavingWithLowerResolutionFile, Direct saving to file is supported. Also, a cut down version of the image 

			will be saved to another specified file. Callbacks used are MCaptureImageObserver::ImageDirectSavingCompleted()

			for actual image and MCaptureImageObserver::CutDownImageDirectSavingCompleted() for lower resolution image.

	@leave  May leave with any error code.	

	*/

	virtual void GetSupportedDirectSavingTypeL(CCamera::CCameraPreImageCaptureControl::TDirectSavingType& aSupportedDirectSavingType) const=0;

	/**

	Provides the base name for file used to save images. If there are sequential images, files will be created by 

	implementation with names appearing as base name and appended by increasing integers which would start from 

	aStartingSequenceNumber. This is used for the original image only, but not for the cut down version of the original

	image.

	@param  aFilename

			A const TDesC8&: Base name for files which ECam implementation needs to create in order to collect every sequential

			image.

	@param  aStartingSequenceNumber

			The starting sequence number which will be appended to the base name 'aFilename'. The sequence number will keep

			on increasing for every individual still image capture.

	@leave  May leave with any error code.

	@note   It is upto the implementation how many digits it uses for sequence number. Accordingly, padding will be done with 

			zeroes.

	*/

	virtual void SetSequentialImageFilenameL(const TDesC8& aFilename, TInt aStartingSequenceNumber)=0;

	/**

	Provides the base name for file used to save cut down version of the original images. If there are sequential images, 

	files will be created by implementation with names appearing as base name and appended by increasing integers which would 

	start from aStartingSequenceNumber. This is used for the cut down version of the original image.

	@param  aLowerResolutionFilename

			A const TDesC8&: Base name for files which ECam implementation needs to create in order to collect the cut down version

			of every sequential image.

	@param  aStartingSequenceNumber

			The starting sequence number which will be appended to the base name 'aFilename'. The sequence number will keep

			on increasing for every individual still image capture.

	@leave  May leave with any error code.

	@note   It is upto the implementation how many digits it uses for sequence number. Accordingly, padding will be done with 

			zeroes.

	*/

	virtual void SetLowerResolutionSequentialImageFilenameL(const TDesC8& aLowerResolutionFilename, TInt aStartingSequenceNumber)=0;

	/**

	Retrieves the type of direct saving currently used. This will be represented as a direct saving state as given by 

	TDirectSavingType. 

	Whether or not the direct saving option is used, client will receive the MCaptureImageObserver::ImageCaptureComplete() 

	callback to mark the completion of the image capture operation.

	@param  aDirectSavingType

			Current type of the direct saving. 

			If EDirectSavingNotUsed, direct saving is not used. Images will be received in buffer MCameraImageBuffer through

			callback MCaptureImageObserver::ImageBufferReady().

			If EDirectSavingHighResolutionFileOnly, direct saving to file option is currently used. But no cut down version of

			the image will be saved to file. Callback used is MCaptureImageObserver::ImageDirectSavingCompleted().

			If EDirectSavingWithLowerResolutionFile, apart from direct saving to file option for the actual image, a cut down 

			version of the image will be saved to another specified file. Callbacks used are MCaptureImageObserver::

			ImageDirectSavingCompleted() for actual image and MCaptureImageObserver::CutDownImageDirectSavingCompleted() 

			for lower resolution image.

	@leave  May leave with any error code.

	@note   Direct saving to file will continue even if the client application gets closed for any reasons.

	*/

	virtual void GetDirectSavingTypeL(CCamera::CCameraPreImageCaptureControl::TDirectSavingType& aDirectSavingType) const=0;

	/**

	Instructs the ECam implementation to use the desired type of direct saving option as specifed by its state.

	Whether or not the direct saving option is used, client will receive the MCaptureImageObserver::ImageCaptureComplete() 

	callback to mark the completion of the image capture operation.

	@param  aDirectSavingType

			The desired type of the direct saving. 

			If EDirectSavingNotUsed, direct saving will not be used. Images will be received in buffer MCameraImageBuffer 

			through	callback MCaptureImageObserver::ImageBufferReady().

			If EDirectSavingHighResolutionFileOnly, direct saving to file option will be used. But no cut down version of

			the image will be saved to file. Callback to be used is MCaptureImageObserver::ImageDirectSavingCompleted().

			If EDirectSavingWithLowerResolutionFile, apart from direct saving to file option for the actual image, a cut down 

			version of the image will be saved to another specified file. Callbacks to be used are MCaptureImageObserver::

			ImageDirectSavingCompleted() for actual image and MCaptureImageObserver::CutDownImageDirectSavingCompleted()

			for lower resolution image.

	@leave  May leave with any error code.

	@note   Clients need to provide the filename before capturing still images under direct saving option. Callback 

			MCaptureImageObserver::ImageDirectSavingCompleted() may provide error KErrNotReady if filenames are not 

			provided before images are captured for direct saving. Similarly, if cut down version of image is also to be 

			saved to file, MCaptureImageObserver::CutDownImageDirectSavingCompleted() may provide error KErrNotReady if 

			filenames are not provided before hand.

	@note   Direct saving to file will continue even if the client application gets closed for any reasons.

	*/

	virtual void SetDirectSavingTypeL(CCamera::CCameraPreImageCaptureControl::TDirectSavingType aDirectSavingType)=0;

 	/**

	Retrieves whether the camera device is capable of providing capture event notification to the client. Client may take

	the responsibility of playing the capture sound after receiving the notification. 

	@param  aSupportedDriveModes

			A reference to bit-field of TUint which indicates the drive modes in which the capture event notification is

			supported. If aSupportedDriveModes =0, capture event notification is not supported.

	@note   If capture event notification is supported, ECam implementation will use KUidECamEventImageCaptureEvent to notify 

			clients that the image has been exposed to the camera sensor. Clients may play capture sound if they desire to do so.

	@leave  May leave with any error code.

	@see    CCamera::CCameraAdvancedSettings::TDriveMode	

	*/

	virtual void GetCaptureEventSupportInfoL(TUint& aSupportedDriveModes) const=0;

	/**

	Retrieves the supported image formats for a given resolution.

	@param  aImageFormatsSupported

			A bit field which retrieves the supported image formats for a given resolution.

			Formats have been defined as CCamera::TFormat

	@param  aSize

			The resolution (or size) for which the total number of supported image formats have to be retrieved.

	@leave  May leave with any error code.

	*/

	virtual void GetImageFormatsSupportedL(TUint& aImageFormatsSupported, const TSize& aSize) const=0;

	/**

	Retrieves the supported pixel aspect ratio for a given resolution in case of still image.

	@param  aPixelAspectsSupported

			A bit field which retrieves the supported pixel aspect ratio for a given resolution.

			Pixel aspect ratio have been defined as CCamera::CCameraAdvancedSettings::TPixelAspectRatio

	@param  aImageFormat

			The image format for which the supported pixel aspect ratio have to be retrieved.

	@param  aSize

			The resolution (or size) for which the supported pixel aspect ratio have to be retrieved.

	@leave  May leave with any error code.

	*/

	virtual void GetPixelAspectsSupportedL(TUint& aPixelAspectsSupported, CCamera::TFormat aImageFormat, const TSize& aSize) const=0;

	/**

	Performs setup and allocation of memory for image capture operation. Implementation creates a new CCameraImageCapture*

	object which reflects the prepare image parameters passed by the client. The callback MPreImageCaptureControlObserver::

	PrepareImageComplete() passes the ownership of the CCameraImageCapture* object to the client.

	This needs to be called every time client wishes to change prepare image parameters or if the client wishes to create

	a new CCameraImageCapture* object. 

	@param  aPrepareImageParameters 

	        The desired image parameters to be used for capturing still images using the CCameraImageCapture instance

	        which would be passed by the implementation.

	@param  aCaptureImageObserver

			The Capture image observer which is needed by the implementation in order to pass it to the 

			CCameraImageCapture while creating it.

	@note 	Next PrepareImageCapture can be called only after receiving the notification KUidECamEventReadyForNextPrepare.

	@note   Implementation will call CCameraImageCapture::CreateL(CCamera& aCamera, MCaptureImageObserver& 

			aCaptureImageObserver) method and pass the CCameraImageCapture* to the client through the 

			MPreImageCaptureControlObserver::PrepareImageComplete() callback.

	@note	If drive mode is EDriveModeTimeNudgeCapture the ECam implementation will immediately begin capturing images after

			creating a new CCameraImageCapture object. Once the client initiates image capture, the total amount of images

			requested by the client	(specified by the client in	TDriveModeDependentAttributes) will be returned to the client

			(via MCaptureImageObserver::ImageBufferReady())	or saved to file. The implementation should not create another

			instance of CCameraImageCapture whilst using this drive mode until the first instance is destroyed by the client.

	@see 	CCamera::PrepareImageCaptureL(TFormat aImageFormat,TInt aSizeIndex)

	*/

	virtual void PrepareImageCapture(const CCamera::CCameraPreImageCaptureControl::TPrepareImageParameters& 

											aPrepareImageParameters, MCaptureImageObserver& aCaptureImageObserver)=0;

	/**

	Informs whether or not the setting of maximum memory size when encoding to the current format is supported.

	@param  aIsImageMaxMemorySizeSettingSupported

			ETrue indicates that setting of maximum memory size is supported.

			EFalse indicates that setting of maximum memory size is not supported.

	@leave  May leave with any error code.

	*/

	virtual void GetImageMaxMemorySizeSettingSupportInfoL(TBool& aIsImageMaxMemorySizeSettingSupported) const=0;

	/**

	Get the maximum memory size in kilo bytes when encoding to the current format.

	@param  aMemorySize

			Retrieves the maximum memory size in kilo bytes.

	@note   In case of JPEG, the maximum memory size will take preference over JPEG quality if the maximum memory size is 

			not sufficient to achieve the desired quality. Refer CCamera::JpegQuality()

	@leave  May leave with any error code.

	*/

	virtual void GetImageMaxMemorySizeL(TUint& aMemorySize) const=0;

	/**

	Retrieves the supported processing options.

	@param  aEcamProcessingOptionsSupported

			Bitfield containing the available processing options.

	@leave  May leave with error code.

	*/

	virtual void GetSupportedProcessingOptionsL(TUint& aEcamProcessingOptionsSupported) const=0;

	};

/** 

Mixin class for implementation by providers of the ImageCapture Camera Extension API. 

CameraImageCapture class exposes an API for capturing the image and controlling the overall capture.

This class also provides concrete implementation of API exposed by CCameraPostImageCaptureControl.

CameraPostImageCaptureControl class exposes an API for retrieving the image data from individual images (in case 

continuous drive mode is used for capturing the images) and also to apply control on the captured images individually.

@publishedPartner

@prototype 

*/	

class MCameraImageCapture

	{

public:

	/** 

	Releases the interface. 

	@param  aCameraImageCapture

			The pointer to the image capture class object which would be destroyed by the client.

	*/

	virtual void Release(CCamera::CCameraImageCapture* aCameraImageCapture)=0;

	/**

	Retrieves the concrete factory handle for the histogram implementation in order to use it specifically for a

	specific still image capture.

	@param  aImplFactoryPtr

		    The concrete factory handle for the histogram implementation specific to the still image capture.

	@leave  May leave with any error code.

	*/

	virtual void CreateHistogramImplFactoryL(MImplementationFactory*& aImplFactoryPtr) const=0;

	/**

	Retrieves the concrete factory handle for the snapshot implementation in order to 

	use it specifically for a specific still image capture.

	@param  aImplFactoryPtr

		    The concrete factory handle for the snapshot implementation specific to the still image capture.

	@leave  May leave with any error code.

	*/

	virtual void GetSnapshotImplFactoryL(MImplementationFactory*& aImplFactoryPtr) const=0;

	/**

	Retrieves the concrete factory handle for the image processing implementation in order to use it specifically for 

	a specific still image capture.

	@param  aImplFactoryPtr

		    The concrete factory handle for the image processing implementation specific to the still image capture.

	@leave  May leave with any error code.

	*/

	virtual void GetImageProcessingImplFactoryL(MImplementationFactory*& aImplFactoryPtr) const=0;

	/**

	The observer for the image capture is passed to the implementation for passing callbacks on it.

	@param  aCaptureImageObserver

			The reference to the capture image observer.

	*/

	virtual void SetCaptureImageObserver(MCaptureImageObserver& aCaptureImageObserver)=0;	

	/**

	Retrieves the prepare image parameters tied with this image capture class object.

	@param aPrepareImageParameters

		   TPrepareImageParameters tied with this image capture class object.

	@leave May leave with any error code

	*/

	virtual void GetPrepareImageParametersL(CCamera::CCameraPreImageCaptureControl::TPrepareImageParameters& aPrepareImageParameters) const=0;

	/**

	The prepare image parameters needed to capture images using the particular capture image class object.

	@param aPrepareImageParameters

		   The prepare image parameters used to capture images.

	*/

	virtual void SetPrepareImageParameters(const CCamera::CCameraPreImageCaptureControl::TPrepareImageParameters& aPrepareImageParameters)=0;

	/**

	Provides the interface pointers for the concrete implementation of CCameraPostImageCaptureControl.

	Every time this method is called, a newly created interface is provided since it represents the individual image.

	The ID maps the individual image with the CCameraPostImageCaptureControl instance and may also be stored by the 

	concrete implementation of CCameraPostImageCaptureControl.	

	@param  aInterface

			The uid representing the interface required.

	@param  aPostCaptureControlId

			The ID which maps the individual image with the CCameraPostImageCaptureControl object. This may be stored

			by the concrete implementation of CCameraPostImageCaptureControl.

	@return Interface pointer. 

	@note   It is this implementation which creates/owns CCameraPostImageCaptureControl class object after receiving image

			capture	requests by the client. Implementation may store all such mappings between aPostCaptureControlId and 

			CCameraPostImageCaptureControl* for a particular instance of CCameraImageCapture. 

	*/

	virtual TAny* CreatePostImageCaptureControlImpl(TUid aInterface, TPostCaptureControlId aPostCaptureControlId)=0;

	/**

	Performant image capture. This postpones the processing options involved with current image captured in order to 

	capture/prepare for next images. 

	Previously created CCameraPostImageCaptureControl objects for this CCameraImageCapture object will become unavailable 

	after this call.

	@param  aCameraImageCapture

			Pointer to aCameraImageCapture. This will be used by the implementation in order to pass in callbacks and to

			create CCameraPostImageCaptureControl object for every image and pass it to the client. Implementation is not

			supposed to not destroy this object.

	@note   Further images (either still or video) can be captured only after receiving the notification 

			KUidECamEventReadyForNextCapture. Current image may be outstanding in order to undergo any processing options.

	@note   Callback MCaptureImageObserver::ImageCaptureComplete() informs the client that the image capture operation has 

			been completed. The CCameraImageCapture& can be further used for next image captures.

			In case of continuous drive modes, this callback will be received by the client only once in order to provide the 

			result of the whole image capture operation. 

	@note   Callback MCaptureImageObserver::ImageBufferReady() provides client the link to CCameraPostImageCaptureControl& 

			which helps retrieving the image buffer. In case of continuous drive modes, this callback will be received by the

			client for every individual image. In case of single shots, this will be received by the client only once in 

			order to retrieve the image buffer.

	*/	

	virtual void CaptureImage(CCamera::CCameraImageCapture* aCameraImageCapture)=0;

	/**

	Cancels the outstanding Capture Image operation. This will also cancel any outstanding processing options associated

	with the concerned Capture Image operation. This method is synchronous. Hence, no callback shall be issued for the 

	concerned capture image operation.

	*/

	virtual void CancelCaptureImage()=0;

	/**

	Retrieves the number of images exposed to sensor with respect to a specific image capture command. Any Processing

	options associated with these images may be pending.

	@param  aNumImagesExposed

			Retrieves the number of images exposed to sensor till now. For single shot type of drive modes, this value will

			be one after the image gets exposed to sensor. For multiple shot type of drive modes, this value will be the 

			number of images exposed till now.

	@note   May leave with any error code.

	*/

	virtual void GetNumImagesExposedL(TUint& aNumImagesExposed) const=0;

	/**

	Retrieves the total number of images which is supposed to be captured with respect to a specific image capture command. 

	@param  aNumTotalImages

			Retrieves the total number of images supposed to be captured. For single shot type of drive modes, this value 

			will be	always be one. For multiple shot type of drive modes, this value will be greater than one.

	@note   May leave with any error code.

	*/

	virtual void GetNumTotalImagesL(TUint& aNumTotalImages) const=0;

	/**

	Retrieves the post capture control handle based on the ID passed to it. Client may use this handle for post capture 

	operations of the image identified by the ID. The ID is received by the clients through MCaptureImageObserver callbacks.

	@param  aPostCaptureControlHandle

			Retrieves pointer to the post capture control class object.

	@param  aPostCaptureControlId

			The ID used to retrieve the post capture control handle of the captured image.

	@note   May leave with any error code.

	@note   It is this implementation which creates/owns CCameraPostImageCaptureControl class object after receiving image

			capture	requests by the client. Implementation may store all such mappings between aPostCaptureControlId and 

			CCameraPostImageCaptureControl* for a particular instance of CCameraImageCapture. 

	*/	

	virtual void GetPostCaptureControlHandleL(CCamera::CCameraPostImageCaptureControl*& aPostCaptureControlHandle, 

																TPostCaptureControlId aPostCaptureControlId) const=0;

	/**

	Prioritises the Capture Image operation. This implies that the processing options associated with the concerned 

	Capture	Image operation will be prioritised over other pending processing options.

	@param  aCaptureImagePriority

			The desired level of priority.

	@leave  May leave with any error code.

	*/

	virtual void SetCaptureImagePriorityL(TECamImagePriority aCaptureImagePriority)=0;

	/**

	Retrieves the priority of the Capture Image operation.

	@param  aCaptureImagePriority

			Retrieves the current level of priority.

	@leave  May leave with any error code.

	*/

	virtual void GetCaptureImagePriorityL(TECamImagePriority& aCaptureImagePriority) const=0;

	/**

	Pauses processing options associated with the concerned Capture Image operation.

	@param  aProcessingTypes

			The processing options which need to be paused.

	*/

	virtual void PauseProcessing(TUint aProcessingTypes)=0;

	/**

	Resumes processing options associated with the concerned Capture Image operation.

	@param  aProcessingTypes

			The processing options which need to be resumed.

	@leave May leave with any error code.

	*/

	virtual void ResumeProcessingL(TUint aProcessingTypes)=0;

	};

/** 

This mixin class provides concrete implementation of API exposed by CCameraPostImageCaptureControl.

CameraPostImageCaptureControl class exposes an API for retrieving the image data from individual images (in case 

continuous drive mode is used for capturing the images) and also to apply control on the captured images individually.

@publishedPartner

@prototype 

*/	

class MCameraPostImageCaptureControl

	{

public:

	/** 

	Releases the interface. 

	@param  aPostCaptureControlId

			The ID useful to indentify the post capture control handle of the captured image being deleted.

	*/

	virtual void Release(TPostCaptureControlId aPostCaptureControlId)=0;

	/**

	Retrieves the sequence number of the image being represented by this post capture control object. The sequence number

	specifies the index of the individual image if, in case, the multiple shot type of drive mode is being used. The first 

	individual image which is exposed to the sensor has a sequence number of zero. In case of single shot type of drive mode,

	the sequence number will be zero.

	@param  aSequenceNumber

			Retrieves the sequence number of the image.

	@leave  May leave with any error code.

	*/

	virtual void GetImageSequenceNumberL(TUint& aSequenceNumber) const=0;

	/**

	CCancels the outstanding individual image which the object of this class is referring to. This will also cancel any outstanding 

	processing options associated with this individual image. This method is synchronous. Hence, no callback shall be 

	issued for this individual image.

	*/

	virtual void CancelImage()=0;

	/**

	Prioritises the individual image which the object of this class is referring to. This implies that any processing

	options associated with this individual image will be prioritised over other pending processings options.

	@param  aImagePriority

			The desired level of priority.

	@leave  May leave with any error code.

	*/

	virtual void SetImagePriorityL(TECamImagePriority aImagePriority)=0;

	/**

	Retrieves the priority of the individual image which the object of this class is referring to.

	@param  aImagePriority

			The current level of priority.

	@leave  May leave with any error code.

	*/

	virtual void GetImagePriorityL(TECamImagePriority& aImagePriority) const=0;

	/**

	Pauses processing options associated with the concerned Capture Image operation.

	@param  aProcessingTypes

			The processing options which need to be paused.

	*/

	virtual void PauseProcessing(TUint aProcessingTypes)=0;

	/**

	Resumes processing options associated with the concerned Capture Image operation.

	@param  aProcessingTypes

			The processing options which need to be resumed.

	@leave May leave with any error code.

	*/

	virtual void ResumeProcessingL(TUint aProcessingTypes)=0;

	/**

	Retrieves the image buffer which contains the individual image captured. This method should be called by the client as a 

	result of receiving the callback MCaptureImageObserver::ImageBufferReady(), if the 

	error information received is satisfactory.

	@param  aCameraImageBuffer

			A reference to an MCameraImageBuffer if successful, or NULL if not successful.

	@leave  May leave with any error code.

	*/

	virtual void GetImageBufferL(MCameraImageBuffer& aCameraImageBuffer) const=0;

	/**

	Retrieves the state of the individual image which the object of this class is referring to.

	@param  aImageState

			Retrieves the current state of the individual image.

	@leave  May leave with any error code.

	*/	

	virtual void GetImageStateL(CCamera::CCameraPostImageCaptureControl::TImageState& aImageState) const=0;

	/**

	Retrieves the state of the individual image buffer.

	@param  aBufferState

			Retrieves the current state of the individual image buffer.

	@leave  May leave with any error code.

	*/	

	virtual void GetBufferStateL(CCamera::CCameraPostImageCaptureControl::TBufferState& aBufferState) const=0;

	};

/** 

Mixin class for implementation by providers of the Video Capture Control Camera Extension API.

CCamera Video Capture Control class exposes an API for controlling advanced video capture related settings and control.

@publishedPartner

@prototype 	

*/	

class MCameraVideoCaptureControl

	{

public:

	/** 

	Releases the interface. 

	*/

	virtual void Release()=0;

	/**

	Retrieves the concrete factory handle for the histogram implementation in order to 

	use it specifically for the video capture.

	@param aImplFactoryPtr

		   The concrete factory handle for the histogram implementation specific to the video capture.

	@leave  May leave with any error code.

	*/

	virtual void CreateHistogramImplFactoryL(MImplementationFactory*& aImplFactoryPtr) const=0;

	/**

	Retrieves the concrete factory handle for the snapshot implementation in order to 

	use it specifically for the video capture.

	@param  aImplFactoryPtr

		    The concrete factory handle for the snapshot implementation specific to the video capture.

	@leave  May leave with any error code.

	*/

	virtual void GetSnapshotImplFactoryL(MImplementationFactory*& aImplFactoryPtr) const=0;

	/**

	Retrieves the concrete factory handle for the image processing implementation in order to 

	use it specifically for the video capture.

	@param aImplFactoryPtr

		   The concrete factory handle for the image processing implementation specific to the video capture.

	@leave  May leave with any error code.

	*/

	virtual void GetImageProcessingImplFactoryL(MImplementationFactory*& aImplFactoryPtr) const=0;

	/**

	The observer for the video capture is passed to the implementation for passing callbacks on it.

	@param  aCaptureVideoObserver

			The reference to the capture video observer.

	*/

	virtual void SetCaptureVideoObserver(MCaptureVideoObserver& aCaptureVideoObserver)=0;

    /**

	Retrieves the supported video formats for a given resolution.

	@param  aVideoFormatsSupported

			A bit field which retrieves the supported video formats for a given resolution.

			Formats have been defined as CCamera::TFormat

	@param  aSize

			The resolution (or size) for which the total number of supported video formats have to be retrieved.

	@leave  May leave with any error code.

	*/

	virtual void GetVideoFormatsSupportedL(TUint& aVideoFormatsSupported, const TSize& aSize) const=0;

	/**

	Retrieves the supported pixel aspect ratio for a given resolution in case of video.

	@param  aPixelAspectsSupported

			A bit field which retrieves the supported pixel aspect ratio for a given resolution.

			Pixel aspect ratio have been defined as CCamera::CCameraAdvancedSettings::TPixelAspectRatio

	@param	aVideoFormat

			The video format for which the supported pixel aspect ratio have to be retrieved.

	@param  aSize

			The resolution (or size) for which the supported pixel aspect ratio have to be retrieved.

	@leave  May leave with any error code.

	*/

	virtual void GetPixelAspectsSupportedL(TUint& aPixelAspectsSupported, CCamera::TFormat aVideoFormat, const TSize& aSize) const=0;

	/**

	Informs whether or not the 'embedded still capture' feature is supported. Allowing still image capture in between 

	on-going video capture is referred to as embedded still capture.

	@param  aSupportedEmbeddedStillCaptureTypes

			Retrieves the supported embedded still capture. The TInt is retrieved as a bit field of supported 

			TEmbeddedStillCaptureTypes.

	@leave  May leave with any error code.

	*/

	virtual void GetEmbeddedStillCaptureSupportInfoL(TInt& aSupportedEmbeddedStillCaptureTypes) const=0;

	/**

	Asynchronous method to prepare for video capture.

	Performs setup and allocation of memory prior to calling StartVideoCapture()

	to keep the latency of that function to a minimum.

	@param  aPrepareVideoParameters 

	 		Parameters necessary to prepare for video capture.

	@note   Event KUidECamEventVideoCaptureControlPrepareComplete is used to notify clients about completing the preparation

			for video capture.

	@note 	Next PrepareVideoCapture can be called only after receiving the notification KUidECamEventReadyForNextPrepare.

	@note   If some camera settings get affected because of desired video settings such as frame rate/frame size, 

			specific notifications will be sent to the client about camera settings being affected.

	@note	Event KUidECamEventVideoCaptureControlSettingsRangeChanged: informs that range of certain camera settings have been changed.

			Client may call GetRangeAffectedSettingsL(RArray<TUid>& aRangeAffectedSettings) const to get the list of affected camera settings.

	@note	Event KUidECamEventVideoCaptureControlSettingsValueChanged: informs that value of certain camera settings have been changed. 

			Client may call GetValueAffectedSettingsL(RArray<TUid>& aValueAffectedSettings) const to get the list of affected camera settings.

	@note	Event KUidECamEventVideoCaptureControlSettingsDisabled: informs that certain camera settings have been disabled. 

			Client may call GetDisabledSettingsL(RArray<TUid>& aDisabledSettings) const to get the list of affected camera settings.

	@see 	CCamera::PrepareVideoCaptureL(TFormat aFormat,TInt aSizeIndex,TInt aRateIndex,TInt aBuffersToUse,TInt aFramesPerBuffer)

	@see	ReleaseVideoResource()

	*/

	virtual void PrepareVideoCapture(const CCamera::CCameraVideoCaptureControl::TPrepareVideoParameters& aPrepareVideoParameters)=0;

	/**

	Retrieves the camera settings whose range got affected once the desired video settings (frame rate/frame size) are in place. 

	This method may be called by the client after receiving the notification KUidECamEventVideoCaptureControlSettingsRangeChanged.

	@param  aRangeAffectedSettings

			Retrieves the list of range affected settings

	@leave  May leave with any error code.  

	@see 	PrepareVideoCapture(const TPrepareVideoParameters& aPrepareVideoParameters)

	*/

	virtual void GetRangeAffectedSettingsL(RArray<TUid>& aRangeAffectedSettings) const=0;

	/**

	Retrieves the camera settings whose value got affected once the desired video settings (frame rate/frame size) are in place. 

	This method may be called by the client after receiving the notification KUidECamEventVideoCaptureControlSettingsValueChanged.

	@param  aValueAffectedSettings

			Retrieves the list of value affected settings

	@leave  May leave with any error code.

	@see 	PrepareVideoCapture(const TPrepareVideoParameters& aPrepareVideoParameters)	

	*/

	virtual void GetValueAffectedSettingsL(RArray<TUid>& aValueAffectedSettings) const=0;

	/**

	Retrieves the camera settings whose value got affected once the desired video settings (frame rate/frame size) are in place. 

	This method may be called by the client after receiving the notification KUidECamEventVideoCaptureControlSettingsDisabled.

	@param  aDisabledSettings

			Retrieves the list of disabled settings

	@leave  May leave with any error code.

	@see 	PrepareVideoCapture(const TPrepareVideoParameters& aPrepareVideoParameters)

	*/

	virtual void GetDisabledSettingsL(RArray<TUid>& aDisabledSettings) const=0;

	/**

	Frees the video resources which were set up as a result of CCameraVideoCaptureControl::PrepareVideoCapture call.

	If this methid is called while PrepareVideoCapture call is outstanding, then this will be equivalent to cancelling the

	PrepareVideoCapture call and release any allocated resources.

	*/

	virtual void ReleaseVideoResource()=0;

	/**

	Starts the video capture. This operation gives priority to the low latency aspects.

	Video frames are send to client via MCaptureVideoObserver::VideoBufferReady(MCameraBuffer2& aVideoBuffer, TInt aErrorCode).

	@leave  May leave with any error code.

	@note	This method is recommended to be used rather than CCamera::StartVideoCaptureL().

	*/												

	virtual void StartVideoCaptureL()=0;

	/**

	Stops the video capture. This operation gives priority to the low latency aspects.

	@note	This method is recommended to be used rather than CCamera::StopVideoCapture().

	*/												

	virtual void StopVideoCapture()=0;

	/**

	Pauses the on-going video capture. MCaptureVideoObserver::VideoBufferReady(MCameraBuffer2& aVideoBuffer, TInt aErrorCode) 

	callback will not be received by the client until the video capture is resumed.

	*/

	virtual void PauseVideoCapture()=0;

	/**

	Resumes the on-going video capture. MCaptureVideoObserver::VideoBufferReady(MCameraBuffer2& aVideoBuffer, TInt aErrorCode) 

	callback will again be received by the client.

	@leave  May leave with any error code.

	*/

	virtual void ResumeVideoCaptureL()=0;

	/**

	Retrieves the fading effect state for video capture.

	@param  aFadingEffectState

			Retrieves the current fading effect state for video capture.

	@leave  May leave with any error code.

	@internalTechnology

	*/

	virtual void GetFadingEffectStateL(CCamera::CCameraVideoCaptureControl::TFadingEffectState& aFadingEffectState) const=0;

	/**

	Sets the fading effect state for video capture.

	@param  aFadingEffectState

			The desired fading effect state for video capture.

	@note   Triggers a KUidECamEventVideoCaptureControlFadingEffect event notification.

	@internalTechnology

	*/	

	virtual void SetFadingEffectState(CCamera::CCameraVideoCaptureControl::TFadingEffectState aFadingEffectState)=0;

	/**

	Retrieves the current video capture state.

	@param aVideoCaptureState

		   Retrieves the current video capture state.

	@leave  May leave with any error code.

	*/

	virtual void GetVideoCaptureStateL(CCamera::CCameraVideoCaptureControl::TVideoCaptureState& aVideoCaptureState) const=0;

	/**

	Retrieves the various types of video capture supported. 

	@param  aSupportedVideoCaptureTypes

			Retrieves the supported video capture type. The TInt is retrieved as a bit field of supported 

			TVideoCaptureType.

	@leave  May leave with any error code.

	*/

	virtual void GetVideoCaptureSupportInfoL(TInt& aSupportedVideoCaptureTypes) const=0;

	/**

	Retrieves the current prepare video parameters.

	@param aPrepareVideoParameters

		   Retrieves the current prepare video parameters.

	@leave  May leave with any error code.

	*/

	virtual void GetPrepareVideoParametersL(CCamera::CCameraVideoCaptureControl::TPrepareVideoParameters& aPrepareVideoParameters) const=0;

	};

#endif // ECAMCAPTURECONTROLINTF_H