--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/imagingandcamerafws/camerafw/Include/ECam/ecamcapturecontrolintf.h Tue Feb 02 01:56:55 2010 +0200
@@ -0,0 +1,950 @@
+// 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