| class CCamera::CCameraAdvancedSettings : public CBase |
CCamera advanced settings class exposes an API for controlling individually digital camera advanced settings. These settings directly relate to the image acquisition phase both for still images and video.
This class is not intended for sub-classing and used to standardise existing varieties of implementations.
If the class methods leave, the output type parameter value is not guaranteed to be valid.
| Private Member Enumerations | |
|---|---|
| enum | TECAMEventFilterScheme { EECAMEventFilterSchemeBlackList , EECAMEventFilterSchemeWhiteList } |
| Private Attributes | |
|---|---|
| MCameraAdvancedSettings * | iImpl |
| MCameraAdvancedSettings2 * | iImpl2 |
| MCameraAdvancedSettings3 * | iImpl3 |
| MCameraAdvancedSettings4 * | iImpl4 |
| CCamera & | iOwner |
| IMPORT_C | CCameraAdvancedSettings | ( | CCamera & | aOwner | ) | [private] |
CCameraAdvancedSettings Constructor.
| CCamera & aOwner | a reference to a CCamera object providing the settings. |
| IMPORT_C TInt | Aperture | ( | ) | const |
Get current aperture value. The default aperture value is ECAM implementation specific and could be either auto aperture or any other supported value.
| IMPORT_C TBool | ApertureExposureLockOn | ( | ) | const |
Gets the current state for aperture and exposure lock.
| IMPORT_C TAutoFocusArea | AutoFocusArea | ( | ) | const |
Gets current chosen auto focus area on the camera.
| IMPORT_C TBool | AutoFocusLockOn | ( | ) | const |
Checks whether AutoFocus value is locked or not.
| IMPORT_C TAutoFocusType | AutoFocusType | ( | ) | const |
Gets current auto focus type on the camera. TAutoFocusType
| IMPORT_C TBool | AutomaticSizeSelectionChangeOn | ( | ) | const |
Retrieves the state for automatic size selection option. Default value is EFalse.
| IMPORT_C TBracketParameter | BracketParameter | ( | ) | const |
Get current bracket parameter.
| IMPORT_C TInt | BurstImages | ( | ) | const |
: due to memory or image size limitations the actual number may be less.
| IMPORT_C TInt | CameraIndex | ( | ) | const |
Gets current camera index. The index uniquely identifies the camera on the device.
| IMPORT_C TCameraType | CameraType | ( | TInt | aCameraIndex | ) |
Get the type of a specific camera denoted by its index. A pluggable camera may not necessarily be physically present. The type denotes whether the slot allocated to that index is for pluggable or onboard camera. TCameraType
| TInt aCameraIndex | An integer in the range of [0: CCamera::CamerasAvailable()-1]. |
| IMPORT_C void | ConstructL | ( | ) | [private] |
CCameraAdvancedSettings second phase constructor.
Function used to initialise internal state of the object. Uses reference to the camera to retrieve Camera advanced settings interface pointer.
| IMPORT_C TInt | ContinuousAutoFocusTimeout | ( | ) | const |
Gets the current value for continuous autofocus timeout. Timeouts are in microseconds.
| IMPORT_C void | CreateContinuousZoomL | ( | MContinuousZoomObserver & | aObserver, |
| TContinuousZoomType | aContinuousZoomType, | |||
| CCameraContinuousZoom *& | aContinuousZoom | |||
| ) | ||||
Creates an instance of a CCameraContinuousZoom object and returns it to the client. Ownership of the object is passed to the client.
Client must not delete the continuous zoom object if CCameraContinuousZoom::StartContinuousZoomL() has been called as MContinuousZoomObserver callbacks are still expected by the implementation. Clients should therefore only delete the object once the MContinuousZoomObserver::ContinuousZoomCompleted() callback has been received or has explicitly stopped the continuous zoom via StopContinuousZoom().
| MContinuousZoomObserver & aObserver | Reference to a continuous zoom observer which will be used to issue callbacks to the client. |
| TContinuousZoomType aContinuousZoomType | The continuous zoom type with which the continuous zoom object will be initialised. |
| CCameraContinuousZoom *& aContinuousZoom | Retrieves pointer to the continuous zoom object. Client assumes ownership of the object. |
| void | DisableCameraStateSavingL | ( | RWriteStream & | aCustomCameraState | ) | [private] |
Instructs the implementation to stop saving the custom state in the RWriteStream & as given by SaveCameraStateL(RWriteStream& aCustomCameraState) .
| RWriteStream & aCustomCameraState |
| void | DisableStateSavingL | ( | ) | [private] |
Instructs the implementation to stop saving the current state in the RWriteStream & as given by EnableStateSavingL(RWriteStream& aLatestCameraState) .
| void | EnableStateSavingL | ( | RWriteStream & | aLatestCameraState | ) | [private] |
Instructs the implementation to continuously save the current state before releasing the camera or being overtaken.
The RWriteStream gives the implementation the facility to seek and overwrite any incorrectly updated state (in the event of power failure, for example). Given stream sink shall support repositioning.
The ECam client should be careful not to use the saved state for a particular camera in order to restore a different camera later on. Though the implementation will be expected to take care of such things since the content of the files are only meaningful for the implementation.
The RWriteStream reference is not valid across the process.
| RWriteStream & aLatestCameraState | A RWriteStream reference which will be used by the implementation to continuously save the latest camera state. |
| IMPORT_C void | EnumerateOperationPreferenceL | ( | TUint | aOperationPreferenceIndex, |
| TPerformanceLevel & | aSpeedLevel, | |||
| TPerformanceLevel & | aQualityLevel, | |||
| TPerformanceLevel & | aLowMemoryConsumptionLevel, | |||
| TPerformanceLevel & | aLowPowerConsumptionLevel | |||
| ) | const | |||
Enumerate the available operation preferences.
It is up to the implementation how the performance levels are achieved. For example, shutter opening, JPEQ quality and parallel buffering in case of streamed image output can be controlled in order to provide the desired performance.
| TUint aOperationPreferenceIndex | A particular index which represents an operation preference. The level of different performance vectors may be known through other arguments. This varies from 0 to n-1, where n is given by GetNumOperationPreferenceL(n). |
| TPerformanceLevel & aSpeedLevel | A TPerformanceLevel which specifies the speed level related to the index aOperationPreferenceIndex. |
| TPerformanceLevel & aQualityLevel | A TPerformanceLevel which specifies the quality level related to the index aOperationPreferenceIndex. |
| TPerformanceLevel & aLowMemoryConsumptionLevel | A TPerformanceLevel which specifies the low memory consumption level related to the index aOperationPreferenceIndex. The lower the memory consumption, the higher the level. |
| TPerformanceLevel & aLowPowerConsumptionLevel | A TPerformanceLevel which specifies the low power consumption level related to the index aOperationPreferenceIndex. The lower the power consumption, the higher the level. |
| IMPORT_C TInt | ExposureCompensation | ( | ) | const |
Use TInt GetExposureCompensation(TInt& aExposureCompensation);
Get the current exposure compensation steps. Positive values increase exposure times, negative reduce exposure times. The change is not cumulative i.e. the change is stateless. Each call assumes no previous compensation has been performed i.e. that there is a zero compensation.
if returned value is 2 (compensation steps) and the current exposure compensation step is 0.3 EV, then the actual compensation effect will be 0.6 EV.
| IMPORT_C TInt | ExposureCompensationStep | ( | ) | const |
Use TInt GetExposureCompensationStep(TInt& aExposureCompensationStep);
Get current exposure compensation step.
| IMPORT_C TBool | ExposureLockOn | ( | ) | const |
Checks whether exposure value is locked or not.
| IMPORT_C CCamera::TExposure | ExposureMode | ( | ) | const |
Gets the currently set exposure setting value.
| IMPORT_C TInt | FlashCompensation | ( | ) | const |
Use TInt GetFlashCompensation(TInt& aFlashCompensation);
Get the current flash compensation value as integer steps. Positive values boost flash power, negative reduce flash power. The change is not cumulative i.e. the change is stateless. Each call assumes no previous compensation has been performed i.e. that there is a zero compensation.
if returned value is 2 (compensation steps) and the current flash compensation step is 0.3 EV, then the actual compensation effect will be 0.6 EV.
| IMPORT_C TInt | FlashCompensationStep | ( | ) | const |
Use TInt GetFlashCompensationStep(TInt& aFlashCompensationStep);
Get current flash power compensation step.
| IMPORT_C CCamera::TFlash | FlashMode | ( | ) | const |
Gets the currently set flash mode.
Clients not using the CCamera::New2L() or CCamera::NewDuplicate2L() would be given CCamera::EFlashAuto if current flash mode exceeds CCamera::EFlashManual
| IMPORT_C TFocusMode | FocusMode | ( | ) | const |
Gets current focus mode on the camera. The result is a valid TFocusMode value.
| IMPORT_C TFocusRange | FocusRange | ( | ) | const |
Gets current focus range on the camera.
if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that application is not prepared to receive extra added enum values. So, any extra enum value received from the implementation will be dropped and EFocusRangeAuto would be passed instead. To receive extra added enum values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L() to create camera object. In this case, application is assumed to be prepared to receive unrecognised enum values
| IMPORT_C void | GetAFAssistantLightL | ( | TAFAssistantLight & | aAFAssistantLight | ) | const |
Get the type ( and state) of AF assistant light currently set.
| TAFAssistantLight & aAFAssistantLight | A reference to AF assistant light. If EAFAssistantLightOff, then manual and auto assistant light are switched off. If EAFAssistantLightManualOn, manual assistant light is switched on. If EAFAssistantLightAuto, AF assistant light is set to auto. |
| IMPORT_C void | GetActiveSettingsL | ( | RArray < TUid > & | aActiveSettings | ) | const |
Gets an array of all the advanced settings parameters currently active on the camera. These are identified by UIDs and relate to the set or subset of it of all supported settings UIDs.
if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that application is not prepared to receive extra added uid values (new settings added). So, any extra uid value passed from the implementation will be filtered at this point. To receive extra added uid values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L() to create camera object. In this case, application is assumed to be prepared to receive unrecognised uid values
| IMPORT_C void | GetAperturesL | ( | RArray < TInt > & | aFStops, |
| TValueInfo & | aInfo | |||
| ) | const | |||
Gets the current discrete aperture steps (F-stops) supported by the camera.
When camera device is incapable of revealing the aperture openings supported, it has to be assumed that camera will work only on the parmanently set value. If this value is not known, empty array may be returned and TValueInfo may be ENotActive; corresponding getter/setters for this feature should not be used in such a case.
| RArray < TInt > & aFStops | A reference to an empty array of TInt which would be populated by the implementation with the specific supported values. If the array is empty on return, the camera supports all integer values in the aperture range. Each value is multiplied by a factor of KECamFineResolutionFactor. |
| TValueInfo & aInfo | a reference to TValueInfo, which establishes the type of the returned data. |
| IMPORT_C void | GetBracketMerge | ( | TInt & | aStartIndex, |
| TInt & | aFrames | |||
| ) | const | |||
there must be at least two images to merge. All are assumed to form a sequence and are identified using the first frame index and number of frames e.g. to merge two frames - one on and one +1, when in EBracketMode3Image, one sets the start index to 1 and frames to two.
It is very much TBracketMode setting dependent operation.
| IMPORT_C void | GetCurrentFocusModeStepsL | ( | RArray < TInt > & | aFocusModeSteps, |
| TValueInfo & | aInfo | |||
| ) | const | |||
Get the number of focus steps for current focus mode.
When camera device doesn't support this, empty array may be returned and TValueInfo may be ENotActive; corresponding getter/setters for this feature should not be used in such a case.
| RArray < TInt > & aFocusModeSteps | A reference to an empty array of TInt which would be populated by the implementation with the specific supported values. |
| TValueInfo & aInfo | a reference to TValueInfo, which establishes the type of the returned data. |
| IMPORT_C void | GetDigitalZoomStepsForStillL | ( | RArray < TInt > & | aDigitalZoomSteps, |
| TValueInfo & | aInfo, | |||
| TInt | aSizeIndex, | |||
| CCamera::TFormat | aFormat, | |||
| TBool & | aIsInfluencePossible | |||
| ) | const | |||
Get the digital zoom steps for the still image when a particular image format and size are specified.
This method retrieves the supported digital zoom steps irrespective of any stabilization influence. In case of stabilization etc. influence, the setting function should set the best possible digital zoom value and return error KErrECamDigitalZoomLimited along with dedicated event.
When concrete implementation is provided, but camera device does not support this feature, empty array may be returned and TValueInfo may be ENotActive; corresponding getter/setters for this feature should not be used in such a case.
| RArray < TInt > & aDigitalZoomSteps | A reference to an empty array of TInt to hold digital zoom step values for still image and multiplied by KECamFineResolutionFactor to retain precision. If list returned is empty, this means feature is not supported. |
| TValueInfo & aInfo | A reference to TValueInfo, which establishes the type of the returned data. |
| TInt aSizeIndex | A value providing the size index which must be in the range 0 to TCameraInfo::iNumImageSizesSupported-1 inclusive. |
| CCamera::TFormat aFormat | A value providing the image format which must be one of the formats supported. (see TCameraInfo::iImageFormatsSupported) |
| TBool & aIsInfluencePossible | If True, signals that digital zoom step values may be influenced by some hardware factor like stabilization etc. If False, no influence possible. |
| IMPORT_C void | GetDigitalZoomStepsForVideoL | ( | RArray < TInt > & | aDigitalZoomSteps, |
| TValueInfo & | aInfo, | |||
| TInt | aFrameRateIndex, | |||
| TInt | aSizeIndex, | |||
| CCamera::TFormat | aFormat, | |||
| TBool & | aIsInfluencePossible, | |||
| CCamera::TExposure | aExposure | |||
| ) | const | |||
Get the digital zoom steps for the video when a particular video frame format, size and rate are specified.
This method retrieves the supported digital zoom steps irrespective of any stabilization influence. In case of stabilization etc. influence, the setting function should set the best possible digital zoom value and return error KErrECamDigitalZoomLimited along with dedicated event.
When concrete implementation is provided, but camera device does not support this feature, empty array may be returned and TValueInfo may be ENotActive; corresponding getter/setters for this feature should not be used in such a case.
| RArray < TInt > & aDigitalZoomSteps | A reference to an empty array of TInt to hold digital zoom step values for video and multiplied by KECamFineResolutionFactor to retain precision. If list returned is empty, this means feature is not supported. |
| TValueInfo & aInfo | A reference to TValueInfo, which establishes the type of the returned data. |
| TInt aFrameRateIndex | A value providing the rate index must be in the range 0 to TCameraInfo::iNumVideoFrameRatesSupported-1 inclusive. |
| TInt aSizeIndex | A value providing the size index which must be in the range 0 to TCameraInfo::iNumVideoFrameSizesSupported-1 inclusive. |
| CCamera::TFormat aFormat | A value providing the format which must be one of the video frame formats supported. (see TCameraInfo::iVideoFrameFormatsSupported) |
| TBool & aIsInfluencePossible | If True, signals that digital zoom step values may be influenced by some hardware factor like stabilization etc. If False, no influence possible. |
| CCamera::TExposure aExposure | The exposure mode. |
| IMPORT_C void | GetDigitalZoomStepsL | ( | RArray < TInt > & | aDigitalZoomSteps, |
| TValueInfo & | aInfo | |||
| ) | const | |||
Gets the digital zoom levels.
Such approach allows for support for both linear and non-linear zoom steps. When camera device doesn't support this, empty array may be returned and TValueInfo may be ENotActive; corresponding getter/setters for this feature should not be used in such a case.
| RArray < TInt > & aDigitalZoomSteps | Array to hold digital zoom values multiplied by KECamFineResolutionFactor to retain precision. So that if zoom is not supported the array will return a single element of value KECamFineResolutionFactor. |
| TValueInfo & aInfo | a reference to TValueInfo, which establishes the type of the returned data. |
| IMPORT_C void | GetDisabledSettingsL | ( | RArray < TUid > & | aDisabledSettings | ) | const |
Gets an array of all the advanced settings parameters currently disabled on the camera. These are identified by UIDs and relate to the set or subset of it of all supported settings UIDs.
if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that application is not prepared to receive extra added uid values (new settings added). So, any extra uid value passed from the implementation will be filtered at this point. To receive extra added uid values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L() to create camera object. In this case, application is assumed to be prepared to receive unrecognised uid values
| IMPORT_C TInt | GetExposureCompensation | ( | TInt & | aExposureCompensation | ) | const |
Get the current exposure compensation steps. Positive values increase exposure times, negative reduce exposure times. The change is not cumulative i.e. the change is stateless. Each call assumes no previous compensation has been performed i.e. that there is a zero compensation.
if retrieved value is 2 (compensation steps) and the current exposure compensation step is 0.3 EV, then the actual compensation effect will be 0.6 EV.
Use this method in place of deprecated TInt ExposureCompensation()
| TInt & aExposureCompensation | Reference to the current number of compensation steps as an integer. |
| IMPORT_C void | GetExposureCompensationRangeInSteps | ( | TInt & | aNegativeCompensation, |
| TInt & | aPositiveCompensation | |||
| ) | const | |||
Get current exposure compensation range in steps. It depends on the previously selected exposure compensation step.
| IMPORT_C TInt | GetExposureCompensationStep | ( | TInt & | aExposureCompensationStep | ) | const |
Get current exposure compensation step.
Use this method in place of deprecated TInt ExposureCompensationStep()
| TInt & aExposureCompensationStep | Reference to the current exposure compensation step. |
| IMPORT_C void | GetExposureCompensationStepsL | ( | RArray < TInt > & | aExposureCompensationSteps, |
| TValueInfo & | aInfo | |||
| ) | const | |||
Get exposure compensation steps as integers multiplied by KECamFineResolutionFactor. For example 0.3 EV is 30.
When camera device doesn't support this, empty array may be returned and TValueInfo may be ENotActive; corresponding getter/setters for this feature should not be used in such a case. When camera device is incapable of revealing the exposure compensation steps supported, it has to be assumed that camera will work only on the permanently set value. If this value is not known, empty array may be returned and TValueInfo may be ENotActive; corresponding getter/setters for this feature should not be used in such a case.
| RArray < TInt > & aExposureCompensationSteps | an RArray of integers which is populated to reflect the supported exposure compensation steps, all values have been multiplied by KECamFineResolutionFactor before truncated to integers. |
| TValueInfo & aInfo | a reference to TValueInfo, which establishes the type of the returned data. |
| IMPORT_C TInt | GetFlashCompensation | ( | TInt & | aFlashCompensation | ) | const |
Get the current flash compensation value as integer steps. Positive values boost flash power, negative reduce flash power. The change is not cumulative i.e. the change is stateless. Each call assumes no previous compensation has been performed i.e. that there is a zero compensation.
if retrieved value is 2 (compensation steps) and the current flash compensation step is 0.3 EV, then the actual compensation effect will be 0.6 EV.
Use this method in place of deprecated TInt FlashCompensation()
| TInt & aFlashCompensation | Reference to the current number of compensation steps as an integer. |
| IMPORT_C void | GetFlashCompensationRangeInSteps | ( | TInt & | aNegativeCompensation, |
| TInt & | aPositiveCompensation | |||
| ) | const | |||
This range may change if a different compensation step is selected. For example if flash compensation range is in the range -1EV 1.5EV and the selected flash compensation step is selected to be 0.3 EV, the result of this call will be aNegativeCompensation = -3 and aPositiveCompensation = 5. as there can be only three full steps for negative compensation (1/0.3) and five for flash power boost (1.5/0.3). In this way developers, having pre-selected a step value from the supported set, would need to provide just the multiplier (in steps) and the direction (the sign). Steps are always assumed integers.
| IMPORT_C TInt | GetFlashCompensationStep | ( | TInt & | aFlashCompensationStep | ) | const |
Get current flash power compensation step.
Use this method in place of deprecated TInt FlashCompensationStep()
| TInt & aFlashCompensationStep | Reference to the current flash compensation step. |
| IMPORT_C void | GetFlashCompensationStepsL | ( | RArray < TInt > & | aFlashCompensationSteps, |
| TValueInfo & | aInfo | |||
| ) | const | |||
Get flash compensation steps as integers multiplied by KECamFineResolutionFactor. For example 0.5 EV is 50.
When camera device doesn't support this, empty array may be returned and TValueInfo may be ENotActive; corresponding getter/setters for this feature should not be used in such a case.
When camera device is incapable of revealing the flash compensation steps supported, it has to be assumed that camera will work only on the parmanently set value. If this value is not known, empty array may be returned and TValueInfo may be ENotActive; corresponding getter/setters for this feature should not be used in such a case.
| RArray < TInt > & aFlashCompensationSteps | an RArray of integers which is populated on return to reflect the supported flash compensation steps, |
| TValueInfo & aInfo | an TValueInfo reference, which establishes the organization of the returned data. |
| void | GetFlickerRemovalValueL | ( | TFlickerRemoval & | aFlickerRemovalValue | ) | const [private] |
Get the current flicker removal value being used.
| TFlickerRemoval & aFlickerRemovalValue | Currently used TFlickerRemoval value. |
| IMPORT_C void | GetFocalLengthInfoL | ( | TInt & | aMinFocalLength, |
| TInt & | aCurrentFocalLength, | |||
| TInt & | aMaxFocalLength | |||
| ) | const | |||
Retrieves the minimum, current and maximum focal length in millimeters. This information is useful to find out which zoom directions can be used on the fly.
| TInt & aMinFocalLength | Minimum focal length if positive. Error value if negative (for example, KErrNotFound if information not available). |
| TInt & aCurrentFocalLength | Current focal length if positive. Error value if negative (for example, KErrNotFound if information not available). |
| TInt & aMaxFocalLength | Maximum focal length if positive. Error value if negative (for example, KErrNotFound if information not available). |
| IMPORT_C void | GetISORateL | ( | TISORateType & | aISORateType, |
| TInt & | aParam, | |||
| TInt & | aISORate | |||
| ) | const | |||
Get the type of ISO rate, exposure parameter and value set.
When concrete implementation is provided, but camera device does not support this feature, then aISORateType retrieves EISONone.
Since camera hardware may be incapable of providing the actual ISO value when one of the auto ISO type has been set, then, in these cases, the 3rd argument is retrieved as KErrNotFound.
| TISORateType & aISORateType | A reference to the type of ISO rate set. EISONone means feature is not supported. |
| TInt & aParam | Depending on the value of aISORateType, possible values of aParam are one of the following:- A reference to the redundant parameter in case of manual type of ISO rate(EISOManual) OR A reference to the redundant parameter in case of unprioritised type of auto ISO(EISOAutoUnPrioritised) OR A reference to the highest ISO rate that may be picked up in case of ISO prioritised type of auto ISO(EISOAutoISOPrioritised) OR A reference to the slowest shutter speed that may be picked up in case of shutter speed prioritised type of auto ISO(EISOAutoShutterSpeedPrioritised) OR A reference to the minimum aperture opening that may be picked up in case of aperture prioritised type of auto ISO(EISOAutoAperturePrioritised) |
| TInt & aISORate | A reference to the value of ISO rate currently being used, if camera device is capable of doing that. Otherwise KErrNotFound is retrieved indicating the incapability of camera. |
| IMPORT_C void | GetIndirectFeatureChangesL | ( | TUid | aRequestedSetting, |
| RArray < TUid > & | aIndirectFeatureChanges | |||
| ) | const | |||
Retrieves the indirect feature changes which occur because of a particular requested feature change. Since the camera setting operation is asynchronous in nature, changing a particular camera feature, in certain cases, involves indirectly changing another feature. In order to notify the ECam client about this indirect feature change, event KUidECamEvent2IndirectFeatureChange is issued. After this notification, the client may use this method to retrieve the full list of indirect feature changes.
| TUid aRequestedSetting | The actual requested feature change. This uid is supposed to be ECAM component wide and not restricted to advanced camera settings. |
| RArray < TUid > & aIndirectFeatureChanges | An array of uids which retrieves the indirect feature changes. These uids are supposed to be ECAM component wide and not restricted to advanced camera settings. |
| void | GetLEDEffectL | ( | TLEDEvent | aLEDEvent, |
| TLEDEffect & | aLEDEffect | |||
| ) | const [private] | |||
Get the type of LED effect being used for a particular LED event.
| TLEDEvent aLEDEvent | The TLEDEvent for which the current LED effect has to be retrieved. |
| TLEDEffect & aLEDEffect | The TLEDEffect which is being used for the given LED event. If this is TLEDEffectCustom, then a custom LED effect would have been separately specified by the client. |
| IMPORT_C void | GetManualFlashPowerLevelsL | ( | RArray < TInt > & | aManualFlashPowerLevels, |
| TValueInfo & | aInfo | |||
| ) | const | |||
Gets the current discrete manual flash power levels supported by the camera in range 0-100 as a percentage of maximum power level.
When camera device doesn't support this, empty array may be returned and TValueInfo may be ENotActive; corresponding getter/setters for this feature should not be used in such a case. When camera device is incapable of revealing the manual flash power levels supported, it has to be assumed that camera will work only on the permanently set value. If this value is not known, empty array may be returned and TValueInfo may be ENotActive; corresponding getter/setters for this feature should not be used in such a case.
| RArray < TInt > & aManualFlashPowerLevels | An empty array of TInt which would be populated by the implementation with the specific supported values. If the array is empty on return, the camera does not support this functionality. |
| TValueInfo & aInfo | a reference to TValueInfo, which establishes the type of the returned data. |
| void | GetManualGainL | ( | TInt & | aManualGain, |
| TColorChannel | aColorChannel | |||
| ) | const [private] | |||
Get the current manual gain value to be used for a particular color channel.
| TInt & aManualGain | Currently used manual gain value. The TInt represents the unit in 'db' and multiplied by KECamFineResolutionFactor. |
| TColorChannel aColorChannel | The color channel for which the manual gain value has to be used. |
| IMPORT_C TInt | GetMinFocalLength | ( | ) | const |
Get minimum focus distance in millimetres
Current Focal length is calculated as focalLength = opticalZoom * minFocalLength;
| void | GetNDFilterL | ( | TNDFilter & | aNDFilter | ) | const [private] |
Get the current neutral density filter being used.
| TNDFilter & aNDFilter | Currently used TNDFilter. |
| IMPORT_C void | GetNumOperationPreferenceL | ( | TUint & | aNumOperationPreferenceSupported | ) | const |
Retrieves the total number of operation preferences supported by the implementation. Operation preferences are specified in terms of performance vectors, that is, speed, quality, low memory consumption and low power consumption.
| TUint & aNumOperationPreferenceSupported | Retrieves the number of operation preferences supported. |
| IMPORT_C void | GetOperationPreferenceL | ( | TInt & | aOperationPreferenceIndex | ) | const |
Get the current operation preference being used.
| TInt & aOperationPreferenceIndex | Currently used operation preference index. |
| IMPORT_C void | GetOpticalZoomStepsL | ( | RArray < TInt > & | aOpticalZoomSteps, |
| TValueInfo & | aInfo | |||
| ) | const | |||
Gets the optical zoom levels.
Such approach allows for support for both linear and non-linear zoom steps. When camera device doesn't support this, empty array may be returned and TValueInfo may be ENotActive; corresponding getter/setters for this feature should not be used in such a case.
| RArray < TInt > & aOpticalZoomSteps | Array to hold optical zoom values multiplied by KECamFineResolutionFactor to retain precision. So that if zoom is not supported the array will return a single element of value KECamFineResolutionFactor. |
| TValueInfo & aInfo | a reference to TValueInfo, which establishes the type of the returned data. |
| IMPORT_C void | GetPreCaptureWarningL | ( | TInt & | aPreCaptureWarning | ) | const |
Get the status of every warnings defined.
This method may be called after receiving the event KUidECamEventCameraSettingPreCaptureWarning OR user may also opt for polling on this.
| TInt & aPreCaptureWarning | A reference to the integer - bitfield representing all the TPreCaptureWarning types issued. |
| IMPORT_C void | GetPreCaptureWarningSupportedL | ( | TCameraMode | aCameraMode, |
| TInt & | aPreCaptureWarningSupported | |||
| ) | const | |||
Retrieves the pre capture warnings supported for a given camera mode
| TCameraMode aCameraMode | Desired camera mode for which the supported pre capture warnings may be retrieved. |
| TInt & aPreCaptureWarningSupported | A bitfield of all supported TPreCaptureWarning to be issued in the given camera mode. If no pre capture warning supported for the given camera mode, EPCWNone is retrieved. |
| void | GetRegisterEventsL | ( | TECAMEventFilterScheme | aEventFilter, |
| RArray < TUid > & | aEvents, | |||
| TValueInfo & | aInfo | |||
| ) | const [private] | |||
Retrieve the list of ECAM component wide events for a particular event filtering scheme.
There should be consistency in the information retrieved when GetRegisteredEvents is consecutively called, first for blacklisted events and secondly, for white listed events. Only one of them should be used at a time and hence, for the other one, aInfo will be ENotActive.
| TECAMEventFilterScheme aEventFilter | This is of type TECAMEventFilterScheme. If EECAMEventFilterSchemeBlackList, retrieve the events which are not supposed to be used for notification. If EECAMEventFilterSchemeWhiteList, retrieve the events which are supposed to be used for notification. |
| RArray < TUid > & aEvents | An array of events given to the clients. Helps in filtering the events for notification purposes. An empty array indicates that no events have been registered so far. |
| TValueInfo & aInfo | Retrieved TValueInfo. This will be ENotActive if no event has been yet registered under the 'aEventFilter' filter scheme. This will be EDiscreteSteps if some events have been registered under the 'aEventFilter' filter scheme. |
| IMPORT_C void | GetShutterSpeedsL | ( | RArray < TInt > & | aShutterSpeeds, |
| TValueInfo & | aInfo | |||
| ) | const | |||
Gets the set of supported shutter speeds.
When camera device is incapable of revealing the shutter speeds supported, it has to be assumed that camera will work only on the parmanently set value. If this value is not known, empty array may be returned and TValueInfo may be ENotActive; corresponding getter/setters for this feature should not be used in such a case.
| RArray < TInt > & aShutterSpeeds | a reference to an RArray of TInt representing the discrete shutter speeds supported currently by the camera. |
| TValueInfo & aInfo | a reference to TValueInfo, which establishes the type of the returned data. |
| IMPORT_C void | GetSupportedAFAssistantLightL | ( | TInt & | aSupportedAFAssistantLight | ) | const |
Retrieve the different supported AF assistant light.
When concrete implementation is provided, but camera device does not support this feature, then aSupportedAFAssistantLight retrieves EAFAssistantLightOff. Corresponding getter/setters for this feature should not be called then.
| TInt & aSupportedAFAssistantLight | A reference to integer - bitfield indicating the supported AF assistant light. If EAFAssistantLightOff, this means AF assistant light is not supported. If EAFAssistantLightManualOn, then manual AF assistant light is supported. If EAFAssistantLightAuto, auto assistant light is supported. If combination of EAFAssistantLightManualOn||EAFAssistantLightAuto , then both manual and Auto assistant light are supported. |
| IMPORT_C void | GetSupportedContinuousAutoFocusTimeoutsL | ( | RArray < TInt > & | aTimeouts, |
| TValueInfo & | aInfo | |||
| ) | const | |||
Retrieves the timeout values camera supported by the camera when in continuous auto focus mode. Timeouts are in microseconds.
When camera device doesn't support this, empty array may be returned and TValueInfo may be ENotActive; corresponding getter/setters for this feature should not be used in such a case.
| RArray < TInt > & aTimeouts | An empty array to hold timeout values. |
| TValueInfo & aInfo | a reference to TValueInfo, which establishes the type of the returned data. |
| IMPORT_C void | GetSupportedContinuousZoomTypeL | ( | TUint & | aSupportedContinuousZoomType | ) | const |
Retrieves the supported continuous zoom types.
| TUint & aSupportedContinuousZoomType | Retrieves a bitfield of TUint which indicates the supported continuous zoom type as given by CCamera::CCameraAdvancedSettings::TContinuousZoomType |
| IMPORT_C void | GetSupportedEventsL | ( | RArray < TUid > & | aSupportedEvents | ) | const |
Retrieves the event uids which the underlying implementation supports. Client may use these event notifications as milestones in their application.
This method may retrieve unrecognized events which may be introduced later on.
| void | GetSupportedFlickerRemovalValueL | ( | TUint & | aSupportedFlickerRemovalValue | ) | const [private] |
Retrieves the supported flicker removal values.
| TUint & aSupportedFlickerRemovalValue | A bitfield of all supported TFlickerRemoval to be provided to the client. |
| IMPORT_C void | GetSupportedISORateTypeL | ( | TInt & | aSupportedISORateTypes | ) | const |
Gets all supported ISO types on the device.
When concrete implementation is provided, but camera device does not support this feature, then aSupportedISORateTypes retrieves EISONone.
| TInt & aSupportedISORateTypes | A reference to an integer which is a bitfield of all supported TISORateType values. EISONone means feature is not supported. |
| IMPORT_C void | GetSupportedIsoRatesL | ( | RArray < TInt > & | aSupportedIsoRates | ) | const |
Gets the set of camera supported ISO rates.
When camera device is incapable of revealing the ISO rates supported, it has to be assumed that camera will work only on the permanently set value. If this value is not known, empty array may be returned; corresponding getter/setters for this feature should not be used in such a case.
| void | GetSupportedManualGainL | ( | RArray < TInt > & | aSupportedManualGain, |
| TColorChannel | aColorChannel | |||
| ) | const [private] | |||
Retrieves the supported manual gain for a particular color channel.
| RArray < TInt > & aSupportedManualGain | An array of manual gain. The TInt represent the unit in 'db' and multiplied by KECamFineResolutionFactor. Empty array indicates that feature is not supported. |
| TColorChannel aColorChannel | The TColorChannel for which the supported manual gain values have to be retrieved. |
| void | GetSupportedNDFilterL | ( | TUint & | aSupportedNDFilter | ) | const [private] |
Retrieves the supported neutral density filter.
| TUint & aSupportedNDFilter | A bitfield of all supported TNDFilter to be provided to the client. |
| IMPORT_C void | GetSupportedSettingsL | ( | RArray < TUid > & | aSettings | ) | const |
Gets an array of all the advanced settings parameters supported by the camera. These are identified by UIDs and relate to the set or subset of it of all defined settings UIDs.
if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that application is not prepared to receive extra added uid values (new settings added). So, any extra uid value passed from the implementation will be filtered at this point. To receive extra added uid values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L() to create camera object. In this case, application is assumed to be prepared to receive unrecognised uid values
| IMPORT_C void | GetTimeLapse | ( | TTime & | aStart, |
| TTime & | aEnd, | |||
| TTime & | aInterval | |||
| ) | const | |||
Get current time lapse value. Active only when drive mode EDriveModeTimeLapse. The time lapse is denoted as the uniform time period between consecutive frames and operation is configurable by its start, end and a fixed interval.
| IMPORT_C void | GetTimeLapsePeriodRange | ( | TTime & | aTimeLapseMin, |
| TTime & | aTimeLapseMax | |||
| ) | const | |||
Get camera supported time lapse period range. Active only when drive mode EDriveModeTimeLapse. The time lapse is denoted as the uniform time period between consecutive frames.
| IMPORT_C void | GetTimerIntervalsL | ( | RArray < TInt > & | aTimerIntervals, |
| TValueInfo & | aInfo | |||
| ) | const | |||
Get camera supported timer values. Active only when drive mode EDriveModeTimed. Time is in microseconds. As time interval is expected to be relatively short, integer value is considered sufficient.
When camera device doesn't support this, empty array may be returned and TValueInfo may be ENotActive; corresponding getter/setters for this feature should not be used in such a case.
| RArray < TInt > & aTimerIntervals | an RArray of integers which is populated to reflect the supported timer interval steps. |
| TValueInfo & aInfo | an TValueInfo reference, which establishes the organization of the returned data. |
| IMPORT_C void | GetWBRgbValue | ( | TRgb & | aValue | ) | const |
Get white balance value represented as a RGB triplet.
| TRgb & aValue | a reference to TRgb object which will contain the current white balance. |
| IMPORT_C void | GetWBSupportedColorTemperaturesL | ( | RArray < TInt > & | aWBColorTemperatures, |
| TValueInfo & | aInfo | |||
| ) | const | |||
Get the white balance values, as temperature measured in Kelvin, supported on the camera.
When camera device doesn't support this, empty array may be returned and TValueInfo may be ENotActive; corresponding getter/setters for this feature should not be used in such a case.
| RArray < TInt > & aWBColorTemperatures | A reference to an empty array of TInt which would be populated by the implementation with the specific supported values. |
| TValueInfo & aInfo | a reference to TValueInfo, which establishes the type of the returned data. |
| void | GetWhiteBalanceLockStateL | ( | TBool & | aIsLocked | ) | const [private] |
Get the current state for the white balance lock.
| TBool & aIsLocked | A TBool specifies whether the white balance has been locked or unlocked. ETrue indicates that the white balance has been locked. EFalse indicates that the white balance has been unlocked. |
| IMPORT_C TBool | IsCameraPresent | ( | ) | const |
Checks whether the current camera is present.
| IMPORT_C TBool | IsCameraPresent | ( | TInt | aCameraIndex | ) |
Checks whether the camera, denoted by its index, is currently present. The index uniquely identifies the camera on the device.
| TInt aCameraIndex | An integer in the range of [0:CCamera::CamerasAvailable()-1] specifying the camera device to use |
| IMPORT_C TBool | IsExternalFlashPresent | ( | ) | const |
Check whether there is an external flash source.
| IMPORT_C TInt | IsFlashReady | ( | TBool & | aReady | ) | const |
Checks whether the flash is ready.
| TBool & aReady | A reference to a boolean set by the implementation to ETrue if the flash is ready, EFalse otherwise. |
| IMPORT_C TInt | IsoRate | ( | ) | const |
Gets current ISO rate.
The returned value may be checked with the list of supported ISO rates. If value returned does not belong to this list, then it may be treated as an error case.
| IMPORT_C TInt | ManualFlashPowerLevel | ( | ) | const |
Gets the current manual flash power level on the camera.
| IMPORT_C CCameraAdvancedSettings * | NewL | ( | CCamera & | aCamera | ) | [static] |
Factory function for creating the CCameraAdvancedSettings object.
Clients using MCameraObserver are not recommended to use this extension class since they cannot handle events.
| CCamera & aCamera | a reference to a CCamera object providing the settings. |
| IMPORT_C TPictureOrientation | PictureOrientation | ( | ) | const |
Get current picture orientation
| IMPORT_C TPixelAspectRatio | PixelAspectRatio | ( | ) | const |
Get current pixel aspect ratio.
Some of the pixel aspect ratios are available only for clients using either CCamera::New2L() or CCamera::NewDuplicate2L()
| IMPORT_C TBool | RedEyeReduceOn | ( | ) | const |
Gets whether the flash red eye reduction is switched on.
| void | RegisterEventsL | ( | TECAMEventFilterScheme | aEventFilter, |
| const RArray < TUid > & | aEvents | |||
| ) | [private] | |||
Register the ECAM component wide events in order to decide which events the client needs to be notified about. Previously registered events will be overridden and not augmented.
Method RegisterEvents if called with EECAMEventFilterSchemeBlackList will wipe away any white listed events set previously and make them inactive.
| TECAMEventFilterScheme aEventFilter | This is of type TECAMEventFilterScheme. If EECAMEventFilterSchemeBlackList, the client will not be notified only for the events packed in the array 'aEvents'. If EECAMEventFilterSchemeWhiteList, the client will be notified only for the events packed in the array 'aEvents'. |
| const RArray < TUid > & aEvents | An array of events provided by the client. Helps in filtering the events for notification purposes. An empty array indicates that there are no events to register for a particular filtering scheme as given by aEventFilter. |
| void | ReserveL | ( | const TTimeIntervalMicroSeconds32 & | aMaxTimeToWait, |
| TBool | aKickOut | |||
| ) | [private] | |||
Reserve method which are less strict than existing Reserve methods and hence, expects implementation to be considerate towards camera access/control.
EFalse indicates that KUidECamEvent2CameraRequestTimedTakeOver will be issued to the current reserver.
Event KUidECamEventNewReserveComplete notifies the client who made the new Reserve request. Error value KErrECamHighPriorityReserveRequesterExists indicates another such reserve request is outstanding and has higher priority than this one. Error value KErrCancel indicates a new reserve requester with a higher priority than the current requester has been made and that the current requester has been cancelled.
Event KUidECamEvent2CameraRequestForcedTimedTakeOver notifies the current reserver client about its camera control being forcefully overtaken after a specified time period.
Event KUidECamEvent2CameraRequestTimedTakeOver notifies the current reserver client about a request to release its camera control within a specified time period.
| const TTimeIntervalMicroSeconds32 & aMaxTimeToWait | Maximum specified time for the client to hold the camera control before releasing (KUidECamEvent2CameraRequestTimedTakeOver) or being forcefully overtaken (KUidECamEvent2CameraRequestForcedTimedTakeOver). |
| TBool aKickOut | ETrue indicates that if the requester's priority is greater than the current reserver's, then KUidECamEvent2CameraRequestForcedTimedTakeOver will be issued to the current reserver. Otherwise, KUidECamEvent2CameraRequestTimedTakeOver will be issued. |
| void | RestoreCameraStateL | ( | RReadStream & | aCustomCameraState | ) | [private] |
Instructs the implementation to restore a custom saved state. The camera can be restored in any of the custom camera states saved earlier.
The ECam client should be careful not to use the saved state for a particular camera in order to restore a different camera later on. Though the implementation will be expected to take care of such things since the content of the files are only meaningful for the implementation.
The RReadStream reference is not valid across the process.
| RReadStream & aCustomCameraState | A RReadStream reference which will be used by the implementation to restore a custom camera state which was saved earlier. |
| void | RestoreClientPriorityL | ( | ) | [private] |
Restores the priority of the client. The client issues this call when it receives the notification KUidECamEventCameraSettingRestoreClientPriority. ECam's responsibility is to save the original priority of the client.
Once the legacy client has released the camera (after changing its priority), implementation will notify the client to restore its priority by event KUidECamEventCameraSettingRestoreClientPriority. After receiving this notification, the client issues this method RestoreClientPriorityL() .
| void | RestoreLatestStateL | ( | RReadStream & | aLatestCameraState | ) | [private] |
Instructs the implementation to resume from the last saved state. This may be used after reserving the camera.
The RReadStream gives the implementation the facility to seek and overwrite any incorrectly updated state (in the event of power failure, for example).
The ECam client should be careful not to use the saved state for a particular camera in order to restore a different camera later on. Though the implementation will be expected to take care of such things since the content of the files are only meaningful for the implementation.
The RReadStream reference is not valid across the process.
| RReadStream & aLatestCameraState | A RReadStream reference which will be used by the implementation to restore the latest saved camera state information. |
| void | SaveCameraStateL | ( | RWriteStream & | aCustomCameraState | ) | [private] |
Instructs the implementation to save the current state which will be used by the client as a custom user state. The state saving will be done only once when this call is issued. Many such custom state could be created by the clients.
The ECam client should be careful not to use the saved state for a particular camera in order to restore a different camera later on. Though the implementation will be expected to take care of such things since the content of the files are only meaningful for the implementation.
The RWriteStream reference is not valid across the process.
| RWriteStream & aCustomCameraState | A RWriteStream reference which will be used by the implementation to save the current camera state as a milestone. |
| IMPORT_C void | SetAFAssistantLightL | ( | TAFAssistantLight | aAFAssistantLight | ) |
Set a particular type ( and state) of AF assistant light.
Triggers KUidECamEventCameraSettingAFAssistantLight to all MCameraObserver2 clients of the camera. HandleEvent is used to report the result or any possible error. New setter functions leave only when implementation is not there.
| TAFAssistantLight aAFAssistantLight | Type of AF assistant light to be set. If EAFAssistantLightOff, switch off the manual or auto assistant light. If EAFAssistantLightManualOn, manually switch on the assistant light. If EAFAssistantLightAuto, camera will automatically switch it on/off as per the conditions. |
| IMPORT_C void | SetAperture | ( | TInt | aFStop | ) |
Set a new aperture value. All MCameraObserver2 clients of the camera receive a KUidECamEventCameraSettingAperture event notification when aperture value is changed.
The aperture parameter value is an integer, multiplied by KECamFineResolutionFactor. For example to set an aperture of F2.8, call SetAperture(280).
| TInt aFStop | a new aperture value in the supported by the camera range. |
| IMPORT_C void | SetApertureExposureLockOn | ( | TBool | aAELock | ) |
Sets the current state for aperture and exposure lock. Triggers a KUidECamEventAELock event to all MCameraObserver2 clients.
| TBool aAELock | a value whether to lock exposure and aperture together. |
| IMPORT_C void | SetAutoFocusArea | ( | TAutoFocusArea | aAutoFocusArea | ) |
Sets a specific auto focus area on the camera. Focus area change fires a KUidECamEventCameraSettingAutoFocusArea event to all MCameraObserver2 clients of the camera.
| TAutoFocusArea aAutoFocusArea | Autofocus area selection. |
| IMPORT_C void | SetAutoFocusLockOn | ( | TBool | aState | ) |
Sets autofocus lock state. Triggers a KUidECamEventCameraSettingAutoFocusLock event to all MCameraObserver2 clients.
| TBool aState | Required new state. |
| IMPORT_C void | SetAutoFocusType | ( | TAutoFocusType | aAutoFocusType | ) |
Sets a specific auto focus type on the camera. The focus type change fires both, KUidECamEventCameraSettingAutoFocusType and KUidECamEventCameraSettingAutoFocusType2 event to all MCameraObserver2 clients of the camera. KUidECamEventCameraSettingAutoFocusType
| TAutoFocusType aAutoFocusType | Autofocus selection. |
| IMPORT_C void | SetAutomaticSizeSelectionChangeOn | ( | TBool | aSetOn | ) |
Allow camera to proactively change image size due external factors. Default value is EFalse. Triggers a KUidECamEventCameraSettingAutomaticSizeSelection event notification.
| TBool aSetOn | whether the option should be switched on |
| IMPORT_C void | SetBracketMerge | ( | TInt | aStartIndex, |
| TInt | aFrames | |||
| ) | ||||
there must be at least two images to merge. All are assumed to form a sequence and are identified using the first frame index and number of frames e.g. to merge two frames - one on and one +1, when in EBracketMode3Image, one sets the start index to 1 and frames to 2. MCameraObserver2 clients are notified with a KUidECamEventBracketMerge event.
It is very TBracketMode setting dependent.
| IMPORT_C void | SetBracketMode | ( | TBracketMode | aBracketMode | ) |
Set new bracket mode. All MCameraObserver2 clients are notified with KUidECamEventCameraSettingBracketMode.
| TBracketMode aBracketMode | new selection for bracket mode of type TBracketMode. |
| IMPORT_C void | SetBracketParameter | ( | TBracketParameter | aBracketParameter | ) |
Set new bracket parameter When set all clients are notified with KUidECamEventCameraSettingBracketParameter.
| TBracketParameter aBracketParameter | new selection for parameter type of type TBracketParameter. |
| IMPORT_C void | SetBracketStep | ( | TBracketStep | aBracketStep | ) |
Set new bracket step. All MCameraObserver2 clients are notified with KUidECamEventCameraSettingBracketStep.
| TBracketStep aBracketStep | new selection for step of type TBracketStep. |
| IMPORT_C void | SetBurstImages | ( | TInt | aImages | ) |
: due to memory or image size limitations the actual number may be less.
Unless reduced Latency scheme is not used (ie CaptureImageL(TInt aSequenceNumber) or StartPerformantVideoCaptureL()) if an image/video capture is still outstanding, this method may report error KErrInUse.
| TInt aImages | the number of images set to capture in burst mode |
| void | SetClientPriorityL | ( | TInt | aPriority | ) | [private] |
Sets the priority of the client. The client issues this call when it receives the notification KUidECamEvent2CameraSettingChangeClientPriority. The target priority is also supplied with this notification as iParam.
For example, a higher priority client is currently holding the camera and a lower priority legacy application is continuously requesting to get hold of it. After receiving a number of repeated requests by the same legacy client, the supportive ECam implementation issues the notification KUidECamEvent2CameraSettingChangeClientPriority. After receiving this notification, the client issues this method SetClientPriorityL(TInt aPriority) .
| TInt aPriority | The target priority. |
| IMPORT_C void | SetContinuousAutoFocusTimeout | ( | TInt | aTimeout | ) |
Sets the current value for continuous autofocus timeout. Timeouts are in microseconds. All MCameraObserver2 clients of the camera receive a KUidECamEventCameraSettingsContinuousAutoFocusTimeout event notification when timeout value is changed.
| TInt aTimeout | the timeout value in microseconds. |
| IMPORT_C void | SetDigitalZoom | ( | TInt | aDigitalZoom | ) |
Sets the digital zoom value. Triggers a KUidECamEventCameraSettingDigitalZoom event to all MCameraObserver2 clients.
| TInt aDigitalZoom | Required zoom value. |
| IMPORT_C void | SetDriveMode | ( | TDriveMode | aDriveMode | ) |
Set the current metering mode. When set all MCameraObserver2 clients are notified with KUidECamEventCameraSettingDriveMode.
Unless reduced Latency scheme is not used (ie CaptureImageL(TInt aSequenceNumber) or StartPerformantVideoCaptureL()) if an image/video capture is still outstanding, this method may report error KErrInUse.
| TDriveMode aDriveMode | new selection for drive mode value of type TDriveMode. |
| IMPORT_C void | SetExposureCompensation | ( | TInt | aExposureCompensationInSteps | ) |
Set the current exposure compensation value as integer steps. Triggers a KUidECamEventCameraSettingExposureCompensation event to all MCameraObserver2 clients.
| TInt aExposureCompensationInSteps | a required number of compensation steps - negative value reduce the exposure time positive increases the exposure time. |
| IMPORT_C void | SetExposureCompensationStep | ( | TInt | aExposureCompensationStep | ) |
Set current exposure compensation step as an integer multiplied by KECamFineResolutionFactor. All MCameraObserver2 clients receive a KUidECamEventCameraSettingExposureCompensationStep event, when the value has changed.
| TInt aExposureCompensationStep | a new value for the exposure compensation step. |
| IMPORT_C void | SetExposureLockOn | ( | TBool | aState | ) |
Sets exposure lock state. Triggers a KUidECamEventCameraSettingExposureLock event to all MCameraObserver2 clients.
| TBool aState | Required new state. |
| IMPORT_C void | SetExposureMode | ( | CCamera::TExposure | aExposureMode | ) |
Sets the exposure mode of the camera. Triggers a KUidECamEventCameraSettingExposureMode event to all MCameraObserver2 clients.
| CCamera::TExposure aExposureMode | The required exposure adjustment. |
| IMPORT_C void | SetFlashCompensation | ( | TInt | aFlashCompensationInSteps | ) |
Set the current flash compensation value as integer steps. Positive values increase power, negative reduce power. The change is not acumulative e.g. the change is stateless. Each call assumes no previous compensation has been performed i.e. that there is a zero compensation. Triggers a KUidECamEventCameraSettingFlashCompensation event.
| TInt aFlashCompensationInSteps | a required compensation steps - negative value reduce the flash power positive boosts up the flash power. |
| IMPORT_C void | SetFlashCompensationStep | ( | TInt | aFlashCompensationStep | ) |
Set current flash compensation step as an integer multiplied by KECamFineResolutionFactor. For example to set a compensation of -0.3 EV, one should use a parameter with value -30. All clients receive a KUidECamEventCameraSettingFlashCompensationStep event, when the value has changed.
| TInt aFlashCompensationStep | a new value for the flash compensation step. |
| IMPORT_C void | SetFlashMode | ( | CCamera::TFlash | aMode | ) |
Sets the flash mode.
Triggers a KUidECamEventCameraSettingFlashMode event to all camera MCameraObserver2 clients.
| CCamera::TFlash aMode | The required flash mode. |
| void | SetFlickerRemovalValueL | ( | TFlickerRemoval | aFlickerRemovalValue | ) | [private] |
Set the flicker removal value.
Event KUidECamEventCameraSettingFlickerRemovalValue is used to notify clients about the flicker removal value setting operation.
| TFlickerRemoval aFlickerRemovalValue | The TFlickerRemoval value to be set. |
| IMPORT_C void | SetFocusDistance | ( | TInt | aDistance | ) |
Set focus distance in millimetres. Focus distance change fires a KUidECamEventCameraSettingFocusDistance event to all MCameraObserver2 clients of the camera.
KUidECamEvent2CameraSettingFocusDistance may be used to provide the focussing feedback as well. This means that the feedback will state whether the proper focussing has been achieved after setting the given focus distance.
| TInt aDistance | the new distance value in millimetres. |
| IMPORT_C void | SetFocusMode | ( | TFocusMode | aFocusMode | ) |
Sets a specific focus mode on the camera. Focus mode change fires a KUidECamEventCameraSettingFocusMode event to all MCameraObserver2 clients of the camera.
| TFocusMode aFocusMode | new focus mode of TFocusMode type. |
| IMPORT_C void | SetFocusRange | ( | TFocusRange | aFocusRange | ) |
Sets a specific focus range on the camera. The focus range change fires both, KUidECamEventCameraSettingFocusRange and KUidECamEventCameraSettingFocusRange2 event to all MCameraObserver2 clients of the camera. KUidECamEventCameraSettingFocusRange
| TFocusRange aFocusRange | newly selected focus range. |
| IMPORT_C void | SetISORateL | ( | TISORateType | aISORateType, |
| TInt | aParam | |||
| ) | ||||
Set the type of ISO rate and the exposure parameter or value specified.
Triggers KUidECamEventCameraSettingIsoRateType to all MCameraObserver2 clients of the camera. HandleEvent is used to report the result or any possible error. New setter functions leave only when implementation is not there.
| TISORateType aISORateType | The type of ISO rate to be set. |
| TInt aParam | Depending on the value of aISORateType, possible values of aParam are one of the following:- The value of ISO rate to be used in case of manual type of ISO rate (EISOManual). OR Redundant parameter in case of unprioritised type of auto ISO (EISOAutoUnPrioritised). It is left to the camera hardware/firmware to decide how the ISO rate is selected. No priority regarding exposure is specified. OR Highest ISO rate to be picked by the camera while deciding for the best exposure in case of ISO prioritised type of auto ISO (EISOAutoISOPrioritised). ISO rate closest to this (and lower) may be used so that best possible exposure is achieved. OR Slowest shutter speed to be picked by the camera while deciding for the best exposure in case of shutter speed prioritised type of auto ISO (EISOAutoShutterSpeedPrioritised). After using this shutter speed, ISO rate is chosen by the camera to achieve proper exposure. Shutter speed closest to this (and faster) may be used so that best possible exposure is achieved. OR Minimum aperture opening (deepest depth of field) to be picked by the camera while deciding for the best exposure in case of aperture prioritised type of auto ISO (EISOAutoAperturePrioritised). After using this aperture opening, ISO rate is chosen by the camera to achieve proper exposure. Aperture opening closest to this (and wider) may be used to achieve best possible exposure. |
| IMPORT_C void | SetIsoRate | ( | TInt | aRate | ) |
Set current ISO rate for the camera. Triggers KUidECamEventCameraSettingIsoRate to all MCameraObserver2 clients of the camera.
| TInt aRate | required new ISO rate. |
| void | SetLEDCustomEffectL | ( | TLEDEvent | aLEDEvent, |
| const RArray < TECamLEDSpecialEffectStep > & | aLEDSpecialEffectSteps | |||
| ) | [private] | |||
Set the custom LED effect for a particular LED event.
Event KUidECamEventCameraSettingLEDCustomEffect is used to notify clients about the LED effect setting operation.
Successful setting of a custom LED effect means that the GetLEDEffectL will retrieve TLEDEffectCustom for the LEDEvent aLEDEvent.
| TLEDEvent aLEDEvent | The TLEDEvent for which the custom LED effect has to be set. |
| const RArray < TECamLEDSpecialEffectStep > & aLEDSpecialEffectSteps | An array of custom LED special effect steps. Every member of this array is of type TECamLEDSpecialEffectStep. The array as a whole constitues a custom LED effect. |
| void | SetLEDEffectL | ( | TLEDEvent | aLEDEvent, |
| TLEDEffect | aLEDEffect | |||
| ) | [private] | |||
Set the LED effect for a particular LED event.
Event KUidECamEventCameraSettingLEDEffect is used to notify clients about the LED effect setting operation.
The event will provide error code KErrArgument if TLEDEffectCustom is used as the TLEDEffect. Use the method SetLEDCustomEffectL() to provide the custom LED effect.
| TLEDEvent aLEDEvent | The TLEDEvent for which the LED effect has to be set. |
| TLEDEffect aLEDEffect | The TLEDEffect which has to be set for the given LED event. It should not be TLEDEffectCustom. Use the method SetLEDCustomEffectL() to provide the custom LED effect. |
| IMPORT_C void | SetManualFlashPowerLevel | ( | TInt | aManualFlashPowerLevel | ) |
Sets the current manual flash power level on the camera. Triggers a KUidECamEventCameraSettingFlashManualPower event to all MCameraObserver2 clients.
| TInt aManualFlashPowerLevel | one of the values returned in GetManualFlashPowerLevelsL(). |
| void | SetManualGainL | ( | TInt | aManualGain, |
| TColorChannel | aColorChannel | |||
| ) | [private] | |||
Set the manual gain value for a particular color channel.
Event KUidECamEvent2CameraSettingManualGain is used to notify clients about the manual gain setting operation.
The client will be expected to use either RBG color channel or YUV color channel in order to apply manual gain. If the client sets manual gain values for both the color space, it is up to the implementation to decide which values to use.
| TInt aManualGain | The manual gain value to be set. The TInt represents the unit in 'db' and multiplied by KECamFineResolutionFactor. |
| TColorChannel aColorChannel | Represents the color channel for which the manual gain value has to be set. |
| IMPORT_C void | SetMeteringMode | ( | TMeteringMode | aMeteringMode | ) |
Set the current metering mode. When set, all MCameraObserver2 clients are notified with a KUidECamEventCameraSettingMeteringMode event.
| TMeteringMode aMeteringMode | new selection for metering mode of type TMeteringMode. |
| void | SetNDFilterL | ( | TNDFilter | aNDFilter | ) | [private] |
Set the neutral density filter.
Event KUidECamEventCameraSettingNDFilter is used to notify clients about the neutral density setting operation.
| TNDFilter aNDFilter | The TNDFilter value to be set. |
| IMPORT_C void | SetOperationPreferenceL | ( | TUint | aOperationPreferenceIndex | ) |
Set a particular operation preference.
Event KUidECamEventCameraSettingOperationPreference is used to notify clients about setting an operation preference.
| TUint aOperationPreferenceIndex | An index which reveals a set of levels to be used for performance vectors, that is, speed, quality, low memory consumption and low power consumption. |
| IMPORT_C void | SetOpticalZoom | ( | TInt | aOpticalZoom | ) |
Sets the zoom using a specific value. Triggers a KUidECamEventCameraSettingOpticalZoom event to all MCameraObserver2 clients.
| TInt aOpticalZoom | Required zoom value. |
| IMPORT_C void | SetPictureOrientation | ( | TPictureOrientation | aOrientation | ) |
Set a new picture orientation This triggers a KUidECamEventCameraSettingPictureOrientation event to all MCameraObserver2 clients.
| TPictureOrientation aOrientation | a value of TPictureOrientation denoting the new orientation. |
| IMPORT_C void | SetPixelAspectRatio | ( | TPixelAspectRatio | aPixelAspectRatio | ) |
Set a new pixel aspect ratio. This triggers a KUidECamEventPixelAspectRatio event to all MCameraObserver2 clients.
| TPixelAspectRatio aPixelAspectRatio | a value of TPixelAspectRatio denoting the new pixel aspect ratio. |
| IMPORT_C void | SetRedEyeReduceOn | ( | TBool | aState | ) |
Sets the flash red eye reduction on or off.
Triggers a KUidECamEventCameraSettingFlashRedEyeReduce event to all camera MCameraObserver2 clients.
| TBool aState | The required state ETrue for switching it on and EFalse for switching it off. |
| IMPORT_C void | SetReferenceScreenL | ( | CWsScreenDevice & | aScreenDevice | ) |
Provide reference screen for orientation information.
Triggers KUidECamEventCameraSettingReferenceScreen to all MCameraObserver2 clients of the camera. HandleEvent is used to report the result or any possible error. New setter functions leave only when implementation is not there.
| CWsScreenDevice & aScreenDevice | A reference to the screen device. |
| IMPORT_C void | SetShootClickOn | ( | TBool | aShootClickOn | ) |
Sets the button clicking sound on /off. Triggers a KUidECamEventSoundClick event to all MCameraObserver2 clients.
| TBool aShootClickOn | ETrue to switch clicking sound on, EFalse sound is switched off. |
| IMPORT_C void | SetShutterSpeed | ( | TInt | aShutterSpeed | ) |
Sets the current shutter speed. When set, all MCameraObserver2 clients of the camera receive a KUidECamEventCameraSettingShutterSpeed event
| TInt aShutterSpeed | the required shutter speed in microseconds. |
| IMPORT_C void | SetStabilizationComplexity | ( | TStabilizationAlgorithmComplexity | aComplexity | ) |
Sets a specific stabilization algorithm on the camera. When a value is set, MCameraObserver2 clients for that camera will receive a KUidECamEventSettingsStabilizationAlgorithmComplexity event notification.
| TStabilizationAlgorithmComplexity aComplexity | stabilization effect selection of type TStabilizationAlgorithmComplexity. |
| IMPORT_C void | SetStabilizationEffect | ( | TStabilizationEffect | aEffect | ) |
Sets a specific stabilization effect on the camera. When a value is set, MCameraObserver2 clients for that camera will receive a KUidECamEventCameraSettingsStabilizationEffect event notification.
| TStabilizationEffect aEffect | stabilization effect selection of type TStabilizationEffect. |
| IMPORT_C void | SetStabilizationMode | ( | TStabilizationMode | aStabilizationMode | ) |
Sets a specific stabilization mode on the camera.
Stabilization mode change fires a KUidECamEventCameraSettingStabilizationMode event to all MCameraObserver2 clients of this specific camera.
| TStabilizationMode aStabilizationMode | new stabilization mode of TStabilizationMode type. |
| IMPORT_C void | SetTimeLapse | ( | const TTime & | aStart, |
| const TTime & | aEnd, | |||
| const TTime & | aInterval | |||
| ) | ||||
Set current time lapse value. Active only when drive mode EDriveModeTimeLapse. The time lapse is denoted as the uniform time period between consecutive frames. Setting triggers a KUidECamEventCameraSettingTimeLapse event to all MCameraObserver2 camera clients.
| IMPORT_C void | SetTimerInterval | ( | TInt | aTimerInterval | ) |
Set current timer value. Active only when drive mode EDriveModeTimed. This is the time interval (delay) in microseconds between user pressing the button and image is taken. The setting of the value triggers a KUidECamEventCameraSettingTimerInterval event to all MCameraObserver2 clients.
| TInt aTimerInterval | The selected timer interval in microseconds. |
| IMPORT_C void | SetWBColorTemperature | ( | TInt | aWBColorTemperature | ) |
Set the white balance as a temperature in Kelvin
| TInt aWBColorTemperature | white balance value as a temperature in Kelvins. |
| IMPORT_C void | SetWBRgbValue | ( | const TRgb & | aValue | ) |
Set white balance value using a RGB triplet. Change in value causes an event notification KUidECamEventCameraSettingsWBValue to be sent to all MCameraObserver2 clients of this camera.
| const TRgb & aValue | a const reference to TRgb object, which contains the new white balance. |
| void | SetWhiteBalanceLockL | ( | TBool | aEnableLock | ) | [private] |
Control the white balance lock. It can be either locked or unlocked. The white balance can be locked after aiming at a white or grey card. This helps in using the same white balance setting for the next image shots.
Event KUidECamEventCameraSettingLockWhiteBalance is used to notify clients about setting the state of white balance lock.
| TBool aEnableLock | ETrue instructs to lock the white balance. EFalse instructs to unlock the white balance. |
| IMPORT_C void | SetWhiteBalanceMode | ( | CCamera::TWhiteBalance | aWhiteBalanceMode | ) |
Sets the white balance adjustment of the camera.
No effect if this is not supported, see TCameraInfo::iWhiteBalanceModesSupported . Triggers KUidECamEventCameraSettingWhiteBalanceMode event to all MCameraObserver2 clients.
| CCamera::TWhiteBalance aWhiteBalanceMode | The required white balance mode. |
| IMPORT_C void | SetYuvRange | ( | TYuvRange | aYuvRange | ) |
Set a new YUV range. This triggers a KUidECamEventYuvRange event to all MCameraObserver2 clients.
| TYuvRange aYuvRange | a value of TYuvRange denoting the new YUV range. |
| IMPORT_C TBool | ShootClickOn | ( | ) | const |
Gets the current state for button clicking sound effect.
| IMPORT_C TStabilizationAlgorithmComplexity | StabilizationComplexity | ( | ) | const |
Gets current active stabilization algorithm selection on the camera.
| IMPORT_C TStabilizationEffect | StabilizationEffect | ( | ) | const |
Gets all supported stabilization effects on the camera.
| IMPORT_C TStabilizationMode | StabilizationMode | ( | ) | const |
Gets current stabilization mode on the camera. The result is a valid TStabilizationMode value.
| IMPORT_C void | SubscribeToPreCaptureWarningL | ( | TInt | aPreCaptureWarning | ) |
Subscribe in order to receive event which indicates warnings on occurrence of some specific unfavourable conditions before image/video capture.
When any of the subscribed warnings (represented by aPreCaptureWarning) get generated by the camera device, event KUidECamEventCameraSettingPreCaptureWarning is issued. TECAMEvent2 class should be used in order to provide the status of every PreCaptureWarning.
| TInt aPreCaptureWarning | A bitfield specifying all the TPreCaptureWarning types to be subscribed for. |
| IMPORT_C TInt | SupportedAutoFocusAreas | ( | ) | const |
Gets all supported auto focus areas on the camera.
| IMPORT_C TInt | SupportedAutoFocusTypes | ( | ) | const |
Gets all supported auto focus types on the camera.
| IMPORT_C TInt | SupportedBracketModes | ( | ) | const |
Get all supported bracket modes as bitfields.
| IMPORT_C TInt | SupportedBracketParameters | ( | ) | const |
Get all supported bracket parameters as bitfields.
| IMPORT_C TInt | SupportedBracketSteps | ( | ) | const |
Get all supported bracket steps as bitfields.
| IMPORT_C TInt | SupportedDriveModes | ( | ) | const |
Get all supported drive modes as bitfields of TDriveMode type.
| IMPORT_C TInt | SupportedExposureModes | ( | ) | const |
Get Supported exposure modes - bitfields of CCamera::TExposure
| IMPORT_C TInt | SupportedFlashModes | ( | ) | const |
Get camera all supported flash modes CCamera::TFlash
Some of the flash modes are available only for clients using either CCamera::New2L() or CCamera::NewDuplicate2L()
| IMPORT_C TInt | SupportedFocusModes | ( | ) | const |
Gets all of the supported focus modes on the camera. The result is a bitfield of the valid TFocusMode flags. TFocusMode
| IMPORT_C TInt | SupportedFocusRanges | ( | ) | const |
Gets all supported focus ranges on the camera.
if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that application is not prepared to receive extra added enum values. So, any extra enum value passed from the implementation will be filtered at this point. To receive extra added enum values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L() to create camera object. In this case, application is assumed to be prepared to receive unrecognised enum values
| IMPORT_C TInt | SupportedMeteringModes | ( | ) | const |
Get all supported metering modes on this camera represented as bitfield of type TMeteringMode.
| IMPORT_C TInt | SupportedPixelAspectRatios | ( | ) | const |
Get supported pixel aspect ratio.
Some of the pixel aspect ratios are available only for clients using either CCamera::New2L() or CCamera::NewDuplicate2L()
| IMPORT_C TInt | SupportedStabilizationComplexityValues | ( | ) | const |
Gets all supported stabilization algorithm values on the camera.
| IMPORT_C TInt | SupportedStabilizationEffects | ( | ) | const |
Gets the current stabilization effect on the camera.
| IMPORT_C TInt | SupportedStabilizationModes | ( | ) | const |
Gets all of the supported stabilization modes on the camera. The result is a bitfield of the valid TStabilizationMode flags. TStabilizationMode
| IMPORT_C TWBUnits | SupportedWBUnits | ( | ) | const |
The methods used to get or set these differ depending on the supported unit type. It is expected that a camera will support only a single type or none.
| IMPORT_C TInt | SupportedWhiteBalanceModes | ( | ) | const |
Gets camera supported set of white balance adjustments.
if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that application is not prepared to receive extra added enum values. So, any extra enum value(unrecognised) passed from the implementation will be filtered at this point. To receive extra added enum values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L() to create camera object. In this case, application is assumed to be prepared to receive unrecognised enum values
| IMPORT_C TInt | TimerInterval | ( | ) | const |
Get current timer value. Active only when drive mode is EDriveModeTimed. Timer resolution is in microseconds.
| IMPORT_C void | UnSubscribePreCaptureWarningL | ( | ) |
Unsubscribe so that further events are not received when warnings get issued.
| IMPORT_C TInt | WBColorTemperature | ( | ) | const |
Get the white balance as a temperature in Kelvin
| IMPORT_C CCamera::TWhiteBalance | WhiteBalanceMode | ( | ) | const |
Gets the current white balance value.
if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that application is not prepared to receive extra added enum values. So, any extra enum value(unrecognised) received from the implementation will be dropped and EWBAuto would be passed instead. To receive extra added enum values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L() to create camera object. In this case, application is assumed to be prepared to receive unrecognised enum values
Specifies the different types of auto focus assistant light
| EAFAssistantLightOff = 0x00 |
switch off the AF assistant light from either of 'manual on' or 'auto' mode |
| EAFAssistantLightManualOn = 0x01 |
switch on the AF assistant light manually |
| EAFAssistantLightAuto = 0x02 |
Put the AF assistant light in auto mode. It will be automatically decided when to switch on or off. |
Specifies the autofocus area.
| EAutoFocusTypeAuto = 0x00 |
Automatic. Default value |
| EAutoFocusTypeSingleArea = 0x01 |
Single area, suitable for relatively flat surfaces and portrait. |
| EAutoFocusTypeMultiAreaCentered = 0x02 |
Multiple points of an object, more weighting for centre points. |
Specifies the supported autofocus types.
| EAutoFocusTypeOff = 0x00 |
Autofocus is switched off. |
| EAutoFocusTypeSingle = 0x01 |
Operates on a single shot, consumes less power. |
| EAutoFocusTypeContinuous = 0x02 |
Continious autofocus, more precise but consumes more power. also known as AF Servo. |
Specifies Bracket mode.
| EBracketModeOff = 0x0000 |
Bracket mode is switched off. Default value. |
| EBracketMode3Image = 0x0001 |
Bracket mode on. Three consecutive pictures are taken in order under (-1), on (0), over (+1), where correction magnitude is defined by bracket step size and by TBracketParameter TBracketStep TBracketParameter |
| EBracketMode5Image = 0x0002 |
Bracket mode on. Five consecutive pictures are taken in order under (-2),under (-1), on (0), over (+1), over (+2), where correction magnitude is defined by bracket step size and by TBracketParameter TBracketStep TBracketParameter |
Bracket mode parameter value changes by a selected uniform step between successive image shots.
| EBracketParameterNone = 0x0000 |
None. |
| EBracketParameterExposure = 0x0001 |
Exposure settings change. |
| EBracketParameterFlashPower = 0x0002 |
Flash power change. |
| EBracketParameterColourBalance = 0x0004 |
Colour balance settings change. |
| BracketParameterAperture = 0x0008 |
Aperture settings change. |
| BracketParameterAutoFocus = 0x0010 |
Autofocus settings change. |
Specifies the magnitude of bracketing step. The actual value and availability is parameter dependent. TBracketParameter
| EBracketStepNonConfig = 0x00 |
Not supported. |
| EBracketStepSmall = 0x01 |
Small value. |
| EBracketStepMedium = 0x02 |
Medium value. |
| EBracketStepLarge = 0x04 |
Large value. |
Describes the camera mode.
| EModeIdle = 0x00 |
Camera is Idle |
| EModeDSAViewFinder = 0x01 |
DSA based Viewfinder runs |
| EModeClientViewFinder = 0x02 |
Client based Viewfinder runs |
Specifies camera type.
| ECameraUnknown = 0x00 |
Unable to identify. |
| ECameraOnBoard = 0x01 |
Camera is non-detachable from device. Camera is always present. |
| ECameraPluggable = 0x02 |
Camera is detachable from device. Camera is not always present. |
Color channels on which manual gain can be selectively applied. The enumeration list may be extended in future.
| EColorChannelRed |
Red Color Channel (RGB model). |
| EColorChannelGreen |
Green Color Channel (RGB model). |
| EColorChannelBlue |
Blue Color Channel (RGB model). |
| EChannelLumaY |
Luminance Y component (YUV model). |
| EChannelChromaU |
Chrominance U component (YUV model). |
| EChannelChromaV |
Chrominance V component (YUV model). |
Specifies the different types of continuous zoom supported. The enumeration list may be extended in future.
| EContinuousZoomNotSupported = 0x00 |
Continuous zoom not supported |
| EContinuousZoomOpticalOnly = 0x01 |
Continuous zoom 'Optical' only, No 'Digital' |
| EContinuousZoomMixed = 0x02 |
Continuous zoom 'Optical' and 'Digital' |
| EContinuousZoomDigitalOnly = 0x04 |
Continuous zoom 'Digital' only, No 'Optical' |
Specifies the drive mode for the camera. This determines how and in what sucession are images shot. EDriveModeSingleShot is the default.
| EDriveModeAuto = 0x0000 |
Automatic. Default |
| EDriveModeSingleShot = 0x0001 |
Camera takes a single image/shot. |
| EDriveModeContinuous = 0x0002 |
Camera continuously captures images (as fast as it can) until stopped or out of storage medium. |
| EDriveModeBracket = 0x0004 |
Camera is in bracketing mode, producing individual frames. TBracketMode |
| EDriveModeBracketMerge = 0x0008 |
Camera is in bracketing mode, but producing a single image. TBracketMode |
| EDriveModeTimed = 0x0010 |
camera captures a single shot after specified time period. Timer() |
| EDriveModeTimeLapse = 0x0020 |
Camera captures a set of images with an uniform interval between them. TimeLapse() |
| EDriveModeBurst = 0x0040 |
Camera captures a set of images as fast as it can, but in batches(bursts). |
| EDriveModeTimeNudgeCapture = 0x0080 |
Camera captures a set of images before and after camera capture key press event. Client can specify the amount of pre-capture and post-capture images to be saved via TDriveModeDependentAttributes. The total amount of images to be saved will be pre-capture images + 1 + post-capture images.
Note:
This drive mode is only available to clients using the CCamera::New2L() or CCamera::NewDuplicate2L() in addition to the new image capture APIs ie. CCameraPreImageCaptureControl , CCameraImageCapture and CCameraPostImageCaptureControl . |
| EECAMEventFilterSchemeBlackList |
Black listing will mean not to receive specific events |
| EECAMEventFilterSchemeWhiteList |
White listing will mean to receive only specific events |
Specifies flicker removal options. The enumeration list may be extended in future.
| EFlickerRemovalNone = 0x00 |
Not Supported. |
| EFlickerRemoval50Hz = 0x01 |
Flicker removal for Field frequency of 50Hz. |
| EFlickerRemoval60Hz = 0x02 |
Flicker removal for Field frequency of 60Hz. |
| EFlickerRemovalAuto = 0x04 |
Auto flicker removal. |
| EFlickerRemovalSwitchOff = 0x08 |
Switch Off flicker removal. |
Supported focus modes.
| EFocusModeUnknown = 0x00 |
Focus mode is unknown. |
| EFocusModeAuto = 0x01 |
Focus is automatic, default. |
| EFocusModeFixed = 0x02 |
Focus is fixed. |
| EFocusModeManual = 0x04 |
Focus is manually set. |
Supported focus ranges.
| EFocusRangeAuto = 0x00 |
Auto. Default |
| EFocusRangeMacro = 0x01 |
Focus operates in close range (macro). |
| EFocusRangeNormal = 0x02 |
Normal operation. |
| EFocusRangeTele = 0x04 |
Extended (tele) operation. |
| EFocusRangePortrait = 0x08 |
Focus at larger areas at short to medium distance. |
| EFocusRangeSuperMacro = 0x10 |
Optimised macro operation, where depth of field is very shallow and observation area changes quickly. |
| EFocusRangeHyperfocal = 0x20 |
All objects at distances from half of the hyperfocal distance out to infinity will be in focus. This gives gives maximum depth of field. This enum value is available from the 'supported' or 'getter' methods only to the API clients using CCamera::New2L() or CCamera::NewDuplicate2L() . |
| EFocusRangeInfinite = 0x40 |
When there is a near obstacle or better focus wanted for far away objects. This enum value is available from the 'supported' or 'getter' methods only to the API clients using CCamera::New2L() or CCamera::NewDuplicate2L() . |
Specifies the ISO type supported by the camera. ISO refers to the sensivity of the image sensor and is one of the factors influencing the exposure.
| EISONone = 0x00 |
ISO Not supported. Camera uses a fixed ISO rate internally and never reveals this information. |
| EISOManual = 0x01 |
Camera gives a list of manual ISO rates to the user to set. Recommendation is to start camera in the manual ISO mode, by default. |
| EISOAutoUnPrioritised = 0x02 |
Camera chooses the ISO on its own without prioritising any particular exposure parameters. |
| EISOAutoISOPrioritised = 0x04 |
Camera chooses the ISO on its own by prioritising ISO. |
| EISOAutoShutterSpeedPrioritised = 0x08 |
Camera chooses the ISO on its own after prioritising shutter speed. |
| EISOAutoAperturePrioritised = 0x10 |
Camera chooses the ISO on its own after prioritising aperture opening. |
Specifes the type of LED effects available. The enumeration list may be extended in future.
| ELEDEffectNone = 0x00 |
Not supported. |
| ELEDEffectHardwired = 0x01 |
LED always on. |
| ELEDEffectAuto = 0x02 |
LED auto. |
| ELEDEffectManualSwitchOn = 0x04 |
LED Effect manually switched on. |
| ELEDEffectSwitchOff = 0x08 |
LED Effect switched off. |
| ELEDEffectCustom = 0x10 |
LED Custom Effect. |
Specifies the various events for which the LED effects could be used. The enumeration list may be extended in future.
| ELEDEventNone = 0x00 |
Not supported. |
| ELEDEventSelfTimer = 0x01 |
LED effect needed for self timer. |
| ELEDEventViewfinderStart = 0x02 |
LED effect needed for starting of viewfinder. |
| ELEDEventViewfinderStop = 0x04 |
LED effect needed for stoping of viewfinder. |
| ELEDEventStillImageCapture = 0x08 |
LED effect needed for still image capture. |
| ELEDEventVideoRecording = 0x10 |
LED effect needed for video recording. |
Specifies the Metering mode for the camera. EMeteringModeAuto is the default value.
| EMeteringModeAuto = 0x0000 |
Automatic mode, default. |
| EMeteringModeCenterWeighted = 0x0001 |
Metering in which the center is given a weighted priority. |
| EMeteringModeSpot = 0x0002 |
Metering of a central area/spot only, also known as partial. |
| EMeteringModeEvaluative = 0x0004 |
Metering is evaluated over a matrix(several spots) and calculated as a function of that. Usually best but with increased power consumption. Alternative name multi-metering mode. |
Specifes the type of neutral density filters available. The enumeration list may be extended in future.
| ENDFilterNone = 0x00 |
Not Supported. |
| ENDFilterAuto = 0x01 |
Auto ND Filter. |
| ENDFilterSwitchedOff = 0x02 |
Switched off ND Filter. |
| ENDFilterHigh = 0x04 |
High level ND Filter. |
| ENDFilterMedium = 0x08 |
Medium level ND Filter. |
| ENDFilterLow = 0x10 |
Low level ND Filter. |
| ENDFilterGeneral = 0x20 |
General ND Filter. |
Different levels for performance vectors like speed, quality, low memory consumption and low power consumption. The enumeration list may be extended in future.
| ELevelHigh = 1 |
High level preference. |
| ELevelMedium = 2 |
Medium level preference. |
| ELevelLow = 3 |
Low level preference. |
| ELevelDontCare = 4 |
Dont care (No preference). |
Specifies the orientation of the picture.
| EPictureOrientationUnknown = 0x00 |
No information about picture orientation. |
| EPictureOrientationPortrait = 0x01 |
Portrait - height larger than width. |
| EPictureOrientationLandscape = 0x02 |
Landscape width larger than height. |
| EPictureOrientationSquare = 0x04 |
Square width equals the height. |
It is specified as a fraction of (x) horizontal pixel size divided by vertical (y) pixel size. The pixel aspect ratio for square pixels is 1/1.
| EPixelAspectUnknown = 0x00 |
Pixel ratio undetermined |
| EPixelAspect1To1 = 0x01 |
Pixel Ratio 1:1. |
| EPixelAspect12To11 = 0x02 |
Pixel Ratio 12:11 |
| EEPixelAspect11To10 = 0x04 |
Pixel Ratio 11:10. |
| EEPixelAspect59To54 = 0x08 |
Pixel Ratio 59:54. |
| EEPixelAspect16To11 = 0x10 |
Pixel Ratio 16:11.
Note:
This value is available only to the API clients using CCamera::New2L() or CCamera::NewDuplicate2L() |
| EEPixelAspect10To11 = 0x20 |
Pixel Ratio 10:11.
Note:
This value is available only to the API clients using CCamera::New2L() or CCamera::NewDuplicate2L() |
| EEPixelAspect40To33 = 0x40 |
Pixel Ratio 40:33.
Note:
This value is available only to the API clients using CCamera::New2L() or CCamera::NewDuplicate2L() |
Specifies the unfavourable circumstances as pre capture warnings which may be issued before image/video capture.
| EPCWNone = 0x0000 |
No warnings |
| EPCWOverExposure = 0x0001 |
warning to indicate that camera sensor is over exposed |
| EPCWUnderExposure = 0x0002 |
warning to indicate that camera sensor is under exposed |
| EPCWLowLight = 0x0004 |
warning to indicate that camera operates under insufficient lightning conditions |
| EPCWBadFocus = 0x0008 |
warning to indicate that focussing is not optimum. This is valid for manual/fixed focus only |
| EPCWHandShakePossible = 0x0010 |
warning to indicate that camera might not be firmly gripped (Tripod required). This is same as long exposure |
| EPCWNotEnoughPowerForFlash = 0x0020 |
warning to indicate that camera has not enough power to survive the flash operations (battery discharged) |
| EPCWWrongWhiteBalanceValue = 0x0040 |
warning to indicate that the current white balance is not the desired one |
| EPCWWrongFlashValue = 0x0080 |
warning to indicate that the current flash value is not the desired one |
| EPCWWrongDigiZoomValue = 0x0100 |
warning to indicate that the current digital zoom value is not the desired one |
| EPCWDigiZoomBadQuality = 0x0200 |
warning to indicate that the desired digital zoom affects the quality of image |
| EPCWFlashNotReady = 0x0400 |
warning to indicate that flash is not ready. Recommendation: user may subscribe for this warning or issue IsFlashReady() also. Using both options is not encouraged |
| EPCWGeneralWarning = 0x0800 |
unknown reason |
| EPCWFlashOverheated = 0x1000 |
warning to indicate that flash has been overheated.
Note:
This value is available only to the API clients using CCamera::New2L() or CCamera::NewDuplicate2L() |
| EPCWFlashNotNeeded = 0x2000 |
warning to indicate that flash will not be fired because of enough ambient light.
Note:
This value is available only to the API clients using CCamera::New2L() or CCamera::NewDuplicate2L() |
Supported stabilization algorithms, graded on complexity.
| EStabilizationComplexityAuto = 0x00 |
Stabilization algorithm selection is automatic, default. |
| EStabilizationComplexityLow = 0x01 |
Stabilization algorithm is simple - less precise but fast. |
| EStabilizationComplexityMedium = 0x02 |
Stabilization algorithm is of medium complexity. |
| EStabilizationComplexityHigh = 0x04 |
Stabilization algorithm is of high complexity. |
Supported magnitudes of stabilization effect when in manual mode.
| EStabilizationOff = 0x00 |
Stabilization effect is off. |
| EStabilizationAuto = 0x01 |
Stabilization effect is automatic, default. |
| EStabilizationFine = 0x02 |
Stabilization effect is very small in magnitude. |
| EStabilizationMedium = 0x04 |
Stabilization effect is average in magnitude. |
| EStabilizationStrong = 0x08 |
Stabilization effect is large in magnitude. |
Specifies stabilization mode of the camera.
| EStabilizationModeOff = 0x00 |
Not present or switched off, default |
| EStabilizationModeHorizontal = 0x01 |
Stabilization only in horizontal direction. |
| EStabilizationModeVertical = 0x02 |
Stabilization only in vertical direction. |
| EStabilizationModeRotation = 0x04 |
Rotational stabilization. |
| EStabilizationModeAuto = 0x08 |
Automatic stabilization. |
| EStabilizationModeManual = 0x10 |
Manual stabilization. |
Specifies the units supported by the camera for manual white balance setting.
| EWBUnknown |
The units type is undetermined or not supported. |
| EWBColorTemperature |
The white balance is represented as temperature degrees in Kelvin. |
| EWBRgb |
The white balance is represented as RGB triples. |
video compressors often use narrower than the default range. The nominal Y range is [16:235] and the U and V ranges [16:240].
| EYuvRangeUnknown = 0x00 |
Yuv range undetermined |
| EYuvRangeFull = 0x01 |
Yuv Full Range. The nominal Y,U and V colours range is [0:255]. |
| EYuvRangeVideoCropped = 0x02 |
Yuv Cropped Range. The nominal Y range is [16:235] and the U and V ranges [16:240]. |
Specifies the zoom direction for continuous zoom operation. The enumeration list may be extended in future.
| EZoomDirectionNone = 0x00 |
Implies that feature not supported. |
| EZoomDirectionWide = 0x01 |
Implies zooming out. |
| EZoomDirectionTele = 0x02 |
Implies zooming in. |
Copyright ©2010 Nokia Corporation and/or its subsidiary(-ies).
All rights
reserved. Unless otherwise stated, these materials are provided under the terms of the Eclipse Public License
v1.0.