ecam.h

Go to the documentation of this file.

// Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of "Eclipse Public License v1.0"
// which accompanies this distribution, and is available
// at the URL "http://www.eclipse.org/legal/epl-v10.html".
//
// Initial Contributors:
// Nokia Corporation - initial contribution.
//
// Contributors:
//
// Description:
//
 
#ifndef ECAM_H
#define ECAM_H
 
#include <e32base.h>
#include <ecamuids.hrh>
#include <e32property.h>
 
#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS
#include <ecamdef.h>
#endif
 
class MFrameBuffer;
class RWsSession;
class CWsScreenDevice;
class RWindowBase;
class CFbsBitmap;
 
typedef TInt TPostCaptureControlId;
 
class TCameraInfo
    {
public:
    enum TCameraOrientation
        {
        EOrientationOutwards,
        EOrientationInwards,
        EOrientationMobile,
        EOrientationUnknown
        };
 
    enum TOptions
        {
        EViewFinderDirectSupported      = 0x0001,
        EViewFinderBitmapsSupported     = 0x0002,
        EImageCaptureSupported          = 0x0004,
        EVideoCaptureSupported          = 0x0008,
        EViewFinderMirrorSupported      = 0x0010,
        EContrastSupported              = 0x0020,
        EBrightnessSupported            = 0x0040,
        EViewFinderClippingSupported    = 0x0080,
        EImageClippingSupported         = 0x0100,
        EVideoClippingSupported         = 0x0200
        };
public:
    TVersion iHardwareVersion;
    TVersion iSoftwareVersion;
    TCameraOrientation iOrientation;
 
    TUint32 iOptionsSupported;
    TUint32 iFlashModesSupported;
    TUint32 iExposureModesSupported;
    
    TUint32 iWhiteBalanceModesSupported;
 
    TInt iMinZoom;
    TInt iMaxZoom;
    TInt iMaxDigitalZoom;
 
    TReal32 iMinZoomFactor;
    TReal32 iMaxZoomFactor;
    TReal32 iMaxDigitalZoomFactor;
 
    TInt iNumImageSizesSupported;
    TUint32 iImageFormatsSupported;
 
    TInt iNumVideoFrameSizesSupported;
    TInt iNumVideoFrameRatesSupported;
    TUint32 iVideoFrameFormatsSupported;
    TInt iMaxFramesPerBufferSupported;
    TInt iMaxBuffersSupported;
    };
 
class MCameraObserver
    {
public:
    virtual void ReserveComplete(TInt aError)=0;
 
    virtual void PowerOnComplete(TInt aError)=0;
 
    virtual void ViewFinderFrameReady(CFbsBitmap& aFrame)=0;
 
    virtual void ImageReady(CFbsBitmap* aBitmap,HBufC8* aData,TInt aError)=0;
 
    virtual void FrameBufferReady(MFrameBuffer* aFrameBuffer,TInt aError)=0;
    };
 
 
class MCameraBuffer
    {
public:
    virtual TInt NumFrames()=0;
    virtual TDesC8* DataL(TInt aFrameIndex)=0;
 
    virtual CFbsBitmap& BitmapL(TInt aFrameIndex)=0;
 
    virtual RChunk& ChunkL()=0;
 
    virtual TInt ChunkOffsetL(TInt aFrameIndex)=0;
 
    virtual TInt FrameSize(TInt aFrameIndex)=0;
 
    virtual void Release()=0;
public:
 
    TInt iIndexOfFirstFrameInBuffer;
 
    TTimeIntervalMicroSeconds iElapsedTime;
    };
 
static const TUid  KUidECamEventReserveComplete = {0x101F7D3B};
 
static const TUid  KUidECamEventPowerOnComplete = {0x101F7D3C};
 
static const TUid  KUidECamEventCameraNoLongerReserved = {0x101F7D3D};
 
static const TUid  KUidECamEventNewReserveComplete = {KUidECamEventNewReserveCompleteUidValue};
 
class TECAMEvent
    {
public:
    
    IMPORT_C TECAMEvent(TUid aEventType, TInt aErrorCode);
 
    IMPORT_C TECAMEvent();
    
    TUid iEventType;
 
    TInt iErrorCode;
    };
 
