// 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 <e32std.h>

#include "tsu_3gplibrary_composer_api.h"

_LIT8(KDummyData, "DummyData");

_LIT8(KFtypAtom, "ftyp");

_LIT8(K3g2Brand, "3g2a");	// 3g2a

_LIT8(K3gpBrand, "3gp");	// 3gp4, 3gp6

_LIT8(KMp4Brand, "mp42");	// mp42 

_LIT(KLargeVideoFile, "c:\\3gplibrary\\cube-xvid-640x480-10fps-10s.3gp");

const TInt KLargeFileWriteBufferSize = 16384;  // 16K

const TInt KLargeFileWriteBufferMaxCount = 15;

const TInt64 K3GigaBytes = 0xC0000000;

// -----------------------------------------------------------------------------

// C3GPLibComposeBase - this should not be used directly

// -----------------------------------------------------------------------------

//     

C3GPLibComposeBase::C3GPLibComposeBase()

	{

	}

TVerdict C3GPLibComposeBase::doTestStepPreambleL()

	{

	// ensure there's always a Active Scheduler for the Composer

	if (!CActiveScheduler::Current())

		{

		iScheduler = new (ELeave) CActiveScheduler;

		CActiveScheduler::Install(iScheduler);	

		}

	SetTestStepResult(EPass);

	return TestStepResult();

	}

TVerdict C3GPLibComposeBase::doTestStepPostambleL()

	{

	if (iScheduler)

		{

		CActiveScheduler::Install(NULL);

		delete iScheduler;

		}

	return TestStepResult();

	}

TVerdict C3GPLibComposeBase::doTestStepL()

	{

	if (TestStepResult() != EPass)

		{

		return TestStepResult();

		}

	SetTestStepError(KErrNone);

	C3GPCompose* composer = doTestStepCreateComposerL(); 

	CleanupStack::PushL(composer);

	doTestStepComposeOpenL(*composer);

	if (TestStepResult() == EPass)

		{

		// set it to EFail, if both calls below does not leave, then it will be reset

		// back to EPass

		SetTestStepResult(EFail);

		doTestStepComposeWriteVideoAudioL(*composer);

		doTestStepComposeSetUserDataL(*composer);

		SetTestStepResult(EPass);

		}

	TInt err = composer->Complete();

	if (err != KErrNone)

		{

		SetTestStepResult(EFail);

		User::Leave(err);

		}

	CleanupStack::PopAndDestroy(composer);	

	return TestStepResult();

	}

C3GPCompose* C3GPLibComposeBase::doTestStepCreateComposerL()

	{

	return C3GPCompose::NewL();

	}

void C3GPLibComposeBase::doTestStepComposeWriteVideoAudioL(C3GPCompose& /* aComposer */)

	{

	}

void C3GPLibComposeBase::doTestStepComposeSetUserDataL(C3GPCompose& /* aComposer */)

	{

	}

// -----------------------------------------------------------------------------

// C3GPLibComposeFilename

// -----------------------------------------------------------------------------

//     

C3GPLibComposeFilename::C3GPLibComposeFilename()

	{

	}

TVerdict C3GPLibComposeFilename::doTestStepPreambleL()

	{

	// ensure all basic setup is completed first

	C3GPLibComposeBase::doTestStepPreambleL();	

	if (TestStepResult() == EPass)

		{

		TPtrC fileNamePtr;

		if (GetStringFromConfig(ConfigSection(), _L("filename"), fileNamePtr))

			{

			// save a copy of the filename specified for the test

			iFilename.CreateL(fileNamePtr);		

			}

		else 

			{

			// cannot find filename!

			ERR_PRINTF1(_L("Filename not specified.  Test cannot proceed."));

			SetTestStepResult(ETestSuiteError);

			}

		}

	return TestStepResult();

	}

TVerdict C3GPLibComposeFilename::doTestStepPostambleL()

	{

	iFilename.Close();

	// clean up all composer test base setups

	C3GPLibComposeBase::doTestStepPostambleL();

	return TestStepResult();

	}

