Bug 3673 - Seeking via grabbing the Music Player progress bar does not work.
// 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