// 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 __TESTCAMERA_H__
#define __TESTCAMERA_H__


#include <ecam/ecamplugin.h>
#include <ecam/ecaminfoplugin.h>
#include <bitdev.h>
#include <ecam.h>
#include <w32std.h>
#include <ecamadvsettings.h>

_LIT(KTestCameraPluginName, "C:\\102070cc.txt");

const TInt KMinTestCameraZoom = -3;
const TInt KMaxTestCameraZoom = 3;
const TReal32 KMaxTestCameraDigitalZoomFactor = 1.0;
const TInt KMaxTestCameraDigitalZoom = 0;
const TInt KFramePosIncrement = 5;
const TInt KFrameFeatureSize = 25;
const TInt KFrameFeatureBorderThickness = 5;
const enum CCamera::TFormat KInitialViewFinderFormat = CCamera::EFormatFbsBitmapColor16M;
const TDisplayMode KViewFinderDisplayMode = EColor4K;

class CTestCamAdvSet;
class CTestCamPresets;
class CTestCamSnapshot;
class CTestCamImgProc;

class RTestCameraFrameBuffer : public MCameraBuffer
	{
public:
	RTestCameraFrameBuffer(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;}
public:	
	volatile TBool iAvailable;
	CFbsBitmap*& iFrame;
	RChunk iChunk;
	};

class RTestFrameBuffer : public MFrameBuffer
	{
public:
	RTestFrameBuffer(CFbsBitmap*& aFrame): iAvailable(ETrue), iFrame(aFrame) {}
	virtual TDesC8* DataL(TInt /*aIndex*/) { User::Leave(KErrNotSupported); return NULL; }
	virtual CFbsBitmap* FrameL(TInt aIndex) { if (aIndex != 0) User::Leave(KErrNotSupported); return iFrame; }
	virtual void Release() { iAvailable = ETrue; }
public:
	TBool iAvailable;
	CFbsBitmap*& iFrame;
	};

class CDirectScreenAccess;

