/*
* 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:
*
*/


#ifndef OMXSCRIPTTEST_H_
#define OMXSCRIPTTEST_H_

#include "omxscriptparser.h"
#include "asbreakeventhandler.h"
#include "videotesttimer.h"
#include <e32msgqueue.h>
#include "omxthreadrequest.h"
#include "omx_xml_script.h"
//#include <multimedia/mmfbuffershared.h>
#include <openmax/il/khronos/v1_x/OMX_IVCommon.h>
#include <openmax/il/khronos/v1_x/OMX_Types.h>
#include "portbufferhandler.h"

class CNonTunneledHandler;
class CVideoBufferHandler;
class CVideoBufferSinkHandler;
class CBaseProfileHandler;
class CWindowManager;

const OMX_VERSIONTYPE KOmxVersion = { OMX_VERSION_MAJOR, OMX_VERSION_MINOR, OMX_VERSION_REVISION, OMX_VERSION_STEP };

/**
 * Class to parse and execute an OMX test case specified in
 * an XML file.
 */
NONSHARABLE_CLASS(ROmxScriptTest) : public MOmxScriptIf, public MASBreakCallback, public MTimerObserver
	{
public:
    
    NONSHARABLE_CLASS(CComponentInfo) : public CBase
        {
    public:
        static CComponentInfo* NewL(ROmxScriptTest& aTestController);
        ~CComponentInfo();
    
    private:
        CComponentInfo(ROmxScriptTest& aTestController);
        void ConstructL();
        
    public:
        HBufC8* iShortName;
        HBufC8* iComponentName;
        OMX_COMPONENTTYPE* iComponent;
        CBaseProfileHandler* iBaseHandler;    //NULL if not being used via OMX IL Base Profile
        COmxThreadRequest* iThreadRequest;
        
    private:
        ROmxScriptTest& iTestController;        
        };
        
    class TExpectedEvent
        {
    public:
        OMX_COMPONENTTYPE* iComponent;
        OMX_EVENTTYPE iEvent;
        TUint32 iData1;
        TUint32 iData2;
        TAny* iEventData;
        };
    typedef void (*THashFilter)(RBuf8&);
    THashFilter GetHashFilterByName(const TDesC8& aName);
    
	ROmxScriptTest(MOmxScriptTestLogger& aLogger);
	void Close();
	
	void RunTestL(const TDesC& aScriptFilename, const TDesC& aScriptSection);
	
	// MOmxScriptIf
	TBool MosLoadComponentL(const TDesC8& aComp, const TDesC8& aName, TBool aBaseProfile, const TDesC8* aBaseImpl, TBool aLoadInCoreServerThread);
	TBool MosSetupTunnel(const TDesC8& aSourceComp, TInt aSourcePort,
			             const TDesC8& aSinkComp, TInt aSinkPort, OMX_ERRORTYPE aExpectedError);
	TBool MosSetupNonTunnel(const TDesC8& aSourceComp, TInt aSourcePort,
                          const TDesC8& aSinkComp, TInt aSinkPort,
                          OMX_BUFFERSUPPLIERTYPE aSupplier);
	TBool MosSetWindowL(const TDesC8& aComp);
	TBool MosSetDroppedFrameEvent(const TDesC8& aComp, const TDesC8& aAction);
	TBool MosAllTransitionL(OMX_STATETYPE aState,OMX_ERRORTYPE aExpectedError, TTransitionOrder aOrder);
	TBool MosWaitEOS();
	TBool MosWaitEOS(const TDesC8& aComp);
	TBool MosSetFilename(const TDesC8& aComp, const TDesC& aFilename);

	TBool MosSetFilename_bellagio(const TDesC8& aComp, char *filepath);
	
	TBool MosSetBadFilename(const TDesC8& aComp);
	TBool MosGetFilename(const TDesC8& aComp, TDesC& aFilename, OMX_ERRORTYPE aExpectedError);

	TBool MosSetBufferCount(const TDesC8& aComp, TInt aPortIndex, TInt aCount, OMX_ERRORTYPE aExpectedError);
	TBool MosCompareFilesL(const TDesC& aFileOne, const TDesC& aFileTwo);
    TBool MosFilterAndCompareFilesL(
            const TDesC& aFileOne, const TDesC8& aFile1Filter1, const TDesC8& aFile1Filter2, const TDesC8& aFile1Filter3,
            const TDesC& aFileTwo, const TDesC8& aFile2Filter1, const TDesC8& aFile2Filter2, const TDesC8& aFile2Filter3);
	TBool MosBufferSupplierOverrideL(const TDesC8& aSourceComp, TInt aSourcePort,
				                     const TDesC8& aSinkComp, TInt aSinkPort,
				                     OMX_BUFFERSUPPLIERTYPE aSupplier, 
				                     OMX_ERRORTYPE aExpectedSourceError, OMX_ERRORTYPE aExpectedSinkError);
	TBool MosSetVideoPortDefL(const TDesC8& aComp, TInt aPortIndex, TInt aWidth, TInt aHeight, OMX_COLOR_FORMATTYPE* aColorFormat, OMX_VIDEO_CODINGTYPE* aCodingType, TInt aStride, TReal aFps, OMX_ERRORTYPE aExpectedError);
	TBool MosSetCameraOneShotL(const TDesC8& aComp, TInt aIsOneShot, OMX_ERRORTYPE aExpectedError);
	TBool MosSetCameraCaptureL(const TDesC8& aComp, TInt aPortIndex, TInt aIsCapturing, OMX_ERRORTYPE aExpectedError);
	void MosParseError(const TDesC& aError);
	TBool MosWaitL(TTimeIntervalMicroSeconds32 aDelay);
	TBool MosExpectEventL(const TDesC8& aComp, OMX_EVENTTYPE aEvent, TUint32 nData1, TUint32 nData2);
	TBool MosWaitForAllEventsL();
	TBool MosTransition(const TDesC8& aComp, OMX_STATETYPE aState, TBool aAsync);
	TBool MosFailingTransition(const TDesC8& aComp, OMX_STATETYPE aState,OMX_ERRORTYPE aExpectedError);
	TBool MosCheckStateL(const TDesC8& aComp, OMX_STATETYPE aState);	
	TBool MosCheckVideoPortDefL(const TDesC8& aComp, TInt aPortIndex, TInt aWidth, TInt aHeight, OMX_VIDEO_CODINGTYPE aCoding, OMX_COLOR_FORMATTYPE aColorFormat);
	TBool MosCheckMetaDataL(const TDesC8& aComp, TInt aPortIndex, OMX_METADATASCOPETYPE aScope, const TDesC8& aAtomType, TUint32 aAtomIndex, const TDesC8& aData);
	TBool MosGetParameterUnknownIndexTypeL(const TDesC8& aComp, TInt aPortIndex, OMX_METADATASCOPETYPE aScope, const TDesC8& aAtomType, TUint32 aAtomIndex, const TDesC8& aData);
	TBool MosSetParameterUnknownIndexTypeL(const TDesC8& aComp, TInt aPortIndex, OMX_METADATASCOPETYPE aScope, const TDesC8& aAtomType, TUint32 aAtomIndex, const TDesC8& aData);

	TBool MosDisablePort(const TDesC8& aComp, TInt aPortIndex);
	TBool MosEnablePort(const TDesC8& aComp, TInt aPortIndex);
	TBool MosIgnoreEventL(const TDesC8& aComp, OMX_EVENTTYPE aEvent, TUint32 nData1, TUint32 nData2);
	TBool MosSetPcmAudioPortDefL(const TDesC8& aComp, TInt aPortIndex, TInt aNumChannels, TInt aSamplingRate, TInt aBitsperSample, OMX_NUMERICALDATATYPE aNumData, OMX_ENDIANTYPE aEndian, OMX_BOOL* aInterleaved, const TDesC8* aEncoding);
	TBool MosSetConfigAudioVolumeL(const TDesC8& aComp, TInt aPortIndex, TBool aLinear, TInt aMinVolume, TInt aMaxVolume, TInt aVolume, OMX_ERRORTYPE aExpectedError);
	TBool MosCheckConfigAudioVolumeL(const TDesC8& aComp, TInt aPortIndex, TBool aLinear, TInt aMinVolume, TInt aMaxVolume, TInt aVolume);
	TBool MosCheckConfigAudioMuteL(const TDesC8& aComp, TInt aPortIndex, TBool aMute);
	TBool MosSetConfigAudioMuteL(const TDesC8& aComp, TInt aPortIndex, TBool aMute);
	TBool MosSetAacAudioPortDefL(const TDesC8& aComp, TInt aPortIndex, TInt aNumChannels, TInt aSamplingRate, TInt aBitRate, TInt aAudioBandwidth, TInt aFrameLength, TInt aAacTools, TInt aAacErTools, TInt aProfile, TInt aStreamFormat, TInt aChannelMode);
	TBool MosSetAudioPortDefL(const TDesC8& aComp, TInt aPortIndex, OMX_AUDIO_CODINGTYPE* aCodingType, OMX_ERRORTYPE aExpectedError);
	TBool MosSetRefClockTypeL(const TDesC8& aComp, OMX_TIME_REFCLOCKTYPE aRefClockType);
	TBool MosSetClockTimeScale(const TDesC8& aComp, OMX_S32 aScale);
	TBool MosSetClockStateL(const TDesC8& aComp, OMX_TIME_CLOCKSTATE aClockState, TInt aStartTime, TInt aOffset, TUint32 aWaitMask);
	TBool MosCheckClockStateL(const TDesC8& aComp, OMX_TIME_CLOCKSTATE aClockState);
	TBool MosCheckTimePositionL(const TDesC8& aComp, TInt aPortIndex, TInt aTimestamp);
	TBool MosSetTimePositionL(const TDesC8& aComp, TInt aPortIndex, TInt aTimestamp);
	TBool MosSetClientStartTimeL(const TDesC8& aComp, TInt aPortIndex, TInt aTimestamp);
	TBool MosSetCurrentAudioReferenceTimeL(const TDesC8& aComp, TInt aPortIndex, TInt aTimestamp);
	TBool MosSetVideoFitModeL(TVideoFitMode aVideoFitMode);
	TBool MosNegativeSetDataChunk(const TDesC8& aComp, OMX_ERRORTYPE aExpectedError, TInt aExpectedSystemError);
	TBool MosCheckFrameCountL(const TDesC& aFilename, TInt aCount);
    TBool InitialiseBufferHandlerL(const TDesC8& aComp, TDesC& aName, const TDesC8* aType);
	void StartBufferHandler();
	void StopBufferHandler();
	void SendInvalidBufferId(TInt aInvalidId);
	TBool InitialiseBufferSinkHandlerL(const TDesC8& aComp, TDesC& aName);
    void StartBufferSinkHandler();
    void StopBufferSinkHandler();

	TBool MosSetBufferSize(const TDesC8& aComp, TInt aPortIndex, TInt aCount, OMX_ERRORTYPE aExpectedError);
	TBool MosGetAndCompareBufferCount(const TDesC8& aComp, TInt aPortIndex, TInt aDataToCompare);
	TBool MosGetAndCompareBufferSize(const TDesC8& aComp, TInt aPortIndex, TInt aDataToCompare);
	TBool MosFlushBuffer(const TDesC8& aComp, TInt aPortIndex, OMX_ERRORTYPE aExpectedError);
	TBool MosForceFlushBuffer(const TDesC8& aComp, TInt aPortIndex, OMX_ERRORTYPE aExpectedError);
	TBool MosSetActiveStream(const TDesC8& aComp, TUint32 aPortIndex);
	TBool MosGetActiveStream(const TDesC8& aComp, TUint32 aPortIndex);
	TBool MosChangeFilledBufferLength(const TDesC8& aComp, TInt aValue);
	TBool MosSetOMX_SymbianIndexParamBufferMsgQueueData(const TDesC8& aComp, OMX_ERRORTYPE aExpectedError);
	TBool MosGetExtensionIndex(const TDesC8& aComp, const TDesC8& aParameterName, OMX_ERRORTYPE aExpectedError);

	TBool MosCheckTimeClockState(const TDesC8& aComp, OMX_TIME_CLOCKSTATE aExpectedState);
	TBool MosCheckMediaTime(const TDesC8& aComp, TInt aPortIndex, OMX_TICKS aMediaTime, TBool aMoreThan);
	TBool MosBaseSupportPortL(const TDesC8& aComp, TInt aPortIndex);
	TBool MosBaseSetAutonomous(const TDesC8& aComp, TInt aPortIndex, TBool aEnabled);
	TBool MosBaseAllocateBuffersL(const TDesC8& aComp, TInt aPortIndex, TInt aNumberBuffers);
	TBool MosBaseFreeAllocatedBuffersL(const TDesC8& aComp);
	TBool MosBaseSetBufSupplier(const TDesC8& aComp, TInt aPortIndex, TBool aComponentSupplier);
	TBool MosBaseFillThisBuffer(const TDesC8& aComp, TInt aPortIndex, TInt aPortRelBufIndex);
    TBool MosBaseEmptyThisBuffer(const TDesC8& aComp, TInt aPortIndex, TInt aPortRelBufIndex);
    TBool MosBaseWaitForBuffer(const TDesC8& aComp, TInt aPortIndex, TInt aPortRelBufIndex);
    TBool MosBaseTimestampPassClock(const TDesC8& aCompReceiving, const TDesC8& aClockCompToPass);
	TBool MosBaseTimestampCheckTimestampL(const TDesC8& aComp, TInt aPortIndex, TUint aExpectedTime, TUint aTolerance);
	TBool MosBaseTimestampCompareWithRefClockL(const TDesC8& aComp, TInt aPortIndex, TUint aTolerance);
	TBool MosMarkBuffer(const TDesC8& aComp, TInt aPortIndex, const TDesC8& aTargetComp, TInt markData);
	
	// mpeg4 encoder component
	TBool MosSetVideoEncQuantL(const TDesC8& aComp, TInt aPortIndex, TInt aQpb);
    TBool MosSetVideoEncMotionVectL(const TDesC8& aComp, TInt aPortIndex, TInt aAccuracy, TInt aSxSearchrange, TInt aSySearchrange, OMX_ERRORTYPE aExpectedError);
    TBool MosSetVideoEncMpeg4TypeL(const TDesC8& aComp, TInt aPortIndex, OMX_VIDEO_MPEG4PROFILETYPE aMpeg4Profile, OMX_VIDEO_MPEG4LEVELTYPE aMpeg4Level, OMX_ERRORTYPE aExpectedError);
	TBool MosSetVideoEncBitRateL(const TDesC8& aComp, TInt aPortIndex, OMX_VIDEO_CONTROLRATETYPE aControlRate, TInt aTargetBitrate, OMX_ERRORTYPE aExpectedError);
	
	TBool MosSetAACProfileL(const TDesC8& aComp, TInt aPortIndex, TInt aChannels, TInt aSamplingRate, TInt aBitRate, TInt aAudioBandwidth, TInt aFrameLength, TInt aAACTools, TInt aAACERTools, OMX_AUDIO_AACPROFILETYPE aProfile, OMX_AUDIO_AACSTREAMFORMATTYPE aStreamFormat, OMX_AUDIO_CHANNELMODETYPE aChannelMode);
	
	// Camera
	
	TBool MosSetSensorModeTypeL(const TDesC8& aComp, TInt aPort, TInt aFrameRate, TBool aOneShot, TInt aWidth, TInt aHeight);
	TBool MosSetCaptureModeTypeL(const TDesC8& aComp, TInt aPort, TBool aContinuous, TBool aFrameLimited, TInt aFrameLimit);


	// Debugging/Utility functions.
	TBool MosDeleteFileL(const TDesC& aFileName, TBool aFileMustExist);
	TBool MosLogAllEventsL();

	// MASBreakCallback
	void AllComponentsEOS();
	void AllComponentsTransitioned(OMX_STATETYPE aNewState,
				                   OMX_STATETYPE aOldState);
	void EventReceived(OMX_COMPONENTTYPE* aComponent, OMX_EVENTTYPE aEvent, TUint32 aData1, TUint32 aData2, TAny* aEventData);
	void ComponentTransitioned(OMX_STATETYPE aNewState,
				                   OMX_STATETYPE aOldState);
	void BufferDone(OMX_COMPONENTTYPE* aComponent, OMX_BUFFERHEADERTYPE* aBufHdr, TBool aSource);
				                   
	// MTimerObserver
	void TimerExpired();
	
	TBool MosSetupBufferForPortL(const TDesC8& comp,TInt aPortIndex, const TDesC& aFileName,TInt aHeaderLength,OMX_BUFFERSUPPLIERTYPE aSupplier);
	TBool MosStartBuffersforPort(const TDesC8& aComp, TInt aPortIndex);
#ifdef OLD_ADPCM_EXTENSION
	TBool MosSetAdPcmAudioPortDefL(const TDesC8& aComp, TInt aPortIndex, TInt aNumChannels, TInt aSamplingRate, TInt aBitsperSample);
    TBool MosConfigAdPcmDecoderBlockAlign(const TDesC8& aComp, OMX_S32 aBlockAlign);  
#endif
	
public:
	enum TOmxScriptTestVerdict
		{
		EPass, EFail, EPending
		};

	TInt Reason() const;
	TOmxScriptTestVerdict Verdict() const;
    void FailWithOmxError(const TDesC& aOperation, OMX_ERRORTYPE aError);   
    void StopTest(TOmxScriptTestVerdict aVerdict);
    void StopTest(TInt aError, TOmxScriptTestVerdict aVerdict);
    void FailTest(const TDesC& aErrorMsg);   

	TBool MosForceBufferSourceFlushBufferL(const TDesC8& aComp, TInt aPortIndex, OMX_ERRORTYPE aExpectedError);
	TBool MosForceBufferSinkFlushBuffer(const TDesC8& aComp, TInt aPortIndex, OMX_ERRORTYPE aExpectedError);

    static TBool ShortNameMatchComparison(const TDesC8* aShortName, const ROmxScriptTest::CComponentInfo& aComponentInfo);
    
    void BeginWait();
    void EndWait();
		
private:
    TBool ComponentLogicalIL(const TDesC8& aName);
    TBool ComponentPhysicalIL(const TDesC8& aName);
	OMX_COMPONENTTYPE* ComponentByName(const TDesC8& aName);
	void GetComponentName(const OMX_COMPONENTTYPE* aHandle, TDes& aName);
	void FailWithOmxError(const TDesC8& aComponent, const TDesC& aOperation, OMX_ERRORTYPE aError);
	// static void CleanupOmxComponent(TAny*);	
	static void FormatHex(const TDesC8& bin, TDes& hex);
	void WriteInt32(TUint8* aPtr, TInt32 aData);
	void HashFileL(const TDesC& aFileName, TDes8& aHash, void (*aFilter1)(RBuf8&) = NULL, void (*aFilter2)(RBuf8&) = NULL, void (*aFilter3)(RBuf8&) = NULL );	
	TBool HandleNonTunneledBuffers(OMX_STATETYPE aNewState, OMX_COMPONENTTYPE* aComp);
	TBool HandlePortBufferHandler(OMX_STATETYPE aNewState, OMX_COMPONENTTYPE* aComp);

	void LogExtra(const TText8* aFile, TInt aLine, TOmxScriptSeverity aSeverity,
			TRefByValue<const TDesC16> aFmt,...);
	void RegisterTunnel(OMX_COMPONENTTYPE* aSourceComp, TInt aSourcePort, OMX_COMPONENTTYPE* aSinkComp, TInt aSinkPort);
	
	class TComponentInfo
		{
	public:
		HBufC8* iShortName;
		HBufC8* iComponentName;
		OMX_COMPONENTTYPE* iComponent;
		};
class TFilledBufferHeaderV2
	{
public:
	/** Amount of buffer filled with actual data */
	TUint iFilledLength; 
	/** Any timestamp associated with the buffer */
	TInt64 iTimeStamp;
	/** Combination of OMX_BUFFERFLAG_*, specified at page 68 in the OpenMAX spec. */
	TUint iFlags; 
	/** offset **/
	TUint32 iOffset;
	};
	class TTunnelInfo
		{
	public:
		OMX_COMPONENTTYPE* iSourceComponent;
		TInt iSourcePort;
		OMX_COMPONENTTYPE* iSinkComponent;
		TInt iSinkPort;
		};
	
	RArray<TTunnelInfo> iTunnels;
	typedef RArray<TTunnelInfo> RTunnelRelations;
	void FindTransitionOrderL(const RPointerArray<CComponentInfo>& aComponents,
								  const RTunnelRelations& aTunnelRelations,
								  RArray<TInt>& aOrder);

private:
	TBool iCoreLoaded;
	RPointerArray<CComponentInfo> iComponents;
	RASBreakEventHandler iEventHandler;
	OMX_STATETYPE iState;
	
	// Symbian graphic sink specialisation
	CWindowManager* iWindowManager;
	TVideoFitMode iVideoFitMode;
	OMX_INDEXTYPE iExtSurfaceConfigIndex;
	OMX_COMPONENTTYPE* iGraphicSink;
	
	CVideoTestTimer			*iTimer;
	
	RArray<TExpectedEvent> iExpectedEvents;
	TBool iWaitingForEvents;
	
	CNonTunneledHandler* iNonTunneledHandler;
	RArray<TExpectedEvent> iIgnoredEvents;

    // Buffer component handler
	CVideoBufferHandler* iBufferHandler;
	CVideoBufferSinkHandler* iBufferSinkHandler;
	
	TInt iReason;
	TOmxScriptTestVerdict iVerdict;
	MOmxScriptTestLogger& iLogger;
	
	CAsyncCallBack* iStopSchedulerCallback;
		
 	RMsgQueue<TFilledBufferHeaderV2> iMsgQueue;
	CPortBufferHandler* iPortBufferHandler;
	};

#endif /*OMXSCRIPTTEST_H_*/