/*

* Copyright (c) 2006 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 FILES

#include "H264DecTestEngine.h"

#include "T_DevVideoConstants.h"

#ifdef __CI_HEADERS__

#include <buffermanagementci.h>  // Custom interface buffre management

#endif

#ifdef __SECUREOUTPUTCI__

#include <secureoutputci.h>

#endif

#include <Devvideoplay.h>

#include <Devvideobase.h>

#include <Devvideoconstants.h>

#include <hal.h>

#include <hal_data.h>

//#define __MEM_CHECK_

// Ecom

#include <ecom.h>

/* ----------------------------------------------------------------------------

* Name:       CVDecTestEngine::~CVDecTestEngine()

* Purpose:    Deconstructor

* Parameters: None

* Return:     None

* --------------------------------------------------------------------------*/

CVDecTestEngine::~CVDecTestEngine ()

{

	delete iDecTestAO;

	delete iClock;

}

/* ----------------------------------------------------------------------------

* Name:       CVDecTestEngine:NewL()

* Purpose:    Create instance of test engine

* Parameters: MVDecEngineObserver& aTestClass

* Return:     CVDecTestEngine*

* --------------------------------------------------------------------------*/

CVDecTestEngine* CVDecTestEngine::NewL(MVDecEngineObserver& aTestClass)

{

	CVDecTestEngine* self = new(ELeave) CVDecTestEngine;

	CleanupStack::PushL( self );

	self->ConstructL(aTestClass);

	CleanupStack::Pop();

	return self;

}

/* ----------------------------------------------------------------------------

* Name:       CVDecTestEngine::ConstructL()

* Purpose:    Symbian second phase constructor, which may leave

* Parameters: MVDecEngineObserver& aTestClass

* Return:     None

* --------------------------------------------------------------------------*/

void CVDecTestEngine::ConstructL(MVDecEngineObserver& aTestClass)

{

	iState = EStateNone;

	iTestClass = &aTestClass;

	iScreenDevice = NULL;

	//Create Active object

	iDecTestAO = new(ELeave) CVDecTestAO(this);

	//clock source from system clock

	iClock = CSystemClockSource::NewL();

}

/* ----------------------------------------------------------------------------

* Name:       CVDecTestEngine::AssertTIntEqualL()

* Purpose:

*

* Parameters: TInt aExpected, TInt aActual

* Return:     None

* --------------------------------------------------------------------------*/

void CVDecTestEngine::AssertTIntEqualL(TInt aExpected, TInt aActual)

{

	if ( aExpected != aActual )

	{

		User::Leave(aActual);

	}

}

/* ----------------------------------------------------------------------------

* Name:       CVDecTestEngine::SetUp()

* Purpose:    Create DevVideoPlay, Initilize Engine paramters

* Parameters: TSize aSize, TBool aScreenAccess, TBool aSynchronized, TBool aCIBuffMgmt

* Return:     None

* --------------------------------------------------------------------------*/

void CVDecTestEngine::SetUpL(TSize aSize, TBool aScreenAccess, TBool aCIBuffMgmt)

