// 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 "tsu_3gplibrary_parse_compose.h"

const TUint16 KAudioModeSet = 0x81ff;

const TReal KMillisecondsInSecond = 1000;

const TReal KOneHalf = 0.5;

const TInt KLargeFileWriteBufferSize = 16384;  // 16K

const TInt KLargeFileWriteBufferMaxCount = 15;

_LIT( KAvcBaseline, "Baseline" );

_LIT( KAvcMain, "Main" );

_LIT( KAvcExtended, "Extended" );

_LIT( KAvcHigh, "High" );

const static TDesC* KAvcProfileNames[] = {

        &KAvcBaseline,

        &KAvcMain,

        &KAvcExtended,

        &KAvcHigh

    };

C3GPLibParseComposeFile::C3GPLibParseComposeFile() :

	iCompareOriginal(EFalse),

	iLargeFile(EFalse)	

	{

	}

TVerdict C3GPLibParseComposeFile::doTestStepPreambleL()

	{

	#ifdef __WINSCW__

	_LIT(KInputDir, "inputDirEmul");

	_LIT(KOutputDir, "outputDirEmul");

	#else

	_LIT(KInputDir, "inputDirHw");

	_LIT(KOutputDir, "outputDirHw");

	#endif

	// ensure test always starts with clean results

	SetTestStepResult(EPass);

	SetTestStepError(KErrNone);

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

	if (!CActiveScheduler::Current())

		{

		iScheduler = new (ELeave) CActiveScheduler;

		CActiveScheduler::Install(iScheduler);	

		}

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

	// retrieve the input files' directory 

	TPtrC inputFileDir;

	TBool composeFile = EFalse;

	TPtrC outputFileDir;					

	if (GetStringFromConfig(ConfigSection(), KInputDir, inputFileDir))

		{

		if (inputFileDir.Length() == 0)

			{

			ERR_PRINTF1(_L("Ensure input directory is specified."));

			SetTestStepResult(EInconclusive);			

			return TestStepResult();

			}

		else 

			{

			iInputDir.CreateL(inputFileDir);

			}

		GetIntFromConfig(ConfigSection(), _L("expectedFailure"), iExpectedNumberOfFailure);

		if (GetBoolFromConfig(ConfigSection(), _L("composeFile"), composeFile))

			{

			if (composeFile)

				{

				if (GetStringFromConfig(ConfigSection(), KOutputDir, outputFileDir))

					{

					if (outputFileDir.Length() == 0)

						{

						ERR_PRINTF1(_L("Ensure output directory is specified."));

						SetTestStepResult(EInconclusive);			

						return TestStepResult();

						}

					else if (outputFileDir == inputFileDir)

						{

						ERR_PRINTF1(_L("Ensure output directory is not the same as input directory."));

						SetTestStepResult(EInconclusive);			

						return TestStepResult();						

						}

					else if (!GetIntFromConfig(ConfigSection(), _L("fileFormat"), iFileFormat))

						{

						ERR_PRINTF1(_L("Ensure a output file format is specified."));

						SetTestStepResult(EInconclusive);			

						return TestStepResult();												

						}

					GetIntFromConfig(ConfigSection(), _L("composeFlag"), iComposeFlag);

					GetBoolFromConfig(ConfigSection(), _L("compareOriginal"), iCompareOriginal);

					GetBoolFromConfig(ConfigSection(), _L("largeFile"), iLargeFile);					

					}

				else

					{

					ERR_PRINTF1(_L("Ensure output directory is specified."));

					SetTestStepResult(EInconclusive);

					}

				}

			}

		}

	else

		{

		ERR_PRINTF1(_L("Ensure input directory is specified."));

		SetTestStepResult(EInconclusive);

		}

	if (TestStepResult() == EPass)

		{

		// Create a list of all files contained in the input directory

		User::LeaveIfError(iFs.GetDir(inputFileDir, KEntryAttNormal, ESortNone, iDirList));			

		if (!iDirList || iDirList->Count() == 0)

			{

			ERR_PRINTF1(_L("Input directory is empty."));

			SetTestStepResult(EInconclusive);		

			}

		}

	if (TestStepResult() == EPass)

		{

		iParser = C3GPParse::NewL();

		if (composeFile)

			{

			if (iLargeFile)

				{

				iComposer = C3GPCompose::NewL(KLargeFileWriteBufferSize, KLargeFileWriteBufferMaxCount);				

				}

			else

				{

				iComposer = C3GPCompose::NewL();				

				}

			iOutputDir.CreateL(outputFileDir);

			TInt err = iFs.MkDirAll(iOutputDir);

			if (err != KErrNone && err != KErrAlreadyExists)

				{

				User::Leave(err);

				}

			}

		}

	return TestStepResult();

	}		

