// 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 <mmf/common/mmferrors.h>

#include <caf/caf.h>

#include "tsu3gplibraryapi.h"

using namespace ContentAccess;

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

// C3GPLibParser_base 

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

//

TVerdict C3GPLibParser_base::doTestStepPreambleL()

	{

	SetTestStepResult(EPass);

	SetTestStepError(KErrNone);

	TPtrC testSection = ConfigSection();

	TInt err = iTestSection.Create(testSection.Length());

	if( err != KErrNone )

		{

		ERR_PRINTF2(_L("Cannot create buffer for inputFilename. err = %d"), err);

		SetTestStepResult(EInconclusive);

		return TestStepResult();

		}

	iTestSection += testSection;

	TBuf<20> testFolderName;

	testFolderName.Zero();

	if (ConfigSection().Compare(_L("3GP-H264-MP4-LARGE")) == 0)

		{

 		#ifdef __WINSCW__

 		testFolderName.Append(_L("inputFileEmu"));

 		#else

 		testFolderName.Append(_L("inputFileHw"));

 		#endif		

		}

	else	

		{

 		testFolderName.Append(_L("inputFile"));

		}

	TPtrC inputFile;

	if(!GetStringFromConfig(ConfigSection(), testFolderName, inputFile))

		{

		ERR_PRINTF1(_L("Cannot read inputFile from ini file."));

		SetTestStepResult(ETestSuiteError);

		return TestStepResult();

		}

	err = iInputFile.Create(inputFile.Length() + 1);

	if( err != KErrNone )

		{

		ERR_PRINTF2(_L("Cannot create buffer for inputFilename. err = %d"), err);

		SetTestStepResult(EInconclusive);

		return TestStepResult();

		}

	iInputFile += inputFile;

	iInputFile.ZeroTerminate();

	return TestStepResult();

	}

TVerdict C3GPLibParser_base::doTestStepPostambleL()

	{

	iInputFile.Close();

	iTestSection.Close();

	// Close file

	iSourceFile.Close();

	iSourceFile64.Close();

    //Close the file server session

    iFsSession.Close();

	return TestStepResult();

	}

TInt C3GPLibParser_base::CheckError(TInt aError, TInt aExpectError, const TDesC& aFunction)

	{

	if (aError != aExpectError)

		{

		ERR_PRINTF4(_L("%S expected %d, but returns %d; "), &aFunction, aExpectError, aError);

		if (aError != KErrNone)

			{

			return aError;

			}

		// expected an error, but return KErrNone

		return KErrGeneral;

		}

	return KErrNone;

	}

void C3GPLibParser_base::ParserOpenL(C3GPParse* aParser, TInt aExpectedError)

	{

	ASSERT(aParser);

	TInt err = aParser->Open();

	if (aExpectedError == KErrInUse && err == KErrNone)

		{

		err = aParser->Open();

		}

	if (ShouldRunOOMTest() && err != KErrNone && err != aExpectedError)

		{

		INFO_PRINTF2(_L("Parser open using buffer mode (OOM), returns %d"), err);

		User::Leave(err);

		}

	if (!ShouldRunOOMTest())

		{

		INFO_PRINTF2(_L("Parser open using buffer mode, returns %d"), err);

		}

	User::LeaveIfError(CheckError(err, aExpectedError, _L("aParser->Open() buffer mode")));

	}

void C3GPLibParser_base::ParserOpenFileL(C3GPParse* aParser, TInt aExpectedError)

	{

	ASSERT(aParser);

	TInt err = aParser->Open(iInputFile);

	if (aExpectedError == KErrInUse && err == KErrNone)

		{

		err = aParser->Open(iInputFile);

		}

	if (ShouldRunOOMTest() && err != KErrNone && err != aExpectedError)

		{

		INFO_PRINTF2(_L("Parser open using file path (OOM), returns %d"), err);

		User::Leave(err);

		}

	if (!ShouldRunOOMTest())

		{

		INFO_PRINTF2(_L("Parser open using file path, returns %d"), err);

		}

	User::LeaveIfError(CheckError(err, aExpectedError, _L("aParser->Open() file path")));

	}

void C3GPLibParser_base::ParserCompleteL(C3GPParse* aParser)

	{

	ASSERT(aParser);

	TInt err = aParser->Complete();

	User::LeaveIfError(CheckError(err, KErrNone, _L("aParser->Complete()")));

	}

void C3GPLibParser_base::FileOpenL(TUint aFileMode)	

	{

	iSourceFile.Close();

	//Create a connection to the file server    

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

    //Open the source file passing in the file server session handle, source 

    //file path and file access mode 

    User::LeaveIfError(iSourceFile.Open(iFsSession, iInputFile, aFileMode ));

	}

void C3GPLibParser_base::FileClose()	

	{

	// Close file

	iSourceFile.Close();

    //Close the file server session

    iFsSession.Close();

	}

void C3GPLibParser_base::FileOpen64L(TUint aFileMode)	

	{

	iSourceFile64.Close();

	//Create a connection to the file server    

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

    //Open the source file passing in the file server session handle, source 

    //file path and file access mode 

    User::LeaveIfError(iSourceFile64.Open(iFsSession, iInputFile, aFileMode ));

	}