void C3GPLibComposeFilename::doTestStepComposeOpenL(C3GPCompose& aComposer)

	{

	T3GPAudioPropertiesMpeg4Audio audio(100, KDummyData);

	T3GPVideoPropertiesAvc video(100, TSize(100, 100), KDummyData);

	TInt err = aComposer.Open(E3GP3GP, &video, &audio, iFilename);

	if (err != KErrNone)

		{		

		if (!ShouldRunOOMTest())

			{

			ERR_PRINTF2(_L("C3GPCompose::Open failed with error = %d"), err);

			}

		SetTestStepError(err);

		SetTestStepResult(EFail);

		}

	else 

		{

		INFO_PRINTF1(_L("C3GPCompose::Open completes with no error"));

		SetTestStepResult(EPass);

		}

	}

// -----------------------------------------------------------------------------

// C3GPLibComposeWithoutOpen

// -----------------------------------------------------------------------------

//     

C3GPLibComposeWithoutOpen::C3GPLibComposeWithoutOpen()

	{

	}

void C3GPLibComposeWithoutOpen::doTestStepComposeOpenL(C3GPCompose& /* aComposer */)

	{

	// This test needs the composer NOT initialised.  Do nothing here

	}

void C3GPLibComposeWithoutOpen::doTestStepComposeWriteVideoAudioL(C3GPCompose& aComposer)

	{

	if (TestStepResult() != EPass)

		{

		return;

		}

	TInt err = aComposer.WriteVideoFrame(KDummyData, 100, ETrue);

	if (err != KErrNotReady)

		{

		ERR_PRINTF2(_L("C3GPCompose::WriteVideoFrame failed with error = %d instead of KErrNotReady"), err);

		SetTestStepResult(EFail);				

		}

	if (TestStepResult() == EPass)

		{

		T3GPFrameDependencies dependencies;	

		err = aComposer.WriteVideoFrame(KDummyData, 100, ETrue, dependencies);

		if (err != KErrNotReady)

			{

			ERR_PRINTF2(_L("C3GPCompose::WriteVideoFrame failed with error = %d instead of KErrNotReady"), err);

			SetTestStepResult(EFail);				

			}		

		}

	if (TestStepResult() == EPass)

		{

		err = aComposer.WriteAudioFrames(KDummyData, 100);

		if (err != KErrNotReady)

			{

			ERR_PRINTF2(_L("C3GPCompose::WriteAudioFrames failed with error = %d instead of KErrNotReady"), err);			

			SetTestStepResult(EFail);				

			}				

		}	

	}

void C3GPLibComposeWithoutOpen::doTestStepComposeSetUserDataL(C3GPCompose& aComposer)

	{

	if (TestStepResult() != EPass)

		{

		return;

		}

	TInt err = aComposer.SetUserData(E3GPUdtaMoov, KDummyData);

	if (err != KErrNotReady)

		{

		ERR_PRINTF2(_L("C3GPCompose::SetUserData failed with error = %d instead of KErrNotReady"), err);			

		SetTestStepResult(EFail);				

		}				

	if (TestStepResult() == EPass)

		{

		err = aComposer.SetUserData(E3GPUdtaVideoTrak, KDummyData);

		if (err != KErrNotReady)

			{

			ERR_PRINTF2(_L("C3GPCompose::SetUserData failed with error = %d instead of KErrNotReady"), err);			

			SetTestStepResult(EFail);				

			}

		}

	if (TestStepResult() == EPass)

		{

		err = aComposer.SetUserData(E3GPUdtaAudioTrak, KDummyData);

		if (err != KErrNotReady)

			{

			ERR_PRINTF2(_L("C3GPCompose::SetUserData failed with error = %d instead of KErrNotReady"), err);			

			SetTestStepResult(EFail);				

			}

		}

	}

// -----------------------------------------------------------------------------

// C3GPLibComposeFile

// -----------------------------------------------------------------------------

//     

C3GPLibComposeFile::C3GPLibComposeFile() :

	iInputFileFormat(E3GP3GP),

	iVideoType(E3GPNoVideo),

	iAudioType(E3GPNoAudio)

	{

	}