{

	iMemAlloc = 0;

	iMemDelete = 0;

	//Create DevVideoPlay

	iDevvp = CMMFDevVideoPlay::NewL(*this);

	PRINT((_L("CVDecTestEngine::SetUpL, DevVideo Created")))

	#ifdef __MEM_CHECK_

	PRINT((_L("CVDecTestEngine::SetUpL, mem alloc, iDevvp") ))

	#endif

	iMemAlloc++;

	iState = ECreated;

	// Initilize Engine parameters

	iError = KErrNone;

	iDecHWDevId = 0;

	iPostProcId = 0;

	iInBuffSize = 0;

	iRawDataArea = NULL;

	iCodecType = ENoCodec;

	iInputEnd = EFalse;

	iFrameMatch = EFalse;

	iFrameJump = 0;

	iFrameJumpCounter = 0;

	iCorruptMarker = EFalse;

	iOutCorruptedFileOpen = EFalse;

	iFrameCounter = 0;

	iCorruptCounter = 0;

	iFlvCounter = 0;

	iFrameDropCounter = 0;

	iFrameDropInterval = 0;

	iFrameDropNum = 0;

	iFrameDropMarker = EFalse;

	iCurrentFilePos = 0;

	iFrameDropNumCounter = 0;

	iSetPassword = EFalse;

	iUseSecondScreen = EFalse;

	#ifdef __CI_HEADERS__

	iCIBuffMgmtOn = aCIBuffMgmt;

	#endif

	iDirectScreenAccess = aScreenAccess;

	iSynchronized = EFalse;

	iLandscapeMode =EFalse;

	PRINT((_L("CVDecTestEngine::SetUpL, reserving data chunk")));

	if (aSize.iWidth > 720 && aSize.iWidth > 576 )

	{

		iDataChunkSize = KMP4MaxCodedSize720P*4;

		iDataThreshold = KMP4MaxCodedSize720P;

	}

	else if (aSize.iWidth > 640 && aSize.iWidth > 480 )

	{

		iDataChunkSize = KMP4MaxCodedSizePAL*4;

		iDataThreshold = KMP4MaxCodedSizePAL;

	}

	else if (aSize.iWidth > 352 && aSize.iWidth > 288 )

	{

		iDataChunkSize = KMP4MaxCodedSizeVGA*4;

		iDataThreshold = KMP4MaxCodedSizeVGA;

	}

	else if (aSize.iWidth <= 352 && aSize.iWidth > 176)

	{

		iDataChunkSize = KMP4MaxCodedSizeCIF*4;

		iDataThreshold = KMP4MaxCodedSizeCIF;

	}

	else

	{

		iDataChunkSize = KMP4MaxCodedSizeQCIF*4;

		iDataThreshold = KMP4MaxCodedSizeQCIF;

	}

	PRINT((_L("CVDecTestEngine::SetUpL, Data chunk size is [%d]"), iDataChunkSize));

	PRINT((_L("CVDecTestEngine::SetUpL, Data threshold [%d]"), iDataThreshold));

	iDataChunk = new (ELeave) TUint8[iDataChunkSize];

	iMemAlloc++;

	#ifdef __MEM_CHECK_

	PRINT((_L("CVDecTestEngine::SetUpL, mem alloc, iDataChunk") ));

	#endif

	iReadDataChunk = iDataChunk;

	iWriteDataChunk = iDataChunk;

	iPictureSize.SetSize(aSize.iWidth,aSize.iHeight);

	TRect rect(iPictureSize);

	iDispRect = rect;

	iFrameMeasurement = EFalse;

	iDsaStarted = EFalse;

	if ( aScreenAccess )

	{

		User::LeaveIfError( FbsStartup() );

		PRINT((_L("CVDecTestEngine::SetUpL, Fbs server started:")))

	}

	//Open File session

	TInt err;

	if ( (err = iFs.Connect()) != KErrNone )

	{

		PRINT((_L("CVDecTestEngine::SetUpL, Open File server session fail ")))

		User::Leave(err);

	}

}

/* ----------------------------------------------------------------------------

* Name:       CVDecTestEngine::EnableFrameMeasurementTest

* Purpose:    Enable Perforamce test flag

* Note

* Parameters: TBool a Enable

* Return:     None

* --------------------------------------------------------------------------*/

void CVDecTestEngine::EnableFrameMeasurementTest(TBool aEnable)

{

	iFrameMeasurement = aEnable;

}

/* ----------------------------------------------------------------------------

* Name:       CVDecTestEngine::SetInputBufferSize

* Purpose:

* Note

* Parameters: TBool a Enable

* Return:     None

* --------------------------------------------------------------------------*/

void CVDecTestEngine::SetInputBufferSize(TInt aSize)

{

	iInBuffSize = aSize;

	if ( iCIBuffMgmtOn )  //Custom interfarce Buffer management is used

	{

		PRINT((_L("CVDecTestEngine::SetInputBufferSize, CI Buffer management")))

		#ifdef __CI_HEADERS__

		iCIBuffMgmt = (MMmfVideoBufferManagement*)iDevvp->CustomInterface(iPostProcId, KMmfVideoBuffermanagementUid);

		iCIBuffMgmt->MmvbmSetObserver(this);

		iCIBuffMgmt->MmvbmEnable(ETrue);

		MMmfVideoBufferManagement::TBufferOptions options;

		options.iNumInputBuffers = KNumOfInputBuffers;

		options.iBufferSize = iPictureSize;

		iCIBuffMgmt->MmvbmSetBufferOptionsL(options);

		PRINT((_L("CVDecTestEngine::SetInputBufferSize, CI Buffer management Set, Buff size:[%d],[%d]"),iPictureSize.iWidth,iPictureSize.iHeight))

		#endif

	}

	else  //Use default Devvideo API for buffer management

	{

		iRawInBuffer = new(ELeave) TVideoPicture;

		iMemAlloc++;

		#ifdef __MEM_CHECK_

		PRINT((_L("CVDecTestEngine::SetInputBufferSize, mem alloc, iRawInBuffer") ));

		#endif

		TUint8* ptr = new (ELeave) TUint8[iInBuffSize];

		iMemAlloc++;

		#ifdef __MEM_CHECK_

		PRINT((_L("CVDecTestEngine::SetInputBufferSize, mem alloc, ptr") ));

		#endif

		TPtr8*  temp = new (ELeave) TPtr8(ptr, 0, iInBuffSize);

		iMemAlloc++;

		#ifdef __MEM_CHECK_

		PRINT((_L("CVDecTestEngine::SetInputBufferSize, mem alloc, temp") ));

		#endif

		iRawInBuffer->iData.iRawData = temp;

		iRawInBuffer->iData.iDataSize.SetSize(iPictureSize.iWidth,iPictureSize.iHeight); //set picture size

		iRawInBuffer->iOptions = 0;

		iRawInBuffer->iTimestamp = 0;

		delete ptr;

		iMemDelete++;

		delete temp;

		iMemDelete++;

		#ifdef __MEM_CHECK_

		PRINT((_L("CVDecTestEngine::SetInputBufferSize, mem del, ptr & temp") ));

		#endif

		PRINT((_L("CVDecTestEngine::SetInputBufferSize, Buffer created: Size[%d]"),iInBuffSize))

	}

}

