// 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;

	}

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