diff -r 000000000000 -r bde4ae8d615e os/mm/mmdevicefw/mdf/src/video/decoderadapter/mdfvideodecodehwdeviceadapter.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/os/mm/mmdevicefw/mdf/src/video/decoderadapter/mdfvideodecodehwdeviceadapter.h Fri Jun 15 03:10:57 2012 +0200 @@ -0,0 +1,294 @@ +// 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 +#include +#include "mdfvideodecodehwdeviceadapter.hrh" +#include + +#include +#include +#include +#include +#include +#include +#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS +#include +#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& 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& 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 iInputVidFormats; + RArray iOutputVidFormats; + RArray 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