TVerdict C3GPLibParseComposeFile::doTestStepL()

	{

	if( TestStepResult() == EPass)

		{

		TInt failCount = 0;

		TInt fileCount = 0;

		RBuf filePath;

		CleanupClosePushL(filePath);

		filePath.CreateL(KMaxFileName);

		for (TInt i = 0; i < iDirList->Count(); i++)

			{

			const TEntry& entry = (*iDirList)[i];

			if (!entry.IsDir())

				{

				fileCount++;

				filePath.Copy(iInputDir);

				filePath.Append(entry.iName);

				INFO_PRINTF2(_L("ParseAndComposeL: file=%S"), &filePath);				

				TRAPD(err, ParseFileL(filePath));

				INFO_PRINTF2(_L("ParseAndComposeL returns: err = %d"), err);

				if( err != KErrNone )

					{

					iParser->Complete();

					if (iComposer)

						{

						iComposer->Complete();

						}

					failCount++;

					}

				else

					{

					if (iCompareOriginal && iComposer)

						{

						if (!CompareInputOuputFileL(filePath))

							{

							ERR_PRINTF1(_L("Input & output file is not the same"));

							failCount ++;

							}

						else

							{

							INFO_PRINTF1(_L("Input & output file is the same."));

							}

						}

					}				

				}

			}

		// clean up

		CleanupStack::PopAndDestroy(&filePath);

		INFO_PRINTF3(_L("%d of %d files failed"), failCount, fileCount);

		if (failCount != iExpectedNumberOfFailure)

			{

			ERR_PRINTF2(_L("Expected failure: %d - Test Failed"), iExpectedNumberOfFailure);

			SetTestStepResult(EFail);

			}		

		}

	return TestStepResult();

	}

TVerdict C3GPLibParseComposeFile::doTestStepPostambleL()

	{

	if( iScheduler )

		{

		CActiveScheduler::Install(NULL);

		delete iScheduler;

		}

	iOutputDir.Close();

	iInputDir.Close();

	iComposedFile.Close();

	delete iDirList;

	iParsedFileHandle64.Close();

	iComposedFileHandle64.Close();

	iFs.Close();

	delete iParser;	

	if (iComposer)

		{

		delete iComposer;

		}	

	return TestStepResult();

	}

