// Copyright (c) 1999-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:

// TMDAVID6.CPP

// 

//

#include "tmdatest.h"

/*

Tests:

File -> Bitmap with alloc failure

File -> Bitmap streaming with alloc failure

Bitmap -> File with alloc failure

*/

//

// CTestImageIO 

// walking class that does image reads and writes. Exploits asynchronous behaviour

// of own properties. Calls are essentially synchronous using AS recursion

//

const TInt KViaDesIncrement = 0x1000;

const TInt KTempHeapSize = 0x100000; // 1M 0x20000; // 128K

class CTestImageIO : public CBase, public MMdaImageUtilObserver

	{

// New data types

protected:

	enum TOperation {ERead, EReadViaDes, EReadViaFile, EWrite};

	enum TState {EStateIdle, EStateOpening, EStateConverting};

// Construction, Destruction

public:

	static CTestImageIO *NewL(RFs &aFs);

	static CTestImageIO *NewLC(RFs &aFs);

	~CTestImageIO();

protected:

	CTestImageIO(RFs &aFs);

	void ConstructL();

// New public functions

public:

	void ReadL(CFbsBitmap& aBitmap, const TDesC& aFileName, TInt aZoomFactor);

	void ReadViaDesL(CFbsBitmap& aBitmap, const TDesC& aFileName, TInt aZoomFactor);

	void ReadViaFileL(CFbsBitmap& aBitmap, const TDesC& aFileName, TInt aZoomFactor);

	void WriteL(CFbsBitmap& aBitmap, const TDesC& aFileName, TMdaClipFormat* aFormat,TMdaPackage* aCodec);

// Virtual functions from MMdaImageUtilObserver

protected:

	virtual void MiuoCreateComplete(TInt aError);

	virtual void MiuoOpenComplete(TInt aError);

	virtual void MiuoConvertComplete(TInt aError);

// Helper functions

protected:

	void Leave(TInt aError);

	void OpenOrigAndTempFilesL();

	void CloseOrigAndTempFiles();

	void CopyFileToTempL(TInt aSize);

	void ResetStreamBufferedSize();

	void IncrementStreamBufferedSize();

	TInt StreamBufferedSize() const { return iBufferedSize; }

// Data properties:

protected:

	CMdaImageUtility*	iUtility;

	TOperation			iOperation;

	TState				iState;

	TInt				iReturnedError;

	TPtr8				iBuffer;		// used in via des streaming

	TPtr8				iCopyBuffer;

	TInt				iBufferedSize;	// running required buffer size for streaming

	TInt				iFileSize;

	TInt				iZoomFactor;

	RFile				iOrigFile;		// used in ReadViaFileL

	RFile				iTempFile;

	TInt				iTempFileSize;

// Linked data

	CFbsBitmap*			iBitmap;

	TPtrC				iFileName;

	RFs&				iFs;

	};

CTestImageIO* CTestImageIO::NewL(RFs &aFs)

	{

	CTestImageIO* result = NewLC(aFs);

	CleanupStack::Pop(); 

	return result;

	}

CTestImageIO* CTestImageIO::NewLC(RFs &aFs)

	{

	CTestImageIO* result = new (ELeave) CTestImageIO(aFs);

	CleanupStack::PushL(result);

	result->ConstructL();

	return result;

	}

CTestImageIO::CTestImageIO(RFs &aFs):

	iBuffer(NULL, 0, 0),

	iCopyBuffer(NULL, 0, 0),

	iFs(aFs)

	{

	}

void CTestImageIO::ConstructL()

	{

	const TInt copySize=KViaDesIncrement;

	iCopyBuffer.Set(STATIC_CAST(TUint8*, User::AllocL(copySize)), 0, copySize);

	}

CTestImageIO::~CTestImageIO()

	{

	delete iUtility;

	User::Free(REINTERPRET_CAST(TAny*,CONST_CAST(TUint8*, iBuffer.Ptr())));

	User::Free(REINTERPRET_CAST(TAny*,CONST_CAST(TUint8*, iCopyBuffer.Ptr())));

	CloseOrigAndTempFiles();

	}

void CTestImageIO::Leave(TInt aError)

	{

	iReturnedError = aError;

	CActiveScheduler::Stop();

	}

void CTestImageIO::OpenOrigAndTempFilesL()

	{

	User::LeaveIfError(iOrigFile.Open(iFs, iFileName, EFileShareReadersOnly|EFileStream|EFileRead));

	User::LeaveIfError(iTempFile.Replace(iFs, KFailVideoTempTestFileName, EFileShareAny|EFileStream|EFileWrite));

	iTempFileSize = 0;

	}

