// 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;
						if (audioBuf2.Length() == 0)
							{
							// duration for the last batch of audio frames = total audio length - the 2nd last audio frame
							duration = audioLengthInTS - audioTS1;
							}
						else
							{
							duration = audioTS2 - audioTS1;			
							}	
							
						User::LeaveIfError(iComposer->WriteAudioFrames(audioBuf1, duration));
						audioFrameCount++;
						
						audioBuf1.Close();
						audioBuf1.Swap(audioBuf2);
						framePerSample1 = framePerSample2;
						audioTS1 = audioTS2;
						}
					break;
					
				case E3GPVideo:
					if (videoBuf1.Length() == 0)
						{
						User::LeaveIfError(ReadVideoFrame(*iParser, videoBuf1, keyFrame1, videoTS1, dep1));
						}					
					err = ReadVideoFrame(*iParser, videoBuf2, keyFrame2, videoTS2, dep2);
					
					if (videoBuf1.Length() > 0 && videoBuf2.Length() > 0 || 
						videoBuf1.Length() > 0 && err == KErrNotFound)
						{
						TUint duration = 0;
						if (videoBuf2.Length() == 0)
							{
							// duration for the last batch of audio frames = total audio length - the 2nd last audio frame
							duration = videoLengthInTS - videoTS1;
							}
						else
							{
							duration = videoTS2 - videoTS1;			
							}	
							
						User::LeaveIfError(iComposer->WriteVideoFrame(videoBuf1, duration, keyFrame1, dep1));
						videoFrameCount++;
						
						videoBuf1.Close();
						videoBuf1.Swap(videoBuf2);
						keyFrame1 = keyFrame2;
						videoTS1 = videoTS2;
						dep1.iDependsOn = dep2.iDependsOn;
						dep1.iIsDependedOn = dep2.iIsDependedOn;
						dep1.iHasRedundancy = dep2.iHasRedundancy;		
						}
					break;
					
				default:
					ERR_PRINTF1(_L("Unknown frame type detected."));
					User::Leave(KErrUnknown);
					break;
				}
			}	// end of while loop
		}	// if (iComposer)
	
	CleanupStack::PopAndDestroy(5);
	
	INFO_PRINTF2(_L("ReadWriteAudioVideoFramesL wrote %d video frames."), videoFrameCount);
	INFO_PRINTF2(_L("ReadWriteAudioVideoFramesL wrote %d audio frames."), audioFrameCount);	
	}

TInt C3GPLibParseComposeFile::GetAudioDecoderSpecificInfo(RBuf8& aBuffer)
	{
	ASSERT(iParser);
	
	TInt size;
	TInt err = iParser->GetAudioDecoderSpecificInfoSize(size);
	if( err != KErrNone )
		{
		ERR_PRINTF2(_L("GetAudioDecoderSpecificInfoSize() failed: %d"), err);
		return err;
		}

	err = aBuffer.Create(size);
	if( err != KErrNone )
		{
		ERR_PRINTF1(_L("Create buffer failed"));
		return err;
		}

	err = iParser->GetAudioDecoderSpecificInfo(aBuffer);
	if( err != KErrNone )
		{
		ERR_PRINTF2(_L("GetAudioDecoderSpecificInfo() failed: %d"), err);
		}
	
	return err;
	}