TVerdict C3GPLibComposeFile::doTestStepPreambleL()

	{

	// ensure the base class setup is completed first

	C3GPLibComposeBase::doTestStepPreambleL();

	if (TestStepResult() == EPass)

		{		

		TInt temp;

		if (GetIntFromConfig(ConfigSection(), _L("inputFormat"), temp))

			{

			iInputFileFormat = (T3GPFileFormatType)temp;

			if (GetIntFromConfig(ConfigSection(), _L("video"), temp))

				{

				iVideoType = (T3GPVideoType)temp;

				}

			if (GetIntFromConfig(ConfigSection(), _L("audio"), temp))

				{

				iAudioType = (T3GPAudioType)temp;

				}

			if (iVideoType == E3GPNoVideo && iAudioType == E3GPNoAudio)

				{

				// At least audio or video should be specified

				ERR_PRINTF1(_L("Specify at least video or audio"));

				SetTestStepResult(ETestSuiteError);

				}			

			else

				{

				#ifdef __WINSCW__

				_LIT(KTestFolderName, "testFolderNameEmu");

				#else

				_LIT(KTestFolderName, "testFolderNameHw");

				#endif

				TPtrC testFolderName;

				if (GetStringFromConfig(_L("general"), KTestFolderName, testFolderName))

					{

					TInt err = iFs.Connect();					

					if (err == KErrNone)

						{			

						iFs.MkDirAll(testFolderName);

						TFileName fileName;												

						// Create a temp file for the composer to write data into

						err = iFile.Temp(iFs, testFolderName, fileName, EFileShareExclusive);						

						if (err == KErrNone)

							{

							iFileName.CreateL(fileName);						

							}

						}

					if (err != KErrNone)

						{

						ERR_PRINTF1(_L("Fail to create temp file for testing."));

						SetTestStepResult(ETestSuiteError);

						}			

					}

				else

					{

					ERR_PRINTF1(_L("Fail to provide test directory."));			

					SetTestStepResult(ETestSuiteError);

					}

				}				

			}

		else 

			{

			// file format has to be specified 

			ERR_PRINTF1(_L("Specify file format of the file to be composed"));

			SetTestStepResult(ETestSuiteError);		

			}

		}

	return TestStepResult();

	}

TVerdict C3GPLibComposeFile::doTestStepPostambleL()

	{	

	// clean up of temp file

	iFile.Close();

	iFs.Delete(iFileName);	

	iFs.Close();

	iFileName.Close();

	// clean up all composer test base setups	

	C3GPLibComposeBase::doTestStepPostambleL();

	return TestStepResult();

	}

void C3GPLibComposeFile::doTestStepComposeOpenL(C3GPCompose& aComposer)

	{

	T3GPVideoPropertiesBase* video = SetupVideoPropertiesL();

	CleanupStack::PushL(video);

	T3GPAudioPropertiesBase* audio = SetupAudioPropertiesL(); 

	CleanupStack::PushL(audio);

	TInt err = aComposer.Open(iInputFileFormat, video, audio, iFile);

	if (err == KErrNone)

		{

		SetTestStepResult(EPass);

		}

	else 

		{		

		if (!ShouldRunOOMTest())

			{

			ERR_PRINTF2(_L("C3GPLibComposeFile::doTestStepComposeOpenL => C3GPComposer::Open returns = %d"), err);

			}

		SetTestStepError(err);

		SetTestStepResult(EInconclusive);

		} 

	CleanupStack::PopAndDestroy(2);	// audio, video

	}