/* ----------------------------------------------------------------------------

* Name:       CVDecTestEngine::GetHeaderInformationL()

* Purpose:    Ritrieve header  Information

* Parameters: TVideoDataUnitType aDataUnitType, TVideoDataUnitEncapsulation aDataUnitEncapsulation

* Return:     None

*---------------------------------------------------------------------------*/

void CVDecTestEngine::GetHeaderInformationL(TVideoDataUnitType aDataUnitType, TVideoDataUnitEncapsulation aDataUnitEncapsulation)

{

	TInt err = KErrNone;

	TVideoPictureHeader* headerInfo = NULL;

	HBufC8* tempBuff = NULL;

	//Read Picture header : Size is not known

	TVideoInputBuffer* codedBuffer = new(ELeave) TVideoInputBuffer;

	iMemAlloc++;

	CleanupStack::PushL( codedBuffer );

	#ifdef __MEM_CHECK_

	PRINT((_L("CVDecTestEngine::GetHeaderInformationL, mem alloc, codedBuffer") ))

	#endif

	iInBuffSize = KMaxCodedSize;

	err = KErrOverflow;

	while ( (err == KErrOverflow) && (iInBuffSize <= KMaxCodedSize) )

	{

		tempBuff = HBufC8::NewL(iInBuffSize);

		iMemAlloc++;

		CleanupStack::PushL( tempBuff );

		#ifdef __MEM_CHECK_

		PRINT((_L("CVDecTestEngine::GetHeaderInformationL, mem alloc, codedBuffer") ))

		#endif

		codedBuffer->iData.Set(tempBuff->Des());

		if ( iFrameSizeList.Count() > 0 )

		{

			err = ReadOneCodedPicture(codedBuffer, iFrameSizeList[0] );

		}

		else

		{

			err = ReadOneCodedPicture(codedBuffer);

		}

		PRINT((_L("CVDecTestEngine::GetHeaderInformationL, return err [%d]"),err))

		TInt pos =0;

		if ( iInFile.Seek(ESeekStart,pos) )

		{

			err = KErrGeneral;

			PRINT((_L("CVDecTestEngine::GetHeaderInformationL, err = KErrGeneral")))

		}

		if ( iInputEnd )

		{

			err = KErrNotFound;

			PRINT((_L("CVDecTestEngine::GetHeaderInformationL, err = KErrNotFound")))

		}

		if ( err < 0 )

		{

			CleanupStack::PopAndDestroy(tempBuff);

			iMemDelete++;

			#ifdef __MEM_CHECK_

			PRINT((_L("CVDecTestEngine::GetHeaderInformationL, mem del, tempBuff") ))

			#endif

			iInBuffSize = 4*iInBuffSize;

		}

	}

	// Reitrieve header information from bitstream

	if ( err < 0 )

	{

		CleanupStack::PopAndDestroy(codedBuffer);

		iMemDelete++;

		#ifdef __MEM_CHECK_

		PRINT((_L("CVDecTestEngine::GetHeaderInformationL, mem del, codedBuffer") ))

		#endif

		PRINT((_L("CVDecTestEngine::GetHeaderInformationL, Reading input data fail")))

	}

	else

	{

		err = KErrNone;

		PRINT((_L("CVDecTestEngine::GetHeaderInformationL, call adaptation layer")))

		headerInfo = iDevvp->GetHeaderInformationL(aDataUnitType,aDataUnitEncapsulation,codedBuffer);

		CleanupStack::PopAndDestroy(tempBuff);

		iMemDelete++;

		CleanupStack::PopAndDestroy(codedBuffer);

		iMemDelete++;

		#ifdef __MEM_CHECK_

		PRINT((_L("CVDecTestEngine::GetHeaderInformationL, mem del, tempBuff & codedBuffer") ))

		#endif

		//Check Header info

		if ( !err && headerInfo )

		{

			//Size in Memory

			iPictureSize = headerInfo->iDisplayedRect.Size();

			PRINT((_L("CVDecTestEngine::GetHeaderInformationL, Picture Size :width[%d], height[%d]"),iPictureSize.iWidth,iPictureSize.iHeight))

			// Display rect

			iDispRect = headerInfo->iDisplayedRect;

			PRINT((_L("CVDecTestEngine::GetHeaderInformationL, Displayed image portion: Width[%d] to Height[%d]"),headerInfo->iDisplayedRect.Width(),headerInfo->iDisplayedRect.Height()))

			//return headerInfo

			iDevvp->ReturnHeader(headerInfo);

		}

		else  //temp modify because MP4HwDevice of Emuzed returns null information in 1st release

		{

			PRINT((_L("CVDecTestEngine::GetHeaderInformationL, Get header info fail")))

			err = KErrGeneral;

		}

	}

	AssertTIntEqualL(KErrNone, err);

}

