// Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// extendedfunctionality.h

// 

//

#ifndef EXTENDEDFUNCTIONALITY_H

#define EXTENDEDFUNCTIONALITY_H

#include <ecam/ecamplugin.h>

#include <ecam/ecaminfoplugin.h>

#include "ECamUnitTestPlugin.h"

#include <fbs.h>

#include <ecam/mcamerahistogram.h>

#include <ecam/mcamerasnapshot.h>

#include <ecam/ecamcapturecontrolintf.h>

#include <ecam/ecamimageprocessingintf.h>

#include <ecam/ecamviewfinderintf.h>

#include <ecam/implementationfactoryintf.h>

class CCamUnitTestPlugin;

const TInt KSupportedDirectVCType		= 0;

const TInt KSupportedClientVCType		= 1;

//

// camera buffer 2

class RCamBuffer2 : public MCameraBuffer2

	{

public:

	RCamBuffer2(CFbsBitmap*& aFrame): iAvailable(ETrue), iFrame(aFrame) {}

	virtual TInt NumFrames() {return 0;}

	virtual TDesC8* DataL(TInt aFrameIndex) {if (aFrameIndex != 0) { User::Leave(KErrArgument); } return NULL; }

	virtual CFbsBitmap& BitmapL(TInt aFrameIndex) {if (aFrameIndex != 0) { User::Leave(KErrArgument); } return *iFrame;}

 	virtual	RChunk& ChunkL() { return iChunk;}

	virtual TInt ChunkOffsetL(TInt aFrameIndex) {if (aFrameIndex != 0) { User::Leave(KErrArgument); } return 0;}

	virtual TInt FrameSize(TInt aFrameIndex) {if (aFrameIndex != 0) { User::Leave(KErrArgument); } return 0; }

	virtual void Release() {iAvailable = ETrue;}

	virtual TInt GetInterfaceUids(RArray<TUid>& aInterfaceUids) {aInterfaceUids.Reset(); return KErrNotSupported;}

	virtual TInt CustomInterface(TUid /*aInterface*/, TAny*& aPtrInterface) {aPtrInterface = NULL; return KErrNotSupported;}

public:	

	TBool iAvailable;

	CFbsBitmap*& iFrame;

	RChunk iChunk;

	};

//

//pre image capture control impl

class CCamPreImageCaptureControl: public CBase, public MCameraPreImageCaptureControl

	{

public:

	static CCamPreImageCaptureControl* NewL(CCamUnitTestPlugin& aOwner);

	~CCamPreImageCaptureControl();

	void Release();

	void SetPreImageCaptureControlObserver(MPreImageCaptureControlObserver& aPreImageCaptureControlObserver);

	void GetDirectSnapshotSupportInfoL(TUint& aDirectSnapshotSupportInfo) const;

	void GetSupportedEmbeddedStillCaptureSettingsL(RArray<TUid>& aSupportedEmbeddedStillCaptureSettings) const;

	void GetSupportedDirectSavingTypeL(CCamera::CCameraPreImageCaptureControl::TDirectSavingType& aSupportedDirectSavingType) const;

	void SetSequentialImageFilenameL(const TDesC8& aFilename, TInt aStartingSequenceNumber);

	void SetLowerResolutionSequentialImageFilenameL(const TDesC8& aLowerResolutionFilename, TInt aStartingSequenceNumber);

	void GetDirectSavingTypeL(CCamera::CCameraPreImageCaptureControl::TDirectSavingType& aDirectSavingType) const;

	void SetDirectSavingTypeL(CCamera::CCameraPreImageCaptureControl::TDirectSavingType aDirectSavingType);

	void GetCaptureEventSupportInfoL(TUint& aSupportedDriveModes) const;

	void GetImageFormatsSupportedL(TUint& aImageFormatsSupported, const TSize& aSize) const;

	void GetPixelAspectsSupportedL(TUint& aPixelAspectsSupported, CCamera::TFormat aImageFormat, const TSize& aSize) const;

	void PrepareImageCapture(const CCamera::CCameraPreImageCaptureControl::TPrepareImageParameters& 

										aPrepareImageParameters, MCaptureImageObserver& aCaptureImageObserver);

	void GetImageMaxMemorySizeSettingSupportInfoL(TBool& aIsImageMaxMemorySizeSettingSupported) const;

	void GetImageMaxMemorySizeL(TUint& aMemorySize) const;

	void GetSupportedProcessingOptionsL(TUint& aSupportedProcessingOptions) const;

	inline MPreImageCaptureControlObserver* PreImageCaptureControlObserver() {return iPreImageCaptureControlObserver;}

private:	

	CCamPreImageCaptureControl(CCamUnitTestPlugin& aOwner);

	void CreateCaptureImageL(CCamera::CCameraImageCapture*& aCameraImageCapture, const CCamera::CCameraPreImageCaptureControl::

			TPrepareImageParameters& aPrepareImageParameters, MCaptureImageObserver& aCaptureImageObserver);

private:

	CCamUnitTestPlugin& iOwner;

	MPreImageCaptureControlObserver* iPreImageCaptureControlObserver;

	};

