// 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:
// testsnapshot.cpp
// 
//

#include "test_snapshot.h"
#include <ecamerrors.h>

CTestCamSnapshot::CTestCamSnapshot(CTestCamera& aOwner): iOwner(aOwner), iSnapshotBuffer(iSnapshot)
	{
	Init();
	}
	
CTestCamSnapshot::~CTestCamSnapshot()
	{
	delete iSnapshotImage;
	iSnapshotImage = NULL;
	delete iSnapshotImageGc;
	iSnapshotImage = NULL;
	delete iSnapshotImageDev;
	iSnapshotImageDev = NULL;
	
	delete iSnapshot;
	iSnapshot = NULL;
	delete iSnapshotGc;
	iSnapshotGc = NULL;
	delete iSnapshotDev;
	iSnapshotDev = NULL;
	
	iSupportedSnapshotRect.Close();
	
	CDataGlobal* globalData = static_cast <CDataGlobal*> (Dll::Tls());
	if(globalData != NULL)
		{
		if(!globalData->iTestCamPresets && !globalData->iTestCamAdvSet && !globalData->iTestCamImgProc)
			{
			delete globalData;
			Dll::FreeTls();
			}	
		else
			{
			globalData->iTestCamSnapshot = NULL;	
			Dll::SetTls(globalData);
			}
		}
	}
		
CTestCamSnapshot* CTestCamSnapshot::NewL(CTestCamera& aOwner)
	{
	CDataGlobal* globalData = static_cast <CDataGlobal*> (Dll::Tls());
	
	if(globalData == NULL)
		{
		globalData = new (ELeave) CDataGlobal;
		CleanupStack::PushL(globalData);
		globalData->iSnapshotReferenceCount = 0;
		globalData->iTestCamSnapshot = new (ELeave) CTestCamSnapshot(aOwner);
		CleanupStack::PushL(globalData->iTestCamSnapshot);
		globalData->iTestCamSnapshot->ConstructL();
		globalData->iTestCamSnapshot->iRefCount = 1;
		User::LeaveIfError(Dll::SetTls(globalData));
		CleanupStack::Pop(globalData->iTestCamSnapshot);
		CleanupStack::Pop(globalData);
		return globalData->iTestCamSnapshot;
		}
	else
		{
		if(globalData->iTestCamSnapshot == NULL)
			{
			globalData->iSnapshotReferenceCount = 0;
			globalData->iTestCamSnapshot = new (ELeave) CTestCamSnapshot(aOwner);
			CleanupStack::PushL(globalData->iTestCamSnapshot);
			globalData->iTestCamSnapshot->ConstructL();
			globalData->iTestCamSnapshot->iRefCount = 1;
			User::LeaveIfError(Dll::SetTls(globalData));
			CleanupStack::Pop(globalData->iTestCamSnapshot);
			return globalData->iTestCamSnapshot;
			}
		
		CTestCamSnapshot* self = globalData->iTestCamSnapshot;
		
		globalData->iSnapshotReferenceCount++;
		self->iRefCount = globalData->iSnapshotReferenceCount + 1;
		if (globalData->iSnapshotReferenceCount == KNumOfSnapshotExtensions-1 )
			{
			globalData->iTestCamSnapshot = NULL;
			if(!globalData->iTestCamPresets && !globalData->iTestCamAdvSet && !globalData->iTestCamImgProc)
				{
				delete globalData;
				Dll::FreeTls();
				}
			else
				{
				User::LeaveIfError(Dll::SetTls(globalData));	
				}
			}
		else
			{
			User::LeaveIfError(Dll::SetTls(globalData));	
			}
		return self;		
		}
	}

void CTestCamSnapshot::Release()
	{
	iRefCount--; 
	if(iRefCount == 0)
		{
		iOwner.iSnapshotImpl = NULL;
		delete this;
		}
	}	
	
