diff -r 666f914201fb -r 2fe1408b6811 epoc32/include/ecamimageprocessing.h --- a/epoc32/include/ecamimageprocessing.h Tue Nov 24 13:55:44 2009 +0000 +++ b/epoc32/include/ecamimageprocessing.h Tue Mar 16 16:12:26 2010 +0000 @@ -1,1 +1,731 @@ -ecamimageprocessing.h +// Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies). +// All rights reserved. +// This component and the accompanying materials are made available +// under the terms of the License "Symbian Foundation License v1.0" to Symbian Foundation members and "Symbian Foundation End User License Agreement v1.0" to non-members +// which accompanies this distribution, and is available +// at the URL "http://www.symbianfoundation.org/legal/licencesv10.html". +// +// Initial Contributors: +// Nokia Corporation - initial contribution. +// +// Contributors: +// +// Description: +// + + + +/** + @file + @publishedAll + @released +*/ +#ifndef ECAMIMAGEPROCESSING_H +#define ECAMIMAGEPROCESSING_H + +#include +#include +#include +#include +#include + +class MCameraImageProcessing; +class MCameraImageProcessing2; +class MCameraImageProcessing3; + +class MImplementationFactory; + +/** +The current Version of the TColorOperationCapabilities class. + +*/ +static const TUint KECamColorOperationCapabilitiesCurrentVersion = 1; + +/** +The current Version of the TBitsIgnore class. + +*/ +static const TUint KECamBitsIgnoreCurrentVersion = 1; + +/** +The current Version of the TColorOperationEntry class. + +*/ +static const TUint KECamColorOperationEntryCurrentVersion = 1; + + +/* General purpose constants */ + +/** + Uid used to identify the CCamera Post Processing API. + Such image operations are performed on the acquired image by the camera itself. + @see CCamera::CCameraPresets +*/ +static const TUid KECamImageProcessingUid = {KECamImageProcessingUidValue}; + +/** Transformations */ +/* Adjustments */ +/** Brightness adjustment - recognized range [-100:100] */ +static const TUid KUidECamEventImageProcessingAdjustBrightness = {KUidECamEventImageProcessingAdjustBrightnessUidValue}; +/** Contrast adjustment - recognized range [-100:100] */ +static const TUid KUidECamEventImageProcessingAdjustContrast = {KUidECamEventImageProcessingAdjustContrastUidValue}; +/** Gamma adjustment - recognized range [0:1000] */ +static const TUid KUidECamEventImageProcessingAdjustGamma = {KUidECamEventImageProcessingAdjustGammaUidValue}; +/** Sharpness adjustment - recognized range [-100:100] */ +static const TUid KUidECamEventImageProcessingAdjustSharpness = {KUidECamEventImageProcessingAdjustSharpnessUidValue}; +/** Saturation adjustment - recognized range [-100:100] */ +static const TUid KUidECamEventtImageProcessingAdjustSaturation = {KUidECamEventtImageProcessingAdjustSaturationUidValue}; +static const TUid KUidECamEventImageProcessingAdjustSaturation = {KUidECamEventtImageProcessingAdjustSaturationUidValue}; +/** Hue adjustment - recognized range [-100:100] */ +static const TUid KUidECamEventtImageProcessingAdjustHue = {KUidECamEventtImageProcessingAdjustHueUidValue}; +static const TUid KUidECamEventImageProcessingAdjustHue = {KUidECamEventtImageProcessingAdjustHueUidValue}; +/** Contrast Enhancement + +This uid value is available from the 'supported' or 'getter' methods only to the API clients using CCamera::New2L() or +CCamera::NewDuplicate2L(). + +@internalTechnology +*/ +static const TUid KUidECamEventCIPAdjustContrastEnhancement = {KUidECamEventCIPAdjustContrastEnhancementUidValue}; +/** Software based Red Eye Reduction + +This uid value is available from the 'supported' or 'getter' methods only to the API clients using CCamera::New2L() or +CCamera::NewDuplicate2L() + +@internalTechnology +*/ +static const TUid KUidECamEventCIPAdjustRedEyeReduction = {KUidECamEventCIPAdjustRedEyeReductionUidValue}; + +/** +Image distortion correction. + +This uid value is available from the 'supported' or 'getter' methods only to the API clients using CCamera::New2L() or +CCamera::NewDuplicate2L() + +@internalTechnology +*/ +static const TUid KUidECamEventCIPImageDistortionCorrection = {KUidECamEventCIPImageDistortionCorrectionUidValue}; + + +/** Effect value */ +static const TUid KUidECamEventImageProcessingEffect = {KUidECamEventImageProcessingEffectUidValue}; + +/* Transforms */ +/** Crop */ +static const TUid KUidECamEventImageProcessingTransformCrop = {KUidECamEventImageProcessingTransformCropUidValue}; +/** Rotation */ +static const TUid KUidECamEventImageProcessingTransformRotate = {KUidECamEventImageProcessingTransformRotateUidValue}; +/** Mirroring */ +static const TUid KUidECamEventImageProcessingTransformMirror = {KUidECamEventImageProcessingTransformMirrorUidValue}; +/** Rescale */ +static const TUid KUidECamEventImageProcessingTransformScale = {KUidECamEventImageProcessingTransformScaleUidValue}; +/** origin subset */ +static const TUid KUidECamEventImageProcessingSourceRect = {KUidECamEventImageProcessingSourceRectUidValue}; +/** Noise reduction */ +static const TUid KUidECamEventImageProcessingNoiseReduction = {KUidECamEventImageProcessingNoiseReductionUidValue}; +/** Glare removal */ +static const TUid KUidECamEventImageProcessingGlareRemoval = {KUidECamEventImageProcessingGlareRemovalUidValue}; +/** Relative Orientation + +This uid value is available from the 'supported' or 'getter' methods only to the API clients using CCamera::New2L() or +CCamera::NewDuplicate2L(). + +@publishedPartner +@prototype +*/ +static const TUid KUidECamEventImageProcessingTransformRelativeOrientation = {KUidECamEventImageProcessingTransformRelativeOrientationUidValue}; + +/** Default value for image processing */ +static const TInt KECamImageProcessingDefaultValue = 0; + +/** +Uid used to indicate completion of StartColorSwap + +*/ +static const TUid KUidECamEventCIPStartColorSwap = {KUidECamEventCIPStartColorSwapUidValue}; + +/** +Uid used to indicate completion of StartColorAccent + +*/ +static const TUid KUidECamEventCIPStartColorAccent = {KUidECamEventCIPStartColorAccentUidValue}; + +/** +Uid used to notify that the current picture orientation is unachievable after setting the relative custom orientation. + +@see CCamera::CCameraImageProcessing::SetRelativeCustomOrientationL(TOrientationReference aOrientationReference, + TRelativeCustomOrientation aRelativeCustomOrientation); + +@publishedPartner +@prototype +*/ +static const TUid KUidECamEventPictureOrientationUnachievable = {KUidECamEventPictureOrientationUnachievableUidValue}; + +/** +This class is used to perform image processing operations on the camera. +These include brightness, contrast, gamma, hue, sharpness and saturation adjustments. The client is also +able to perform simple image transformations like cropping, rotation, mirroring, scaling, noise reduction and glare reduction. . +When an operation selection is complete, all clients are notified with the respective event UID. + +As often cameras may support only a subset of discrete values of the allowed range, +the API allows the client to retrieve those and use them explicitly. + +@note This class is not intended for sub-classing and used to standardise existing + varieties of implementations. + +@note it is assumed that setting a new value for a transformations(transform, adjust, effect) effectively + activates the transformations. Whilst for effects and adjustments there is always a value, transforms + may have a dependency on other parameters and + crop - requires setting of source rectangle. + scale - will use setting of source rectangle, and the magnification factor is + determined by the source rectangle and the output size. This is always magnification. + if a value is set, it is assumed to be a scaling factor multiplied by KECamFineResolutionFactor + and set to integer. + mirror - values of TMirror type. + rotation - the angle in degrees. + noise reduction - TNoiseReduction. + glare removal - TGlareReduction. + + Example + + @code + // Lets assume that an application would need to check whether gamma correction is + // supported on a particular platform. After obtaining a valid pointer to the interface, + // it would call GetSupportedTransformationsL() to obtain the list of the supported + // transformations and check whether KUidECamEventImageProcessingAdjustGamma + // is in the list. If it is then call SetTranformationValue(KUidECamEventImageProcessingAdjustGamma, 200); + // to set the new value. A notification will be generated to the client to indicate success. + + RArray suppTransforms; // array of supported transformations + CleanupClosePushL(suppTransforms); + + imageProcess->GetSupportedTransformationsL(suppTransfUids); + ... + // if the gamma is supported + TInt gammaCorrection = 200; // gamma correction of 2.0 + imageProcess->SetTranformationValue(KUidECamEventImageProcessingAdjustGamma, gammaCorrection); + ... + // pop stack to close the RArray + @endcode + +@note If the class methods leave, the output type parameter value is not guaranteed to be valid. + +@publishedAll +@released +*/ +class CCamera::CCameraImageProcessing : public CBase + { + + // so can use internal factory functions etc. + friend class CCamera; + +public: + + /** Gamma settings */ + enum TGamma + { + /** Sets the gamma adjustment automatically. */ + EGammaAuto = KMinTInt + }; + /** Sharpness Settings */ + enum TSharpness + { + /** Sets the sharpness adjustment automatically. */ + ESharpnessAuto = KMinTInt + }; + /** Saturation Settings */ + enum TSaturation + { + /** Sets the saturation adjustment automatically. */ + ESaturationAuto = KMinTInt + }; + /** Hue Settings */ + enum THue + { + /** Sets the hue adjustment automatically. */ + EHueAuto = KMinTInt + }; + + /** Settings for the supported effects */ + enum TEffect + { + /** Effects off is default, always supported */ + EEffectNone = 0x00000000, + /** Negative visual effect. */ + EEffectNegative = 0x00000001, + /** Black and white visual effect. */ + EEffectMonochrome = 0x00000002, + /** Solarization visual effect. */ + EEffectSolarize = 0x00000004, + /** Sepia visual effect. */ + EEffectSepia = 0x00000008, + /** Emboss visual effect. */ + EEffectEmboss = 0x00000010, + /** Red eye glare reduction visual effect. */ + EEffectRedEyeReduction = 0x00000020, + /** Vivid colour visual effect. */ + EEffectVivid = 0x00000040, + /** Neutral colour visual effect. */ + EEffectNeutral = 0x00000080, + /** Selective sharpening visual effect. */ + EEffectLowSharpening = 0x00000100, + /** + Natural visual effect. + + This enum value is available from the 'supported' or 'getter' methods only to the API clients using CCamera::New2L() or + CCamera::NewDuplicate2L(). + + */ + EEffectNatural = 0x00000200, + /** + Cine visual effect. + + This enum value is available from the 'supported' or 'getter' methods only to the API clients using CCamera::New2L() or + CCamera::NewDuplicate2L(). + + */ + EEffectCine = 0x00000400, + /** + Old film visual effect. + + This enum value is available from the 'supported' or 'getter' methods only to the API clients using CCamera::New2L() or + CCamera::NewDuplicate2L(). + + */ + EEffectOldFilm = 0x00000800, + /** + Color swap visual effect. + + This enum value is available from the 'supported' or 'getter' methods only to the API clients using CCamera::New2L() or + CCamera::NewDuplicate2L(). + + */ + EEffectColorSwap = 0x00001000, + /** + Where a list of color can be kept as they are and the rest converted to gray. + + This enum value is available from the 'supported' or 'getter' methods only to the API clients using CCamera::New2L() or + CCamera::NewDuplicate2L(). + + */ + EEffectColorAccent = 0x00002000 + }; + + /** Mirror settings */ + enum TMirror + { + /** Default value. Mirroring is disabled. */ + EMirrorNone = 0x00000000, + /** Mirror along horizontal axis. */ + EMirrorHorizontal = 0x00000001, + /** Mirror along vertical axis. */ + EMirrorVertical = 0x00000002, + /** Mirror along horizontal and vertical axis. */ + EMirrorBoth = 0x00000003 + }; + + /** Noise filter settings */ + enum TNoiseReduction + { + /** Default value. Noise reduction disabled. */ + ENoiseReductionNone = 0x0000, + /** most basic noise reduction. */ + ENoiseReductionBasic = 0x0001 + }; + + /** Glare reduction settings */ + enum TGlareReduction + { + /** Default value. Glare reduction disabled. */ + EGlareReductionNone = 0x0000, + /** most basic glare reduction. */ + EGlareReductionBasic = 0x0001 + }; + + /** + Used for color swap and color accent feature in TEffect. It describes whether the given source + or target color represents itself or a group of color. + + */ + enum TColorOperationRepresentation + { + /** Feature is not supported */ + ERepresentationNone = 0x00, + /** The given color is uniquely represented */ + ERepresentationSingle = 0x01, + /** The given color represents a group of colors */ + ERepresentationMultiple = 0x02 + }; + + /** + Used for color swap and color accent feature in TEffect. It describes the type of grouping for + source and target colors when they represent a group of color. + + */ + enum TColorOperationRgbGroupingMode + { + /** Feature is not supported */ + ERgbGroupingNone = 0x00, + /** This means no neighbourhood colors are considered */ + ERgbGroupingFixed = 0x01, + /** This means neighbourhood colors are to be automatically decided by the implementation or hardware */ + ERgbGroupingAutomatic = 0x02, + /** This means neighbourhood colors for source have to be decided by ignoring few starting bits. Used for source only */ + ERgbGroupingSignificantBits = 0x04, + /** This means colors in target are obtained as some uniform proportion using source. Used for target only */ + ERgbGroupingUniform = 0x08 + }; + + /** + Used to provide different types of references for orientation of images retrieved. These references are the various + means by the orientation of an image can be defined. Client needs to choose a particular TOrientationReference and + specify any relative rotation, mirroring and flipping on top of it. + + This enumeration has nothing to do with absolute rotation. Uid KUidECamEventImageProcessingTransformRotate is used + for absolute rotation purposes. + + The enumeration list may be extended in future. + + @publishedPartner + @prototype + */ + enum TOrientationReference + { + /** The retrieved images will follow the camera sensor orientation. This orientation would be relative + to the current screen mode as given by the reference screen. */ + EOrientationReferenceCameraSensorOrientation, + + /** The retrieved images will get oriented as per the tilt sensor information. + So,the orientation would be relative to the current screen mode as given by the reference screen. */ + EOrientationReferenceTiltOrientation + }; + + /** + Used to describe the various relative rotation. The term 'relative' means that the rotation is applied after the + image undergoes orientation as given by TOrientationReference. + + The enumeration list may be extended in future. + + @publishedPartner + @prototype + */ + enum TRelativeRotation + { + /** Zero degree Rotation applied on top of orientation reference and is relative to current reference screen. */ + ERelativeRotation0Degrees = 0x00, + /** 90 degree clockwise Rotation applied on top of orientation reference and is relative to current reference screen. */ + ERelativeRotation90DegreesClockwise = 0x01, + /** 180 degree clockwise Rotation applied on top of orientation reference and is relative to current reference screen. */ + ERelativeRotation180DegreesClockwise = 0x02, + /** 270 degree clockwise Rotation applied on top of orientation reference and is relative to current reference screen. */ + ERelativeRotation270DegreesClockwise = 0x04 + }; + + /** + Used to describe the various relative mirroring. The term 'relative' means that the mirroring is applied after the + image undergoes orientation as given by TOrientationReference. + + The enumeration list may be extended in future. + + @publishedPartner + @prototype + */ + enum TRelativeMirror + { + /** No mirroring. */ + ERelativeMirrorNone = 0x00, + /** Used to mirror an image about the horizontal axis. This is applied on top of orientation reference and is + relative to current reference screen. */ + ERelativeMirrorHorizontalAxis = 0x10, + /** Used to mirror an image about the vertical axis. This is applied on top of orientation reference and is + relative to current reference screen. */ + ERelativeMirrorVerticalAxis = 0x20 + }; + + /** + Used to describe the various relative flipping. The term 'relative' means that the flipping is applied after the + image undergoes orientation as given by TOrientationReference. + + The enumeration list may be extended in future. + + @publishedPartner + @prototype + */ + enum TRelativeFlipping + { + /** No flipping. */ + ERelativeFlippingNone = 0x00, + /** Used to flip an image horizontally. This is applied on top of orientation reference and is relative to current + reference screen. */ + ERelativeFlippingHorizontal = 0x10, + /** Used to flip an image vertically. This is applied on top of orientation reference and is relative to current + reference screen. */ + ERelativeFlippingVertical = 0x20 + }; + + /** + Different types of contrast enhancement options. + The enumeration list may be extended in future. + + @publishedPartner + @prototype + */ + enum TContrastEnhancement + { + /** Not Supported. */ + EContrastEnhancementNone =0x00, + /** Contrast Enhancement switched off. */ + EContrastEnhancementSwitchOff =0x01, + /** Contrast Enhacement switched On manually. */ + EContrastEnhancementManualSwitchOn =0x02, + /** Contrast Enhancement in auto mode. */ + EContrastEnhancementSwitchAuto =0x04 + }; + + /** + Different types of software-based red eye reduction options. + The enumeration list may be extended in future. + + @publishedPartner + @prototype + */ + enum TRedEyeReduction + { + /** Not Supported. */ + ERedEyeReductionNone =0x00, + /** Software based Red Eye Reduction can be switched off(disabled). */ + ERedEyeReductionSwitchOff =0x01, + /** Software based Red Eye Reduction can be switched on (enabled). */ + ERedEyeReductionManualSwitchOn =0x02, + /** Software based Red Eye Reduction can be put to auto mode. */ + ERedEyeReductionSwitchAuto =0x04 + }; + + /** + Color operation capabilities characterizing both color swap and color accent feature + + */ + class TColorOperationCapabilities + { + public: + /** + Constructor. + Sets the size of this class in iSize. + */ + IMPORT_C TColorOperationCapabilities(); + + IMPORT_C TInt Size() const; + IMPORT_C TUint Version() const; + + private: + //for future expansion + TUint iSize:24; + TUint iVersion:8; + + // reserved for future expansion + TInt iReserved; + + public: + /** The source color representation that the server supports. + The supported representations are held as a bitwise logical OR of the relevant individual modes + defined in CCamera::CCameraImageProcessing:: TColorOperationRepresentation. */ + TUint iSupportedSourceRepresentation; + + /** The target color representation that the server supports. + The supported representations are held as a bitwise logical OR of the relevant individual modes + defined in CCamera::CCameraImageProcessing:: TColorOperationRepresentation. + Not applicable for color accent */ + TUint iSupportedTargetRepresentation; + + /** The source color Rgb grouping modes that the server supports. + The modes are held as a bitwise logical OR of the relevant individual modes + defined in CCamera::CCameraImageProcessing:: TColorOperationRgbGroupingMode. */ + TUint iSupportedSourceRgbGroupingMode; + + /** The target color Rgb grouping modes that the server supports. + The modes are held as a bitwise logical OR of the relevant individual modes + defined in CCamera::CCameraImageProcessing:: TColorOperationRgbGroupingMode. + Not applicable for color accent */ + TUint iSupportedTargetRgbGroupingMode; + + /** This indicates whether the mapping mode and Rgb grouping mode uniform for every color entry */ + TBool iIsCapabilityUniform; + }; + + /** + Class used to control the number of bits to ignore for Red, Green, Blue or Alpha. + This may be used when deciding for neighbourhood for source color in case of color swap and color accent feature + + */ + class TBitsIgnore + { + public: + /** + Constructor. + Sets the size of this class in iSize. + */ + IMPORT_C TBitsIgnore(); + + IMPORT_C TInt Size() const; + IMPORT_C TUint Version() const; + + private: + //for future expansion + TUint iSize:24; + TUint iVersion:8; + + // for future use + TUint iReservedBits:16; + + public: + /** This gives the no. of bits to ignore for Red color. Varies from 0 to 8. + Any other value should be an error */ + TUint iRedBitsIgnore:4; + + /** This gives the no. of bits to ignore for Green color. Varies from 0 to 8. + Any other value should be an error */ + TUint iGreenBitsIgnore:4; + + /** This gives the no. of bits to ignore for Blue color. Varies from 0 to 8. + Any other value should be an error */ + TUint iBlueBitsIgnore:4; + + /** This gives the no. of bits to ignore for Alpha. Varies from 0 to 8. + Any other value should be an error */ + TUint iAlphaBitsIgnore:4; + }; + + /** + Color operation parameters characterizing both color swap and color accent feature; and for a particular entry. + + */ + class TColorOperationEntry + { + public: + /** + Constructor. + Sets the size of this class in iSize. + */ + IMPORT_C TColorOperationEntry(); + + IMPORT_C TInt Size() const; + IMPORT_C TUint Version() const; + + private: + //for future expansion + TUint iSize:24; + TUint iVersion:8; + + // reserved for future expansion + TInt iReserved; + + public: + /** The source color (rgb triplet) which is changed to target color in case of Color Swap operation + and remains unaffected in case of Color Accent operation */ + TRgb iSourceColor; + + /** The target color (rgb triplet) which replaces the source color in case of Color Swap operation. + Redundant for Color Accent operation */ + TRgb iTargetColor; + + /** This defines whether the given source color represents itself or a group of colors */ + TColorOperationRepresentation iSourceColorRepresentation; + + /** This defines whether the given target color represents itself or a group of colors in case of + Color Swap operation. Redundant for Color Accent operation */ + TColorOperationRepresentation iTargetColorRepresentation; + + /** This defines the type of grouping for multiple representation of source color */ + TColorOperationRgbGroupingMode iColorOperationSourceRgbGroupingMode; + + /** This defines the type of grouping for multiple representation of target color in case of + Color Swap operation. Redundant for Color Accent operation */ + TColorOperationRgbGroupingMode iColorOperationTargetRgbGroupingMode; + + /** This gives the number of bits to ignore in case ERgbGroupingSignificantBits is used for + multiple representation of source color. For any other case, no. of bits ignored for red, green, + blue or alpha should be 0 */ + TBitsIgnore iNumBitsIgnored; + + /** This gives the entry status of every color operation entry. If entry is not set or removed, + this is ENotActive. And if entry is set, then this is EDiscreteSteps */ + TValueInfo iEntryStatus; + }; + +public: + + IMPORT_C static CCameraImageProcessing* NewL(CCamera& aCamera); + + IMPORT_C static CCameraImageProcessing* CreateL(CCamera& aCamera, MImplementationFactory& aImplFactory); + + IMPORT_C void GetSupportedTransformationsL(RArray& aTransformations) const; + + IMPORT_C void GetActiveTransformationsL(RArray& aTransformations) const; + + IMPORT_C void GetTransformationSupportedValuesL(TUid aTransformation, RArray& aValues, TValueInfo& aInfo) const; + + IMPORT_C TInt TransformationValue(TUid aTransformation) const; + + IMPORT_C TInt GetTransformationValue(TUid aTransformation, TInt& aTransformationValue) const; + + IMPORT_C void SetTransformationValue(TUid aTransformation, TInt aValue); + + IMPORT_C void GetActiveTransformSequenceL(RArray& aTransformSequence) const; + + IMPORT_C void SetActiveTransformSequenceL(RArray& aTransformSequence); + + IMPORT_C void SetSourceRect(const TRect& aRect); + + IMPORT_C void GetSourceRect(TRect& aRect) const; + + IMPORT_C ~CCameraImageProcessing(); + + IMPORT_C void GetConcurrentColorSwappingsSupportedL(TInt& aConcurrentColorSwappingSupported) const; + + IMPORT_C void GetColorSwapCapabilitiesL(TInt aIndex, TColorOperationCapabilities& aColorSwapCapabilities) const; + + IMPORT_C void SetColorSwapEntryL(TInt aIndex, const TColorOperationEntry& aColorSwapParameters); + + IMPORT_C void RemoveColorSwapEntryL(TInt aIndex); + + IMPORT_C void GetColorSwapEntryL(TInt aIndex, TColorOperationEntry& aColorSwapParameters) const; + + IMPORT_C void StartColorSwappingL(); + + IMPORT_C void CancelColorSwappingL(); + + IMPORT_C void GetConcurrentColorAccentSupportedL(TInt& aConcurrentColorAccentSupported) const; + + IMPORT_C void GetColorAccentCapabilitiesL(TInt aIndex, TColorOperationCapabilities& aColorAccentCapabilities) const; + + IMPORT_C void SetColorAccentEntryL(TInt aIndex, const TColorOperationEntry& aColorAccentParameters); + + IMPORT_C void RemoveColorAccentEntryL(TInt aIndex); + + IMPORT_C void GetColorAccentEntryL(TInt aIndex, TColorOperationEntry& aColorAccentParameters) const; + + IMPORT_C void StartColorAccentL(); + + IMPORT_C void CancelColorAccentL(); + + IMPORT_C void GetSupportedRelativeOrientationOptionsL(TOrientationReference aOrientationReference, + TUint& aSupportedRelativeRotation, TUint& aSupportedRelativeMirroring, TUint& aSupportedRelativeFlipping) const; + + IMPORT_C void GetCurrentRelativeOrientationOptionsL(TOrientationReference& aOrientationReference, + TRelativeRotation& aRelativeRotation, TRelativeMirror& aRelativeMirror, TRelativeFlipping& aRelativeFlipping) const; + + IMPORT_C void SetRelativeOrientationOptionsL(TOrientationReference aOrientationReference, + TRelativeRotation aRelativeRotation, TRelativeMirror aRelativeMirror, TRelativeFlipping aRelativeFlipping); + +private: + CCameraImageProcessing(CCamera& aOwner); + void ConstructL(); + void ConstructL(const MImplementationFactory& aImplFactory); + +private: + CCamera& iOwner; + MCameraImageProcessing* iImpl; // not owned + MCameraImageProcessing2* iImpl2; //not owned + MCameraImageProcessing3* iImpl3; //not owned + }; +#endif//ECAMIMAGEPROCESSING_H