//

//image capture impl	

class CCamSnapshotForImage;

class CCamImgProcImpForImage;

class CCamPostImageCaptureControl;

class CCamImageCapture: public CBase, public MCameraImageCapture

	{

friend class CSnapshotFactoryForImage;

friend class CImgProcFactoryForImage;

friend class CCamPostImageCaptureControl;

public:

	static CCamImageCapture* NewL(CCamUnitTestPlugin& aOwner);

	~CCamImageCapture();

	void Release(CCamera::CCameraImageCapture* aCameraImageCapture);

	void CreateHistogramImplFactoryL(MImplementationFactory*& aImplFactoryPtr) const;

	void GetSnapshotImplFactoryL(MImplementationFactory*& aImplFactoryPtr) const;

	void GetImageProcessingImplFactoryL(MImplementationFactory*& aImplFactoryPtr) const;

	void SetCaptureImageObserver(MCaptureImageObserver& aCaptureImageObserver);

	void GetPrepareImageParametersL(CCamera::CCameraPreImageCaptureControl::TPrepareImageParameters& aPrepareImageParameters) const;

	void SetPrepareImageParameters(const CCamera::CCameraPreImageCaptureControl::TPrepareImageParameters& aPrepareImageParameters);

	TAny* CreatePostImageCaptureControlImpl(TUid aInterface, TPostCaptureControlId aPostCaptureControlId);

	void CaptureImage(CCamera::CCameraImageCapture* aCameraImageCapture);

	void CancelCaptureImage();

	void GetNumImagesExposedL(TUint& aNumImagesExposed) const;

	void GetNumTotalImagesL(TUint& aNumTotalImages) const;

	void GetPostCaptureControlHandleL(CCamera::CCameraPostImageCaptureControl*& aPostCaptureControlHandle, 

									TPostCaptureControlId aPostCaptureControlId) const;

	void SetCaptureImagePriorityL(TECamImagePriority aCaptureImagePriority);

	void GetCaptureImagePriorityL(TECamImagePriority& aCaptureImagePriority) const;

	void PauseProcessing(TUint aProcessingType);

	void ResumeProcessingL(TUint aProcessingType);

	inline MCaptureImageObserver* CaptureImageObserver() {return iCaptureImageObserver;}

	inline CCamera::CCameraImageCapture* CameraImageCapture() {return iCameraImageCapture;}

	inline CCamUnitTestPlugin& Owner() {return iOwner;}

private:

	CCamImageCapture(CCamUnitTestPlugin& aOwner);

	void CreatePostImageCaptureControlL(CCamera::CCameraPostImageCaptureControl*& aPostCaptureControlHandle, 

						TPostCaptureControlId aPostCaptureControlId);

private:

	CCamUnitTestPlugin& iOwner;

	MCaptureImageObserver* iCaptureImageObserver;

	CCamera::CCameraPreImageCaptureControl::TPrepareImageParameters iPrepareImageParameters;

	mutable CCamSnapshotForImage* iSnapshotImpForImage;

	CCamImgProcImpForImage* iCamImgProcImpForImage;

	RArray<TInt> iArrayPostCaptureControlId;

	RArray<CCamPostImageCaptureControl*> iArrayPostCaptureControlImpl;

	RArray<CCamera::CCameraPostImageCaptureControl*> iArrayPostCaptureControlHandle;

	CCamera::CCameraImageCapture* iCameraImageCapture;

	};

