--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/imaging/imagingfws/MediaClientImage/Source/Test/TMdaFailVid/TMdaFailVid1.cpp Wed Aug 25 12:29:52 2010 +0300
@@ -0,0 +1,884 @@
+// 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));
+ 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];
+
+ TBuf<64> text;
+ text.Zero();
+ text.Append(_L("Stream with alloc fail - "));
+ text.Append(entry.iName);
+ iEngine->Print(text);
+
+ TFileName fileName;
+ User::LeaveIfError(iFs.DefaultPath(fileName));
+ fileName.Append(entry.iName);
+
+ StreamImageWithAllocFailureL(*bmp,fileName,1,EStreamViaDes);
+ LoadImageL(*src,fileName,1);
+ CheckBitmaps(*src,*bmp);
+ StreamImageWithAllocFailureL(*bmp2,fileName,1,EStreamViaFile);
+ CheckBitmaps(*bmp, *bmp2);
+
+ StreamImageWithAllocFailureL(*bmp,fileName,8,EStreamViaDes);
+ LoadImageL(*src,fileName,8);
+ CheckBitmaps(*src,*bmp);
+ StreamImageWithAllocFailureL(*bmp2,fileName,8,EStreamViaFile);
+ CheckBitmaps(*bmp, *bmp2);
+ __UHEAP_MARKEND;
+ }
+
+ CleanupStack::PopAndDestroy(3); // src, bmp2 and bmp
+ }
+
+void CMdaFailVidTest1::Test3L()
+ {
+ TFileName fileName;
+ User::LeaveIfError(iFs.DefaultPath(fileName));
+ fileName.Append(KVideoTestSourceFileName);
+
+ CFbsBitmap* srcBmp = new(ELeave) CFbsBitmap;
+ CleanupStack::PushL(srcBmp);
+ User::LeaveIfError(srcBmp->Load(fileName));
+
+ for (TInt formatIndex = 0; ; formatIndex++)
+ {
+ TMdaClipFormat* format = NULL;
+ TMdaPackage* codec = NULL;
+ ConfigDestPortL(format,codec,formatIndex);
+
+ if (format == NULL && codec == NULL)
+ break;
+
+ TBuf<64> text(_L("Save with alloc fail - "));
+ text.Append(SaveFileName(formatIndex));
+ iEngine->Print(text);
+
+ SaveImageWithAllocFailureL(*srcBmp,format,codec);
+
+ iFs.Delete(KFailVideoTempTestFileName);
+ }
+
+ CleanupStack::PopAndDestroy(); // srcBmp
+ }
+
+void CMdaFailVidTest1::LoadImageWithAllocFailureL(CFbsBitmap& aBitmap,const TDesC& aFileName,TInt aZoomFactor)
+ {
+ TInt failCount = 1;
+ TInt err;
+
+ __UHEAP_MARK;
+ TRAP(err,LoadImageL(aBitmap,aFileName,aZoomFactor));
+ if (err != KErrNone)
+ iEngine->TestFailed(err);
+ __UHEAP_MARKEND;
+
+ for(;;) {
+#if defined(_DEBUG) && 0
+ RDebug::Print(_L("CMdaFailVidTest1::LoadImageWithAllocFailureL(%S,%d) failCount=%d"), &aFileName, aZoomFactor, failCount);
+#endif defined(_DEBUG)
+ __UHEAP_SETFAIL(RHeap::EDeterministic, failCount);
+ __UHEAP_MARK;
+
+ TRAP(err,LoadImageL(aBitmap,aFileName,aZoomFactor));
+ if (err != KErrNoMemory && err != KErrNone)
+ iEngine->TestFailed(err);
+
+ __UHEAP_MARKEND;
+ __UHEAP_SETFAIL(RHeap::ENone, 0);
+
+ if (err!=KErrNoMemory)
+ break;
+ failCount++;
+ }
+ failCount -= 1; // we are one over
+
+ TBuf<80> format;
+ format.Zero();
+ format.AppendFormat(_L(" Completed OK at zoom factor %d with %d memory allocations tested"),aZoomFactor,failCount);
+ iEngine->Print(format);
+ }
+
+void CMdaFailVidTest1::StreamImageWithAllocFailureL(CFbsBitmap& aBitmap,const TDesC& aFileName,TInt aZoomFactor,TStreamMethod aStreamMethod)
+ {
+ TInt failCount = 1;
+ TInt err;
+
+#if defined(_DEBUG) && 0
+ RDebug::Print(_L("CMdaFailVidTest1::StreamImageWithAllocFailureL(%S,%d,%d)"), &aFileName, aZoomFactor, aStreamMethod);
+#endif defined(_DEBUG)
+
+ __UHEAP_MARK;
+ TRAP(err,StreamImageL(aBitmap,aFileName,aZoomFactor,aStreamMethod));
+ if (err != KErrNone)
+ iEngine->TestFailed(err);
+ __UHEAP_MARKEND;
+
+ for(;;) {
+#if defined(_DEBUG) && 0
+ RDebug::Print(_L("CMdaFailVidTest1::StreamImageWithAllocFailureL(%S,%d,%d) failCount=%d"), &aFileName, aZoomFactor, aStreamMethod, failCount);
+#endif defined(_DEBUG)
+ __UHEAP_SETFAIL(RHeap::EDeterministic, failCount);
+ __UHEAP_MARK;
+
+ TRAP(err,StreamImageL(aBitmap,aFileName,aZoomFactor,aStreamMethod));
+ if (err != KErrNoMemory && err != KErrNone)
+ iEngine->TestFailed(err);
+
+ __UHEAP_MARKEND;
+ __UHEAP_SETFAIL(RHeap::ENone, 0);
+
+ if (err!=KErrNoMemory)
+ break;
+ failCount++;
+ }
+ failCount -= 1; // we are one over
+
+ TBuf<80> format;
+ format.Zero();
+ TPtrC method;
+ if (aStreamMethod==EStreamViaDes)
+ method.Set(_L("Desc"));
+ else
+ method.Set(_L("File"));
+ format.AppendFormat(_L(" Completed OK (%S) at zoom factor %d with %d memory allocations tested"),&method,aZoomFactor,failCount);
+ iEngine->Print(format);
+ }
+
+void CMdaFailVidTest1::LoadImageL(CFbsBitmap& aBitmap,const TDesC& aFileName,TInt aZoomFactor)
+ {
+ CTestImageIO* testIO = CTestImageIO::NewLC(iFs);
+ testIO->ReadL(aBitmap, aFileName, aZoomFactor);
+ CleanupStack::PopAndDestroy(); // testIO
+ }
+
+void CMdaFailVidTest1::StreamImageL(CFbsBitmap& aBitmap,const TDesC& aFileName,TInt aZoomFactor, TStreamMethod aStreamMethod)
+ {
+ CTestImageIO* testIO = CTestImageIO::NewLC(iFs);
+ if (aStreamMethod == EStreamViaDes)
+ testIO->ReadViaDesL(aBitmap, aFileName, aZoomFactor);
+ else
+ {
+ ASSERT(aStreamMethod==EStreamViaFile);
+ testIO->ReadViaFileL(aBitmap, aFileName, aZoomFactor);
+ }
+ CleanupStack::PopAndDestroy(); // testIO
+ }
+
+void CMdaFailVidTest1::SaveImageWithAllocFailureL(CFbsBitmap& aBitmap,TMdaClipFormat* aFormat,TMdaPackage* aCodec)
+ {
+ TInt failCount = 1;
+ TInt err;
+
+ __UHEAP_MARK;
+ TRAP(err,SaveImageL(aBitmap,aFormat,aCodec));
+ if (err != KErrNone)
+ iEngine->TestFailed(err);
+ __UHEAP_MARKEND;
+
+ for(;;) {
+ __UHEAP_SETFAIL(RHeap::EDeterministic, failCount);
+ __UHEAP_MARK;
+
+ TRAP(err,SaveImageL(aBitmap,aFormat,aCodec));
+ if (err != KErrNoMemory && err != KErrNone)
+ iEngine->TestFailed(err);
+
+ __UHEAP_MARKEND;
+ __UHEAP_SETFAIL(RHeap::ENone, 0);
+
+ if (err != KErrNoMemory)
+ break;
+
+ failCount++;
+ }
+ failCount -= 1; // we are one over
+
+ TBuf<80> format;
+ format.Zero();
+ format.AppendFormat(_L(" Completed OK with %d memory allocations tested"),failCount);
+ iEngine->Print(format);
+ }
+
+
+void CMdaFailVidTest1::SaveImageL(CFbsBitmap& aBitmap,TMdaClipFormat* aFormat,TMdaPackage* aCodec)
+ {
+ ASSERT(aFormat);
+
+ iFs.Delete(KFailVideoTempTestFileName);
+
+#if 0
+ RMdaSourceStreamPort srcPort;
+ srcPort.OpenLC(iSession);
+ TMdaFbsBitmapDevice bmpDev;
+ srcPort.ResourceConfigL(bmpDev);
+ TMdaFbsBitmapHandle bmpHandle;
+ bmpHandle.iBitmapHandle = aBitmap.Handle();
+ srcPort.PortConfigL(bmpHandle);
+
+ RMdaDestinationClipPort dstPort;
+ dstPort.OpenLC(iSession);
+ TMdaFileClipLocation location;
+ location.iName = KFailVideoTempTestFileName;
+ dstPort.ResourceConfigL(location);
+ dstPort.ResourceConfigL(*aFormat);
+ if (aCodec)
+ dstPort.ResourceConfigL(*aCodec);
+
+ RMdaController controller;
+ controller.OpenLC(iSession);
+ TMdaConnection connection(srcPort,dstPort,KUidMdaMediaTypeVideo);
+ controller.ConnectL(connection);
+ controller.PrepareL();
+ controller.PrimeL();
+
+ CleanupStack::PopAndDestroy(3); // controller, dstPort, srcPort
+#else 0
+ CTestImageIO* testIO = CTestImageIO::NewLC(iFs);
+ testIO->WriteL(aBitmap, KFailVideoTempTestFileName, aFormat, aCodec);
+ CleanupStack::PopAndDestroy(); // testIO
+#endif 0
+ }
+
+const TDesC& CMdaFailVidTest1::SaveFileName(TInt aFormatIndex)
+ {
+ switch (aFormatIndex)
+ {
+ case 0: return KVideoTest1BppMonoMbm;
+ case 1: return KVideoTest2BppMonoMbm;
+ case 2: return KVideoTest4BppMonoMbm;
+ case 3: return KVideoTest8BppMonoMbm;
+ case 4: return KVideoTest4BppColorMbm;
+ case 5: return KVideoTest8BppColorMbm;
+ case 6: return KVideoTest12BppColorMbm;
+ case 7: return KVideoTest16BppColorMbm;
+ case 8: return KVideoTest24BppColorMbm;
+ case 9: return KVideoTestMono10Jfif;
+ case 10: return KVideoTestMono30Jfif;
+ case 11: return KVideoTestMono60Jfif;
+ case 12: return KVideoTestMono100Jfif;
+ case 13: return KVideoTest420C10Jfif;
+ case 14: return KVideoTest420C30Jfif;
+ case 15: return KVideoTest420C60Jfif;
+ case 16: return KVideoTest420C100Jfif;
+ case 17: return KVideoTest422C10Jfif;
+ case 18: return KVideoTest422C30Jfif;
+ case 19: return KVideoTest422C60Jfif;
+ case 20: return KVideoTest422C100Jfif;
+ case 21: return KVideoTest444C10Jfif;
+ case 22: return KVideoTest444C30Jfif;
+ case 23: return KVideoTest444C60Jfif;
+ case 24: return KVideoTest444C100Jfif;
+ case 25: return KVideoTest1BppBmp;
+ case 26: return KVideoTest4BppBmp;
+ case 27: return KVideoTest8BppBmp;
+ case 28: return KVideoTest24BppBmp;
+ default: return KNullDesC;
+ }
+ }
+
+void CMdaFailVidTest1::ConfigDestPortL(TMdaClipFormat*& aFormat,TMdaPackage*& aCodec,TInt aFormatIndex)
+ {
+ aFormat = NULL;
+ aCodec = NULL;
+
+ if (aFormatIndex >= 0 && aFormatIndex <= 8)
+ {
+ switch (aFormatIndex)
+ {
+ case 0: iMbmFormat.iDisplayMode = EGray2; break;
+ case 1: iMbmFormat.iDisplayMode = EGray4; break;
+ case 2: iMbmFormat.iDisplayMode = EGray16; break;
+ case 3: iMbmFormat.iDisplayMode = EGray256; break;
+ case 4: iMbmFormat.iDisplayMode = EColor16; break;
+ case 5: iMbmFormat.iDisplayMode = EColor256; break;
+ case 6: iMbmFormat.iDisplayMode = EColor4K; break;
+ case 7: iMbmFormat.iDisplayMode = EColor64K; break;
+ case 8: iMbmFormat.iDisplayMode = EColor16M; break;
+ default: User::Invariant();
+ }
+ aFormat = &iMbmFormat;
+ }
+ else if (aFormatIndex >= 9 && aFormatIndex <= 24)
+ {
+ switch (aFormatIndex)
+ {
+ case 9: case 10: case 11: case 12:
+ iJfifFormat.iSettings.iSampleScheme = TMdaJpgSettings::EMonochrome;
+ break;
+ case 13: case 14: case 15: case 16:
+ iJfifFormat.iSettings.iSampleScheme = TMdaJpgSettings::EColor420;
+ break;
+ case 17: case 18: case 19: case 20:
+ iJfifFormat.iSettings.iSampleScheme = TMdaJpgSettings::EColor422;
+ break;
+ case 21: case 22: case 23: case 24:
+ iJfifFormat.iSettings.iSampleScheme = TMdaJpgSettings::EColor444;
+ break;
+ default: User::Invariant();
+ }
+ switch (aFormatIndex)
+ {
+ case 9: case 13: case 17: case 21:
+ iJfifFormat.iSettings.iQualityFactor = 10;
+ break;
+ case 10: case 14: case 18: case 22:
+ iJfifFormat.iSettings.iQualityFactor = 30;
+ break;
+ case 11: case 15: case 19: case 23:
+ iJfifFormat.iSettings.iQualityFactor = 60;
+ break;
+ case 12: case 16: case 20: case 24:
+ iJfifFormat.iSettings.iQualityFactor = 100;
+ break;
+ default: User::Invariant();
+ }
+ aFormat = &iJfifFormat;
+ }
+ else if (aFormatIndex >= 25 && aFormatIndex <= 28)
+ {
+ switch (aFormatIndex)
+ {
+ case 25: aCodec = &iBmp1BppCodec; break;
+ case 26: aCodec = &iBmp4BppCodec; break;
+ case 27: aCodec = &iBmp8BppCodec; break;
+ case 28: aCodec = &iBmp24BppCodec; break;
+ default: User::Invariant();
+ }
+ aFormat = &iBmpFormat;
+ }
+ }
+