// Copyright (c) 2006-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 MDFVIDEODECODEHWDEVICEADAPTER_H

 #define MDFVIDEODECODEHWDEVICEADAPTER_H

 #include <fbs.h>

 #include <mmf/devvideo/videoplayhwdevice.h>

 #include "mdfvideodecodehwdeviceadapter.hrh"

 #include <mmf/server/mmfdatabuffer.h>

 #include <mdf/mdfinputport.h>

 #include <mdf/mdfoutputport.h>

 #include <mdf/mdfprocessingunit.h>

 #include <mdf/mdfpuloader.h>

 #include <mdf/codecapivideoresolverutils.h>

 #include <mmf/devvideo/devvideopuconfig.h>

 #ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

 #include <mmf/devvideo/devvideohwdeviceadaptersetup.h>

 #endif

 // From hwdevicevideoutils.dll

 #include "mdfvideodecoderbuffermanager.h"

 #include "mdfplayerengine.h"

 const TUid KUidDevVideoDecodeHwDevice = {KUidDevVideoDecoderHwDeviceDefine};

 // decoder info

 _LIT(KVideoDecoderInfoManufacturer, "Symbian Ltd.");

 _LIT8(KVideoDecoderInfoCSInfo, "Coded by Symbian");

 _LIT8(KVideoDecoderInfoISInfo, "Implemented by Symbian");

 const TInt KVideoDecoderInfoVersionMaj = 0;

 const TInt KVideoDecoderInfoVersionMin = 1;

 const TInt KVideoDecoderInfoVersionBuild = 1;

 /**

 Video decoder hardware device. 

 This is the DevVideo decoder plugin component

 @internalComponent

 */

 class CMdfVideoDecodeHwDeviceAdapter :	public CMMFVideoDecodeHwDevice,

 				       					public MMdfVideoPlayerHwDeviceObserver,

 				       					public MMdfInputPortObserver,

 				       					public MMdfOutputPortObserver,

 				       					public MMdfProcessingUnitObserver,

 				       					public MDevVideoHwDeviceAdapterSetup		       					

 {

 public:

 	/**

 	The current state of the Hardware Device Adapter.

 	*/

 	enum THwDevAdapterState

 		{

 		/*

 		The PULoader has been loaded.

 		*/

 		EProcessingUnitLoaderLoaded,

 		/*

 		The Processing Units have been loaded.

 		*/

 		EProcessingUnitLoaded,

 		/*

 		The Processing Units are currently being initialised.

 		*/

 		EProcessingUnitInitializing,

 		/*

 		The Processing Units are currently in the idle state.

 		*/

 		EProcessingUnitIdle,

 		/*

 		The Processing Units are currently in the executing state.

 		*/

 		EProcessingUnitExecuting,

 		/*

 		The Processing Units are currently in the paused state.

 		*/

 		EProcessingUnitPaused		

 		};	

 	static CMdfVideoDecodeHwDeviceAdapter* NewL();

 	~CMdfVideoDecodeHwDeviceAdapter();		

 	TBool FrameBufferAvailable() const;

 	// from CMMFVideoHwDevice

     TAny* CustomInterface(TUid aInterface);

 	// from CMMFVideoPlayHwDevice

 	CPostProcessorInfo* PostProcessorInfoLC();

 	void GetOutputFormatListL(RArray<TUncompressedVideoFormat>& aFormats);

 	void SetOutputFormatL(const TUncompressedVideoFormat &aFormat);

 	void SetPostProcessTypesL(TUint32 aPostProcCombination);

 	void SetInputCropOptionsL(const TRect& aRect);

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

 	void SetYuvToRgbOptionsL(const TYuvToRgbOptions& aOptions);

 	void SetRotateOptionsL(TRotationType aRotationType);

 	void SetScaleOptionsL(const TSize& aTargetSize, TBool aAntiAliasFiltering);

 	void SetOutputCropOptionsL(const TRect& aRect);

 	void SetPostProcSpecificOptionsL(const TDesC8& aOptions);

 	void SetClockSource(MMMFClockSource* aClock);

 	void SetVideoDestScreenL(TBool aScreen);

 	void Initialize();

 	void StartDirectScreenAccessL(const TRect& aVideoRect, CFbsScreenDevice& aScreenDevice, const TRegion& aClipRegion);

 	void SetScreenClipRegion(const TRegion& aRegion);

 	void SetPauseOnClipFail(TBool aPause);

 	void AbortDirectScreenAccess();

 	TBool IsPlaying();

 	void Redraw();

 	void Start();

 	void Stop();

 	void Pause();

 	void Resume();

 	void SetPosition(const TTimeIntervalMicroSeconds& aPlaybackPosition);

 	void FreezePicture(const TTimeIntervalMicroSeconds& aTimestamp);

 	void ReleaseFreeze(const TTimeIntervalMicroSeconds& aTimestamp);

 	TTimeIntervalMicroSeconds PlaybackPosition();

 	TUint PictureBufferBytes();

 	void GetPictureCounters(CMMFDevVideoPlay::TPictureCounters& aCounters);

 	void SetComplexityLevel(TUint aLevel);

 	TUint NumComplexityLevels();

 	void GetComplexityLevelInfo(TUint aLevel, CMMFDevVideoPlay::TComplexityLevelInfo& aInfo);

 	void ReturnPicture(TVideoPicture* aPicture);

 	TBool GetSnapshotL(TPictureData& aPictureData, const TUncompressedVideoFormat& aFormat);

 	void GetTimedSnapshotL(TPictureData* aPictureData, const TUncompressedVideoFormat& aFormat, const TTimeIntervalMicroSeconds& aPresentationTimestamp);

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

 	void CancelTimedSnapshot();

 	void GetSupportedSnapshotFormatsL(RArray<TUncompressedVideoFormat>& aFormats);

 	void InputEnd();

 	void CommitL();

 	void Revert();

 	// from CMMFVideoDecodeHwDevice

     CVideoDecoderInfo* VideoDecoderInfoLC();

 	TVideoPictureHeader* GetHeaderInformationL(TVideoDataUnitType aDataUnitType, TVideoDataUnitEncapsulation aEncapsulation, TVideoInputBuffer* aDataUnit);

     void ReturnHeader(TVideoPictureHeader* aHeader);

     void SetInputFormatL(const CCompressedVideoFormat& aFormat, TVideoDataUnitType aDataUnitType, TVideoDataUnitEncapsulation aEncapsulation, TBool aDataInOrder);

     void SynchronizeDecoding(TBool aSynchronize);

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

     void GetBufferOptions(CMMFDevVideoPlay::TBufferOptions& aOptions);

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

     void SetOutputDevice(CMMFVideoPostProcHwDevice* aDevice);

     TTimeIntervalMicroSeconds DecodingPosition();

     TUint PreDecoderBufferBytes();

     void GetBitstreamCounters(CMMFDevVideoPlay::TBitstreamCounters& aCounters);

     TUint NumFreeBuffers();

     TVideoInputBuffer* GetBufferL(TUint aBufferSize);

     void WriteCodedDataL(TVideoInputBuffer* aBuffer);

 	void SetProxy(MMMFDevVideoPlayProxy& aProxy);

 	void ConfigureDecoderL(const TVideoPictureHeader& aVideoPictureHeader);

 	// from MMdfVideoPlayerHwDeviceObserver

 	TUint Time() const;

 	TBool FrameAvailable() const;

 	void DisplayFrame();

 	void DiscardFrame();

 	// from MMdfInputPortObserver

 	void MipoWriteDataComplete(const MMdfInputPort* aInputPort, CMMFBuffer* aBuffer,

 		TInt aErrorCode);

 	void MipoDisconnectTunnelComplete(const MMdfInputPort* aInputPort, TInt aErrorCode);

 	void MipoRestartTunnelComplete(const MMdfInputPort* aInputPort,	TInt aErrorCode);

 	// from MMdfOutputPortObserver

 	void MopoReadDataComplete(const MMdfOutputPort* aOutputPort, CMMFBuffer* aBuffer,

 		TInt aErrorCode);

 	void MopoDisconnectTunnelComplete(const MMdfOutputPort* aOutputPort, TInt aErrorCode);

 	void MopoRestartTunnelComplete(const MMdfOutputPort* aOutputPort, TInt aErrorCode);

 	// from MMdfProcessingUnitObserver

 	void InitializeComplete(const CMdfProcessingUnit* aPu, TInt aErrorCode);

 	void ExecuteComplete(const CMdfProcessingUnit* aPu, TInt aErrorCode);

 	// from MDevVideoHwDeviceAdapterSetup

 	void LoadProcessingUnitL(const CImplementationInformation& aImplInfo);

 private:

 	CMdfVideoDecodeHwDeviceAdapter();

 	void ConstructL();

 	void InitializeL();

 	void DoPostPictureNotify();

 	void DisplayFrameDirect(TVideoPicture* aPicture); 

 	void DisplayLastFrameDirect(); 

 	void SendLastBuffer();

 private:

 	// minimum decoder buffer useful data size.

 	// to work around a problem with the decoder when too 

 	// small a buffer passed to it will cause a KERN-EXEC:3;

 	// the alternative is putting bounds-checking into the C code

 	// throughout reading an encoded header, which would be inefficient

 	static const TInt KVideoDecoderMinUsefulDataSize = 256;

 	// minimum decoder data buffer size.

 	// the decoder will always return a buffer of at least this size.

 	static const TInt KVideoDecoderMinDataBufferSize = 0x2000; // 8k

 	// maximum decoder data buffer size.

 	// this is the largest buffer the decoder is able to return.

 	static const TInt KVideoDecoderMaxDataBufferSize = 0x40000; // 512k

 	MMMFDevVideoPlayProxy* iProxy;

 	// the decoder itself

 	CMdfProcessingUnit* iDecoderPU;

 	// the buffer manager

 	CMdfVideoDecoderBufferManager* iBufferManager;

 	// the player engine

 	CMdfVideoPlayerEngine* iPlayerEngine;

 	// the Processing Unit Loader plugin

 	CMdfPuLoader* iPuLoader;

 	// video format arrays (for VideoDecoderInfoLC())

 	RPointerArray<CCompressedVideoFormat> iInputVidFormats;

 	RArray<TUncompressedVideoFormat> iOutputVidFormats;

 	RArray<TPictureRateAndSize> iPictureRates;

 	// Processing Unit Ports

 	MMdfInputPort* iDecoderPUInputPort; 

 	MMdfOutputPort* iDecoderPUOutputPort;

 	// decoder settings

 	TUncompressedVideoFormat iFormat;

 	TReal32 iFrameRate;

 	CMMFDevVideoPlay::TPictureCounters iPictureCounters;

 	CMMFDevVideoPlay::TBitstreamCounters iBitstreamCounters;

 	CMMFDevVideoPlay::TComplexityLevelInfo iComplexityLevelInfo;

 	CMMFDevVideoPlay::TBufferOptions iBufferOptions;

 	// clock settings

 	MMMFClockSource* iClockSource;

 	TBool iSynchronize;

 	TInt64 iSystemClock;	// system clock without HAL

 	// header info

 	TVideoPictureHeader* iPictureHeader;

 	// input data buffer pointers 

 	CVideoDataBuffer* iInputBuffer; // not owned

 	CMMFBuffer* iPUInputBuffer; // not owned

 	// parameters for decoding loop

 	TInt iInDataSize;

 	TInt iTotalBytesUsed;

 	// player settings

 	TBool iPrimed;

 	TBool iInputBufferWaiting;

 	TBool iInputEnd;

 	TSize iFrameSize;

 	TBool iDisplayPictureAvailable;

 	// post-processor output device, if any

 	CMMFVideoPostProcHwDevice* iPostProcOutputDevice;

 	// direct screen access

 	TBool iDSAEnabled;

 	TBool iDSAStarted;

 	CFbsScreenDevice* iScreenDevice; // not owned

 	CFbsBitGc* iScreenDeviceGc;

 	TRect iScreenDeviceRect;

 	TUid iPuLoaderDtorKey;	

 	THwDevAdapterState iState;	

 	TBool iPUInitialized;

 	CCodecApiVideoOpaqueData* iPuData;	

 	HBufC* iManufacturer;

 	TUid iPuUid;

 	TBool iLastFrameBufferReceived;

 	TSize iMaxPictureSize;

 	TBool iWriteRequestOutstanding;

 	};

 #endif // MDFVIDEODECODEHWDEVICEADAPTER_H