class CTestCamera : public CCameraPlugin, public MDirectScreenAccess
	{
	friend class CTestCamAdvSet;
	friend class CTestCamPresets;
	friend class CTestCamSnapshot;
	friend class CTestCamImgProc;
	
public:
	static CTestCamera* NewL();
	~CTestCamera();
	void ConstructL();
	// from CCameraPlugin
	void Construct2L(MCameraObserver& aObserver,TInt aCameraIndex);
	void Construct2DupL(MCameraObserver& aObserver,TInt aCameraHandle);
	void Construct2L(MCameraObserver2& aObserver,TInt aCameraIndex,TInt aPriority);
	void Construct2DupL(MCameraObserver2& aObserver,TInt aCameraHandle);
private:
	// From CCamera
	virtual void CameraInfo(TCameraInfo& aInfo) const;
	virtual void Reserve();
	virtual void Release();
	virtual void PowerOn();
	virtual void PowerOff();
	virtual TInt Handle();

	virtual void SetZoomFactorL(TInt aZoomFactor = 0);
	virtual TInt ZoomFactor() const;
	virtual void SetDigitalZoomFactorL(TInt aDigitalZoomFactor = 0);
	virtual TInt DigitalZoomFactor() const;

	virtual void SetContrastL(TInt aContrast);
	virtual TInt Contrast() const;
	virtual void SetBrightnessL(TInt aBrightness);
	virtual TInt Brightness() const;
	virtual void SetFlashL(TFlash aFlash = EFlashNone);
	virtual TFlash Flash() const;
	virtual void SetExposureL(TExposure aExposure = EExposureAuto);
	virtual TExposure Exposure() const;
	virtual void SetWhiteBalanceL(TWhiteBalance aWhiteBalance = EWBAuto);
	virtual TWhiteBalance WhiteBalance() const;

	virtual void StartViewFinderDirectL(RWsSession& aWs,CWsScreenDevice& aScreenDevice,RWindowBase& aWindow,TRect& aScreenRect);
	virtual void StartViewFinderDirectL(RWsSession& aWs,CWsScreenDevice& aScreenDevice,RWindowBase& aWindow,TRect& aScreenRect,TRect& aClipRect);
	virtual void StartViewFinderBitmapsL(TSize& aSize);
	virtual void StartViewFinderBitmapsL(TSize& aSize,TRect& aClipRect);
	virtual void StartViewFinderL(TFormat aImageFormat,TSize& aSize);
	virtual void StartViewFinderL(TFormat aImageFormat,TSize& aSize,TRect& aClipRect);
	virtual void StopViewFinder();
	virtual TBool ViewFinderActive() const;
	virtual void SetViewFinderMirrorL(TBool aMirror);
	virtual TBool ViewFinderMirror() const;

	virtual void PrepareImageCaptureL(TFormat aImageFormat,TInt aSizeIndex);
	virtual void PrepareImageCaptureL(TFormat aImageFormat,TInt aSizeIndex,const TRect& aClipRect);
	virtual void CaptureImage();
	virtual void CancelCaptureImage();
	virtual void EnumerateCaptureSizes(TSize& aSize,TInt aSizeIndex,TFormat aFormat) const;

	virtual void PrepareVideoCaptureL(TFormat aFormat,TInt aSizeIndex,TInt aRateIndex,TInt aBuffersToUse,TInt aFramesPerBuffer);
	virtual void PrepareVideoCaptureL(TFormat aFormat,TInt aSizeIndex,TInt aRateIndex,TInt aBuffersToUse,TInt aFramesPerBuffer,const TRect& aClipRect);
	virtual void StartVideoCapture();
	virtual void StopVideoCapture();

	virtual TBool VideoCaptureActive() const;
	virtual void EnumerateVideoFrameSizes(TSize& aSize,TInt aSizeIndex,TFormat aFormat) const;
	virtual void EnumerateVideoFrameRates(TReal32& aRate,TInt aRateIndex,TFormat aFormat,TInt aSizeIndex,TExposure aExposure = EExposureAuto) const;
	virtual void GetFrameSize(TSize& aSize) const;
	virtual TReal32 FrameRate() const;
	virtual TInt BuffersInUse() const;
	virtual TInt FramesPerBuffer() const;

	virtual void SetJpegQuality(TInt aQuality);
	virtual TInt JpegQuality() const;

	virtual TAny* CustomInterface(TUid aInterface);

	// From MAbortDirectScreenAccess
	virtual void AbortNow(RDirectScreenAccess::TTerminationReasons aReason);

	// From MDirectScreenAccess
	virtual void Restart(RDirectScreenAccess::TTerminationReasons aReason);

	// New functions
	static TInt TimerCallBack(TAny* aThis);
	void FrameReady();
	void GetFrame(CFbsBitGc& aGc, TPoint& aPos) const;
	void GetImgProcessedFrame(CFbsBitGc& aGc, TPoint& aPos) const;
	void ServiceVideo(TInt aBuferNum);
	void ServiceViewFinder(CFbsBitmap* aSourceFrame);
	void ServiceImageCapture(const CFbsBitGc& aSourceBitmapGc);
	void ServiceBurstImageCapture(const CFbsBitGc& aSourceBitmapGc);
	void DoCaptureImageL();
	void CheckReserveAndPowerL();
	TInt CheckReserveAndPower() const;
	void CustomInterfaceL(TAny*& aIface, TUid aInterface);
	static TInt ReserveCallBack(TAny* aThis);
	static TInt PowerOnCallBack(TAny* aThis);
	static TInt ImageCaptureCallBack(TAny* aThis);
	static TInt VideoCaptureCallBack(TAny* aThis);
	static TInt HandleEventCallBack(TAny* aThis);
	static TInt HandleEvent2CallBack(TAny* aThis);
	
private:
	 CTestCamera();	
private:
	MCameraObserver* iObserver; // not owned
	MCameraObserver2* iObserver2; // not owned
	TBool iReserved;
	TBool iPowerOn;

	TCameraInfo iInfo;
	CPeriodic* iTimer;
	TTimeIntervalMicroSeconds32 iFrameDelay;
	TInt iFrameIndex;
	TTimeIntervalMicroSeconds iElapsedTime;
	TPoint iStillImagePos;
	TPoint iVideoFramePos;

	TReal32 iVideoFrameRate;
	TInt iBuffersInUse;
	TSize iVideoFrameSize;
	TFormat iVideoFrameFormat;

	CFbsBitmap* iVideoFrame1;
	CFbsBitmapDevice* iVideoFrameDev1;
	CFbsBitGc* iVideoFrameGc1;
	CFbsBitmap* iVideoFrame2;
	CFbsBitmapDevice* iVideoFrameDev2;
	CFbsBitGc* iVideoFrameGc2;

	TInt iStillCaptureErr;
	TSize iStillImageSize;
	TFormat iStillImageFormat;
	CFbsBitmap* iStillImage;
	CFbsBitmapDevice* iStillImageDev;
	CFbsBitGc* iStillImageGc;

	TSize iViewFinderSize;
	TFormat iViewFinderFormat;
	CFbsBitmap* iViewFinderBitmap;
	CFbsBitmapDevice* iViewFinderBitmapDev;
	CFbsBitGc* iViewFinderBitmapGc;

	CDirectScreenAccess* iDSA;
	CFbsScreenDevice* iScreenDev;
	CFbsBitGc* iScreenGc;
	TRect iScreenRect;
	TRect iClipRect;

	CFbsBitmap* iImage;
	CFbsBitmapDevice* iDev;
	CFbsBitGc* iGc;

	CAsyncCallBack iReserveAsync;
	CAsyncCallBack iPowerOnAsync;
	CAsyncCallBack iImageCaptureAsync;
	CAsyncCallBack iVideoCaptureAsync;
	CAsyncCallBack iHandleEventAsync;
	CAsyncCallBack iHandleEvent2Async;

	RTestFrameBuffer iFrameBuffer1;
	RTestFrameBuffer iFrameBuffer2;
	
	RTestCameraFrameBuffer iFrameCameraBuffer1;
	RTestCameraFrameBuffer iFrameCameraBuffer2;

	TInt iVideoCaptureErr;
	// Members to store the current optical or digital value set with SetZoomFactorL() and SetDigitalZoomFactorL()
	// Although arguments have trailing Factor in fact they must contain values in the ranges specified by
	//  	iInfo.iMinZoom : iInfo.iMaxZoom for optical zoom and 
	//		0 : iInfo.iMaxDigitalZoom for digital zoom 
	// The factor values cannot be modified using Camera API as it is assumed 
	// that they are determined by the camera hardware.  
	TInt iZoom;
	TInt iDigitalZoom;
	
	TInt iContrast;
	TInt iBrightness;
	
	TInt iImgProcBrightness;
	TInt iImgProcContrast;
	
	volatile TBool iViewFinderActive;
	volatile TBool iVideoCaptureActive;
	volatile TBool iImageCaptureActive;
	volatile TBool iVideoPreparedLast;
	volatile TBool iVideoCapturePrepared;
	volatile TBool iImageCapturePrepared;

	RArray<TSize> iImageSizes;
	RArray<TSize> iVideoFrameSizes;
	RArray<TReal32> iVideoFrameRates;
	TInt iCameraIndex;
	TInt iCameraHandle;
	TInt iPriority;	
	
	TECAMEvent iECamEvent;
	TECAMEvent2 iECamEvent2;
	TInt iEventError;
	
	CTestCamAdvSet* iAdvSettingsImpl;
	CTestCamSnapshot* iSnapshotImpl;
	CTestCamImgProc* iImgProcImpl;
	
	CCamera::CCameraAdvancedSettings::TDriveMode iDriveMode;
	TInt iBurstImages;
	};
	
class CTestCameraInfo : public CCameraInfoPlugin
	{
public:
	static CTestCameraInfo* NewL();
	~CTestCameraInfo();
	// from CCameraInfoPlugin
	TInt CamerasAvailable();
private:
	CTestCameraInfo();	
	};
	
enum TStubPanicReasons
	{
	EPanicUnimplemented=1
	};	

class FileDependencyUtil
	{
public:
	static void CheckFileDependencyL();
	};

class CDataGlobal : public CBase
	{
public:
	CTestCamAdvSet* iTestCamAdvSet;
	CTestCamPresets* iTestCamPresets;
	CTestCamSnapshot* iTestCamSnapshot;
	CTestCamImgProc* iTestCamImgProc;
	TInt 		iAdvSetReferenceCount;	
	TInt 		iPresetsReferenceCount;
	TInt 		iSnapshotReferenceCount;	
	TInt 		iImgProcReferenceCount;
	};
	
#endif