void C3GPLibComposeFile::doTestStepComposeWriteVideoAudioL(C3GPCompose& aComposer)

	{

	// add a dummy video frame.  The content is of no importance for this test case, 

	// only the file format is of interest

	TInt err = KErrNone;

	if (iVideoType != E3GPNoVideo)

		{

		err = aComposer.WriteVideoFrame(KDummyData, 10, ETrue);

		if (err != KErrNone)

			{

			ERR_PRINTF2(_L("Fail to write video frame, err = %d"), err);

			}

		}

	if (err == KErrNone && iAudioType != E3GPNoAudio)

		{

		// add a dummy audio frame.  The content is of no importance for this test case, 

		// only the file format is of interest

		err = aComposer.WriteAudioFrames(KDummyData, 10);

		if (err != KErrNone)

			{			

			ERR_PRINTF2(_L("Fail to write audio frame, err = %d"), err);

			} 	

		}

	if (err != KErrNone)

		{			

		SetTestStepResult(EInconclusive); 

		} 		

	}

T3GPVideoPropertiesBase* C3GPLibComposeFile::SetupVideoPropertiesL()

	{

	if (iVideoType == E3GPNoVideo)

		{

		return NULL;

		}

	// create a dummy video property for setting the composer

	T3GPVideoPropertiesBase* video = NULL;

	switch(iVideoType)

		{

		case E3GPMpeg4Video:

			video = SetupMpeg4VideoL();		

			break;

		case E3GPAvcProfileBaseline:

		case E3GPAvcProfileMain:

		case E3GPAvcProfileExtended:

		case E3GPAvcProfileHigh:

			video = SetupAvcVideoL();

			break;

		case E3GPH263Profile0:

		case E3GPH263Profile3:

			video = SetupH263VideoL();

			break;

		default:

			User::Leave(KErrUnknown);

		}

	return video;

	}

T3GPVideoPropertiesBase* C3GPLibComposeFile::SetupAvcVideoL()

	{

	T3GPVideoPropertiesBase* video = new (ELeave) T3GPVideoPropertiesAvc(1000, TSize(100, 100), KDummyData);

	return video;

	}

T3GPVideoPropertiesBase* C3GPLibComposeFile::SetupH263VideoL()

	{

	T3GPVideoPropertiesH263::TProfile profile = T3GPVideoPropertiesH263::EProfile0;

	if (iVideoType == E3GPH263Profile3)

		{

		profile = T3GPVideoPropertiesH263::EProfile3;

		}

	T3GPVideoPropertiesBase* video = new (ELeave) T3GPVideoPropertiesH263(1000, TSize(100, 100), 10, profile);	

	return video;

	}

T3GPVideoPropertiesBase* C3GPLibComposeFile::SetupMpeg4VideoL()

	{

	T3GPVideoPropertiesBase* video = new (ELeave) T3GPVideoPropertiesMpeg4Video(1000, TSize(100, 100), 4000, 400, KDummyData);

	return video;

	}

T3GPAudioPropertiesBase* C3GPLibComposeFile::SetupAudioPropertiesL()

	{

	if (iAudioType == E3GPNoAudio)

		{

		return NULL;

		}

	// create a dummy audio property for setting the composer

	T3GPAudioPropertiesBase* audio = NULL;

	switch(iAudioType)

		{

		case E3GPMpeg4Video:

			audio = SetupMpeg4AudioL();

			break;

		case E3GPQcelp13K:

			audio = SetupQcelpAudioL();

			break;

		case E3GPAmrNB:			

		case E3GPAmrWB:

			audio = SetupAmrAudioL();

			break;

		default:

			User::Leave(KErrUnknown);

			break;

		}

	return audio;

	}

T3GPAudioPropertiesBase* C3GPLibComposeFile::SetupQcelpAudioL()

	{

	// for this test's purpose, just use the default QCELP sample entry storage mode 

	T3GPAudioPropertiesBase* audio = new (ELeave) T3GPAudioPropertiesQcelp(1000, 10);

	return audio;

	}

T3GPAudioPropertiesBase* C3GPLibComposeFile::SetupAmrAudioL()

	{

	T3GPAudioPropertiesAmr::TSpeechCodec codec = T3GPAudioPropertiesAmr::EAmrWB;

	if (iAudioType == E3GPAmrNB)

		{

		codec = T3GPAudioPropertiesAmr::EAmrNB;

		}

	T3GPAudioPropertiesBase* audio = new (ELeave) T3GPAudioPropertiesAmr(1000, 10, 150, codec);

	return audio;

	}