TInt C3GPLibParseComposeFile::ParseVideoProperties(C3GPParse& aParser,
												   RBuf8& aDecoderSpecificInfo,
												   T3GPVideoPropertiesBase*& aProperties,
												   TUint& aLengthInMs) 
	{
	ASSERT(iParser);
	
	T3GPVideoType type; 
	TReal frameRate;
	TUint avgBitRate;
	TSize size;
	TUint timeScale;	
	
	TInt err = aParser.GetVideoProperties(type, aLengthInMs, frameRate, avgBitRate, size, timeScale);
	if ((err != KErrNone) && (err != KErrNotSupported))
		{
		ERR_PRINTF2(_L("aParser->GetVideoProperties failed: %d"), err);
		return err;
		}

	switch(type)
		{
		case E3GPMpeg4Video:
			{
			INFO_PRINTF1(_L("Video Type: Mpeg4"));			
			err = GetVideoDecoderSpecificInfo(aDecoderSpecificInfo);		
			if (err == KErrNone)
				{
				aProperties = new T3GPVideoPropertiesMpeg4Video(timeScale, size,
						64000, avgBitRate, aDecoderSpecificInfo);
				if (!aProperties)
					{
					ERR_PRINTF1(_L("T3GPVideoPropertiesMpeg4Video allocation failed"));
					err = KErrNoMemory;
					}
				}
			break;			
			}
		
		case E3GPAvcProfileBaseline:
		case E3GPAvcProfileMain:
		case E3GPAvcProfileExtended:
		case E3GPAvcProfileHigh:
			{
			err = GetVideoDecoderSpecificInfo(aDecoderSpecificInfo);
			if (err == KErrNone)
				{
				INFO_PRINTF2(_L("Video Type: Avc Profile %S"), KAvcProfileNames[type-E3GPAvcProfileBaseline] );
				aProperties = new T3GPVideoPropertiesAvc(timeScale, size, aDecoderSpecificInfo);
				if (!aProperties)
					{
					ERR_PRINTF1(_L("T3GPVideoPropertiesAvc allocation failed"));
					err = KErrNoMemory;
					}
                else
                    {
                    // T3GPVideoPropertiesAvc defaults the video type to AVC baseline profile.
                    // Need to override that here because we want to check for the specific
                    // profile in this test.
                    aProperties->iType = type;
                    }
				}
			break;
			}
			
		case E3GPH263Profile0:
		case E3GPH263Profile3:
			{
			INFO_PRINTF1(_L("Video Type: H263"));			
			T3GPVideoPropertiesH263::TProfile profile = T3GPVideoPropertiesH263::EProfile0;
			if (type == E3GPH263Profile3)
				{
				profile = T3GPVideoPropertiesH263::EProfile3;
				}
			
			TInt videoLevel;
			err = iParser->GetH263VideoLevel(videoLevel);
			if( err != KErrNone )
				{
				ERR_PRINTF1(_L("aParser->GetH263VideoLevel() failed"));
				}
			else
				{			
				aProperties = new T3GPVideoPropertiesH263(timeScale, size, videoLevel, profile);
				if( !aProperties )
					{
					ERR_PRINTF1(_L("T3GPVideoPropertiesH263 allocation failed"));
					err = KErrNoMemory;
					}
				}
			break;			
			}
		
		case E3GPNoVideo:
			INFO_PRINTF1(_L("Video Type: None"));
			break;
			
		default:
			err = KErrNotSupported;
			break;
		}
	
	return err;
	}

TInt C3GPLibParseComposeFile::GetVideoDecoderSpecificInfo(RBuf8& aBuffer)
	{	
	TInt size;
	TInt err = iParser->GetVideoDecoderSpecificInfoSize(size);
	if (err != KErrNone)
		{
		ERR_PRINTF1(_L("GetVideoDecoderSpecificInfoSize() failed"));
		return err;
		}
	
	err = aBuffer.Create(size);
	if (err != KErrNone)
		{
		ERR_PRINTF1(_L("Create buffer failed"));
		return err;
		}

	err = iParser->GetVideoDecoderSpecificInfo(aBuffer);
	if( err != KErrNone )
		{
		ERR_PRINTF1(_L("GetVideoDecoderSpecificInfo() failed"));
		}
	
	return err;
	}