void CTestImageIO::CloseOrigAndTempFiles()

	{

	iOrigFile.Close();

	iTempFile.Close();

	}

void CTestImageIO::CopyFileToTempL(TInt aSize)

	{

	TInt copySize = aSize - iTempFileSize;

	ASSERT(copySize >= 0); // should not occur

	if(copySize == 0)

		return;

	User::LeaveIfError(iOrigFile.Read(iCopyBuffer, copySize));

	ASSERT(iCopyBuffer.Length() == copySize); // should not have any shortfall

	User::LeaveIfError(iTempFile.Write(iCopyBuffer));

	iTempFileSize += copySize;

	}

void CTestImageIO::ResetStreamBufferedSize()

	{

	ASSERT(iFileSize>0); // don't copy with real empty files

	iBufferedSize = 1; // start stream at size 1

	}

void CTestImageIO::IncrementStreamBufferedSize()

	{

	TInt newSize;

	if (iBufferedSize < 100)

		newSize = iBufferedSize + 1;

	else

		newSize = iBufferedSize + KViaDesIncrement;

	iBufferedSize = Min(iFileSize, newSize);

#if defined(_DEBUG) && 0

	RDebug::Print(_L("IncrementStreamBuffer->%d"), iBufferedSize); 

#endif defined(_DEBUG)

	}

void CTestImageIO::ReadL(CFbsBitmap& aBitmap, const TDesC& aFileName, TInt aZoomFactor)

	{

	ASSERT(iState==EStateIdle); // ensure in idle state

	delete iUtility; iUtility=NULL; // could be non-NULL if previous error

	iFileName.Set(aFileName); // remember parameters

	iBitmap = &aBitmap;

	iZoomFactor = aZoomFactor;

	iOperation = ERead;

	iUtility = CMdaImageFileToBitmapUtility::NewL(*this, NULL);

	CMdaImageFileToBitmapUtility* utility = STATIC_CAST(CMdaImageFileToBitmapUtility*, iUtility);

	utility->OpenL(iFileName);

	iState = EStateOpening;

	CActiveScheduler::Start(); // recurse into AO

	ASSERT(iState == EStateIdle); // we should have come back here

	delete iUtility; iUtility = NULL;

	User::LeaveIfError(iReturnedError);

	}

void CTestImageIO::ReadViaDesL(CFbsBitmap& aBitmap, const TDesC& aFileName, TInt aZoomFactor)

	{

	ASSERT(iState==EStateIdle); // ensure in idle state

	delete iUtility; iUtility=NULL; // could be non-NULL if previous error

	iFileName.Set(aFileName); // remember parameters

	iBitmap = &aBitmap;

	iZoomFactor = aZoomFactor;

	iOperation = EReadViaDes;

	// read the whole of the original file into a buffer of the correct size

	RFile file;

	User::LeaveIfError(file.Open(iFs, aFileName, EFileShareReadersOnly|EFileStream|EFileRead));

	CleanupClosePushL(file);

	User::LeaveIfError(file.Size(iFileSize));

	iBuffer.Set(STATIC_CAST(TUint8 *, User::AllocL(iFileSize)), 0, iFileSize);

	User::LeaveIfError(file.Read(iBuffer));

	CleanupStack::PopAndDestroy(); // file

	ResetStreamBufferedSize(); // initial bit we try to read

	iBuffer.SetLength(StreamBufferedSize()); 

	iUtility = CMdaImageDescToBitmapUtility::NewL(*this, NULL);

	CMdaImageDescToBitmapUtility* utility = STATIC_CAST(CMdaImageDescToBitmapUtility*, iUtility);

	utility->OpenL(iBuffer);

	iState = EStateOpening;

	CActiveScheduler::Start(); // recurse into AO

	ASSERT(iState == EStateIdle); // we should have come back here

	delete iUtility; iUtility = NULL;

	User::LeaveIfError(iReturnedError);

	}

void CTestImageIO::ReadViaFileL(CFbsBitmap& aBitmap, const TDesC& aFileName, TInt aZoomFactor)

	{

	ASSERT(iState==EStateIdle); // ensure in idle state

	delete iUtility; iUtility=NULL; // could be non-NULL if previous error

	iFileName.Set(aFileName); // remember parameters

	iBitmap = &aBitmap;

	iZoomFactor = aZoomFactor;

	iOperation = EReadViaFile;

	TEntry entry;

	User::LeaveIfError(iFs.Entry(iFileName, entry));

	iFileSize = entry.iSize;

	// copy bytes from the original file, as required

	OpenOrigAndTempFilesL();

	ResetStreamBufferedSize(); // initial bit we try to read

	CopyFileToTempL(StreamBufferedSize()); 

	iUtility = CMdaImageFileToBitmapUtility::NewL(*this, NULL);

	CMdaImageFileToBitmapUtility* utility = STATIC_CAST(CMdaImageFileToBitmapUtility*, iUtility);

	TPtrC tempFileName(KFailVideoTempTestFileName);

	utility->OpenL(tempFileName);

	iState = EStateOpening;

	CActiveScheduler::Start(); // recurse into AO

	ASSERT(iState == EStateIdle); // we should have come back here

	delete iUtility; iUtility = NULL;

	CloseOrigAndTempFiles();

	(void) iFs.Delete(KFailVideoTempTestFileName); // delete temp file

	User::LeaveIfError(iReturnedError);

	}