T3GPAudioPropertiesBase* C3GPLibComposeFile::SetupMpeg4AudioL()

	{

	T3GPAudioPropertiesBase* audio = new (ELeave)T3GPAudioPropertiesMpeg4Audio(1000, KDummyData);

	return audio;

	}

// -----------------------------------------------------------------------------

// C3GPLibComposeFileWithFileFormatCheck

// -----------------------------------------------------------------------------

//     

C3GPLibComposeFileWithFileFormatCheck::C3GPLibComposeFileWithFileFormatCheck() :

	iOutputFileFormat(E3GP3GP)

	{

	}

TVerdict C3GPLibComposeFileWithFileFormatCheck::doTestStepPreambleL()

	{

	// ensure base class setup is completed first

	C3GPLibComposeFile::doTestStepPreambleL();

	if (TestStepResult() == EPass)

		{

		TInt temp;

		if (!GetIntFromConfig(ConfigSection(), _L("outputFormat"), temp))

			{

			ERR_PRINTF1(_L("outputFormat not specified"));

			SetTestStepResult(ETestSuiteError);

			}

		else 

			{	

			iOutputFileFormat = (T3GPFileFormatType)temp;		

			}

		}

	return TestStepResult();

	}

TVerdict C3GPLibComposeFileWithFileFormatCheck::doTestStepL()

	{

	if (TestStepResult() != EPass)

		{

		return TestStepResult();

		}

	// this triggers: 

	// 1. Create a composer

	// 2. Open the composer - C3GPLibComposeFileFormatCheck::doTestStepComposeOpenL

	// 3. Write Video & Audio Data - C3GPLibComposeFileFormatCheck::doTestStepComposeWriteVideoAudioL

	// 4. Write User Data - C3GPLibComposeFileFormatCheck::doTestStepComposeSetUserDataL

	// 5. Complete the composer 

	TVerdict verdict = C3GPLibComposeFile::doTestStepL();

	if (verdict == EPass)

		{

		// once the file is composed, it can be verified if the file composed is the same as the 

		// expected file format 

		verdict = VerifyFileFormatL(iFile);

		}

	else

		{

		INFO_PRINTF1(_L("<C3GPLibComposeFileWithFileFormatCheck> C3GPLibComposeFile::doTestStepL returns failed result"));		

		}

	SetTestStepResult(verdict);

	if (!ShouldRunOOMTest())

		{

		INFO_PRINTF2(_L("C3GPLibComposeFile::doTestStepL returns %d"), TestStepResult());	

		}

	return TestStepResult();		

	}