TInt C3GPLibParseComposeFile::ParseAudioProperties(C3GPParse& aParser, 
												   RBuf8& aAudioDecoderSpecificInfo,
												   T3GPAudioPropertiesBase*& aAudioProperties,
												   TUint& aLength)
	{
	
	ASSERT(iParser);
	
	T3GPAudioType type; 
	TInt audioFPS; 
	TUint audioAvgBitRate; 
	TUint timeScale;	
	
	TInt err = aParser.GetAudioProperties(type, aLength, audioFPS, audioAvgBitRate, timeScale);
	if(( err != KErrNone ) && ( err != KErrNotSupported ))
		{
		ERR_PRINTF2(_L("GetAudioProperties() failed: %d"), err);
		return err;
		}

	switch(type)
		{
		case E3GPMpeg4Audio:
			{
			INFO_PRINTF1(_L("Audio Type: Mpeg4"));
			err = GetAudioDecoderSpecificInfo(aAudioDecoderSpecificInfo);
			if (err == KErrNone)
				{
				aAudioProperties = new T3GPAudioPropertiesMpeg4Audio(timeScale, aAudioDecoderSpecificInfo);
				if( !aAudioProperties )
					{
					ERR_PRINTF1(_L("T3GPAudioPropertiesMpeg4Audio allocation failed"));
					err = KErrNoMemory;
					}
				}
			break;
			}
			
		case E3GPQcelp13K:
			{
			INFO_PRINTF1(_L("Audio Type: Qcelp13K"));
			T3GPQcelpStorageMode mode;
			err = iParser->GetQcelpStorageMode(mode);
			if (err != KErrNone)
				{
				ERR_PRINTF1(_L("GetQcelpStorageMode failed"));
				}
			else 
				{
				if( mode == E3GPMP4AudioDescriptionBox)
					{
					err = GetAudioDecoderSpecificInfo(aAudioDecoderSpecificInfo);
					aAudioProperties = new T3GPAudioPropertiesQcelp(timeScale, audioFPS, aAudioDecoderSpecificInfo);
					}
				else
					{
					aAudioProperties = new T3GPAudioPropertiesQcelp(timeScale, audioFPS);
					}
				
				if( !aAudioProperties )
					{
					ERR_PRINTF1(_L("T3GPAudioPropertiesQcelp allocation failed"));
					err = KErrNoMemory;
					}
				}
			break;
			}
			
		case E3GPAmrNB:
			{
			INFO_PRINTF1(_L("Audio Type: AMR NB"));
			aAudioProperties = new T3GPAudioPropertiesAmr(timeScale, audioFPS, KAudioModeSet, T3GPAudioPropertiesAmr::EAmrNB);
			if( !aAudioProperties )
				{
				ERR_PRINTF1(_L("T3GPAudioPropertiesAmr allocation failed"));
				err = KErrNoMemory;
				}
			break;
			}
			
		case E3GPAmrWB:
			{
			INFO_PRINTF1(_L("Audio Type: AMR WB"));
			aAudioProperties = new T3GPAudioPropertiesAmr(timeScale, audioFPS, KAudioModeSet, T3GPAudioPropertiesAmr::EAmrWB);
			if( !aAudioProperties )
				{
				ERR_PRINTF1(_L("T3GPAudioPropertiesAmr allocation failed"));
				err = KErrNoMemory;
				}
			break;
			}
			
		case E3GPNoAudio:
			INFO_PRINTF1(_L("Audio Type: None"));			
			break;
			
		default:
			INFO_PRINTF1(_L("Audio Type: Unrecognized!"));
			err = KErrNotSupported;
			break;
		}
	
	return err;
	}