//

//post image capture control impl

class CCamPostImageCaptureControl: public CBase, public MCameraPostImageCaptureControl

	{

public:

	static CCamPostImageCaptureControl* NewL(CCamImageCapture& aCamImageCaptureImpl);

	~CCamPostImageCaptureControl();

	void Release(TPostCaptureControlId aPostCaptureControlId);

	void GetImageSequenceNumberL(TUint& aSequenceNumber) const;

	void CancelImage();

	void SetImagePriorityL(TECamImagePriority aImagePriority);

	void GetImagePriorityL(TECamImagePriority& aImagePriority) const;

	void PauseProcessing(TUint aProcessingType);

	void ResumeProcessingL(TUint aProcessingType);

	void GetImageBufferL(MCameraImageBuffer& aCameraImageBuffer) const;

	void GetImageStateL(CCamera::CCameraPostImageCaptureControl::TImageState& aImageState) const;

	void GetBufferStateL(CCamera::CCameraPostImageCaptureControl::TBufferState& aBufferState) const;

	inline CCamImageCapture& CamImageCaptureImpl() {return iCamImageCaptureImpl;}

private:

	CCamPostImageCaptureControl(CCamImageCapture& aCamImageCaptureImpl);

private:

	CCamImageCapture& iCamImageCaptureImpl;

	};

//

//video capture control impl

class CCamSnapshotForVideo;	

class CCamVideoCaptureControl : public CBase, public MCameraVideoCaptureControl

	{

friend class CSnapshotFactoryForVideo;

public:

	static CCamVideoCaptureControl* NewL(CCamUnitTestPlugin& aOwner);

	~CCamVideoCaptureControl();

	void Release();

	void CreateHistogramImplFactoryL(MImplementationFactory*& aImplFactoryPtr) const;

	void GetSnapshotImplFactoryL(MImplementationFactory*& aImplFactoryPtr) const;

	void GetImageProcessingImplFactoryL(MImplementationFactory*& aImplFactoryPtr) const;

	void SetCaptureVideoObserver(MCaptureVideoObserver& aCaptureVideoObserver);

	void GetVideoFormatsSupportedL(TUint& aVideoFormatsSupported, const TSize& aSize) const;

	void GetPixelAspectsSupportedL(TUint& aPixelAspectsSupported, CCamera::TFormat aVideoFormat, const TSize& aSize) const;

	void GetEmbeddedStillCaptureSupportInfoL(TInt& aSupportedEmbeddedStillCaptureTypes) const;

	void PrepareVideoCapture(const CCamera::CCameraVideoCaptureControl::TPrepareVideoParameters& aPrepareVideoParameters);

	void GetRangeAffectedSettingsL(RArray<TUid>& aRangeAffectedSettings) const;

	void GetValueAffectedSettingsL(RArray<TUid>& aValueAffectedSettings) const;

	void GetDisabledSettingsL(RArray<TUid>& aDisabledSettings) const;

	void ReleaseVideoResource();

	void StartVideoCaptureL();

	void StopVideoCapture();

	void PauseVideoCapture();

	void ResumeVideoCaptureL();

	void GetFadingEffectStateL(CCamera::CCameraVideoCaptureControl::TFadingEffectState& aFadingEffectState) const;

	void SetFadingEffectState(CCamera::CCameraVideoCaptureControl::TFadingEffectState aFadingEffectState);

	void GetVideoCaptureStateL(CCamera::CCameraVideoCaptureControl::TVideoCaptureState& aVideoCaptureState) const;

	void GetVideoCaptureSupportInfoL(TInt& aSupportedVideoCaptureTypes) const;

	void GetPrepareVideoParametersL(CCamera::CCameraVideoCaptureControl::TPrepareVideoParameters& aPrepareVideoParameters) const;

	inline MCaptureVideoObserver* CaptureVideoObserver() {return iCaptureVideoObserver;}

	inline CCamUnitTestPlugin& Owner() {return iOwner;}

private:

	CCamVideoCaptureControl(CCamUnitTestPlugin& aOwner);

	void ConstructL();

private:

	CCamUnitTestPlugin& iOwner;	

	MCaptureVideoObserver* iCaptureVideoObserver;

	CCamSnapshotForVideo* iSnapshotImpForVideo;

	CCamera::CCameraVideoCaptureControl::TPrepareVideoParameters iPrepareVideoParameters;

	CFbsBitmap* iBitmap;

	};