static const TUid  KUidECamEventClass2 = {KUidECamEventClass2UidValue};
 
static const TUid  KUidECamEventCIPSetColorSwapEntry           = {KUidECamEventCIPSetColorSwapEntryUidValue};
static const TUid  KUidECamEvent2CIPSetColorSwapEntry          = {KUidECamEventCIPSetColorSwapEntryUidValue};
 
static const TUid  KUidECamEventCIPRemoveColorSwapEntry        = {KUidECamEventCIPRemoveColorSwapEntryUidValue};
static const TUid  KUidECamEvent2CIPRemoveColorSwapEntry       = {KUidECamEventCIPRemoveColorSwapEntryUidValue};
 
static const TUid  KUidECamEventCIPSetColorAccentEntry         = {KUidECamEventCIPSetColorAccentEntryUidValue};
static const TUid  KUidECamEvent2CIPSetColorAccentEntry        = {KUidECamEventCIPSetColorAccentEntryUidValue};
 
static const TUid  KUidECamEventCIPRemoveColorAccentEntry      = {KUidECamEventCIPRemoveColorAccentEntryUidValue};
static const TUid  KUidECamEvent2CIPRemoveColorAccentEntry     = {KUidECamEventCIPRemoveColorAccentEntryUidValue};
 
static const TUid  KUidECamEventCameraSettingPreCaptureWarning  = {KUidECamEventCameraSettingPreCaptureWarningUidValue};
static const TUid  KUidECamEvent2CameraSettingPreCaptureWarning = {KUidECamEventCameraSettingPreCaptureWarningUidValue};
    
class TECAMEvent2 : public TECAMEvent
    {
public:
 
    IMPORT_C static TBool IsEventEncapsulationValid(const TECAMEvent& aECAMEvent);
 
    IMPORT_C TECAMEvent2(TUid aEventType, TInt aErrorCode, TInt aParam);
    
    IMPORT_C const TUid& EventClassUsed() const;
    
private:
    TUid iEventClassUsed;
    
    TInt iReserved2; 
    
    
public:
    TInt iParam1;
    
    TInt iParam;
    };
 
class MCameraObserver2
    {
public:
    virtual void HandleEvent(const TECAMEvent& aEvent)=0;
 
    virtual void ViewFinderReady(MCameraBuffer& aCameraBuffer,TInt aError)=0;
 
    virtual void ImageBufferReady(MCameraBuffer& aCameraBuffer,TInt aError)=0;
 
    virtual void VideoBufferReady(MCameraBuffer& aCameraBuffer,TInt aError)=0;
    };
 
 