TInt C3GPLibParseComposeFile::ReadVideoFrame(C3GPParse& aParser,
											 RBuf8& aVideoBuffer, 
											 TBool& aVideoKeyFrame, 
											 TUint& aVideoTimestampInTS, 
											 T3GPFrameDependencies& aDependencies)
	{
	ASSERT(iParser);
	
	// flush all data in the buffer
	aVideoBuffer.Close();
	
	TInt err = aParser.GetVideoFrameDependencies(aDependencies);
	if (err != KErrNone)
		{
		aDependencies.iDependsOn = E3GPDependencyUnknown;
		aDependencies.iIsDependedOn = E3GPDependencyUnknown;
		aDependencies.iHasRedundancy = E3GPRedundancyUnknown;
		}
	
	TUint frameSize = 0;
	err = aParser.GetVideoFrameSize(frameSize);
	if (err == KErrNone)
		{
		if (frameSize > KMaxTInt / 2)
			{
			ERR_PRINTF1(_L("Video Frame too large!"));
			err = KErrOverflow;
			}
		else
			{
			err = aVideoBuffer.Create((TInt)frameSize);
			if (err == KErrNone)
				{
				TUint videoTimestampMS = 0;
				err = aParser.ReadVideoFrame(aVideoBuffer, aVideoKeyFrame, videoTimestampMS, aVideoTimestampInTS);				
				if (err == KErrNone)
					{
					if (err == KErrNotSupported)
						{
						// Not supported error is OK
						err = KErrNone;
						}
					else if (err != KErrNone)
						{
						ERR_PRINTF2(_L("GetVideoFrameDependencies failed with err = %d"), err);					
						}
					}
				else
					{
					ERR_PRINTF2(_L("ReadVideoFrame failed with err = %d"), err);					
					}
				}
			}
		}
	else
		{
		ERR_PRINTF2(_L("GetVideoFrameSize fails with %d"), err);		
		}
	
	return err;	
	}

TInt C3GPLibParseComposeFile::ReadAudioFrames(C3GPParse& aParser, 
											  RBuf8& aBuffer, 
											  TInt& aFramesInSample, 
											  TUint& aTimestampInTS)
	{
	// flush all existing data
	aBuffer.Close();
	
	TUint size = 0;
	TInt err = aParser.GetAudioFramesSize(size);
	if (err == KErrNone)
		{
		if (size > KMaxTInt / 2)	
			{
			// cannot create RBuf of size > KMaxTInt / 2 
			ERR_PRINTF1(_L("Audio Frames too large!"));
			err = KErrOverflow;
			}
		else
			{
			err = aBuffer.Create((TInt)size);
			if (err == KErrNone)
				{
				TUint audioTimestampMS = 0;
				err = aParser.ReadAudioFrames(aBuffer, aFramesInSample, audioTimestampMS, aTimestampInTS);
				if (err != KErrNone)
					{
					ERR_PRINTF2(_L("ReadAudioFrames failed with err = %d"), err);							
					}
				}
			}
		}
	else
		{
		ERR_PRINTF2(_L("GetAudioFramesSize failed with err = %d"), err);		
		}
	
	return err;
	}

TBool C3GPLibParseComposeFile::CompareInputOuputFileL(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 1 Open() returns %d"), err);
		User::Leave(err);
		}
	
	RBuf outputFile;
	CleanupClosePushL(outputFile);
	
	outputFile.CreateL(KMaxFileName);
	outputFile.Copy(iOutputDir);
	
	TParsePtrC parsePtr(aInputFile);
	TPtrC name = parsePtr.NameAndExt();	
	outputFile.Append(parsePtr.NameAndExt());

	C3GPParse* parser2 = C3GPParse::NewL();
	CleanupStack::PushL(parser2);

	RFile64 file2;
	if (iLargeFile)
		{
		err = file2.Open(iFs, outputFile, EFileShareReadersOrWriters);
		if (err == KErrNone)
			{
			err = parser2->Open(file2);		
			}
		}
	else
		{
		err = parser2->Open(outputFile);		
		}
		
	if (err != KErrNone)
		{
		ERR_PRINTF2(_L("C3GPParse 2 Open() returns %d"), err);
		User::Leave(err);
		}
	
	TBool result = EFalse;	
	if (CompareVideoPropertiesL(*iParser, *parser2))
		{
		if (CompareAudioPropertiesL(*iParser, *parser2))
			{
			if (CompareAudioVideoData(*iParser, *parser2))
				{
				result = ETrue;
				}			
			else
				{
				ERR_PRINTF1(_L("Audio/Video Data not matching"));
				}					
			}
		else
			{
			ERR_PRINTF1(_L("Audio Properites not matching"));
			}		
		}
	else
		{
		ERR_PRINTF1(_L("Video Properites not matching"));
		}
	
	parser2->Complete();
	iParser->Complete();
	
	if (iLargeFile)
		{
		file2.Close();
		iParsedFileHandle64.Close();
		}
	
	CleanupStack::PopAndDestroy(2);		// outputFile, parser2
	
	return result;
	}