//	

//direct snapshot implementation to be used by version2 direct viewfinder.

class CCamDirectSnapshot : public CBase, public MCameraDirectSnapshot

	{

public:

	static CCamDirectSnapshot* NewL();

	~CCamDirectSnapshot();

	void Release();

	void SetDirectViewFinder(const CCamera::CCameraV2DirectViewFinder* aDirectViewFinder);

	void GetDirectViewFinderL(CCamera::CCameraV2DirectViewFinder*& aDirectViewFinder) const;

	void EnableDirectSnapshotL(CCamera::CCameraDirectSnapshot::TDirectSnapshotParameters& aDirectSnapshotParameters);

	void DisableDirectSnapshot();

	void GetDirectSnapshotStateL(CCamera::CCameraDirectSnapshot::TDirectSnapshotState& aDirectSnapshotState) const;

	void GetDirectSnapshotParametersL(CCamera::CCameraDirectSnapshot::TDirectSnapshotParameters& aDirectSnapshotParameters) const;

	void SetDirectSnapshotParametersL(const CCamera::CCameraDirectSnapshot::TDirectSnapshotParameters& aDirectSnapshotParameters);

private:

	CCamDirectSnapshot();

private:

	const CCamera::CCameraV2DirectViewFinder* iCameraV2DirectVF;

	CCamera::CCameraDirectSnapshot::TDirectSnapshotParameters iDirectSnapshotParameters;

	CCamera::CCameraDirectSnapshot::TDirectSnapshotState iDirectSnapshotState;

	};

//

//V2 direct viewfinder impl

class CCamV2DirectViewFinder: public CBase, public MCameraViewFinder, public MCameraV2DirectViewFinder

	{

public:

	static CCamV2DirectViewFinder* NewL(CCamUnitTestPlugin& aOwner);

	~CCamV2DirectViewFinder();

	void Release(CCamera::CCameraV2DirectViewFinder* aDirectViewFinderHandle);

	void Release();

	void GetViewFinderFadingCapabilitiesL(CCameraViewFinder::TViewFinderFadingCapabilities& aVFFadingCapabilities) const;

	void GetViewFinderFadingEffectL(CCameraViewFinder::TViewFinderFadingEffect& aCurrentVFFadingEffect) const;

	void SetViewFinderFadingEffect(const CCameraViewFinder::TViewFinderFadingEffect& aVFFadingEffect);

	void GetViewFinderHandleL(TInt& aVFHandle) const;

	void CreateHistogramImplFactoryL(MImplementationFactory*& aImplFactoryPtr) const;

	void GetImageProcessingImplFactoryL(MImplementationFactory*& aImplFactoryPtr) const;

	void SetDirectViewFinderObserver(MDirectViewFinderObserver& aDirectViewFinderObserver);

	void SetDirectViewFinderHandle(CCamera::CCameraV2DirectViewFinder* aDirectViewFinderHandle);

	void StartViewFinderDirectL(RWsSession& aWs, CWsScreenDevice& aScreenDevice, RWindowBase& aWindow, TRect& aScreenRect);

	void StartViewFinderDirectL(RWsSession& aWs, CWsScreenDevice& aScreenDevice, RWindowBase& aWindow, TRect& aScreenRect, TRect& aClipRect);

	void GetDirectViewFinderPropertiesL(TInt& aScreenNumber, TRect& aScreenRect, TRect& aClipRect) const;

	void PauseViewFinderDirect();

	void ResumeViewFinderDirect();

	void GetViewFinderStateL(CCamera::CCameraV2DirectViewFinder::TViewFinderState& aViewFinderState) const;

	void StopDirectViewFinder();

	TAny* GetDirectSnapshotImpl(TUid aInterface) const;

	inline MDirectViewFinderObserver* DirectViewFinderObserver() {return iDirectViewFinderObserver;}

	inline CCamera::CCameraV2DirectViewFinder& DirectViewFinderHandle() {return *iDirectViewFinderHandle;}

	inline CCamUnitTestPlugin& Owner() {return iOwner;}

private:

	CCamV2DirectViewFinder(CCamUnitTestPlugin& aOwner);

public:

	TInt iRefCount;

private:

	CCamUnitTestPlugin& iOwner;

	MDirectViewFinderObserver* iDirectViewFinderObserver;

	CCamera::CCameraV2DirectViewFinder* iDirectViewFinderHandle;

	TInt iVFHandle;

	mutable CCamDirectSnapshot* iDirectSnapshot;

	};

