// 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:

//

#include <w32std.h>

#include <ecom/ecom.h>

#include <ecom/implementationproxy.h>

#include <f32file.h> 

#include "TestCamera.h"

#include "test_advanced_settings.h"

#include "test_snapshot.h"

#include "test_image_processing.h"

#include "TestCameraUids.hrh"

#include <ecam.h>

//

// Main stuff

//

// 

// 2nd stage ConstructL calls called by framework

//

CTestCamera* CTestCamera::NewL()

	{

	FileDependencyUtil::CheckFileDependencyL();

   	CTestCamera* self = new(ELeave) CTestCamera;

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

void CTestCamera::Construct2L(MCameraObserver& aObserver,TInt aCameraIndex)

	{

	iObserver = &aObserver;

	iCameraIndex = aCameraIndex;

	}

void CTestCamera::Construct2DupL(MCameraObserver& aObserver,TInt aCameraHandle)

	{

	iObserver = &aObserver;

	iCameraHandle = aCameraHandle;

	}

void CTestCamera::ConstructL()	

	{

	TInt err;

	TRAP(err, iScreenDev = CFbsScreenDevice::NewL(_L(""),EColor16MA));

	if (err == KErrNotSupported)

		{

		TRAP(err, iScreenDev = CFbsScreenDevice::NewL(_L(""),EColor16M));

		}

	if (err == KErrNotSupported)

		{

		TRAP(err, iScreenDev = CFbsScreenDevice::NewL(_L(""),EColor64K));

		}

	if (err == KErrNotSupported)

		{

		TRAP(err, iScreenDev = CFbsScreenDevice::NewL(_L(""),EColor4K));

		}

	if (err == KErrNotSupported)

		{

		TRAP(err, iScreenDev = CFbsScreenDevice::NewL(_L(""),EColor256));

		}

	if (err == KErrNotSupported)

		{

		iScreenDev = CFbsScreenDevice::NewL(_L(""),EColor16MAP);

		}		

	else

		{

		User::LeaveIfError(err);		

		}

	User::LeaveIfError(iScreenDev->CreateContext(iScreenGc));

	User::LeaveIfError(iImageSizes.Append( TSize(640, 480) )); // VGA

	User::LeaveIfError(iImageSizes.Append( TSize(160, 120) )); // QQVGA

	iInfo.iNumImageSizesSupported = iImageSizes.Count();

	iStillImageSize = iImageSizes[1]; // Defaults to QQVGA

	User::LeaveIfError(iVideoFrameSizes.Append( TSize(176, 144) )); // QCIF

	User::LeaveIfError(iVideoFrameSizes.Append( TSize(128, 96) ));  // subQCIF

	iInfo.iNumVideoFrameSizesSupported = iVideoFrameSizes.Count();

	User::LeaveIfError(iVideoFrameRates.Append( 10.00 ));

	User::LeaveIfError(iVideoFrameRates.Append(  5.00 ));

	User::LeaveIfError(iVideoFrameRates.Append(  1.00 ));

	iInfo.iNumVideoFrameRatesSupported = iVideoFrameRates.Count();

	iVideoFrameRate = iVideoFrameRates[0];

	// Still image used as view finder source if not defined otherwise

	iStillImage = new(ELeave) CFbsBitmap;

	User::LeaveIfError(iStillImage->Create(iStillImageSize, KViewFinderDisplayMode));

	iStillImageDev = CFbsBitmapDevice::NewL(iStillImage);

	User::LeaveIfError(iStillImageDev->CreateContext(iStillImageGc));

	iStillImageGc->SetPenColor(KRgbBlack);

	iStillImageGc->SetPenSize(TSize(KFrameFeatureBorderThickness, KFrameFeatureBorderThickness));

	iStillImageGc->SetBrushColor(KRgbWhite);

	iStillImageGc->SetFaded(ETrue);

	iVideoPreparedLast = EFalse;

	iTimer = CPeriodic::NewL(CActive::EPriorityHigh);

	}

void CTestCamera::Construct2L(MCameraObserver2& aObserver,TInt aCameraIndex,TInt aPriority)

	{

	iObserver2 = &aObserver;

	iCameraIndex = aCameraIndex;

	iPriority = aPriority;

	}

void CTestCamera::Construct2DupL(MCameraObserver2& aObserver,TInt aCameraHandle)

	{

	iObserver2 = &aObserver;

	iCameraHandle = aCameraHandle;

	}

CTestCamera::CTestCamera():

	iStillImageFormat(KInitialViewFinderFormat),

	iReserveAsync(CActive::EPriorityStandard),

	iPowerOnAsync(CActive::EPriorityStandard),

	iImageCaptureAsync(CActive::EPriorityStandard),

	iVideoCaptureAsync(CActive::EPriorityStandard),

	iHandleEventAsync(CActive::EPriorityStandard),

	iHandleEvent2Async(CActive::EPriorityStandard),	

	iFrameBuffer1(iVideoFrame1),

	iFrameBuffer2(iVideoFrame2),

	iFrameCameraBuffer1(iVideoFrame1),

	iFrameCameraBuffer2(iVideoFrame2),

	iContrast(0),

	iBrightness(0),

	iImgProcBrightness(0),

	iImgProcContrast(0),

	iVideoCaptureActive(EFalse),

	iImageCaptureActive(EFalse),

	iVideoPreparedLast(EFalse),

	iVideoCapturePrepared(EFalse),

	iImageCapturePrepared(EFalse),

	iECamEvent(KNullUid, KErrNone),

	iECamEvent2(KNullUid, KErrNone, 0),

	iAdvSettingsImpl(NULL),

	iSnapshotImpl(NULL),

	iImgProcImpl(NULL),

	iDriveMode(KDefaultDriveMode),

	iBurstImages(KBurstImages)

	{

	TCallBack reserveCallBack(ReserveCallBack,this);

	iReserveAsync.Set(reserveCallBack);

	TCallBack powerOnCallBack(PowerOnCallBack,this);

	iPowerOnAsync.Set(powerOnCallBack);

	TCallBack imageCaptureCallBack(ImageCaptureCallBack,this);

	iImageCaptureAsync.Set(imageCaptureCallBack);

	TCallBack videoCaptureCallBack(VideoCaptureCallBack,this);

	iVideoCaptureAsync.Set(videoCaptureCallBack);

	TCallBack handleEventCallBack(HandleEventCallBack,this);

	iHandleEventAsync.Set(handleEventCallBack);

	TCallBack handleEvent2CallBack(HandleEvent2CallBack,this);

	iHandleEvent2Async.Set(handleEvent2CallBack);

	iInfo.iHardwareVersion.iMajor = 0;

	iInfo.iHardwareVersion.iMinor = 0;

	iInfo.iHardwareVersion.iBuild = 0;

	iInfo.iSoftwareVersion.iMajor = 0;

	iInfo.iSoftwareVersion.iMinor = 0;

	iInfo.iSoftwareVersion.iBuild = 0;

	iInfo.iOrientation = TCameraInfo::EOrientationOutwards;

	iInfo.iOptionsSupported = 0;

	iInfo.iOptionsSupported |= TCameraInfo::EViewFinderDirectSupported;

	iInfo.iOptionsSupported |= TCameraInfo::EViewFinderBitmapsSupported;

	iInfo.iOptionsSupported |= TCameraInfo::EImageCaptureSupported;

	iInfo.iOptionsSupported |= TCameraInfo::EVideoCaptureSupported;

	iInfo.iOptionsSupported |= TCameraInfo::EContrastSupported;

	iInfo.iOptionsSupported |= TCameraInfo::EBrightnessSupported;

	iInfo.iOptionsSupported |= TCameraInfo::EViewFinderClippingSupported;

	iInfo.iFlashModesSupported = 0; // Bitfield of TFlash values

	iInfo.iExposureModesSupported = 0; // Bitfield of TExposure values

	iInfo.iWhiteBalanceModesSupported = 0; // Bitfield of TWhiteBalance values

	iInfo.iMinZoom = KMinTestCameraZoom;

	// KMinTestCameraZoom is zero or negative

	// note the algorithm for creating of zoom factor

	iInfo.iMinZoomFactor = TReal32(1)/TReal32(1 << -KMinTestCameraZoom);

	iInfo.iMaxZoom = KMaxTestCameraZoom;

	iInfo.iMaxZoomFactor = 1 << KMaxTestCameraZoom;

	iInfo.iMaxDigitalZoom = KMaxTestCameraDigitalZoom;

	iInfo.iMaxDigitalZoomFactor = KMaxTestCameraDigitalZoomFactor;

	iInfo.iImageFormatsSupported = 0;

	iInfo.iImageFormatsSupported |= EFormatFbsBitmapColor4K;

	iInfo.iImageFormatsSupported |= EFormatFbsBitmapColor64K;

	iInfo.iImageFormatsSupported |= EFormatFbsBitmapColor16M;

	iInfo.iVideoFrameFormatsSupported = 0;

	iInfo.iVideoFrameFormatsSupported |= EFormatFbsBitmapColor4K;

	iInfo.iVideoFrameFormatsSupported |= EFormatFbsBitmapColor64K;

	iInfo.iVideoFrameFormatsSupported |= EFormatFbsBitmapColor16M;

	iInfo.iMaxFramesPerBufferSupported = 1;

	iInfo.iMaxBuffersSupported = 2;

	iScreenRect = TRect(TPoint(0,0), TPoint(0,0));

	iEventError = KErrNone;

	}

CTestCamera::~CTestCamera()

	{

	delete iTimer;

	delete iStillImage;

	delete iStillImageGc;

	delete iStillImageDev;

	delete iVideoFrame1;

	delete iVideoFrameGc1;

	delete iVideoFrameDev1;

	delete iVideoFrame2;

	delete iVideoFrameGc2;

	delete iVideoFrameDev2;

	delete iViewFinderBitmapGc;

	delete iViewFinderBitmapDev;

	delete iViewFinderBitmap;

	delete iDSA;

	delete iScreenGc;

	delete iScreenDev;

	delete iGc;

	delete iDev;

	delete iImage;

	delete iAdvSettingsImpl;

	delete iSnapshotImpl;

	delete iImgProcImpl;

	iImageSizes.Reset();

	iVideoFrameSizes.Reset();

	iVideoFrameRates.Reset();

	}

void CTestCamera::CameraInfo(TCameraInfo& aInfo) const

	{

	aInfo = iInfo;

	}

void CTestCamera::Reserve()

	{

	iReserved = ETrue;

	iReserveAsync.CallBack();

	}

void CTestCamera::Release()

	{

	iReserved = EFalse;

	iTimer->Cancel();

	}

void CTestCamera::PowerOn()

	{

	if (!iReserved || iPowerOn)

		{

		iPowerOnAsync.CallBack();

		return;

		}

	iPowerOn = ETrue;

	TCallBack callback(TimerCallBack,this);

	iTimer->Start(0,TInt(TReal32(1000000) / iVideoFrameRate), callback);

	iPowerOnAsync.CallBack();

	}

void CTestCamera::PowerOff()

	{

	iPowerOn = EFalse;

	iTimer->Cancel();

	}

TInt CTestCamera::Handle()

	{

	return 0;

	}

void CTestCamera::SetZoomFactorL(TInt aZoomFactor)

	{

	// it is equivalent to comparing with iInfo members as they are initialised with the same constants

	// if (aZoomFactor < iInfo.iMinZoom || aZoomFactor > iInfo.iMaxZoom)

	if (aZoomFactor < KMinTestCameraZoom || aZoomFactor > KMaxTestCameraZoom)

		{

		User::Leave(KErrNotSupported);	

		}

	iZoom = aZoomFactor;

	}

TInt CTestCamera::ZoomFactor() const

	{

	// default value is 0

	return iZoom;

	}

void CTestCamera::SetDigitalZoomFactorL(TInt aDigitalZoomFactor)

	{

	CheckReserveAndPowerL();

	// it is equivalent to comparing with iInfo member as it is initialised with the same constant

	// if (aDigitalZoomFactor < 0 || aDigitalZoomFactor > iInfo.iMaxDigitalZoom)

	if (aDigitalZoomFactor < 0 || aDigitalZoomFactor > KMaxTestCameraDigitalZoom)

		{

		User::Leave(KErrNotSupported);	

		}

	iDigitalZoom = aDigitalZoomFactor;

	}

TInt CTestCamera::DigitalZoomFactor() const

	{

	// default value is 0

	return iDigitalZoom;

	}

void CTestCamera::SetContrastL(TInt aContrast)

	{

	CheckReserveAndPowerL();

	iContrast = Min(Max(aContrast,-100),100);

	}

TInt CTestCamera::Contrast() const

	{

	return iContrast;

	}

void CTestCamera::SetBrightnessL(TInt aBrightness)

	{

	CheckReserveAndPowerL();

	iBrightness = Min(Max(aBrightness,-100),100);

	}

TInt CTestCamera::Brightness() const

	{

	return iBrightness;

	}

void CTestCamera::SetFlashL(TFlash aFlash)

	{

	CheckReserveAndPowerL();

	if (aFlash != EFlashNone)

		{

		User::Leave(KErrNotSupported);	

		}

	}

CCamera::TFlash CTestCamera::Flash() const

	{

	return EFlashNone;

	}

void CTestCamera::SetExposureL(TExposure aExposure)

	{

	CheckReserveAndPowerL();

	if (aExposure != EExposureAuto)

		{

		User::Leave(KErrNotSupported);

		}

	}

CCamera::TExposure CTestCamera::Exposure() const

	{

	return EExposureAuto;

	}

void CTestCamera::SetWhiteBalanceL(TWhiteBalance aWhiteBalance)

	{

	CheckReserveAndPowerL();

	if (aWhiteBalance != EWBAuto)

		{

		User::Leave(KErrNotSupported);

		}

	}

CCamera::TWhiteBalance CTestCamera::WhiteBalance() const

	{

	return EWBAuto;

	}

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

	{

	TRect emptyRect;

	StartViewFinderDirectL(aWs,aScreenDevice,aWindow,aScreenRect,emptyRect);

	}

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

	{

	if (!iReserved)

		{

		User::Leave(KErrInUse);		

		}

	if (!iPowerOn || iViewFinderActive)

		{

		User::Leave(KErrNotReady);	

		}

	iScreenRect = aScreenRect;

	iClipRect = aClipRect;

	delete iDSA;

	iDSA = NULL;

	iViewFinderActive = EFalse;

	iDSA = CDirectScreenAccess::NewL(aWs,aScreenDevice,aWindow,*this);

	iDSA->StartL();

	iViewFinderActive = ETrue;

	iDSA->Gc()->SetOrigin(); // Set Origin to top left of screen (0,0)

	if (!iClipRect.IsEmpty())

		{

		iDSA->Gc()->SetClippingRect(iClipRect);	

		}

	}

void CTestCamera::StartViewFinderBitmapsL(TSize& aSize)

	{

	TRect emptyRect;

	StartViewFinderBitmapsL(aSize,emptyRect);

	}

void CTestCamera::StartViewFinderBitmapsL(TSize& aSize, TRect& aClipRect)

	{

	if (!iReserved)

		{

		User::Leave(KErrInUse);

		}

	if (!iPowerOn || iViewFinderActive)

		{

		User::Leave(KErrNotReady);

		}

	iViewFinderActive = ETrue;

	iScreenRect = TRect(TPoint(0,0), aSize);

	iClipRect = aClipRect;

	iClipRect.Intersection(iScreenRect);

	delete iViewFinderBitmapGc;

	iViewFinderBitmapGc = NULL;

	delete iViewFinderBitmapDev;

	iViewFinderBitmapDev = NULL;

	delete iViewFinderBitmap;

	iViewFinderBitmap = NULL;

	iViewFinderBitmap = new(ELeave) CFbsBitmap;

	if (!iClipRect.IsEmpty())

		{

		User::LeaveIfError(iViewFinderBitmap->Create(iClipRect.Size(), KViewFinderDisplayMode));		

		}

	else

		{

		User::LeaveIfError(iViewFinderBitmap->Create(aSize, KViewFinderDisplayMode));		

		}

	iViewFinderBitmapDev = CFbsBitmapDevice::NewL(iViewFinderBitmap);

	User::LeaveIfError(iViewFinderBitmapDev->CreateContext(iViewFinderBitmapGc));

	}

void CTestCamera::StartViewFinderL(TFormat aImageFormat,TSize& aSize)

       {

       TRect emptyRect;

       StartViewFinderL(aImageFormat,aSize,emptyRect);

       }

void CTestCamera::StartViewFinderL(TFormat aImageFormat,TSize& /*aSize*/,TRect& aClipRect)	

       {

     	if(!iReserved)

     		{

     		User::Leave(KErrInUse);

     		}

		if(!iPowerOn || iViewFinderActive)

			{

			User::Leave(KErrNotReady);

			}

		iViewFinderActive = ETrue;

		iClipRect = aClipRect;

		if(!(aImageFormat & iInfo.iImageFormatsSupported))

			{

			 User::Leave(KErrNotSupported);

			}

       }

void CTestCamera::StopViewFinder()

	{

	iViewFinderActive = EFalse;

	delete iDSA;

	iDSA = NULL;

	delete iViewFinderBitmapGc;

	iViewFinderBitmapGc = NULL;

	delete iViewFinderBitmapDev;

	iViewFinderBitmapDev = NULL;

	delete iViewFinderBitmap;

	iViewFinderBitmap = NULL;

	}

TBool CTestCamera::ViewFinderActive() const

	{

	return iViewFinderActive;

	}

void CTestCamera::SetViewFinderMirrorL(TBool aMirror)

	{

	if (aMirror)

		{

		User::Leave(KErrNotSupported);	

		}

	}

TBool CTestCamera::ViewFinderMirror() const

	{

	return EFalse;

	}