TBool C3GPLibParseComposeFile::CompareVideoPropertiesL(C3GPParse& aParser1, 
													   C3GPParse& aParser2)
	{
	//
	// Retrieve Video Properties from Parser 1
	//	
	T3GPVideoPropertiesBase* videoProperties1 = NULL;
	CleanupStack::PushL(videoProperties1);
	
	RBuf8 videoDecoderSpecificInfo1;
	CleanupClosePushL(videoDecoderSpecificInfo1);
	
	TUint videoLengthInMs1 = 0;
		
	TInt err1 = ParseVideoProperties(aParser1, videoDecoderSpecificInfo1, videoProperties1, videoLengthInMs1);
	if (err1 != KErrNone && err1 != KErrNotSupported)
		{
		ERR_PRINTF2(_L("ParseVideoProperties 1 failed: err = %d"), err1);
		User::Leave(err1);
		}
	
	//
	// Retrieve Video Properties from Parser 2
	//	
	T3GPVideoPropertiesBase* videoProperties2 = NULL;
	CleanupStack::PushL(videoProperties2);
	
	RBuf8 videoDecoderSpecificInfo2;
	CleanupClosePushL(videoDecoderSpecificInfo2);
	
	TUint videoLengthInMs2 = 0;
		
	TInt err2 = ParseVideoProperties(aParser2, videoDecoderSpecificInfo2, videoProperties2, videoLengthInMs2);
	if (err2 != KErrNone && err2 != KErrNotSupported)
		{
		ERR_PRINTF2(_L("ParseVideoProperties 2 failed: err = %d"), err2);
		User::Leave(err2);
		}

	TBool result = EFalse;
	if (err1 == err2 && err1 != KErrNotSupported)
		{
		if (videoLengthInMs1 == videoLengthInMs2)
			{
			if (videoProperties1 && videoProperties2)
				{
				result = (videoProperties1->iType == videoProperties2->iType) &&
						 (videoProperties1->iSize == videoProperties2->iSize) &&
						 (videoProperties1->iTimescale == videoProperties2->iTimescale);
					
				if (result)
					{
					switch(videoProperties1->iType)
						{
						case E3GPMpeg4Video:
							{
							T3GPVideoPropertiesMpeg4Video* video1 = (T3GPVideoPropertiesMpeg4Video*)videoProperties1;
							T3GPVideoPropertiesMpeg4Video* video2 = (T3GPVideoPropertiesMpeg4Video*)videoProperties2;
							
							// NOTE: Comparison of the avg bit rate is omitted.  The reason is that the avg. bit 
							//       rate is calculated by: 
							//       video avg bit rate = stream avg bit rate - audio avg bit rate
							//       However, stream avg. bit rate is not be properly set by the 3GP composer
							//       as it is not very important.  Thus leading to the video avg. bit rate  
							//       retrieved from the output file to NOT match the original.
							result = ((video1->iMaxBitRate == video2->iMaxBitRate) && 
									 //(video1->iAvgBitRate == video2->iAvgBitRate) &&
									 (video1->iDecoderSpecificInfo == video2->iDecoderSpecificInfo)); 
							break;			
							}
								
						case E3GPAvcProfileBaseline:
						case E3GPAvcProfileMain:
						case E3GPAvcProfileExtended:
						case E3GPAvcProfileHigh:
							{
							T3GPVideoPropertiesAvc* video1 = (T3GPVideoPropertiesAvc*)videoProperties1;
							T3GPVideoPropertiesAvc* video2 = (T3GPVideoPropertiesAvc*)videoProperties2;
							
							result = (video1->iDecoderSpecificInfo == video2->iDecoderSpecificInfo); 
							break;
							}
									
						case E3GPH263Profile0:
						case E3GPH263Profile3:
							{
							T3GPVideoPropertiesH263* video1 = (T3GPVideoPropertiesH263*)videoProperties1;
							T3GPVideoPropertiesH263* video2 = (T3GPVideoPropertiesH263*)videoProperties2;

							result = (video1->iVideoLevel == video2->iVideoLevel);
							break;			
							}
						}
					}
				}			
			}		
		}	
	else if (err1 == KErrNotSupported && err2 == err1)
		{
		result = ETrue;
		}

	CleanupStack::PopAndDestroy(4);		// videoProperties1, 
										// videoProperties2, 
										// videoDecoderSpecificInfo1, 
										// videoDecoderSpecificInfo2
	
	return result;
	}