//

//client viewfinder impl

class CCamClientViewFinder: public CBase, public MCameraViewFinder, public MCameraClientViewFinder

	{

public:

	static CCamClientViewFinder* NewL(CCamUnitTestPlugin& aOwner);

	~CCamClientViewFinder();

	void Release(CCamera::CCameraClientViewFinder* aClientViewFinderHandle);

	void Release();

	void GetViewFinderFadingCapabilitiesL(CCameraViewFinder::TViewFinderFadingCapabilities& aVFFadingCapabilities) const;

	void GetViewFinderFadingEffectL(CCameraViewFinder::TViewFinderFadingEffect& aCurrentVFFadingEffect) const;

	void SetViewFinderFadingEffect(const CCameraViewFinder::TViewFinderFadingEffect& aVFFadingEffect);

	void GetViewFinderHandleL(TInt& aVFHandle) const;

	void CreateHistogramImplFactoryL(MImplementationFactory*& aImplFactoryPtr) const;

	void GetImageProcessingImplFactoryL(MImplementationFactory*& aImplFactoryPtr) const;

	void SetClientViewFinderObserver(MClientViewFinderObserver& aClientViewFinderObserver);

	void SetClientViewFinderHandle(CCamera::CCameraClientViewFinder* aClientViewFinderHandle);

	void StartClientViewFinderL(TInt aScreenNumber, CCamera::TFormat aImageFormat, TSize& aSize);

	void StartClientViewFinderL(TInt aScreenNumber, CCamera::TFormat aImageFormat, TSize& aSize, TRect& aClipRect);

	void GetClientViewFinderStateL(TBool& aIsActive) const;

	void GetClientViewFinderPropertiesL(TInt& aScreenNumber, CCamera::TFormat& aImageFormat, TSize& aSize, TRect& aClipRect) const;

	void StopClientViewFinder();

	void GetViewFinderBufferL(MCameraBuffer2& aClientViewFinderBuffer) const;

	inline MClientViewFinderObserver* ClientViewFinderObserver() {return iClientViewFinderObserver;}

	inline CCamera::CCameraClientViewFinder& ClientViewFinderHandle() {return *iClientViewFinderHandle;}

	inline CCamUnitTestPlugin& Owner() {return iOwner;}

private:

	CCamClientViewFinder(CCamUnitTestPlugin& aOwner);

public:

	TInt iRefCount;

private:

	CCamUnitTestPlugin& iOwner;

	MClientViewFinderObserver* iClientViewFinderObserver;

	CCamera::CCameraClientViewFinder* iClientViewFinderHandle;

	TInt iVFHandle;

	};

//

//snapshot impl for image