void CTestImageIO::WriteL(CFbsBitmap& aBitmap, const TDesC& aFileName, TMdaClipFormat* aFormat,TMdaPackage* aCodec)

	{

	ASSERT(iState==EStateIdle); // ensure in idle state

	delete iUtility; iUtility=NULL; // could be non-NULL if previous error

	iFileName.Set(aFileName); // remember parameters

	iBitmap = &aBitmap;

	iOperation = EWrite;

	iUtility = CMdaImageBitmapToFileUtility::NewL(*this, NULL);

	CMdaImageBitmapToFileUtility* utility = STATIC_CAST(CMdaImageBitmapToFileUtility*, iUtility);

	utility->CreateL(iFileName, aFormat, aCodec, aCodec); 

		// note some of the standard codec's look at the standard codec info and some the extra

	iState = EStateOpening;

	CActiveScheduler::Start(); // recurse into AO

	ASSERT(iState == EStateIdle); // we should have come back here

	delete iUtility; iUtility = NULL;

	User::LeaveIfError(iReturnedError);

	}

void CTestImageIO::MiuoOpenComplete(TInt aError)

	{

	ASSERT(iOperation == ERead || iOperation == EReadViaDes || iOperation == EReadViaFile); // only these operations should get here

	ASSERT(iState == EStateOpening); // to be expected

	if (aError!=KErrNone)

		{

		if ((iOperation==EReadViaDes || iOperation==EReadViaFile) &&

			aError == KErrUnderflow && StreamBufferedSize() < iFileSize)

			{

			// doing stream operation and not yet enough data to open the file

			IncrementStreamBufferedSize();

			TInt error = KErrNone;

			if (iOperation == EReadViaDes)

				{

				iBuffer.SetLength(StreamBufferedSize());

				CMdaImageDescToBitmapUtility* utility = STATIC_CAST(CMdaImageDescToBitmapUtility*, iUtility);

				TRAP(error, utility->OpenL(iBuffer));

				}

			else

				{

				ASSERT(iOperation == EReadViaFile);

				TRAP(error, CopyFileToTempL(StreamBufferedSize()));

				CMdaImageFileToBitmapUtility* utility = STATIC_CAST(CMdaImageFileToBitmapUtility*, iUtility);

				TPtrC tempFileName(KFailVideoTempTestFileName);

				if (error==KErrNone)

					TRAP(error,utility->OpenL(tempFileName));

				}

			if (error != KErrNone)

				{

				iState = EStateIdle;

				Leave(error);

				}

			}

		else

			{

			iState = EStateIdle;

			Leave(aError);

			}

		}

	else

		{

		// note for readviades and viafile we only have to resize once - not on subsequent tries

		TFrameInfo frameInfo;

		iUtility->FrameInfo(0, frameInfo);

		TSize frameSize = frameInfo.iFrameCoordsInPixels.Size();

		frameSize.iWidth = (frameSize.iWidth+iZoomFactor-1) / iZoomFactor;

		frameSize.iHeight = (frameSize.iHeight+iZoomFactor-1) / iZoomFactor;

		TInt error = iBitmap->Resize(TSize(0,0));

		if (error==KErrNone)

			error = iBitmap->Resize(frameSize);

		if (error==KErrNone)

			TRAP(error, iUtility->ConvertL(*iBitmap));

		if (error!=KErrNone)

			{

			iState = EStateIdle;

			Leave(error);

			}

		else

			iState = EStateConverting;

		}

	}

void CTestImageIO::MiuoCreateComplete(TInt aError)

	{

	ASSERT(iOperation == EWrite); // only called on write operation

	ASSERT(iState == EStateOpening); // to be expected

	if (aError!=KErrNone)

		{

		iState = EStateIdle;

		Leave(aError);

		}

	else

		{

		TRAPD(error, iUtility->ConvertL(*iBitmap));

		if (error!=KErrNone)

			{

			iState = EStateIdle;

			Leave(error);

			}

		else

			iState = EStateConverting;

		}

	}