TVerdict C3GPLibComposeFileWithFileFormatCheck::VerifyFileFormatL(const RFile& aFile) 

	{

	// Seek to the beginning of the file

	TInt pos = 0;	

	User::LeaveIfError(aFile.Seek(ESeekStart, pos));

	TVerdict verdict = EFail;

	TBuf8<4> atom;

	while(ETrue)

		{

		// read the file content and search for the 'ftyp' atom to check

		// the 32bit value of brand attribute immediately following the 'ftyp' type.

		User::LeaveIfError(aFile.Read(atom));

		if (atom.Length() < atom.MaxLength())

			{

			break;

			}

		// read 4 bytes at a time, if 'ftyp' is found

		if (Mem::Compare((&KFtypAtom)->Ptr(), (&KFtypAtom)->Length(), atom.Ptr(), atom.Length()) == 0)

			{

			// read 4 more bytes, and it should contain the brand value

			User::LeaveIfError(aFile.Read(atom));

			if (atom.Length() < atom.MaxLength())

				{

				// cannot read brand value, test failed.

				ERR_PRINTF1(_L("Failed to read enough data for comparison."));						

				break;

				}

			switch(iOutputFileFormat)

				{

				case E3GP3G2:

					{

					// check if file type is 3G2

					if (!ShouldRunOOMTest())

						{

						INFO_PRINTF1(_L("Check 3GP2 file format."));

						}

					if (Mem::Compare((&K3g2Brand)->Ptr(), (&K3g2Brand)->Length(), atom.Ptr(), atom.Length()) == 0)

						{

						verdict = EPass;

						break;

						}

					}

				break;

				case E3GPMP4:

					{

					if (!ShouldRunOOMTest())

						{

						INFO_PRINTF1(_L("Check MP4 file format."));

						}

					// check if file type is MP4

					if (Mem::Compare((&KMp4Brand)->Ptr(), (&KMp4Brand)->Length(), atom.Ptr(), atom.Length()) == 0)

						{

						verdict = EPass;

						}

					}

				break;

				case E3GP3GP:

					{

					if (!ShouldRunOOMTest())

						{

						INFO_PRINTF1(_L("Check 3GP file format."));

						}

					// check if file type is 3GP

					// Both 3gp4 & 3gp6 are valid brands, thus checking ONLY "3gp" instead of the full atom size 

					if (Mem::Compare((&K3gpBrand)->Ptr(), (&K3gpBrand)->Length(), atom.Ptr(), (&K3gpBrand)->Length()) == 0)						

						{

						verdict = EPass;

						}					

					}

				break;		

				default:

					INFO_PRINTF1(_L("Unknown format expected."));																					

					verdict = EInconclusive;	

				break;	

				}

			// ftyp is found, regardless of the result, finish reading the file

			break;

			}

		}

	return verdict;

	}

// -----------------------------------------------------------------------------

// C3GPLibComposeFrameDependency

// -----------------------------------------------------------------------------

//     

C3GPLibComposeFrameDependency::C3GPLibComposeFrameDependency()

	{

	}

void C3GPLibComposeFrameDependency::doTestStepComposeWriteVideoAudioL(C3GPCompose& aComposer)

	{

	TInt err = KErrNone;

	T3GPFrameDependencies dep;

	for (TInt i = 0; i <= (TInt)E3GPDependencyNone; i++)

		{

		for (TInt j = 0; j <= (TInt)E3GPDependencyNone; j++)

			{

			for (TInt k = 0; k <= (TInt)E3GPRedundancyNone; k++)

				{

				dep.iDependsOn = (T3GPVideoFrameDependency)i;

				dep.iIsDependedOn = (T3GPVideoFrameDependency)j;

				dep.iHasRedundancy = (T3GPVideoFrameRedundancy)k;

				// add a dummy video frame.  The content is of no importance for this test case, 

				// only the different dependency/redundancy is the focus of this test

				err = aComposer.WriteVideoFrame(KDummyData, 100, ETrue, dep);

				if (err != KErrNone)

					{

					ERR_PRINTF2(_L("C3GPCompose::WriteVideoFrame (with frame dependency) failed with error = %d"), err);

					SetTestStepResult(EFail);

					break;

					}

				}

			}

		}

	}

// -----------------------------------------------------------------------------

// C3GPLibComposeVideoProperties

// -----------------------------------------------------------------------------

//     

C3GPLibComposeVideoProperties::C3GPLibComposeVideoProperties()

	{	

	}

