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