void C3GPLibParseComposeFile::ParseFileL(const TDesC& aInputFile)

	{

	ASSERT(iParser);

	TInt err = 0;

	if (iLargeFile)

		{

		iParsedFileHandle64.Close();

		err = iParsedFileHandle64.Open(iFs, aInputFile, EFileShareReadersOrWriters);

		if (err == KErrNone)

			{

			err = iParser->Open(iParsedFileHandle64);		

			}

		}

	else

		{

		err = iParser->Open(aInputFile);		

		}

	if (err != KErrNone)

		{

		ERR_PRINTF2(_L("C3GPParse::Open() returns %d"), err);

		User::Leave(err);

		}

	//

	// Retrieve Video Properties

	//	

	T3GPVideoPropertiesBase* videoProperties = NULL;

	CleanupStack::PushL(videoProperties);

	RBuf8 videoDecoderSpecificInfo;

	CleanupClosePushL(videoDecoderSpecificInfo);

	TUint videoLengthInMs = 0;

	err = ParseVideoProperties(*iParser, videoDecoderSpecificInfo, videoProperties, videoLengthInMs);

	if (err != KErrNone && err != KErrNotSupported)

		{

		ERR_PRINTF2(_L("ParseVideoProperties failed: err = %d"), err);

		User::Leave(err);

		}

	//

	// Retrieve Audio Properties

	//

	T3GPAudioPropertiesBase* audioProperties = NULL;

	CleanupStack::PushL(audioProperties);	

	RBuf8 audioDecoderSpecificInfo;

	CleanupClosePushL(audioDecoderSpecificInfo);

	TUint audioLengthInMs = 0;

	err = ParseAudioProperties(*iParser, audioDecoderSpecificInfo, audioProperties, audioLengthInMs);

	if( err != KErrNone && err != KErrNotSupported)

		{

		ERR_PRINTF2(_L("ParseAudioProperties failed: err = %d"), err);		

		User::Leave(err);

		}

	if (!videoProperties && !audioProperties)

		{

		ERR_PRINTF1(_L("File contains neither video nor audio data"));

		User::Leave(KErrNotFound);		

		}

	//

	// Prepare for the Composer if file output is expected 

	//	

	if (iComposer)

		{

		RBuf outputFile;

		CleanupClosePushL(outputFile);

		outputFile.CreateL(KMaxFileName);

		outputFile.Copy(iOutputDir);

		TParsePtrC parsePtr(aInputFile);

		TPtrC name = parsePtr.NameAndExt();

		outputFile.Append(parsePtr.NameAndExt());

		if (iLargeFile)

			{

			iComposedFileHandle64.Close();

			err = iComposedFileHandle64.Create(iFs, outputFile, EFileShareAny|EFileStream|EFileWrite);

			if (err == KErrAlreadyExists)

				{

				err = iComposedFileHandle64.Replace(iFs, outputFile, EFileShareAny|EFileStream|EFileWrite);

				}

			if (err == KErrNone)

				{

				err = iComposer->Open((T3GPFileFormatType)iFileFormat, videoProperties, audioProperties, iComposedFileHandle64, iComposeFlag);

				}

			}

		else

			{			

			err = iComposer->Open((T3GPFileFormatType)iFileFormat, videoProperties, audioProperties, outputFile, iComposeFlag);

			}

		if (err != KErrNone)

			{

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

			User::Leave(err);			

			}

		CleanupStack::PopAndDestroy(&outputFile);

		}

	//

	// Parse and compose (if specified) video / audio frame data 

	//

	ReadWriteAudioVideoFramesL(videoProperties, audioProperties, videoLengthInMs, audioLengthInMs);

	//

	// Clean up

	//

	CleanupStack::PopAndDestroy(4);	 

									// audioDecoderSpecificInfo

									// audioProperties 

									// videoDecoderSpecificInfo 

									// videoProperties

	if (iComposer)

		{

		err = iComposer->Complete();

		if (err != KErrNone)

			{

			ERR_PRINTF1(_L("aComposer->Complete() failed"));

			User::Leave(err);

			}

		if (iLargeFile)

			{

			iComposedFileHandle64.Close();

			}

		}

	err = iParser->Complete();

	if (err != KErrNone)

		{

		ERR_PRINTF1(_L("aParser->Complete() failed"));

		User::Leave(err);

		}

	if (iLargeFile)

		{

		iParsedFileHandle64.Close();

		}

	INFO_PRINTF1(_L("C3GPLibParseComposeFile::ParseAndComposeL OUT"));		

	}