TVerdict C3GPLibComposeVideoProperties::doTestStepPreambleL()

	{

	C3GPLibComposeFile::doTestStepPreambleL();

	if (TestStepResult() != EPass)

		{

		return TestStepResult();

		}

	TInt temp;

	TBool result = ETrue;

	result = GetIntFromConfig(ConfigSection(), _L("width"), temp);

	if (result)

		{

		iSize.iWidth = temp;

		result = GetIntFromConfig(ConfigSection(), _L("height"), temp); 

		if (result)

			{

			iSize.iHeight = temp;

			result = GetIntFromConfig(ConfigSection(), _L("timescale"), temp);

			if (result)

				{

				iTimescale = temp;

				}			

			}

		}

	if (result && 

	        (iVideoType == E3GPMpeg4Video ||

	         iVideoType == E3GPAvcProfileBaseline ||

	         iVideoType == E3GPAvcProfileMain ||

	         iVideoType == E3GPAvcProfileExtended ||

	         iVideoType == E3GPAvcProfileHigh )

        )

		{

		TPtrC decoder;

		result = GetStringFromConfig(ConfigSection(), _L("decoderSpecInfo"), decoder);

		if (result)

			{	

			iDecoderSpecInfo.CreateL(decoder.Length());

			iDecoderSpecInfo.Copy(decoder);

			}

		}

	if (result && (iVideoType == E3GPMpeg4Video))

		{

		result = GetIntFromConfig(ConfigSection(), _L("avgBR"), temp);

		if (result)

			{

			iAvgBitRate = temp;

			result = GetIntFromConfig(ConfigSection(), _L("maxBR"), temp);

			if (result)

				{

				iMaxBitRate = temp;

				}			

			}

		}	

	if (result && (iVideoType == E3GPH263Profile0 || iVideoType == E3GPH263Profile3))

		{

		result = GetIntFromConfig(ConfigSection(), _L("level"), temp);

		if (result)

			{

			iVideoLevel = temp;

			}

		}

	if (!result)

		{

		ERR_PRINTF1(_L("Cannot retrieve necessary video properties to complete this test."));

		SetTestStepResult(ETestSuiteError);		

		}

	return TestStepResult();

	}

TVerdict C3GPLibComposeVideoProperties::doTestStepPostambleL()

	{	

	iDecoderSpecInfo.Close();

	// clean up base class setups	

	C3GPLibComposeFile::doTestStepPostambleL();

	return TestStepResult();

	}

T3GPVideoPropertiesBase* C3GPLibComposeVideoProperties::SetupAvcVideoL()

	{

	T3GPVideoPropertiesBase* video = new (ELeave) T3GPVideoPropertiesAvc(iTimescale, iSize, iDecoderSpecInfo);

	return video;

	}

T3GPVideoPropertiesBase* C3GPLibComposeVideoProperties::SetupH263VideoL()

	{

	T3GPVideoPropertiesH263::TProfile profile = T3GPVideoPropertiesH263::EProfile0;

	if (iVideoType == E3GPH263Profile3)

		{

		profile = T3GPVideoPropertiesH263::EProfile3;

		}

	T3GPVideoPropertiesBase* video = new (ELeave) T3GPVideoPropertiesH263(iTimescale, iSize, iVideoLevel, profile);	

	return video;

	}

T3GPVideoPropertiesBase* C3GPLibComposeVideoProperties::SetupMpeg4VideoL()

	{

	T3GPVideoPropertiesBase* video = new (ELeave) T3GPVideoPropertiesMpeg4Video(iTimescale, 

																				iSize, 

																				iMaxBitRate, 

																				iAvgBitRate, 

																				iDecoderSpecInfo);

	return video;

	}

// -----------------------------------------------------------------------------

// C3GPLibComposeWithSpecificBufferSize

// -----------------------------------------------------------------------------

//     

C3GPLibComposeWithSpecificBufferSize::C3GPLibComposeWithSpecificBufferSize()

	{	

	}

TVerdict C3GPLibComposeWithSpecificBufferSize::doTestStepPreambleL()

	{

	TVerdict verdict = C3GPLibComposeFile::doTestStepPreambleL();

	if (verdict != EPass)

		{

		return verdict;

		}

	TInt temp;

	if (GetIntFromConfig(ConfigSection(), _L("bufferSize"), temp))

		{

		iBufferSize = temp;		

		if (GetIntFromConfig(ConfigSection(), _L("bufferCount"), temp)) 

			{

			iBufferMaxCount = temp;

			}

		else

			{

			ERR_PRINTF1(_L("C3GPLibComposeWithSpecificBufferSize cannot read Buffer Max Count"));		

			SetTestStepResult(ETestSuiteError);			

			}

		}

	else

		{

		ERR_PRINTF1(_L("C3GPLibComposeWithSpecificBufferSize cannot read Buffer Size"));		

		SetTestStepResult(ETestSuiteError);

		}

	return TestStepResult(); 

	}