TBool C3GPLibParseComposeFile::CompareAudioPropertiesL(C3GPParse& aParser1, 
													   C3GPParse& aParser2)
	{
	//
	// Retrieve Audio Properties 1
	//
	T3GPAudioPropertiesBase* audioProperties1 = NULL;
	CleanupStack::PushL(audioProperties1);	

	RBuf8 audioDecoderSpecificInfo1;
	CleanupClosePushL(audioDecoderSpecificInfo1);
	
	TUint audioLengthInMs1 = 0;
	TInt err1 = ParseAudioProperties(aParser1, audioDecoderSpecificInfo1, audioProperties1, audioLengthInMs1);
	if( err1 != KErrNone && err1 != KErrNotSupported)
		{
		ERR_PRINTF2(_L("ParseAudioProperties failed: err = %d"), err1);		
		User::Leave(err1);
		}

	//
	// Retrieve Audio Properties 2
	//
	T3GPAudioPropertiesBase* audioProperties2 = NULL;
	CleanupStack::PushL(audioProperties2);	

	RBuf8 audioDecoderSpecificInfo2;
	CleanupClosePushL(audioDecoderSpecificInfo2);
	
	TUint audioLengthInMs2 = 0;
	TInt err2 = ParseAudioProperties(aParser2, audioDecoderSpecificInfo2, audioProperties2, audioLengthInMs2);
	if( err2 != KErrNone && err2 != KErrNotSupported)
		{
		ERR_PRINTF2(_L("ParseAudioProperties failed: err = %d"), err2);		
		User::Leave(err2);
		}
	
	TBool result = EFalse;
	if (err1 == err2 && err1 != KErrNotSupported)
		{
		if (audioLengthInMs2 == audioLengthInMs1)
			{
			if (audioProperties1 && audioProperties2)
				{
				result = (audioProperties1->iType == audioProperties2->iType) &&
						 (audioProperties1->iFramesPerSample == audioProperties2->iFramesPerSample) &&
						 (audioProperties1->iTimescale == audioProperties2->iTimescale);
				
				if (result)
					{
					switch(audioProperties1->iType)
						{
						case E3GPMpeg4Audio:
							{
							T3GPAudioPropertiesMpeg4Audio* audio1 = (T3GPAudioPropertiesMpeg4Audio*) audioProperties1;
							T3GPAudioPropertiesMpeg4Audio* audio2 = (T3GPAudioPropertiesMpeg4Audio*) audioProperties2;
							result = (audio1->iDecoderSpecificInfo == audio2->iDecoderSpecificInfo);
							}
							break;							
							
						case E3GPAmrNB:
						case E3GPAmrWB:
							{
							T3GPAudioPropertiesAmr* audio1 = (T3GPAudioPropertiesAmr*) audioProperties1;
							T3GPAudioPropertiesAmr* audio2 = (T3GPAudioPropertiesAmr*) audioProperties2;
							result = (audio1->iModeSet == audio2->iModeSet);
							}
							break;														
							
						case E3GPQcelp13K:
							{
							T3GPAudioPropertiesQcelp* audio1 = (T3GPAudioPropertiesQcelp*) audioProperties1;
							T3GPAudioPropertiesQcelp* audio2 = (T3GPAudioPropertiesQcelp*) audioProperties2;
							result = ((audio1->iDecoderSpecificInfo == audio2->iDecoderSpecificInfo) &&
									 (audio1->iMode == audio2->iMode));
							}
							break;														
						}
					}
				}
			}
		}	
	else if (err1 == KErrNotSupported && err2 == err1)
		{
		result = ETrue;
		}

	CleanupStack::PopAndDestroy(4);		// audioProperties1, audioProperties2, audioDecoderSpecificInfo1, audioDecoderSpecificInfo2
	
	return result;
	}