/* ----------------------------------------------------------------------------

* Name:       CVDecTestEngine::GetHeaderInformationL()

* Purpose:    Retrieve header Information

* Parameters: None

* Return:     None

*---------------------------------------------------------------------------*/

void CVDecTestEngine::GetHeaderInformationL()

{

	PRINT((_L("CVDecTestEngine::GetHeaderInformationL, In")))

	TInt err = KErrNone;

	TVideoPictureHeader* headerInfo = NULL;

	HBufC8* tempBuff = NULL;

	//Read Picture header : Size is not known

	TVideoInputBuffer* codedBuffer = new(ELeave) TVideoInputBuffer;

	iMemAlloc++;

	CleanupStack::PushL( codedBuffer );

	#ifdef __MEM_CHECK_

	PRINT((_L("CVDecTestEngine::GetHeaderInformationL, mem alloc, codedBuffer") ))

	#endif

	iInBuffSize = KMaxCodedSize;

	err = KErrOverflow;

	while ( (err == KErrOverflow) && (iInBuffSize <= KMaxCodedSize) )

	{

		tempBuff = HBufC8::NewL(iInBuffSize);

		iMemAlloc++;

		CleanupStack::PushL( tempBuff );

		#ifdef __MEM_CHECK_

		PRINT((_L("CVDecTestEngine::GetHeaderInformationL, mem alloc, tempBuff") ))

		#endif

		codedBuffer->iData.Set(tempBuff->Des());

		if ( iFrameSizeList.Count() > 0 )

		{

			err = ReadOneCodedPicture(codedBuffer, iFrameSizeList[0] );

		}

		else

		{

			err = ReadOneCodedPicture(codedBuffer);

		}

		TInt pos =0;

		if ( iInFile.Seek(ESeekStart,pos) )

		{

			err = KErrGeneral;

		}

		if ( iInputEnd )

		{

			err = KErrNotFound;

		}

		if ( err < 0 )

		{

			CleanupStack::PopAndDestroy(tempBuff);

			iMemDelete++;

			#ifdef __MEM_CHECK_

			PRINT((_L("CVDecTestEngine::GetHeaderInformationL, mem del, tempBuff") ))

			#endif

			iInBuffSize = 4*iInBuffSize;

		}

	}

	// Reitrieve header information from bitstream

	if ( err  < 0 )

	{

		CleanupStack::PopAndDestroy(codedBuffer);

		iMemDelete++;

		#ifdef __MEM_CHECK_

		PRINT((_L("CVDecTestEngine::GetHeaderInformationL, mem del, codedBuffer") ))

		#endif

		PRINT((_L("CVDecTestEngine::GetHeaderInformationL, Reading input data fail")))

	}

	else

	{

		err = KErrNone;

		headerInfo = iDevvp->GetHeaderInformationL(EDuCodedPicture,EDuElementaryStream,codedBuffer);

		CleanupStack::PopAndDestroy(tempBuff);

		CleanupStack::PopAndDestroy(codedBuffer);

		iMemDelete++;

		iMemDelete++;

		#ifdef __MEM_CHECK_

		PRINT((_L("CVDecTestEngine::GetHeaderInformationL, mem del, tempBuff & codedBuffer") ))

		#endif

		//Check Header info

		if ( headerInfo )

		{

			//Size in Memory

			iPictureSize = headerInfo->iDisplayedRect.Size();

			PRINT((_L("CVDecTestEngine::GetHeaderInformationL, Picture Size :width[%d], height[%d]"),iPictureSize.iWidth,iPictureSize.iHeight))

			// Display rect

			iDispRect = headerInfo->iDisplayedRect;

			PRINT((_L("CVDecTestEngine::GetHeaderInformationL, Displayed image portion: Width[%d] to Height[%d]"),headerInfo->iDisplayedRect.Width(),headerInfo->iDisplayedRect.Height()))