diff -r 000000000000 -r bde4ae8d615e os/mm/mmlibs/mmfw/tsrc/mmfintegrationtest/vclntavi/src/testvideoplayer_subtitles.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/os/mm/mmlibs/mmfw/tsrc/mmfintegrationtest/vclntavi/src/testvideoplayer_subtitles.cpp	Fri Jun 15 03:10:57 2012 +0200
@@ -0,0 +1,806 @@
+// Copyright (c) 2008-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 "testvideoplayer_subtitles.h"
+
+const TUint KCacheSize = 1000000; //1MB
+const TUint KMaxCacheSize = 50000000; //50MB
+
+
+CPlayTimer* CPlayTimer::NewL(RTestVclnt2Subtitle& aTestStep)
+	{
+	CPlayTimer* self = new (ELeave) CPlayTimer(aTestStep);
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	CleanupStack::Pop();
+	return self;
+	}
+
+CPlayTimer::CPlayTimer(RTestVclnt2Subtitle& aTestStep)
+	: CTimer(EPriorityHigh), iTestStep(aTestStep)
+	{
+	CActiveScheduler::Add(this);
+	}
+
+void CPlayTimer::RunL()
+	{
+	iTestStep.DoDuringPlaybackActionsL();
+	}
+
+TInt CPlayTimer::RunError(TInt aError)
+	{
+	// Tell the test to fail with error code aError.  
+	iTestStep.FailTest(aError);
+	return KErrNone;
+	}
+
+//
+// RTestVclnt2Subtitle
+//
+
+RTestVclnt2Subtitle* RTestVclnt2Subtitle::NewL(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TInt aExpectedError)
+	{
+	return new (ELeave) RTestVclnt2Subtitle(aTestName, aSectName, aKeyName, aExpectedError);
+	}
+
+RTestVclnt2Subtitle::RTestVclnt2Subtitle(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TInt aExpectedError)
+	: RTestVclnt2AviPlayerStep(aTestName, aSectName, aKeyName, aExpectedError)
+	{
+	}
+
+void RTestVclnt2Subtitle::FailTest(TInt aError)
+	{
+	ERR_PRINTF2(_L("Test step failed with error %d."), aError);
+	iError = aError;
+	iTestStepResult = EFail;
+    CActiveScheduler::Stop();
+	}
+
+TVerdict RTestVclnt2Subtitle::DoTestStepPreambleL()
+	{
+	User::LeaveIfError(SetCacheSize());
+	TVerdict result = RTestVclnt2AviPlayerStep::DoTestStepPreambleL();
+	
+	if (result == EPass)
+		{
+		iPlayTimer = CPlayTimer::NewL(*this);
+		}
+	
+	return result;
+	}
+
+TVerdict RTestVclnt2Subtitle::DoTestStepPostambleL()
+	{
+	User::LeaveIfError(RevertCacheSize());
+	
+	delete iPlayTimer;
+	iPlayTimer = NULL;
+	return RTestVclnt2AviPlayerStep::DoTestStepPostambleL();
+	}
+
+void RTestVclnt2Subtitle::DoBeforePlaybackActionsL()
+	{
+	if (!iVideoPlayer2->SubtitlesAvailable())
+		{
+		ERR_PRINTF1(_L("SubtitlesAvailable() returned EFalse.  Expected ETrue."));
+		User::Leave(KErrNotSupported);
+		}
+	
+	iVideoPlayer2->EnableSubtitlesL();
+	}
+
+void RTestVclnt2Subtitle::DoDuringPlaybackActionsL()
+	{
+	}
+
+void RTestVclnt2Subtitle::FsmL(TVclntTestPlayEvents aEventCode)
+	{
+	if (FsmCheck(aEventCode))
+		{
+		switch (aEventCode)
+			{
+		case EVPIdle:
+			// Open iVideoPlayer2
+			LOG_CALL(iVideoPlayer2->OpenFileL(iFilename, KMmfTestAviPlayControllerUid));
+			PrepareState(EVPOpenComplete, KErrNone);
+			break;
+
+		case EVPOpenComplete:
+			// Prepare iVideoPlayer2
+			LOG_CALL(iVideoPlayer2->Prepare());
+			PrepareState(EVPPrepareComplete, KErrNone);
+			break;
+
+		case EVPPrepareComplete:
+			// Add display window using default values - ie. video extent & window clipping 
+			// defaulted to whole window.
+			LOG_CALL(iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iWindow));
+			
+			// Perform any actions that the class or subclasses need before starting video playback.
+			DoBeforePlaybackActionsL();
+			
+			// trigger the video to start playing
+			iError = KErrTimedOut;
+			PrepareState(EVPPlayComplete, KErrNone);
+			LOG_CALL(iVideoPlayer2->Play());
+			
+			// Trigger a call to DoDuringPlaybackActionsL
+			iPlayTimer->After(KOneSecond);
+			break;
+
+		case EVPPlayComplete:
+			iTestStepResult = EPass;
+			iPlayTimer->Cancel();
+			CActiveScheduler::Stop();
+			break;
+			}
+		}
+	}
+
+TInt RTestVclnt2Subtitle::SetCacheSize()
+	{
+	TInt error=UserSvr::HalFunction(EHalGroupVM,EVMHalSetCacheSize,(TAny*)KCacheSize,(TAny*)KMaxCacheSize);
+	TInt ret=CheckCacheError(error);
+		
+	return ret;
+	}
+
+TInt RTestVclnt2Subtitle::CheckCacheError(TInt aError)
+	{
+	TInt ret=KErrNone;
+	#ifdef __WINSCW__
+	//Winscw does not support getting cache size. Ignoring -5 error
+	if(aError!=KErrNone)
+		{
+		if(aError!=KErrNotSupported)
+			{
+			INFO_PRINTF2(_L("Could not get the cache size  %d"),aError);
+			ret=aError;
+			}
+		}
+	#else
+	if(aError!=KErrNone)
+		{//For ARMV5 we stop for all errors
+		INFO_PRINTF2(_L("Could not get the cache size  %d"),aError);
+		ret=aError;
+		}
+	#endif
+	return ret;
+	}
+
+TInt RTestVclnt2Subtitle::RevertCacheSize()
+	{
+	TUint defaultCacheSize = 0; 
+	//Done with the test. Setting 0 makes the cache size revert back to boot up values
+	TInt error=UserSvr::HalFunction(EHalGroupVM,EVMHalSetCacheSize,(TAny*)defaultCacheSize,(TAny*)defaultCacheSize);
+	return CheckCacheError(error);
+  	}
+
+
+//
+// RTestVclnt2SubtitleEnableDuringPlayback
+//
+
+RTestVclnt2SubtitleEnableDuringPlayback* RTestVclnt2SubtitleEnableDuringPlayback::NewL(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TInt aExpectedError)
+	{
+	return new (ELeave) RTestVclnt2SubtitleEnableDuringPlayback(aTestName, aSectName, aKeyName, aExpectedError);
+	}
+
+RTestVclnt2SubtitleEnableDuringPlayback::RTestVclnt2SubtitleEnableDuringPlayback(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TInt aExpectedError)
+: RTestVclnt2Subtitle(aTestName, aSectName, aKeyName, aExpectedError)
+	{
+	}
+
+void RTestVclnt2SubtitleEnableDuringPlayback::DoBeforePlaybackActionsL()
+	{
+	INFO_PRINTF1(_L("Don't enable subtitles before playback; do nothing in DoBeforePlaybackActionsL()"));
+	}
+
+void RTestVclnt2SubtitleEnableDuringPlayback::DoDuringPlaybackActionsL()
+	{
+	if (!iVideoPlayer2->SubtitlesAvailable())
+		{
+		ERR_PRINTF1(_L("SubtitlesAvailable() returned EFalse.  Expected ETrue."));
+		User::Leave(KErrNotSupported);
+		}
+	
+	iVideoPlayer2->EnableSubtitlesL();
+	}
+
+//
+// RTestVclnt2SubtitleDisableDuringPlayback
+//
+
+RTestVclnt2SubtitleDisableDuringPlayback* RTestVclnt2SubtitleDisableDuringPlayback::NewL(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TInt aExpectedError)
+	{
+	return new (ELeave) RTestVclnt2SubtitleDisableDuringPlayback(aTestName, aSectName, aKeyName, aExpectedError);
+	}
+
+RTestVclnt2SubtitleDisableDuringPlayback::RTestVclnt2SubtitleDisableDuringPlayback(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TInt aExpectedError)
+: RTestVclnt2Subtitle(aTestName, aSectName, aKeyName, aExpectedError)
+	{
+	}
+
+void RTestVclnt2SubtitleDisableDuringPlayback::DoDuringPlaybackActionsL()
+	{
+	iVideoPlayer2->DisableSubtitles();
+	}
+
+//
+// RTestVclnt2SubtitleDisableTwice
+//
+
+RTestVclnt2SubtitleDisableTwice* RTestVclnt2SubtitleDisableTwice::NewL(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TInt aExpectedError)
+	{
+	return new (ELeave) RTestVclnt2SubtitleDisableTwice(aTestName, aSectName, aKeyName, aExpectedError);
+	}
+
+RTestVclnt2SubtitleDisableTwice::RTestVclnt2SubtitleDisableTwice(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TInt aExpectedError)
+: RTestVclnt2Subtitle(aTestName, aSectName, aKeyName, aExpectedError)
+	{
+	}
+
+void RTestVclnt2SubtitleDisableTwice::DoBeforePlaybackActionsL()
+	{
+	iVideoPlayer2->DisableSubtitles();
+	}
+
+void RTestVclnt2SubtitleDisableTwice::DoDuringPlaybackActionsL()
+	{
+	iVideoPlayer2->DisableSubtitles();
+	}
+
+//
+// RTestVclnt2SubtitleWindowClipBefore
+//
+
+RTestVclnt2SubtitleWindowClipBefore* RTestVclnt2SubtitleWindowClipBefore::NewL(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TInt aExpectedError)
+	{
+	return new (ELeave) RTestVclnt2SubtitleWindowClipBefore(aTestName, aSectName, aKeyName, aExpectedError);
+	}
+
+RTestVclnt2SubtitleWindowClipBefore::RTestVclnt2SubtitleWindowClipBefore(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TInt aExpectedError)
+: RTestVclnt2Subtitle(aTestName, aSectName, aKeyName, aExpectedError)
+	{
+	}
+
+void RTestVclnt2SubtitleWindowClipBefore::DoBeforePlaybackActionsL()
+	{
+	RTestVclnt2Subtitle::DoBeforePlaybackActionsL();
+		
+	TSize windowSize(iWindow->Size().iWidth / 2, iWindow->Size().iHeight / 2);
+    
+    // shrink the window clipping rect by half the height & width            
+    iVideoPlayer2->SetWindowClipRectL(*iWindow, TRect(windowSize));
+	}
+
+//
+// RTestVclnt2SubtitleWindowClipDuring
+//
+
+RTestVclnt2SubtitleWindowClipDuring* RTestVclnt2SubtitleWindowClipDuring::NewL(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TInt aExpectedError)
+	{
+	return new (ELeave) RTestVclnt2SubtitleWindowClipDuring(aTestName, aSectName, aKeyName, aExpectedError);
+	}
+
+RTestVclnt2SubtitleWindowClipDuring::RTestVclnt2SubtitleWindowClipDuring(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TInt aExpectedError)
+: RTestVclnt2Subtitle(aTestName, aSectName, aKeyName, aExpectedError)
+	{
+	}
+
+void RTestVclnt2SubtitleWindowClipDuring::DoDuringPlaybackActionsL()
+	{
+	TSize windowSize(iWindow->Size().iWidth / 2, iWindow->Size().iHeight / 2);
+    
+    // shrink the window clipping rect by half the height & width            
+    iVideoPlayer2->SetWindowClipRectL(*iWindow, TRect(windowSize));
+	}
+
+//
+// RTestVclnt2SubtitleRotateBefore
+//
+
+RTestVclnt2SubtitleRotateBefore* RTestVclnt2SubtitleRotateBefore::NewL(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TInt aExpectedError)
+	{
+	return new (ELeave) RTestVclnt2SubtitleRotateBefore(aTestName, aSectName, aKeyName, aExpectedError);
+	}
+
+RTestVclnt2SubtitleRotateBefore::RTestVclnt2SubtitleRotateBefore(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TInt aExpectedError)
+: RTestVclnt2Subtitle(aTestName, aSectName, aKeyName, aExpectedError)
+	{
+	}
+
+void RTestVclnt2SubtitleRotateBefore::DoBeforePlaybackActionsL()
+	{
+	RTestVclnt2Subtitle::DoBeforePlaybackActionsL();
+    iVideoPlayer2->SetRotationL(*iWindow, EVideoRotationClockwise180);
+	}
+
+//
+// RTestVclnt2SubtitleRotateDuring
+//
+
+RTestVclnt2SubtitleRotateDuring* RTestVclnt2SubtitleRotateDuring::NewL(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TInt aExpectedError)
+	{
+	return new (ELeave) RTestVclnt2SubtitleRotateDuring(aTestName, aSectName, aKeyName, aExpectedError);
+	}
+
+RTestVclnt2SubtitleRotateDuring::RTestVclnt2SubtitleRotateDuring(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TInt aExpectedError)
+: RTestVclnt2Subtitle(aTestName, aSectName, aKeyName, aExpectedError)
+	{
+	}
+
+void RTestVclnt2SubtitleRotateDuring::DoDuringPlaybackActionsL()
+	{
+    iVideoPlayer2->SetRotationL(*iWindow, EVideoRotationClockwise180);
+	}
+
+//
+// RTestVclnt2SubtitleRemoveDisplayDuring
+//
+
+RTestVclnt2SubtitleRemoveDisplayDuring* RTestVclnt2SubtitleRemoveDisplayDuring::NewL(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TInt aExpectedError)
+	{
+	return new (ELeave) RTestVclnt2SubtitleRemoveDisplayDuring(aTestName, aSectName, aKeyName, aExpectedError);
+	}
+
+RTestVclnt2SubtitleRemoveDisplayDuring::RTestVclnt2SubtitleRemoveDisplayDuring(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TInt aExpectedError)
+: RTestVclnt2Subtitle(aTestName, aSectName, aKeyName, aExpectedError)
+	{
+	}
+
+void RTestVclnt2SubtitleRemoveDisplayDuring::DoDuringPlaybackActionsL()
+	{
+    iVideoPlayer2->RemoveDisplayWindow(*iWindow);
+    iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iWindow);
+	}
+
+//
+// RTestVclnt2SubtitleNotAvailable
+//
+
+RTestVclnt2SubtitleNotAvailable* RTestVclnt2SubtitleNotAvailable::NewL(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TInt aExpectedError)
+	{
+	return new (ELeave) RTestVclnt2SubtitleNotAvailable(aTestName, aSectName, aKeyName, aExpectedError);
+	}
+
+RTestVclnt2SubtitleNotAvailable::RTestVclnt2SubtitleNotAvailable(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TInt aExpectedError)
+: RTestVclnt2Subtitle(aTestName, aSectName, aKeyName, aExpectedError)
+	{
+	}
+
+void RTestVclnt2SubtitleNotAvailable::DoBeforePlaybackActionsL()
+	{
+	if (iVideoPlayer2->SubtitlesAvailable())
+		{
+		ERR_PRINTF1(_L("SubtitlesAvailable() returned ETrue.  Expected EFalse."));
+		User::Leave(KErrGeneral);
+		}
+	
+	TRAPD(err, iVideoPlayer2->EnableSubtitlesL());
+	
+	if (KErrNotFound != err)
+		{
+		ERR_PRINTF3(_L("EnableSubtitlesL() left with %d. Expected %d."), err, KErrNotFound);
+		User::Leave(KErrGeneral);
+		}
+	}
+
+//
+// RTestVclnt2SubtitleLanguage
+//
+
+RTestVclnt2SubtitleLanguage* RTestVclnt2SubtitleLanguage::NewL(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TInt aExpectedError)
+	{
+	return new (ELeave) RTestVclnt2SubtitleLanguage(aTestName, aSectName, aKeyName, aExpectedError);
+	}
+
+RTestVclnt2SubtitleLanguage::RTestVclnt2SubtitleLanguage(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TInt aExpectedError)
+: RTestVclnt2Subtitle(aTestName, aSectName, aKeyName, aExpectedError)
+	{
+	}
+
+void RTestVclnt2SubtitleLanguage::DoBeforePlaybackActionsL()
+	{
+	RTestVclnt2Subtitle::DoBeforePlaybackActionsL();
+	
+	TLanguage lang = ELangNone;
+	TRAPD(err, lang = iVideoPlayer2->SubtitleLanguageL());
+	if (KErrNone != err)
+		{
+		ERR_PRINTF3(_L("SubtitleLanguageL() left with %d. Expected %d."), err, KErrNone);
+		User::Leave(err);
+		}
+	else if (ELangNone != lang)
+		{
+		// Languages are not supported; ELangNone should be returned.
+		ERR_PRINTF3(_L("SubtitleLanguageL() returned %d.  Expected %d."), lang, ELangNone);
+		User::Leave(KErrGeneral);
+		}
+	
+	TInt count = -1;
+	TRAP(err, count = iVideoPlayer2->SupportedSubtitleLanguagesL().Count());
+	if (KErrNone != err)
+		{
+		ERR_PRINTF3(_L("SupportedSubtitleLanguagesL() left with %d. Expected %d."), err, KErrNone);
+		User::Leave(KErrGeneral);
+		}
+	if (count != 0)
+		{
+		ERR_PRINTF1(_L("SupportedSubtitleLanguagesL() returned a non-empty array"));
+		User::Leave(KErrGeneral);
+		}
+	
+	TRAP(err, iVideoPlayer2->SetSubtitleLanguageL(lang));
+	
+	if (KErrNotSupported != err)
+		{
+		ERR_PRINTF3(_L("SetSubtitleLanguageL() left with %d. Expected %d."), err, KErrNone);
+		User::Leave(KErrGeneral);
+		}
+	}
+
+//
+// RTestVclnt2SubtitleRedraw
+//
+
+RTestVclnt2SubtitleRedraw* RTestVclnt2SubtitleRedraw::NewL(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TInt aExpectedError, TBool aEnableSubtitles)
+	{
+	return new (ELeave) RTestVclnt2SubtitleRedraw(aTestName, aSectName, aKeyName, aExpectedError, aEnableSubtitles);
+	}
+
+RTestVclnt2SubtitleRedraw::RTestVclnt2SubtitleRedraw(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TInt aExpectedError, TBool aEnableSubtitles)
+: RTestVclnt2Subtitle(aTestName, aSectName, aKeyName, aExpectedError), iEnableSubtitles(aEnableSubtitles)
+	{
+	}
+
+void RTestVclnt2SubtitleRedraw::DoBeforePlaybackActionsL()
+	{
+	if (iEnableSubtitles)
+		{
+		// The parent class will enable subtitle support
+		RTestVclnt2Subtitle::DoBeforePlaybackActionsL();
+		}
+	}
+
+void RTestVclnt2SubtitleRedraw::DoDuringPlaybackActionsL()
+	{
+	// Redraw the whole subtitle
+	iWindow->Invalidate();
+	LOG_CALL(iVideoPlayer2->RedrawSubtitle(*iWindow, TRect(iWindow->Size())));
+	}
+
+//
+// RTestVclnt2SubtitleRotateClipRedraw
+//
+
+RTestVclnt2SubtitleRotateClipRedraw* RTestVclnt2SubtitleRotateClipRedraw::NewL(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TInt aExpectedError)
+	{
+	return new (ELeave) RTestVclnt2SubtitleRotateClipRedraw(aTestName, aSectName, aKeyName, aExpectedError);
+	}
+
+RTestVclnt2SubtitleRotateClipRedraw::RTestVclnt2SubtitleRotateClipRedraw(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TInt aExpectedError)
+: RTestVclnt2Subtitle(aTestName, aSectName, aKeyName, aExpectedError)
+	{
+	}
+
+void RTestVclnt2SubtitleRotateClipRedraw::DoBeforePlaybackActionsL()
+	{
+	RTestVclnt2Subtitle::DoBeforePlaybackActionsL();
+	
+	iVideoPlayer2->SetRotationL(*iWindow, EVideoRotationClockwise90);
+    
+	// shrink the window clipping rect by half the height & width
+	TSize windowSize(iWindow->Size().iWidth / 3, iWindow->Size().iHeight / 2);
+	iVideoPlayer2->SetWindowClipRectL(*iWindow, TRect(windowSize));
+	}
+
+void RTestVclnt2SubtitleRotateClipRedraw::DoDuringPlaybackActionsL()
+	{
+	// Redraw the whole subtitle
+	iWindow->Invalidate();
+	iVideoPlayer2->RedrawSubtitle(*iWindow, TRect(iWindow->Size()));
+	}
+
+//
+// RTestVclnt2SubtitleMultipleWindows
+//
+
+RTestVclnt2SubtitleMultipleWindows* RTestVclnt2SubtitleMultipleWindows::NewL(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TInt aExpectedError)
+	{
+	return new (ELeave) RTestVclnt2SubtitleMultipleWindows(aTestName, aSectName, aKeyName, aExpectedError);
+	}
+
+RTestVclnt2SubtitleMultipleWindows::RTestVclnt2SubtitleMultipleWindows(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TInt aExpectedError)
+: RTestVclnt2Subtitle(aTestName, aSectName, aKeyName, aExpectedError)
+	{
+	}
+
+TVerdict RTestVclnt2SubtitleMultipleWindows::DoTestStepPreambleL()
+	{
+	TVerdict result = RTestVclnt2Subtitle::DoTestStepPreambleL();
+	
+	if (result != EPass)
+		{
+		return result;
+		}
+	
+	iSecondaryWin = new(ELeave) RWindow(iWs);
+	   
+	// Construct an RWindow with a unique id.  Use this pointer to get a unique number.
+	User::LeaveIfError(iSecondaryWin->Construct(iRootWindow, ((TInt) this) + 3));
+	iSecondaryWin->SetRequiredDisplayMode(EColor16MA);
+	iSecondaryWin->SetExtent(TPoint(0,0), TSize(100,100));
+	iSecondaryWin->SetVisible(ETrue);
+	iSecondaryWin->SetBackgroundColor(TRgb(0, 0));
+	iSecondaryWin->Activate();
+	iSecondaryWin->BeginRedraw();
+	iSecondaryWin->EndRedraw();
+    iWs.Flush();
+    
+    return EPass;
+	}
+
+TVerdict RTestVclnt2SubtitleMultipleWindows::DoTestStepPostambleL()
+	{
+	
+	delete iVideoPlayer2;  
+    iVideoPlayer2 = NULL;      
+    
+    iSecondaryWin->Close();
+	delete iSecondaryWin;
+    iSecondaryWin = NULL;
+        
+    // Base DoTestStepPostambleL
+    return RTestVclnt2Subtitle::DoTestStepPostambleL();
+	}
+	
+void RTestVclnt2SubtitleMultipleWindows::DoBeforePlaybackActionsL()
+	{
+	TRAPD(err, iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iSecondaryWin));
+	
+	if (err != KErrNone)
+		{
+		ERR_PRINTF3(_L("Adding second display window with AddDisplayWindowL() left with %d. Expected %d."), err, KErrNone);
+		User::Leave(err);
+		}
+	
+	RTestVclnt2Subtitle::DoBeforePlaybackActionsL();
+	}
+
+//
+// RTestVclnt2SubtitleEnableTwice
+//
+
+RTestVclnt2SubtitleEnableTwice* RTestVclnt2SubtitleEnableTwice::NewL(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TInt aExpectedError)
+	{
+	return new (ELeave) RTestVclnt2SubtitleEnableTwice(aTestName, aSectName, aKeyName, aExpectedError);
+	}
+
+RTestVclnt2SubtitleEnableTwice::RTestVclnt2SubtitleEnableTwice(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TInt aExpectedError)
+: RTestVclnt2Subtitle(aTestName, aSectName, aKeyName, aExpectedError)
+	{
+	}
+
+void RTestVclnt2SubtitleEnableTwice::DoBeforePlaybackActionsL()
+	{	
+	RTestVclnt2Subtitle::DoBeforePlaybackActionsL();
+	
+	// Enable subtitles again
+	TRAPD(err, iVideoPlayer2->EnableSubtitlesL());
+	
+	if (KErrInUse != err)
+		{
+		ERR_PRINTF3(_L("Calling EnableSubtitlesL twice left with %d. Expected %d."), err, KErrInUse);
+		// Leave with KErrGeneral if err is no error.  Otherwise leave with err.
+		User::Leave(KErrNone == err ? KErrGeneral : err);
+		}
+	}
+
+//
+// RTestVclnt2SubtitleEnableDisableStress
+//
+
+RTestVclnt2SubtitleEnableDisableStress* RTestVclnt2SubtitleEnableDisableStress::NewL(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TInt aExpectedError)
+	{
+	return new (ELeave) RTestVclnt2SubtitleEnableDisableStress(aTestName, aSectName, aKeyName, aExpectedError);
+	}
+
+RTestVclnt2SubtitleEnableDisableStress::RTestVclnt2SubtitleEnableDisableStress(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TInt aExpectedError)
+: RTestVclnt2Subtitle(aTestName, aSectName, aKeyName, aExpectedError)
+	{
+	// Expect subtitles to be available if this is not being run with "subtitlesUnavailable" file.
+	iExpectAvailable = (aKeyName != _L("subtitleUnavailable"));
+	}
+
+void RTestVclnt2SubtitleEnableDisableStress::DoBeforePlaybackActionsL()
+	{
+	TBool subtitlesAvail = iVideoPlayer2->SubtitlesAvailable();
+		
+	if (iExpectAvailable != subtitlesAvail)
+		{
+		ERR_PRINTF1(_L("SubtitlesAvailable() gave unexpected result"));
+		User::Leave(KErrGeneral);
+		}
+		
+	if (subtitlesAvail)
+		{		
+		INFO_PRINTF1(_L("Enabling subtitles"));
+		iVideoPlayer2->EnableSubtitlesL();
+		}
+	else
+		{
+		INFO_PRINTF1(_L("Subtitles not available"));
+		}
+	
+	iDisableNext = ETrue;
+	}
+
+void RTestVclnt2SubtitleEnableDisableStress::DoDuringPlaybackActionsL()
+	{
+	TBool subtitlesAvail = iVideoPlayer2->SubtitlesAvailable();
+	
+	if (iExpectAvailable != subtitlesAvail)
+		{
+		ERR_PRINTF1(_L("SubtitlesAvailable() gave unexpected result"));
+		User::Leave(KErrGeneral);
+		}
+	
+	if (iDisableNext)
+		{
+		INFO_PRINTF1(_L("Disabling subtitles"));
+		iVideoPlayer2->DisableSubtitles();
+		}
+	else if (subtitlesAvail)
+		{
+		INFO_PRINTF1(_L("Enabling subtitles"));
+		iVideoPlayer2->EnableSubtitlesL();
+		}
+	else
+		{
+		INFO_PRINTF1(_L("Subtitles not available... cannot enable"));
+		}
+	
+	iDisableNext = !iDisableNext;
+	iPlayTimer->After(KOneSecond / 4);
+	}
+
+//
+// RTestVclnt2SubtitleAlloc
+//
+
+RTestVclnt2SubtitleAlloc* RTestVclnt2SubtitleAlloc::NewL(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TInt aExpectedError)
+	{
+	return new (ELeave) RTestVclnt2SubtitleAlloc(aTestName, aSectName, aKeyName, aExpectedError);
+	}
+
+RTestVclnt2SubtitleAlloc::RTestVclnt2SubtitleAlloc(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TInt aExpectedError)
+: RTestVclnt2Subtitle(aTestName, aSectName, aKeyName, aExpectedError)
+	{
+	}
+
+TVerdict RTestVclnt2SubtitleAlloc::DoTestStepPreambleL()
+	{
+	// Don't do the normal initialization here.  It will be done before each alloc test iteration.
+	return EPass;
+	}
+
+TVerdict RTestVclnt2SubtitleAlloc::DoTestStepPostambleL()
+	{
+	// Don't do the normal cleanup here.  It will be done after each alloc test iteration.
+	return EPass;
+	}
+
+TVerdict  RTestVclnt2SubtitleAlloc::PerformTestL()
+	{	
+	TVerdict result = EFail;
+	TRAPD(err, result = RTestVclnt2Subtitle::DoTestStepPreambleL());
+	if (iError != KErrNone)
+		{
+		err = iError;
+		}
+	
+	if (err == KErrNone && result == EPass && iError == KErrNone)
+		{
+		TRAP(err, result = RTestVclnt2AviPlayerStep::DoTestStepL());
+		
+		if (iError != KErrNone)
+			{
+			err = iError;
+			}
+		}
+	
+	// Call postable function, but don't overwrite verdict from previous test call results.
+	TVerdict postResult = RTestVclnt2Subtitle::DoTestStepPostambleL();
+
+	if (iError != KErrNone)
+		{
+		err = iError;
+		}
+
+	User::LeaveIfError(err);
+	if (EPass != result)
+		{
+		return result;
+		}
+	if (EPass != postResult)
+		{
+		return postResult;
+		}
+	
+	return EPass;
+	}
+
+TVerdict RTestVclnt2SubtitleAlloc::DoTestStepL()
+	{
+	TVerdict allocTestResult = EFail;
+	TVerdict result = EFail;
+	
+	TRAPD(err, result = PerformTestL());
+	
+	if (err != KErrNone || result != EPass)
+		{
+		ERR_PRINTF1(_L("Failed to run test iteration without setting heap allocation failure flag"));
+		return allocTestResult;
+		}
+	
+	TBool completed = EFalse;
+	
+	for (TInt rate = 1; !completed; rate++)
+		{
+		__UHEAP_SETFAIL(RHeap::EFailNext, rate);
+        __MM_HEAP_MARK;
+        
+        result = EFail;
+        TRAPD(err, result = PerformTestL());
+        
+        INFO_PRINTF3(_L("Iteration %d. Alloc failed %d times"), rate, __UHEAP_CHECKFAILURE);
+        
+        if (__UHEAP_CHECKFAILURE == 0)
+        	{
+        	// Heap did not fail.  Test should have passed with no errors.
+        	if (KErrNone != result)
+        		{
+        		ERR_PRINTF2(_L("Failed on iteration %d. Test failed when no heap allocation failed"), rate);
+        		allocTestResult = EFail;
+        		}
+        	else
+        		{
+        		INFO_PRINTF2(_L("Passed on iteration %d."), rate);
+        		allocTestResult = EPass;
+        		}
+        	
+        	completed = ETrue; // Finished iterating the test
+        	}
+        else if ((err == KErrNone && result == EPass) || (err == KErrNoMemory))
+        	{
+        	// Continue with next iteration if (a) alloc fail was handled and no error and a pass or 
+        	// (b) we got an out of memory error.
+        	INFO_PRINTF3(_L("Iteration result is %d, error is %d.  Starting next iteration"), result, err);
+        	}
+        else
+        	{
+        	ERR_PRINTF4(_L("Failed on iteration %d. Test failed with error %d.  Expected %d."), rate, err, KErrNoMemory);
+        	completed = ETrue;
+        	allocTestResult = EFail;
+        	}
+        
+        __MM_HEAP_MARKEND;
+		}
+	
+    __UHEAP_SETFAIL(RHeap::ENone, 0);
+    
+    return allocTestResult;
+	}