TBool C3GPLibParseComposeFile::CompareAudioVideoData(C3GPParse& aParser1, C3GPParse& aParser2)
	{
	T3GPFrameType frameType1;
	T3GPFrameType frameType2;
	TInt err1 = KErrNone;
	TInt err2 = KErrNone;
	TBool keepLooping = ETrue;
	TBool result = EFalse;
	
	while (keepLooping)
		{
		err1 = aParser1.GetFrameType(frameType1);
		err2 = aParser2.GetFrameType(frameType2);
		
		if (err1 != err2)
			{
			break;
			}		
		else
			{
			if (err1 == KErrNotFound)
				{
				// completed looping thru all the frames
				break;
				}
			
			if (err1 != KErrNone)
				{
				// if the error is not KErrNotFound, something's wrong!
				result = EFalse;
				}			
			else if (frameType1 != frameType2)
				{			
				result = EFalse;
				}		
			else if (frameType1 == E3GPVideo)
				{
				result = CompareVideoFrame(aParser1, aParser2);
				}				
			else if (frameType1 == E3GPAudio)			
				{
				result = CompareAudioFrames(aParser1, aParser2);
				}
			
			if (!result)
				{
				break;
				}
			}
		} 
	
	return result;
	}

TBool C3GPLibParseComposeFile::CompareVideoFrame(C3GPParse& aParser1, C3GPParse& aParser2)
	{
	TUint timestamp1 = 0;
	TUint timestamp2 = 0;
	RBuf8 buf1;
	RBuf8 buf2;
	TBool keyFrame1 = EFalse;
	TBool keyFrame2 = EFalse;
	T3GPFrameDependencies dep1;
	T3GPFrameDependencies dep2;
	
	TInt err1 = ReadVideoFrame(aParser1, buf1, keyFrame1, timestamp1, dep1);
	TInt err2 = ReadVideoFrame(aParser2, buf2, keyFrame2, timestamp2, dep2);

	TBool result = EFalse;
	if (err1 == err2)
		{
		if (keyFrame1 == keyFrame2 && timestamp1 == timestamp2)
			{
			if (dep1.iDependsOn == dep2.iDependsOn && 
				dep1.iHasRedundancy == dep2.iHasRedundancy && 
				dep1.iIsDependedOn == dep2.iIsDependedOn)
				{
				if (buf1 == buf2)
					{
					result = ETrue;
					}
				else 
					{
					result = EFalse;
					}
				}
			else 
				{
				result = EFalse;
				}			
			}
		else 
			{
			result = EFalse;
			}		
		}
	else 
		{
		result = EFalse;
		}	

	// cleanup
	buf1.Close();
	buf2.Close();
	
	return result;
	}

TBool C3GPLibParseComposeFile::CompareAudioFrames(C3GPParse& aParser1, C3GPParse& aParser2)
	{
	TInt fps1 = 0;
	TInt fps2 = 0;
	TUint timestamp1 = 0;
	TUint timestamp2 = 0;
	RBuf8 buf1;
	RBuf8 buf2;
	
	TInt err1 = ReadAudioFrames(aParser1, buf1, fps1, timestamp1);
	TInt err2 = ReadAudioFrames(aParser2, buf2, fps2, timestamp2);

	TBool result = EFalse;
	if (err1 == err2)
		{
		if (fps1 == fps2 && timestamp1 == timestamp2)
			{
			if (buf1 == buf2)
				{
				result = ETrue;
				}
			else 
				{
				result = EFalse;
				}			
			}
		else 
			{
			result = EFalse;
			}		
		}
	else 
		{
		result = EFalse;
		}
	
	// cleanup	
	buf1.Close();
	buf2.Close();
	
	return result;
	}