class CCamera : public CBase
 
    {
    
    friend class CCameraPlugin;
 
public:
    class CCameraPresets;
    class CCameraAdvancedSettings;
    class CCameraImageProcessing;
    class CCameraHistogram;
    class CCameraV2Histogram;
    class CCameraOverlay;
    class CCameraSnapshot;
    class CCameraDirectViewFinder;
    class CCameraV2DirectViewFinder;
    class CCameraClientViewFinder;
    class CCameraPreImageCaptureControl;
    class CCameraImageCapture;
    class CCameraPostImageCaptureControl;
    class CCameraVideoCaptureControl;
    class CCameraDirectSnapshot;
    class CCameraContinuousZoom;
 
public:
    enum TFormat
        {
        EFormatMonochrome           = 0x0001,
        EFormat16bitRGB444          = 0x0002,
        EFormat16BitRGB565          = 0x0004,
        EFormat32BitRGB888          = 0x0008,
        EFormatJpeg                 = 0x0010,
        EFormatExif                 = 0x0020,
        EFormatFbsBitmapColor4K     = 0x0040,
        EFormatFbsBitmapColor64K    = 0x0080,
        EFormatFbsBitmapColor16M    = 0x0100,
        EFormatUserDefined          = 0x0200,
        EFormatYUV420Interleaved    = 0x0400,
        EFormatYUV420Planar         = 0x0800,
        EFormatYUV422               = 0x1000,
        EFormatYUV422Reversed       = 0x2000,
        EFormatYUV444               = 0x4000,
        EFormatYUV420SemiPlanar     = 0x8000,
        EFormatFbsBitmapColor16MU   = 0x00010000,
        EFormatMJPEG                = 0x00020000,
        
        EFormatEncodedH264          = 0x00040000,
 
        EFormatYUV222ReversedV2     = 0x00080000
        };
        
    enum TContrast
        {
        EContrastAuto       = KMinTInt
        };
    enum TBrightness
        {
        EBrightnessAuto     = KMinTInt
        };
    enum TFlash
        {
        EFlashNone          = 0x0000,
        EFlashAuto          = 0x0001,
        EFlashForced        = 0x0002,
        EFlashFillIn        = 0x0004,
        EFlashRedEyeReduce  = 0x0008,
        EFlashSlowFrontSync = 0x0010,
        EFlashSlowRearSync  = 0x0020, 
        EFlashManual        = 0x0040,
        EFlashVideoLight    = 0x0080
        };
    enum TExposure
        {
        EExposureAuto       = 0x0000,
        EExposureNight      = 0x0001,
        EExposureBacklight  = 0x0002,
        EExposureCenter     = 0x0004,
        EExposureSport      = 0x0008,
        EExposureVeryLong   = 0x0010,
        EExposureSnow       = 0x0020,
        EExposureBeach      = 0x0040,
        EExposureProgram    = 0x0080,
        EExposureAperturePriority   = 0x0100,
        EExposureShutterPriority    = 0x0200,
        EExposureManual             = 0x0400,
        EExposureSuperNight         = 0x0800,
        EExposureInfra              = 0x1000
        };
        
    enum TWhiteBalance
        {
        EWBAuto             = 0x0000,
        EWBDaylight         = 0x0001,
        EWBCloudy           = 0x0002,
        EWBTungsten         = 0x0004,
        EWBFluorescent      = 0x0008,
        EWBFlash            = 0x0010,
        EWBSnow             = 0x0020,
        EWBBeach            = 0x0040,
        EWBManual           = 0x0080,
        EWBShade            = 0x0100,
        EWBAutoSkin         = 0x0200,
        EWBHorizon          = 0x0400,
        EWBDaylightUnderWater  = 0x0800
        };
 
public:
    IMPORT_C static TInt CamerasAvailable();
 
    IMPORT_C static CCamera* NewL(MCameraObserver2& aObserver,TInt aCameraIndex,TInt aPriority);
 
    IMPORT_C static CCamera* New2L(MCameraObserver2& aObserver,TInt aCameraIndex,TInt aPriority);
 
    IMPORT_C static CCamera* NewL(MCameraObserver& aObserver,TInt aCameraIndex);
 
    IMPORT_C static CCamera* NewDuplicateL(MCameraObserver2& aObserver,TInt aCameraHandle);
    
    IMPORT_C static CCamera* NewDuplicate2L(MCameraObserver2& aObserver,TInt aCameraHandle);
    
    IMPORT_C static CCamera* NewDuplicateL(MCameraObserver& aObserver,TInt aCameraHandle);  
 
    virtual void CameraInfo(TCameraInfo& aInfo) const=0;
 
    virtual void Reserve()=0;
 
    virtual void Release()=0;
 
    virtual void PowerOn()=0;
 
    virtual void PowerOff()=0;
 
    virtual TInt Handle()=0;
 
    virtual void SetZoomFactorL(TInt aZoomFactor = 0)=0;
 
    virtual TInt ZoomFactor() const=0;
 
    virtual void SetDigitalZoomFactorL(TInt aDigitalZoomFactor = 0)=0;
 
    virtual TInt DigitalZoomFactor() const=0;
 
    virtual void SetContrastL(TInt aContrast)=0;
 
    virtual TInt Contrast() const=0;
 
    virtual void SetBrightnessL(TInt aBrightness)=0;
 
    virtual TInt Brightness() const=0;
 
    virtual void SetFlashL(TFlash aFlash = EFlashNone)=0;
 
    virtual TFlash Flash() const=0;
 
    virtual void SetExposureL(TExposure aExposure = EExposureAuto)=0;
 
    virtual TExposure Exposure() const=0;
 
    virtual void SetWhiteBalanceL(TWhiteBalance aWhiteBalance = EWBAuto)=0;
 
    virtual TWhiteBalance WhiteBalance() const=0;
 
    virtual void StartViewFinderDirectL(RWsSession& aWs,CWsScreenDevice& aScreenDevice,RWindowBase& aWindow,TRect& aScreenRect)=0;
 
    virtual void StartViewFinderDirectL(RWsSession& aWs,CWsScreenDevice& aScreenDevice,RWindowBase& aWindow,TRect& aScreenRect,TRect& aClipRect)=0;
 
    virtual void StartViewFinderBitmapsL(TSize& aSize)=0;   
 
    virtual void StartViewFinderBitmapsL(TSize& aSize,TRect& aClipRect)=0;
 
    virtual void StartViewFinderL(TFormat aImageFormat,TSize& aSize)=0;
 
    virtual void StartViewFinderL(TFormat aImageFormat,TSize& aSize,TRect& aClipRect)=0;
 
    virtual void StopViewFinder()=0;
 
    virtual TBool ViewFinderActive() const=0;
 
    virtual void SetViewFinderMirrorL(TBool aMirror)=0;
 
    virtual TBool ViewFinderMirror() const=0;
 
    virtual void PrepareImageCaptureL(TFormat aImageFormat,TInt aSizeIndex)=0;
 
    virtual void PrepareImageCaptureL(TFormat aImageFormat,TInt aSizeIndex,const TRect& aClipRect)=0;
 
    virtual void CaptureImage()=0;
 
    virtual void CancelCaptureImage()=0;
 
    virtual void EnumerateCaptureSizes(TSize& aSize,TInt aSizeIndex,TFormat aFormat) const=0;
 
    virtual void PrepareVideoCaptureL(TFormat aFormat,TInt aSizeIndex,TInt aRateIndex,TInt aBuffersToUse,TInt aFramesPerBuffer)=0;
 
    virtual void PrepareVideoCaptureL(TFormat aFormat,TInt aSizeIndex,TInt aRateIndex,TInt aBuffersToUse,TInt aFramesPerBuffer,const TRect& aClipRect)=0;
 
    virtual void StartVideoCapture()=0;
 
    virtual void StopVideoCapture()=0;
 
    virtual TBool VideoCaptureActive() const=0;
 
    virtual void EnumerateVideoFrameSizes(TSize& aSize,TInt aSizeIndex,TFormat aFormat) const=0;
 
    virtual void EnumerateVideoFrameRates(TReal32& aRate,TInt aRateIndex,TFormat aFormat,TInt aSizeIndex,TExposure aExposure = EExposureAuto) const=0;
 
    virtual void GetFrameSize(TSize& aSize) const=0;
 
    virtual TReal32 FrameRate() const=0;
 
    virtual TInt BuffersInUse() const=0;
 
    virtual TInt FramesPerBuffer() const=0;
 
    virtual void SetJpegQuality(TInt aQuality)=0;
 
    virtual TInt JpegQuality() const=0;
 
    virtual TAny* CustomInterface(TUid aInterface)=0;
    
    IMPORT_C TInt CameraVersion();
    
private:
 
    IMPORT_C CCamera();
    };
 
class MFrameBuffer
    {
public:
    virtual TDesC8* DataL(TInt aIndex)=0;
 
    virtual CFbsBitmap* FrameL(TInt aIndex)=0;
 
    virtual void Release()=0;
    
public:
 
    TInt iIndexOfFirstFrameInBuffer;
 
    TTimeIntervalMicroSeconds iElapsedTime;
    };
 
#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS
#include <ecamconst.h>
#endif
 
class MReserveObserver;
 
 
class CCameraStatusWatch : public CActive
    {
public:
    IMPORT_C ~CCameraStatusWatch();
    static CCameraStatusWatch* NewL(MReserveObserver& aReserveObserver, TInt aCameraIndex, TInt aSecureId);
private:
    
    CCameraStatusWatch(MReserveObserver& aReserveObserver, TInt aCameraIndex, TInt aSecureId);
    void ConstructL();
    void RunL();
    void DoCancel();
    
private:
    RProperty iProperty;
    MReserveObserver& iReserveObserver;
    TInt iCameraIndex;
    TInt iSecureId;
    };
 
    
#endif // ECAM_H