void CTestCamSnapshot::Init()
	{
	iImageFormatsSupported = 0;
	iImageFormatsSupported |= CCamera::EFormatFbsBitmapColor4K;
	iImageFormatsSupported |= CCamera::EFormatFbsBitmapColor64K;
	iImageFormatsSupported |= CCamera::EFormatFbsBitmapColor16M; 
	iSnapshotPrepared = EFalse;
	iSnapshotActive = EFalse;
	iBgColor = KRgbWhite;
	}

void CTestCamSnapshot::ConstructL()
	{
	iSupportedSnapshotRect.Reset();
	iSupportedSnapshotRect.AppendL(TRect(TPoint(0,0), iOwner.iImageSizes[0]));
	iSupportedSnapshotRect.AppendL(TRect(TPoint(0,0), iOwner.iImageSizes[1]));
	}

TUint32 CTestCamSnapshot::SupportedFormats()
	{
	return iImageFormatsSupported;
	}
	
void CTestCamSnapshot::PrepareSnapshotL(CCamera::TFormat aFormat, const TPoint& aPosition, const TSize& aSize, const TRgb& aBgColor, TBool /*aMaintainAspectRatio*/)
	{
	iOwner.CheckReserveAndPowerL();
		
	if (iOwner.iVideoCaptureActive || iOwner.iImageCaptureActive)
		{
		User::Leave(KErrNotReady);
		}
		
	if (!(aFormat & iImageFormatsSupported) )
		{
		User::Leave(KErrNotSupported);
		}
	
	//check if the snapshot size is supported
	TRect snapshot_rect = TRect(aPosition, aSize);
	
	if(snapshot_rect != iSupportedSnapshotRect[0] && snapshot_rect != iSupportedSnapshotRect[1])
		{
		User::Leave(KErrNotSupported);
		}

	if (iSnapshotPrepared
		&& iSnapshotFormat == aFormat
		&& iSnapshotImageRect == snapshot_rect
		&& iBgColor == aBgColor
		)
		{
		return;
		}

	TDisplayMode displayMode = ENone;
	switch (aFormat)
		{
		case CCamera::EFormatFbsBitmapColor4K :
			displayMode = EColor4K;
			break;
		case CCamera::EFormatFbsBitmapColor64K :
			displayMode = EColor64K;
			break;
		case CCamera::EFormatFbsBitmapColor16M :
			displayMode = EColor16M;
			break;
		default :
			User::Leave(KErrNotSupported);
			break;
		}

	delete iSnapshotImage;
	iSnapshotImage = NULL;
	delete iSnapshotImageGc;
	iSnapshotImageGc = NULL;
	delete iSnapshotImageDev;
	iSnapshotImageDev = NULL;

	iSnapshotImage = new(ELeave) CFbsBitmap;
	User::LeaveIfError(iSnapshotImage->Create(aSize, displayMode));
	iSnapshotImageDev = CFbsBitmapDevice::NewL(iSnapshotImage);
	User::LeaveIfError(iSnapshotImageDev->CreateContext(iSnapshotImageGc));
	iSnapshotImageGc->SetPenColor(KRgbBlack);
	iSnapshotImageGc->SetPenSize(TSize(KFrameFeatureBorderThickness, KFrameFeatureBorderThickness));
	iSnapshotImageGc->SetBrushColor(aBgColor);
	iSnapshotImageGc->SetFaded(ETrue);
	
	iSnapshotPrepared = ETrue;
	iSnapshotImageRect = snapshot_rect;
	iSnapshotFormat = aFormat;
	iBgColor = aBgColor;
	}
	
void CTestCamSnapshot::PrepareSnapshotL(CCamera::TFormat /*aFormat*/, const TSize& /*aSize*/, TBool /*aMaintainAspectRatio*/)
	{
	User::Leave(KErrNotSupported);
	}
	
void CTestCamSnapshot::SetBgColorL(const TRgb& /*aBgColor*/)
	{
	User::Leave(KErrNotSupported);
	}
	
void CTestCamSnapshot::SetPositionL(const TPoint& /*aPosition*/)
	{
	User::Leave(KErrNotSupported);
	}
	