C3GPCompose* C3GPLibComposeWithSpecificBufferSize::doTestStepCreateComposerL()

	{

	return C3GPCompose::NewL(iBufferSize, iBufferMaxCount);

	}

// -----------------------------------------------------------------------------

// C3GPLibComposeUserData

// -----------------------------------------------------------------------------

//     

C3GPLibComposeUserData::C3GPLibComposeUserData() :

	iUdtaLocation(-1)

	{

	}

TVerdict C3GPLibComposeUserData::doTestStepPreambleL()	

	{

	// ensure all basic setup is completed first

	C3GPLibComposeFile::doTestStepPreambleL();	

	if (TestStepResult() == EPass)

		{

		GetBoolFromConfig(ConfigSection(), _L("udtaMoov"), iUdtaMoov);

		GetBoolFromConfig(ConfigSection(), _L("udtaVideo"), iUdtaVideo);

		GetBoolFromConfig(ConfigSection(), _L("udtaAudio"), iUdtaAudio);

		GetIntFromConfig(ConfigSection(), _L("udtaLocation"), iUdtaLocation);

		if (!iUdtaMoov && !iUdtaVideo && !iUdtaAudio && iUdtaLocation == -1)

			{

			ERR_PRINTF1(_L("No user data location is specified.  Test cannot proceed."));

			SetTestStepResult(ETestSuiteError);												

			}

		else

			{

			TPtrC userDataPtr;

			if (GetStringFromConfig(ConfigSection(), _L("userData"), userDataPtr))

				{					

				iUserData.CreateL(userDataPtr.Length());

				iUserData.Copy(userDataPtr);

				}

			else

				{

				// user data not specified, use dummy data

				iUserData.CreateL(KDummyData);

				}

			}

		}

	return TestStepResult();

	}

TVerdict C3GPLibComposeUserData::doTestStepPostambleL()

	{	

	iUserData.Close();

	// clean up base class setups	

	C3GPLibComposeFile::doTestStepPostambleL();

	return TestStepResult();

	}

void C3GPLibComposeUserData::doTestStepComposeSetUserDataL(C3GPCompose& aComposer)

	{

	TInt err = KErrNone;

	if (iUdtaVideo)

		{

		err = aComposer.SetUserData(E3GPUdtaVideoTrak, iUserData);

		if (err != KErrNone)

			{

			ERR_PRINTF2(_L("C3GPComposer::SetUserData(E3GPUdtaVideoTrak) fails with %d"), err);

			SetTestStepError(err);

			}

		}

	if (iUdtaAudio)

		{

		err = aComposer.SetUserData(E3GPUdtaAudioTrak, iUserData);

		if (err != KErrNone)

			{

			ERR_PRINTF2(_L("C3GPComposer::SetUserData(E3GPUdtaAudioTrak) fails with %d"), err);

			SetTestStepError(err);

			}

		}

	if (iUdtaMoov)

		{

		err = aComposer.SetUserData(E3GPUdtaMoov, iUserData);

		if (err != KErrNone)

			{

			ERR_PRINTF2(_L("C3GPComposer::SetUserData(E3GPUdtaMoov) fails with %d"), err);

			SetTestStepError(err);

			}

		}

	if (iUdtaLocation != -1)

		{

		// if a specific user data location has been specified, try it!

		err = aComposer.SetUserData((T3GPUdtaLocation)iUdtaLocation, iUserData);

		if (err != KErrNone)

			{

			ERR_PRINTF3(_L("C3GPComposer::SetUserData(%d) fails with %d"), iUdtaLocation, err);

			SetTestStepError(err);

			}		

		}

	}

// -----------------------------------------------------------------------------

// C3GPLibComposeWithFlag

// -----------------------------------------------------------------------------

//     

C3GPLibComposeWithFlag::C3GPLibComposeWithFlag()

	{

	}

TVerdict C3GPLibComposeWithFlag::doTestStepPreambleL()

	{

	// ensure the base class setup is completed first

	C3GPLibComposeFile::doTestStepPreambleL();

	if (TestStepResult() == EPass)

		{