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