TBool CTestCamSnapshot::IsSnapshotActive() const
	{
	return iSnapshotActive;
	}

void CTestCamSnapshot::StartSnapshot()
	{
	TInt error = iOwner.CheckReserveAndPower();
	
	if(error == KErrNone)
		{
		if(!iSnapshotPrepared)
			{
			error = KErrNotReady;
			}
		}
	
	if(error != KErrNone)
		{
		TECAMEvent ecamevent(KUidECamEventCameraSnapshot, error);
		
		iOwner.iECamEvent = ecamevent;
		iOwner.iHandleEventAsync.CallBack();	
		return;	
		}
		
	delete iSnapshot;
	iSnapshot = NULL;
	delete iSnapshotGc;
	iSnapshot = NULL;
	delete iSnapshotDev;
	iSnapshotDev = NULL;
	
	TRAP(error, DoStartSnapshotL());
	
	if(error != KErrNone)
		{
		TECAMEvent ecamevent(KUidECamEventCameraSnapshot, error);
		
		iOwner.iECamEvent = ecamevent;
		iOwner.iHandleEventAsync.CallBack();
		}
	}
	
void CTestCamSnapshot::DoStartSnapshotL()
	{
	CFbsBitmap* snapshot = new(ELeave) CFbsBitmap;
	CleanupStack::PushL(snapshot);
	User::LeaveIfError(snapshot->Create(iSnapshotImageRect.Size(), iSnapshotImage->DisplayMode()));
	CFbsBitmapDevice* dev = CFbsBitmapDevice::NewL(snapshot);
	CleanupStack::PushL(dev);
	CFbsBitGc* gc = NULL;
	User::LeaveIfError(dev->CreateContext(gc));
	CleanupStack::Pop(dev);
	CleanupStack::Pop(snapshot);
	
	iSnapshot = snapshot;
	iSnapshotDev = dev;
	iSnapshotGc = gc;
		
	iSnapshotActive = ETrue;
	}

void CTestCamSnapshot::StopSnapshot()
	{
	delete iSnapshotGc;
	iSnapshotGc = NULL;
	delete iSnapshotDev;
	iSnapshotDev = NULL;
	delete iSnapshot;
	iSnapshot = NULL;
	
	iSnapshotActive = EFalse;
	}
        	
MCameraBuffer& CTestCamSnapshot::SnapshotDataL(RArray<TInt>& /*aFrameIndexOrder*/)
	{
	iSnapshotBuffer.iAvailable = EFalse;
	return iSnapshotBuffer;
	}
	
void CTestCamSnapshot::ServiceSnapshot(const CFbsBitGc& aSourceBitmapGc)
	{
	TInt error = KErrNone;
	if(!iSnapshotBuffer.iAvailable)
		{
		error = KErrInUse;
		}
	else
		{
		iSnapshotGc->BitBlt(TPoint(0,0), aSourceBitmapGc);
		}
			
	iOwner.iObserver2->HandleEvent(TECAMEvent(KUidECamEventCameraSnapshot, error));
	}
	
void CTestCamSnapshot::ServiceBurstImageSnapshot(const CFbsBitGc& aSourceBitmapGc)
	{
	TInt error = KErrNone;
	if(!iSnapshotBuffer.iAvailable)
		{
		error = KErrInUse;
		}
	else
		{
		iSnapshotGc->BitBlt(TPoint(0,0), aSourceBitmapGc);
		}
			
	iOwner.iObserver2->HandleEvent(TECAMEvent(KUidECamEventCameraSnapshot, error));
	
	User::After(500000);
	
	iOwner.iStillImagePos.iX += KFramePosIncrement;
	iOwner.iStillImagePos.iY += KFramePosIncrement;

	if (iOwner.iStillImagePos.iX >= iOwner.iStillImageSize.iWidth)
		{
		iOwner.iStillImagePos.iX = 0;
		}
		
	if (iOwner.iStillImagePos.iY >= iOwner.iStillImageSize.iHeight)
		{
		iOwner.iStillImagePos.iY = 0;
		}
	}