/*

* Copyright (c) 2004 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 __H264DecTestEngine_H

#define __H264DecTestEngine_H

#include <e32base.h>

#include <e32std.h>

#include <f32file.h>

#include "T_DevVideoConstants.h"

#include <Videoplayhwdevice.h>

#include <Devvideoplay.h>

#include <Devvideobase.h> 

//#define __CI_HEADERS__

//#define __SECUREOUTPUTCI__

#ifdef __CI_HEADERS__

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

#endif

#ifdef __SECUREOUTPUTCI__

#include <secureoutputci.h>

#endif

#include <Bitdev.h>   // for display device 

#include <Fbs.h>      // for display device

#include <math.h> //pow

#ifdef __RESOURCENOTIFICATION__

#include <devvideostandardcustominterfaces.h>

#endif

//////////////////

// Utility function

//////////////////

// MACROS

// DATA TYPES

// FORWARD DECLARATIONS

// CLASS DECLARATION

const TUint KMaxNumberOfNals = 100;

//const TUint KDataChunkSize = 500000;

//#ifdef _DEBUG

#define DEBUGPRINT

//#endif

// Debug print macro

#ifdef DEBUGPRINT

#include <e32svr.h>

#define PRINT(x) RDebug::Print x;

#else

#define PRINT(x)

#endif

// ENumerations

enum TEngineState

     {

     EStateNone,

     ECreated,

     EInitialized,

     ERunning,	

     EPaused,	

     EStopped,	

     };

enum TYuvDataOptions

     {

     EYuv420Planner,

     EYuv422Interleaved

     };

enum THWDevice 

	{

	EPostProcessor,

	EDecoder

	};

enum TFLVFileType

	{

	EFLVNotSet,

	EFLVContainer,

	EFLVRaw

	};

// CLASS DECLARATION

class CVDecTestAO;

class CVDecTestEngine;

class MVDecEngineObserver;

/**

*  Video Decoder Test Engine Observer

*  

*  @lib 

*  @since 

*/

class MVDecEngineObserver

{

public:

	virtual void MvdeStreamEndReached() = 0;

	virtual void MvdeSetError(TInt aError) = 0;

};

/**

*  Video Decoder Test Engine 

*  implements common test execution block

*  @lib 

*  @since 

*/

class CVDecTestEngine : public CBase , public MMMFDevVideoPlayObserver 

#ifdef __CI_HEADERS__

,public MMmfVideoBufferManagementObserver

#endif

#ifdef __RESOURCENOTIFICATION__

,public MMmfVideoResourceObserver