class CCamSnapshotForImage : public CBase, public MCameraSnapshot, public MCameraSnapshot2

	{

friend class CHistogramImpForImageSnapshot;

public:	

	static CCamSnapshotForImage* NewL(CCamUnitTestPlugin& aOwner, CCamImageCapture& aCamImageCaptureImpl);

	~CCamSnapshotForImage();

	TUint32 SupportedFormats();

    void PrepareSnapshotL(CCamera::TFormat aFormat, const TPoint& aPosition, const TSize& aSize, const TRgb& aBgColor, TBool aMaintainAspectRatio);

    void PrepareSnapshotL(CCamera::TFormat aFormat, const TSize& aSize, TBool aMaintainAspectRatio);

    void SetBgColorL(const TRgb& aBgColor); 

	void SetPositionL(const TPoint& aPosition);

    TBool IsSnapshotActive() const;

    void StartSnapshot();

	void StopSnapshot();

	MCameraBuffer& SnapshotDataL(RArray<TInt>& aFrameIndexOrder);

	void CreateHistogramImplFactoryL(MImplementationFactory*& aImplFactoryPtr) const;

	void PrepareSnapshotL(const CCamera::CCameraSnapshot::TSnapshotParameters& aSnapshotParameters);

	void GetSnapshotParametersL(CCamera::CCameraSnapshot::TSnapshotParameters& aSnapshotParameters);

	void SetSnapshotParametersL(const CCamera::CCameraSnapshot::TSnapshotParameters& aSnapshotParameters);

	void GetSnapshotStatusL(CCamera::CCameraSnapshot::TSnapshotState& aSnapshotState) const;

	void SelectSnapshotVideoFramesL(CCamera::CCameraSnapshot::TSnapshotVideoFrames aSnapshotVideoFrames);

	void EnableSnapshot();

	void DisableSnapshot();

	void SetClientViewFinderId(TInt aClientViewFinderId);

	void Release();

	inline CCamImageCapture& CamImageCaptureImpl() {return iCamImageCaptureImpl;}

	inline CCamera::CCameraImageCapture& CameraImageCapture() {return *(CamImageCaptureImpl().CameraImageCapture());}

	inline CCamUnitTestPlugin& Owner() {return iOwner;}

private:	

	CCamSnapshotForImage(CCamUnitTestPlugin& aOwner, CCamImageCapture& aCamImageCaptureImpl);

	void ConstructL();

private:

	CCamUnitTestPlugin& iOwner;

	CCamImageCapture& iCamImageCaptureImpl;

	CFbsBitmap* iBitmap;

	RCamBuffer2 iSnapshotbuffer;

	CCamera::CCameraSnapshot::TSnapshotParameters iSnapshotParameters;

	TInt iRefCount;

	};

//

//snapshot factory for image

class CSnapshotFactoryForImage : public CBase, public MImplementationFactory

	{

public:

	static CSnapshotFactoryForImage* NewL(CCamImageCapture& aCamImageCaptureImpl, CCamSnapshotForImage* aSnapshotImpForImage);

	~CSnapshotFactoryForImage();

	TInt GetImpl(TAny*& aIfPtr, TUid aIfaceUid) const;

	TInt GetImpl1(TAny*& aIfPtr, TUid aIfaceUid, TECamImplFactoryParam aParam1) const;

	TInt GetImpl2(TAny*& aIfPtr, TUid aIfaceUid, TECamImplFactoryParam aParam1, TECamImplFactoryParam aParam2) const;

	void Release();

private:

	CSnapshotFactoryForImage();

	void ConstructL(CCamImageCapture& aCamImageCaptureImpl, CCamSnapshotForImage* aSnapshotImpForImage);

private:

	CCamSnapshotForImage* iSnapshotImpForImage;

	mutable TBool iIsSnapshotImpPassed;

	};

//

//snapshot impl for video