void CTestImageIO::MiuoConvertComplete(TInt aError)

	{

	ASSERT(iState == EStateConverting); // to be expected

	if (iOperation == ERead || iOperation == EWrite)

		{

		iState = EStateIdle;

		Leave(aError);

		}

	else

		{

		ASSERT(iOperation == EReadViaDes || iOperation == EReadViaFile);

		if (aError == KErrUnderflow && StreamBufferedSize() < iFileSize)

			// partial decode event - try to decode a bit more

			{

			IncrementStreamBufferedSize();

			TInt error = KErrNone;

			if (iOperation == EReadViaDes)

				iBuffer.SetLength(StreamBufferedSize());

			else

				{

				ASSERT(iOperation == EReadViaFile);

				TRAP(error, CopyFileToTempL(StreamBufferedSize()));

				}

			if (error==KErrNone)

				TRAP(error, iUtility->ConvertL(*iBitmap));

			if (error != KErrNone)

				{

				iState = EStateIdle;

				Leave(error);

				}

			}

		else

			{

			iState = EStateIdle;

			Leave(aError);

			}

		}

	}

//

// CMdaFailVid1

//

void CMdaFailVidTest1::DoTestL()

	{

	User::LeaveIfError(iFs.Connect());

	CleanupClosePushL(iFs);

	CDir* dir = NULL;

	iFs.GetDir(KNullDesC,0,0,dir);

	CleanupStack::PushL(dir);

	TInt error=KErrNone;

	__UHEAP_MARK;

	TRAP(error,Test1L(*dir)); 

	iEngine->Print(_L("After Test1"));

	__UHEAP_MARKEND; 

	User::LeaveIfError(error);

	__UHEAP_MARK;

	TRAP(error,Test2L(*dir));

	iEngine->Print(_L("After Test2"));

	__UHEAP_MARKEND; 

	User::LeaveIfError(error);

	// preload and destroy CFbsBitmap to avoid "memory leak" - really side effect of

	// CFbsBitmap::Load() that is cleaned up properly later

		{

		TFileName fileName;

		User::LeaveIfError(iFs.DefaultPath(fileName));

		fileName.Append(KVideoTestSourceFileName);

		CFbsBitmap* srcBmp = new(ELeave) CFbsBitmap;

		CleanupStack::PushL(srcBmp);

		User::LeaveIfError(srcBmp->Load(fileName));

		CleanupStack::PopAndDestroy(); // srcBmp

		}

	__UHEAP_MARK;

	TRAP(error,Test3L());

	iEngine->Print(_L("After Test3"));

	__UHEAP_MARKEND; 

	User::LeaveIfError(error);

	CleanupStack::PopAndDestroy(2); // dir, iFs

	}

void CMdaFailVidTest1::Test1L(CDir& aDir)

	{

	CFbsBitmap *bmp = new (ELeave) CFbsBitmap;

	CleanupStack::PushL(bmp);

	User::LeaveIfError(bmp->Create(TSize(0,0),EColor16M));

	CFbsBitmap *src = new (ELeave) CFbsBitmap;

	CleanupStack::PushL(src);

	User::LeaveIfError(src->Create(TSize(0,0),EColor16M));

	TInt entries = aDir.Count();

	for (TInt count = 0; count < entries; count++)

		{

		__UHEAP_MARK;

		const TEntry& entry = aDir[count];

		TFileName fileName;

		User::LeaveIfError(iFs.DefaultPath(fileName));

		fileName.Append(entry.iName);

		TBuf<80> text;

		text.Zero();

		text.Append(_L("Load with alloc fail - "));

		text.Append(entry.iName);

		iEngine->Print(text);

		LoadImageL(*src,fileName,1);

		LoadImageWithAllocFailureL(*bmp,fileName,1);

		CheckBitmaps(*src,*bmp);

		LoadImageL(*src,fileName,8);

		LoadImageWithAllocFailureL(*bmp,fileName,8);

		CheckBitmaps(*src,*bmp);

		__UHEAP_MARKEND;

		}

	CleanupStack::PopAndDestroy(2); // src and bmp

	}

void CMdaFailVidTest1::Test2L(CDir& aDir)

	{

	CFbsBitmap *bmp = new (ELeave) CFbsBitmap;

	CleanupStack::PushL(bmp);

	User::LeaveIfError(bmp->Create(TSize(0,0),EColor16M));

	CFbsBitmap *bmp2 = new (ELeave) CFbsBitmap;

	CleanupStack::PushL(bmp2);

	User::LeaveIfError(bmp2->Create(TSize(0,0),EColor16M));