void C3GPLibParser_base::FileClose64()	

	{

	// Close file

	iSourceFile64.Close();

    //Close the file server session

    iFsSession.Close();

	}

void C3GPLibParser_base::ParserOpenFileHandleL(C3GPParse* aParser, TUint aFileMode, TInt aExpectedError)

	{

	ASSERT(aParser);

	FileOpenL(aFileMode);

    TInt err = aParser->Open(iSourceFile);	

    if (aExpectedError == KErrInUse && err == KErrNone)

		{

		err = aParser->Open(iSourceFile);

		}

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

		{

		FileClose();

		if (ShouldRunOOMTest())

			{

			INFO_PRINTF2(_L("Parser open using file handle (OOM), returns %d"), err);

			User::Leave(err);

			}

		}

	if (!ShouldRunOOMTest())

		{

		INFO_PRINTF2(_L("Parser open using file handle, returns %d"), err);		

		}

	if (err == aExpectedError ) 

		{

		err = KErrNone;

		}

	User::LeaveIfError(err);

	}

void C3GPLibParser_base::ParserCompleteHandleL(C3GPParse* aParser)

	{

	ASSERT(aParser);

	TInt err = aParser->Complete();

	if (err != KErrNone)

		{

		ERR_PRINTF2(_L("aParser->Complete() file handle failed with %d"), err);

		}

	FileClose();

    User::LeaveIfError(err);

	}

void C3GPLibParser_base::ParserOpenFileHandle64L(C3GPParse* aParser, TUint aFileMode, TInt aExpectedError)

	{

	ASSERT(aParser);

	FileOpen64L(aFileMode);

    TInt err = aParser->Open(iSourceFile64);	

    if (aExpectedError == KErrInUse && err == KErrNone)

		{

		err = aParser->Open(iSourceFile64);

		}

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

		{

		FileClose();

		if (ShouldRunOOMTest())

			{

			INFO_PRINTF2(_L("Parser open using 64bit file handle (OOM), returns %d"), err);

			User::Leave(err);

			}

		}

	if (!ShouldRunOOMTest())

		{

		INFO_PRINTF2(_L("Parser open using 64bit file handle, returns %d"), err);		

		}

	if (err == aExpectedError ) 

		{

		err = KErrNone;

		}

	User::LeaveIfError(err);

	}

void C3GPLibParser_base::ParserCompleteHandle64L(C3GPParse* aParser)

	{

	ASSERT(aParser);

	TInt err = aParser->Complete();

	if (err != KErrNone)

		{

		ERR_PRINTF2(_L("aParser->Complete() 64bit file handle failed with %d"), err);

		}

	FileClose64();

    User::LeaveIfError(err);

	}

void C3GPLibParser_base::ParserOpenCafLC(C3GPParse* aParser, TInt aExpectedError)

	{

	ASSERT(aParser);

	CContent* content = CContent::NewLC(iInputFile, EContentShareReadWrite);	

	CData* data = content->OpenContentL(EPeek);	

	CleanupStack::PushL(data);

	TInt err = aParser->Open(*data);

	if (aExpectedError == KErrInUse && err == KErrNone)

		{

		err = aParser->Open(*data);

		}

	if (ShouldRunOOMTest() && err != KErrNone && err != aExpectedError)

		{

		INFO_PRINTF2(_L("Parser open using CAF (OOM), returns %d"), err);

		User::Leave(err);	

		}

	if (!ShouldRunOOMTest())

		{

		INFO_PRINTF2(_L("Parser open using CAF, returns %d"), err);

		}

	if (err == aExpectedError)

		{

		err = KErrNone;

		}

	User::LeaveIfError(err);

	}

void C3GPLibParser_base::ParserCompleteCafL(C3GPParse* aParser)

	{

	ASSERT(aParser);

	TInt err = aParser->Complete();

	if ( err != KErrNone )

		{

		ERR_PRINTF2(_L("parse->Complete() CAF failed with %d."), err);

		}

	CleanupStack::PopAndDestroy(2); // content, data

	User::LeaveIfError(err);

	}

// Retrieve both video & audio stream properties

TInt C3GPLibParser_base::GetClipProperties(C3GPParse* aParse, TInt& aVideoError, TUint& aVideoLength, TUint& aAudioLength)

	{

	TInt err = KErrCorrupt;

	T3GPVideoType videoType;

	TReal frameRate;

	TUint avgBitRate;

	TSize videoSize;

	TUint timeScale;

	aVideoError = aParse->GetVideoProperties(videoType, aVideoLength, frameRate, avgBitRate, videoSize, timeScale);

	if (aVideoError == KErrNone || aVideoError == KErrNotSupported || aVideoError == KErr3gpLibMoreDataRequired)

		{

		T3GPAudioType audioType;

		TInt framesPerSample;

		err = aParse->GetAudioProperties(audioType, aAudioLength, framesPerSample, avgBitRate, timeScale);

		}	

	return err;

	}

// Get both audio and video decorder information