void C3GPLibParseComposeFile::ReadWriteAudioVideoFramesL(const T3GPVideoPropertiesBase* aVideoProperties, 

														 const T3GPAudioPropertiesBase* aAudioProperties,

														 TUint aVideoLengthInMs,

														 TUint aAudioLengthInMs)

	{

	ASSERT(iParser);

	TUint videoLengthInTS = 0;

	TUint audioLengthInTS = 0;

	if (aVideoProperties)

		{

        // The "+KOneHalf" in the following calculation has the effect of rounding

        // to the nearest integer instead of just flooring it when converting from

        // TReal to TUint.

        // This is to avoid videoLengthInTS being off by one and leading to false

        // positives when the video properties are compared later on.

		videoLengthInTS = (TUint) ((TReal)(aVideoLengthInMs * aVideoProperties->iTimescale) / KMillisecondsInSecond + KOneHalf );

		}

	if (aAudioProperties)

		{

		// The "+KOneHalf" in the following calculation has the effect of rounding

		// to the nearest integer instead of just flooring it when converting from

		// TReal to TUint.

		// This is to avoid audioLengthInTS being off by one and leading to false

		// positives when the audio properties are compared later on.

		audioLengthInTS = (TUint) ((TReal)(aAudioLengthInMs * aAudioProperties->iTimescale) / KMillisecondsInSecond + KOneHalf );

		}

	TInt framePerSample1 = 0;

	TInt framePerSample2 = 0;

	TUint audioTS1 = 0;

	TUint audioTS2 = 0;

	RBuf8 audioBuf1;	

	RBuf8 audioBuf2;

	CleanupClosePushL(audioBuf1);

	CleanupClosePushL(audioBuf2);

	TUint videoTS1;

	TUint videoTS2;

	TBool keyFrame1;

	TBool keyFrame2;

	T3GPFrameDependencies dep1;

	T3GPFrameDependencies dep2;

	RBuf8 videoBuf1;

	RBuf8 videoBuf2;

	CleanupClosePushL(videoBuf1);		

	CleanupClosePushL(videoBuf2);	

	TInt err = KErrNone;

	T3GPFrameType frameType;

	RArray<T3GPFrameType> frameTypeArray(10);

	CleanupClosePushL(frameTypeArray);

	TInt videoFrameCount = 0;

	TInt audioFrameCount = 0;

	while (err == KErrNone)

		{

		err = iParser->GetFrameType(frameType);

		if (err == KErrNone)

			{		

			switch(frameType)

				{

				case E3GPAudio:

					audioFrameCount++;

					frameTypeArray.AppendL(frameType);		

					err = ReadAudioFrames(*iParser, audioBuf1, framePerSample1, audioTS1);

					audioBuf1.Close();				

					break;

				case E3GPVideo:

					videoFrameCount++;

					frameTypeArray.AppendL(frameType);

					err = ReadVideoFrame(*iParser, videoBuf1, keyFrame1, videoTS1, dep1);

					videoBuf1.Close();				

					break;

				default:

					ERR_PRINTF1(_L("GetFrameType retrieves an unsupported frame type"));

					User::Leave(KErrUnknown);

					break;

				}

			// if there's anything wrong w/ retrieving the frame, exit the function now

			User::LeaveIfError(err);

			}

		}

	INFO_PRINTF2(_L("ReadWriteAudioVideoFramesL read %d video frames."), videoFrameCount);

	INFO_PRINTF2(_L("ReadWriteAudioVideoFramesL read %d audio frames."), audioFrameCount);

	// reset the video and audio cursor at the beginning of the clip 

	TUint videoPos = 0;

	TUint audioPos = 0;

	iParser->Seek(0, EFalse, videoPos, audioPos);

	videoFrameCount = 0;

	audioFrameCount = 0;

	if (iComposer)

		{	

		// if the data should be supplied into a composer to construct an output file

		TInt index = 0;	

		while (index < frameTypeArray.Count())

			{

			frameType = frameTypeArray[index++]; 

			switch (frameType)

				{

				case E3GPAudio:

					if (audioBuf1.Length() == 0)

						{					

						User::LeaveIfError(ReadAudioFrames(*iParser, audioBuf1, framePerSample1, audioTS1));

						}

					err = ReadAudioFrames(*iParser, audioBuf2, framePerSample2, audioTS2);

					if (audioBuf1.Length() > 0 && audioBuf2.Length() > 0 || 

						audioBuf1.Length() > 0 && err == KErrNotFound)

						{

						TUint duration = 0;