#endif

    {

public:

     TEngineState iState;

public:

    CVDecTestEngine () { }

    ~CVDecTestEngine ();

    static CVDecTestEngine* NewL(MVDecEngineObserver& aTestClass);

    //info test method

    void SetCodecType(TVideoCodec aCodec);

    //void GetDecoderInfoL(const TDesC8& aMimeType, TBool aExactMatch);

    //void GetPostProcessorInfoL(TInt aCombination);

    void GetHeaderInformationL();

	void GetHeaderInformationL(TVideoDataUnitType aDataUnitType, TVideoDataUnitEncapsulation aDataUnitEncapsulation);

    //void GetHeaderInfoL(const TUid& aDecUid, TVideoDataUnitType aDataUnitType, TVideoDataUnitEncapsulation aDataUnitEncapsulation);

	void GetBitstreamCountersL();

	void PreDecoderBufferBytes();	

    void PictureBufferBytes();

    // Video test control methods

    //void SetUpL(TBool aScreenAcces);

    void SetUpL(TSize aSize, TBool aScreenAccess, TBool aCIBuffMgmt);

    void CreateDecoderL(const TUid& aDecUid, TVideoCodec aCodec, const TDesC8& aMimeType, TYuvDataOptions aOutFormat);

    void CreatePostProcessorL(const TUid& aPostprocUid, const TYuvFormat& aInputFormat, const TUncompressedVideoFormat& aOutputFormat, TUint32 aCombination);

    void CreateDecPostprocL(const TUid& aDecUid, TVideoCodec aCodec, const TUid& aPostprocUid, TUint32 aCombination);

    TInt Initialize();

    TInt InitializeAndDelete();

    TInt Start(TBool aInputEnd);

    TInt Stop();

    TInt Resume();

    TInt Pause();

    void FreezePicture(TTimeIntervalMicroSeconds aTimeStamp);

    void ReleaseFreeze(TTimeIntervalMicroSeconds aTimeStamp);

    void TearDown();    

    void SetFrameMatch(TBool aMatch);

    TInt FrameJump(TInt aNumToJump );

    void SetFrameDrop(TInt aFrameInterval, TInt aFrameNum, TBool aFrameDropMarker );

    void SetFLVPassword(TDesC8& aPassword); 

    void EnableInstantFpsL(TFileName& aOutFileName);

    // Select and set Postprocessing  

    void SetPostProcessTypesL(TInt aHWDevice, TUint32 aCombination);

    void SetInputCropOptionsL(TInt aHWDevice, TRect aCrop);

    void SetYuvToRgbOptionsL(TInt aHWDevice, TYuvToRgbOptions aOptions);

    void SetRotateOptionsL(TInt aHWDevice, TRotationType aRotation);

    void SetScaleOptionsL(TInt aHWDevice, TSize aSize, TBool aAntiAliasFiltering);

    void SetScaleOptionsL(TInt aNumFactor,TInt aDenoFactor, TBool aAntiAliasFiltering);

    void SetOutputCropOptionsL(TInt aHWDevice, TRect aCrop);

    void CommitL();

    void Revert();    

    void SetClockSource();

    void SetInputBufferSize(TInt aSize);

    void SetHrdVbvSpec(THrdVbvSpecification aHrdVbvSpec, const TDesC8& aHrdVbvParams);

    void SetPostProcSpecificOptionsL(TInt aHWDevice, const TDesC8& aOptions);

    void SetScreenClipRegion(TRegion& aRegion);

    void SetPauseOnClipFail(TBool aPause);    

    void IsPlaying();

    void GetPictureCounters();

    void NumFreeBuffers();

    void NumComplexityLevels(TInt aHWDevice);

    void InputEnd();

    void GetNewPictureInfo(TTimeIntervalMicroSeconds& aEarliestTimestamp, 

						   TTimeIntervalMicroSeconds& aLatestTimestamp);

    void GetTimedSnapshotL(const TUncompressedVideoFormat& aFormat, 

							const TTimeIntervalMicroSeconds& aPresentationTimestamp); 

	void GetTimedSnapshotL(const TUncompressedVideoFormat& aFormat, const TPictureId& aPictureId);						

    void CancelTimedSnapshot();

    void GetSupportedSnapshotFormatsL();

    // Complexity level

    void SetComplexityLevel(TInt aHWDevice, TInt aLevel);

    void GetComplexityLevelInfo(TInt aHWDevice, TInt aLevel);

    //DSA

    void StartDirectScreenAccessL();

    void StartDirectScreenAccessL(TRect aVideoRect, TRect aClipRegion);

    void AbortDirectScreenAccess();    

    void Redraw();

    void SetWindowRect(TInt aX, TInt aY, TSize aSize);

    void SetSecondScreenAccess(TBool aStatus);

    // snap shot methods

    void GetSnapshotL(TUncompressedVideoFormat& aFormat);

    void EnableSynchronization(TInt aFrameRate);

    void EnableFrameMeasurementTest(TBool aEnable);

    void SetSecureOutputL(TBool aSecure);

    void SetPosition(const TTimeIntervalMicroSeconds& aPlaybackPosition);

    void ResetPosition();

    TTimeIntervalMicroSeconds PlaybackPosition();

    void DecodingPosition();

    void ListFrameSizeL(RArray<TInt> aFramesizes);

    TInt GetFrameSizeCount();

    //void GetPictureCounter();

    void SetLandscapeMode();

    void SelectDecoderL(const TUid& aUid);

    void SelectPostProcessorL(const TUid& aUid);

    void SetInputFormatL(TInt aHwDev, const TUncompressedVideoFormat& aFormat);

    void SetInputFormatL(TInt aHwDev, const CCompressedVideoFormat& aFormat, 

						 TVideoDataUnitType aDataUnitType, TVideoDataUnitEncapsulation aEncapsulation,

						 TBool aDataInOrder);

	void SetOutputFormatL(TInt aHwDev, const TUncompressedVideoFormat& aFormat);						 

    void SetBufferOptionsL(const CMMFDevVideoPlay::TBufferOptions& aOptions);

    void GetBufferOptions();

    void SynchronizeDecoding(TBool aSynch);

    void SetVideoDestScreenL(TBool aDest);

    void SetYuvToRgbOptionsL(TInt aHWDevice, const TYuvToRgbOptions& aOptions, const TYuvFormat& aYuvFormat, TRgbFormat aRgbFormat);

    void FindCommonFormatsL();

    TInt FindDecodersL(const TDesC8& aMimeType, TUint32 aPostProcType, TBool aExactMatch, TUid& aUid);

    TInt FindPostProcessorsL(TUid& aUid, TUint32 aPostProcType);

    void GetDecoderListL();

    void ConfigureDecoderL(TVideoPictureHeader& aVideoPictureHeader);

    void ConfigureDecoderL();

    void GetOutputFormatListL(TInt aHWDevice);

    void GetPostProcessorListL();

    void VideoDecoderInfoL(TUid aVideoDecoder);

    void PostProcessorInfoL(TUid aPostProcessor);

    TReal ConvertToRealL(const TDesC& aPtr);

    //File operations

    void OpenFileL(TFileName& aInFileName);

    void OpenFileL(TFileName& aOutFileName, TFileName& aInFileName);

    void CloseFile();

    void CorruptInput(TInt aFilter, TInt aInterval, TInt aFrameNum, TInt aPct);

    void CorruptEngineL();

    void CorruptEngineL( TVideoInputBuffer* aCodedInBuffer ); 

    TInt CreateCorruptedFileL(); 

    void OpenFileToWriteL(TFileName& aInFileName);

    TInt ReadVC1FrameL(TVideoInputBuffer* aCodedInBuffer);

    TInt ReadMPEG4FrameL(TVideoInputBuffer* aCodedInBuffer); 

    TInt SupportsFormatL(const TUid& aUid, const CCompressedVideoFormat& aFormat);

	TInt SupportsFormatInfoL(const TUid& aUid, const CCompressedVideoFormat& aFormat);		

	TInt SupportsAccelerationL(TInt aHwDev, const TUid& aUid);		

	TInt SupportsDirectDisplayL(TInt aHwDev, const TUid& aUid);		

	TInt SupportsMaxBitrateL(const TUid& aUid, TInt aBitrate);		

	TInt SupportsMaxPictureSizeL(const TUid& aUid, TSize aSize);		

	TInt SupportsMaxPictureRateL(const TUid& aUid, TPictureRateAndSize& aRateAndSize);			

	TInt SupportsPictureLossL(const TUid& aUid);		

	TInt SupportsSliceLossL(const TUid& aUid);

 	TInt SupportsOutputFormatL(TInt aHwdev, const TUncompressedVideoFormat& aFormat);

 	void SetSlowClient(TBool aOption);

 	void SetFastClient(TBool aOption);

 	TInt SetAUFormat();

 	TInt MoveFileL(const TDesC &anOld, const TDesC &aNew);

 	TInt CopyFileL(const TDesC &anOld, const TDesC &aNew); 	

    // For Active objects

    void HandleNewBufferL();

    // From DevVideo Play observer 

    void MdvpoNewBuffers();

    void MdvpoReturnPicture(TVideoPicture* aPicture);

    void MdvpoSupplementalInformation(const TDesC8& aData, const TTimeIntervalMicroSeconds& aTimestamp, const TPictureId& aPictureId);

    void MdvpoPictureLoss();

    void MdvpoPictureLoss(const TArray<TPictureId>& aPictures);

    void MdvpoSliceLoss(TUint aFirstMacroblock, TUint aNumMacroblocks, const TPictureId& aPicture);

    void MdvpoReferencePictureSelection(const TDesC8& aSelectionData);

    void MdvpoTimedSnapshotComplete(TInt aError, TPictureData* aPictureData, const TTimeIntervalMicroSeconds& aPresentationTimestamp, const TPictureId& aPictureId);

    void MdvpoNewPictures();

    void MdvpoFatalError(TInt aError);

    void MdvpoInitComplete(TInt aError);

    void MdvpoStreamEnd();

    // Buffer Management Custom Interface observer 

#ifdef __CI_HEADERS__    

    void MmvbmoNewBuffers();

    void MmvbmoReleaseBuffers();

#endif

#ifdef __RESOURCENOTIFICATION__

	void MmvroResourcesLost(TUid aMediaDevice);

    void MmvroResourcesRestored(TUid aMediaDevice);

#endif

protected:

    // Own test functions

    void GetInputBufferL();

    void FillAndSendBufferL();

    void GetReturnedPictureL();

    void SaveAndReturnPicture();

    TInt ReadOneCodedPicture(TVideoInputBuffer* aCodedInBuffer);

    TInt ReadOneCodedPicture(TVideoInputBuffer* aCodedInBuffer, TInt aSize);

    TInt ReadRawPicture();

private:

	TUint8 ReadByteFromFile();

	void GoBackInFile(TUint aBytes);

	void ReadDataToBuffer(TVideoInputBuffer* aCodedInBuffer, TInt aSize, TBool aDiscard = EFalse);

	TBool CheckAndFillDataChunk();

	TBool ReadItemLE(unsigned char *readBuffer, int Size, unsigned char* pItem);

	TInt LoadNextFrameL(TVideoInputBuffer* aCodedInBuffer);

    void ConstructL(MVDecEngineObserver& aTestClass);

    void AssertTIntEqualL(TInt aExpected, TInt aActual);

    void PrintUncompressedFormat(const TUncompressedVideoFormat& aFormat);

private:

    CMMFDevVideoPlay* iDevvp;			  //points to DevVideo Play

    THwDeviceId iDecHWDevId;              //Hwdevise ID of selected Decoder

    THwDeviceId iPostProcId;              //Hwdevise ID of selected postprocessor

    TUid iPostProcessorUid;

    TUid iDecoderUid;

    CVDecTestAO* iDecTestAO;              

    TBool iRunning;                       //State of scheduler

    TYuvFormat iRawFormat;                //Used for Decoder output, postprocessor input 

    TRgbFormat iDispFormat;               // Display Options

    TRect iDispRect;                        

    TInt iError;

    TVideoInputBuffer* iCodedInBuffer;     // Pointer to Decoder input buffer

    TVideoInputBuffer* iCorruptedInBuffer;   //Pointer to corrupted input for decoder

    TInt iInBuffSize;                 // Size of decoder input buffer

    TVideoPicture* iOutBuffer;             // Pointer to picuture class for output data in memory buffer output 

    TVideoPicture* iOutBufferTemp;             // Pointer to picuture class for output data in memory buffer output 

    TVideoPicture* iRawInBuffer;            // Used for postprocessor input

    HBufC8* iRawDataArea;                  // Pointer to Heap buffer, filled with input data to postprocessor

    TInt64 iTimeStamp; 

    TInt64 iFrameTimeInterval;              

    TInt iSentBuffCount;                    //Number of frames sent to target HwDevice    

    TInt iReturnedBuffCount;                //Number of frames returned from target HwDevice

    TInt iPictureLoss;                      // number of picture loss

    TBool iInputEnd;

    TBool iStreamEnd; 

    TVideoCodec iCodecType;                

    TSize iPictureSize; 

    CSystemClockSource* iClock;            //Clock source, based on System clock

    TBool iSynchronized;

    TBool iDirectScreenAccess;

    TBool iCIBuffMgmtOn;

    TBool iDisableInputEnd;

    TBool iFrameMatch;              // input frame number should match output frame number

    TInt  iFrameJump;

    TInt  iFrameJumpCounter;

    TInt iFrameWriteLength;

    TInt iCurrentFilePos;

#ifdef __CI_HEADERS__     	   

    MMmfVideoBufferManagement* iCIBuffMgmt;  

#endif    

    MVDecEngineObserver* iTestClass;

    TBool iFrameMeasurement;

    TBool iDsaStarted;

    TBool iLandscapeMode;

    TInt iNoBuffAvailable;

    RArray<TInt> iFrameSizeList;

    TPictureData iPictureDataSnapshot;

    TBuf8<128> iInFileName;

    TBool iSetSlowClient;

    TBool iSetFastClient;

    TBool iSetAUFormat;

    TBool iOutFileOpen;

    TUint8* iAUBuffer;

    TUint32* iNalOffsetArray;

    TUint32* iNalLengthArray;

    TReal32 iFrameTime;

    TUint8* iDataChunk;

    TUint8* iReadDataChunk;

    TUint8* iWriteDataChunk;

    TUint iDataReadFromFile;

    TUint iDataThreshold;

    TBool iEndOfData;

    TBool iLastFrame;

    TBool iUseSecondScreen;

    //File IO

    RFs   iFs;

    RFile iInFile;                         // Input data file

    RFile iOutFile;                        // Output data file

    RFile iOutCorruptedFile;

    RFile iLogFile;

	TBool iDeleteDecoderFromInitComp;

	TInt iFlvCounter;

	TBool iCorruptMarker;

	TInt iFilter;

	TInt iInterval;

	TInt iFrameNum;

	TInt iPercentage;

	TInt iFrameCounter;

	TInt iCorruptCounter;

	TInt iFrameDropCounter;

	TInt iFrameDropInterval;

	TInt iFrameDropNum;

	TInt iFrameDropNumCounter;

	TBool iFrameDropMarker;

	TFileName iOutFileName;

	TFileName iOutCorruptedFileName;

	TBool iOutCorruptedFileOpen;

	TBuf8<128> iPasswordForFLV;

	TBool iSetPassword;

    TBool iInstantFpsEnabled;

    RArray<TTimeIntervalMicroSeconds> iInstantFpsList;

    RFile iFpsFile;

	// Memory check

	TInt iMemAlloc;

	TInt iMemDelete;

    TInt32 iDataChunkSize;

    //Fbs

    CFbsScreenDevice* iScreenDevice;

    CActiveSchedulerWait* iScheduler;      //Nested scheduler

    TTime							iTime;

	TDateTime						iTimeBeforeDecoding;

	TDateTime						iTimeAfterDecoding;	

	//TInt							iNumFramesDecoded;

	//TUint64							iTotalTime;

	//TBool 							iIsBeforeTimeUsed;

	TUint64							iBeforeDecodingTime;

	RArray<TUint64>					iBeforeDecoingTimesQueue;

    TUint							iFrame;

    //	TInt							iLength;

	//TBool							iFirstTime;

	TBool                           iNumFreeBufsFirstTime;

	TTimeIntervalMicroSeconds		iTimeToPlay;

    TTimeIntervalMicroSeconds		iPresentationTimestamp;

	TBool							iNoOfFreeBuffFlag;

	TInt tempFrame;

	TFLVFileType                    iFLVFileType;

    };

/**

*  Video Decoder Test Engine AO

*  Provides async services

*  @lib 

*  @since 

*/

class CVDecTestAO : public CActive

{

	public:

		CVDecTestAO(CVDecTestEngine* aTestEngine);

  		~CVDecTestAO();

  		void RequestData();

	private:

		void RunL();

  		void DoCancel();

	private:

  		CVDecTestEngine* iTestEngine;

};

#endif