class CCamSnapshotForVideo : public CBase, public MCameraSnapshot, public MCameraSnapshot2

	{

public:	

	static CCamSnapshotForVideo* NewL(CCamUnitTestPlugin& aOwner, CCamVideoCaptureControl& aCamVideoCaptureControlImpl);

	~CCamSnapshotForVideo();

	TUint32 SupportedFormats();

    void PrepareSnapshotL(CCamera::TFormat aFormat, const TPoint& aPosition, const TSize& aSize, const TRgb& aBgColor, TBool aMaintainAspectRatio);

    void PrepareSnapshotL(CCamera::TFormat aFormat, const TSize& aSize, TBool aMaintainAspectRatio);

    void SetBgColorL(const TRgb& aBgColor); 

	void SetPositionL(const TPoint& aPosition);

    TBool IsSnapshotActive() const;

    void StartSnapshot();

	void StopSnapshot();

	MCameraBuffer& SnapshotDataL(RArray<TInt>& aFrameIndexOrder);

	void CreateHistogramImplFactoryL(MImplementationFactory*& aImplFactoryPtr) const;

	void PrepareSnapshotL(const CCamera::CCameraSnapshot::TSnapshotParameters& aSnapshotParameters);

	void GetSnapshotParametersL(CCamera::CCameraSnapshot::TSnapshotParameters& aSnapshotParameters);

	void SetSnapshotParametersL(const CCamera::CCameraSnapshot::TSnapshotParameters& aSnapshotParameters);

	void GetSnapshotStatusL(CCamera::CCameraSnapshot::TSnapshotState& aSnapshotState) const;

	void SelectSnapshotVideoFramesL(CCamera::CCameraSnapshot::TSnapshotVideoFrames aSnapshotVideoFrames);

	void EnableSnapshot();

	void DisableSnapshot();

	void SetClientViewFinderId(TInt aClientViewFinderId);

	void Release();

	inline CCamVideoCaptureControl& CamVideoCaptureControlImpl() {return iCamVideoCaptureControlImpl;}

private:	

	CCamSnapshotForVideo(CCamUnitTestPlugin& aOwner, CCamVideoCaptureControl& aCamVideoCaptureControlImpl);

	void ConstructL();

private:

	CCamUnitTestPlugin& iOwner;

	CCamVideoCaptureControl& iCamVideoCaptureControlImpl;

	CFbsBitmap* iBitmap;

	RCamBuffer2 iSnapshotbuffer;

	CCamera::CCameraSnapshot::TSnapshotParameters iSnapshotParameters;

	TInt iRefCount;

	};

//

//snapshot factory for video

class CSnapshotFactoryForVideo : public CBase, public MImplementationFactory

	{

public:

	static CSnapshotFactoryForVideo* NewL(CCamVideoCaptureControl& aCamVideoCaptureControlImpl, CCamSnapshotForVideo* aSnapshotImpForVideo);

	~CSnapshotFactoryForVideo();

	TInt GetImpl(TAny*& aIfPtr, TUid aIfaceUid) const;

	TInt GetImpl1(TAny*& aIfPtr, TUid aIfaceUid, TECamImplFactoryParam aParam1) const;

	TInt GetImpl2(TAny*& aIfPtr, TUid aIfaceUid, TECamImplFactoryParam aParam1, TECamImplFactoryParam aParam2) const;

	void Release();

private:

	CSnapshotFactoryForVideo();

	void ConstructL(CCamVideoCaptureControl& aCamVideoCaptureControlImpl, CCamSnapshotForVideo* aSnapshotImpForVideo);

private:

	CCamSnapshotForVideo* iSnapshotImpForVideo;

	mutable TBool iIsSnapshotImpPassed;

	};

//

// V2 buffer for histogram: MHistogramV2Buffer

class RCamHistogramV2Buffer : public MHistogramV2Buffer

	{

public:

	RCamHistogramV2Buffer(): iAvailable(ETrue) {}

	CCamera::CCameraV2Histogram::THistogramType Type() {return CCamera::CCameraV2Histogram::EHistNone;}

	TInt ElementSize() {return -5;}

	TInt NumOfElements() {return -5;}

	TDesC8* DataL() {User::Leave(KErrNotSupported); return NULL;}

	RChunk& ChunkL() {User::Leave(KErrNotSupported); return iChunk;}

	TInt ChunkOffsetL() {User::Leave(KErrNotSupported); return -5;}

	void Release() {iAvailable = EFalse;}

public:

	TBool iAvailable;

	RChunk iChunk;	

	};

//	

//histogram impl for video

class CHistogramImpForVideo : public CBase, public MCameraV2Histogram 

	{

public:

	static CHistogramImpForVideo* NewL(CCamUnitTestPlugin& aOwner, CCamVideoCaptureControl& aCamVideoCaptureControlImpl);

	~CHistogramImpForVideo();

	void Release(CCamera::CCameraV2Histogram* aHistogramHandle);

	void SetHistogramHandle(CCamera::CCameraV2Histogram* aHistogramHandle);

	void GetSupportedHistogramsL(TUint& aSupportedHistogramType) const;

	void GetDirectHistogramSupportInfoL(TBool& aIsDirectHistogramSupported) const;