TInt C3GPLibParser_base::ParserGetDecoderInfo(C3GPParse* aParser)

	{

	TInt dsiSize;

	RBuf8 dsiBuffer;

	TInt err = aParser->GetAudioDecoderSpecificInfoSize(dsiSize);

	if ( err == KErrNone )

		{		

		err = dsiBuffer.Create(dsiSize);

		if ( err != KErrNone )

			{

			ERR_PRINTF2(_L("dsiBuffer.Create failed with %d"), err);

			dsiBuffer.Close();

			return err;

			}

		err = aParser->GetAudioDecoderSpecificInfo(dsiBuffer);

		}

	if ( err != KErrNone )

		{

		if (!ShouldRunOOMTest())

			{

			ERR_PRINTF3(_L("GetAudioDecoderSpecificInfo/Size() failed with %d, size %d"), err, dsiSize);

			}

		dsiBuffer.Close();

		return err;

		}

	err = aParser->GetVideoDecoderSpecificInfoSize(dsiSize);

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

		{

		dsiBuffer.Close();

		ERR_PRINTF2(_L("parse->GetVideoDecoderSpecificInfoSize() failed with %d"), err);

		return err;

		}

	if (err != KErrNotSupported)

		{

		dsiBuffer.Close();

		err = dsiBuffer.Create(dsiSize);	

		if ( err != KErrNone )

			{

			ERR_PRINTF2(_L("dsiBuffer.Create failed with %d"), err);

			dsiBuffer.Close();

			return err;

			}

		err = aParser->GetVideoDecoderSpecificInfo(dsiBuffer);

		if ( err != KErrNone )

			{

			ERR_PRINTF2(_L("VideoDecoderSpecificInfo() failed with %d"), err);

			}

		}

	dsiBuffer.Close();

	return err;

	}

// Read data from file and insert it to the buffer

void C3GPLibParser_base::InsertDataL(C3GPParse* aParse, RFile aFile, TInt aBufferSize, TInt aPos)

	{

	TInt err = KErrNone;

	RBuf8 buffer;

	CleanupClosePushL(buffer);

	buffer.CreateL(aBufferSize);

	err = aFile.Read(aPos, buffer); 

	if (err == KErrNone)

		{

		err = aParse->InsertData(buffer);

		if ( err != KErrNone )

			{

			ERR_PRINTF2(_L("parse->InsertData() failed with %d"), err);

			}

		}

	else

		{

		ERR_PRINTF2(_L("aFile.Read(aPos, buffer) failed with %d"), err);

		}

	buffer.Close();

	CleanupStack::PopAndDestroy(&buffer);

	User::LeaveIfError(err);

	}

// Read audio or video frame(s) depending on the input parameter synchronously

TInt C3GPLibParser_base::ReadAudioVideoFrame(C3GPParse* aParse, TBool aRepeat, TBool aReadAudio)

	{

	TInt err = KErrNone;

	// If repeat, read all frames; otherwise, read only one frame

	while (err == KErrNone)

		{

		TUint size;		

		if (aReadAudio)

			{

			err = aParse->GetAudioFramesSize(size);

			}

		else

			{

			err = aParse->GetVideoFrameSize(size);

			}

		if (err == KErrNone)

			{

			TUint timeStampInMs;

			TUint timeStampInTimescale;

			RBuf8 buffer;

			err = buffer.Create(size);				

			if (err != KErrNone)

				{

				ERR_PRINTF2(_L("buffer.Create(size) failed with %d"), err);

				buffer.Close();

				return err;

				}

			if (aReadAudio)

				{				

				TInt returnedFrames;

				err = aParse->ReadAudioFrames(buffer, returnedFrames, timeStampInMs, timeStampInTimescale);

				}

			else

				{

				TBool keyframe;

				err = aParse->ReadVideoFrame(buffer, keyframe, timeStampInMs, timeStampInTimescale);

				}

			if (err != KErrNone && err != KErrNotFound && err != KErr3gpLibMoreDataRequired)

				{

				if (aReadAudio)

					{

					ERR_PRINTF3(_L("parse->GetAudioFrames() failed with %d; frame size: %d"), err, size);

					}

				else

					{

					ERR_PRINTF3(_L("parse->GetVideoFrame() failed with %d; frame size: %d"), err, size);

					}

				buffer.Close();

				return err;

				}

			buffer.Close();

			}

		if (!aRepeat)

			{

			break;

			}

		}

	return err;

	}

// Retrieve user data atom.

TInt C3GPLibParser_base::CallUDTApi(C3GPParse* aParse, TUint32 aUdtType, TUint& aIndex, T3GPUdtaLocation aLocation)

	{

	TInt err = KErrNone;

	TInt udtSize;

	// use a copy of the target index requested by the user, so it does not get overwritten

	// when calling the APIs GetUserDataAtomSize & GetUserDataAtom

	TUint tempIndex1 = aIndex;	

	TUint tempIndex2 = aIndex;	

	err = aParse->GetUserDataAtomSize(aUdtType, aLocation, tempIndex1, udtSize);

	if (err == KErrNone)

		{

		RBuf8 buffer;	

		err = buffer.Create(udtSize); // Use size retrieved from GetUserDataAtomSize