MCL/sf/app/videotelephony: comparison vtprotocolplugins/DisplaySink/inc/CDisplaySink.h

equal deleted inserted replaced

--1:000000000000
+:ed9695c8bcbe
+/*
+* 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:    DisplaySink subsystem.
+*
+*/
+#ifndef CDISPLAYSINK_H
+#define CDISPLAYSINK_H
+//  INCLUDE FILES
+#include <bldvariant.hrh>
+#include <e32base.h>
+#include <mmfutilities.h>
+#include <mmfdatasource.h>
+#include <mmfdatasink.h>
+#include <fbs.h>
+#include <mvtprotocolhandler.h>
+#include "mdisplaysink.h"
+// CONSTANTS
+// QCIF size
+#define QCIF TSize( 176, 144 )
+// Number of bitmap sets (big/small) in array
+const TInt KBitmapTableCount = 2;
+// FORWARD DECLARATIONS
+class CDisplaySink;
+class CVTYUVFbsBitmapConverter;
+class CVtCallback;
+class CVtImageIYUV;
+class CMMFDataBuffer;
+class CVtFrameQueue;
+// CLASS DECLARATION
+/**
+* CVtFrameQueue
+*
+* Storage class for DisplaySink. Used in situations where EmptyBufferL() is
+* called and there's no available bitmaps (or buffers). This class will
+* hold one buffer until next SetBitmapAvailable() is called. Instance operates
+* in protocol thread's active scheduler.
+*
+*  @lib DisplaySink.lib
+*/
+NONSHARABLE_CLASS( CVtFrameQueue ) : public CActive
+{
+public: // new methods
+/**
+* C++ constructor.
+*/
+CVtFrameQueue();
+/**
+* Adds this to protocol thread's active scheduler.
+*/
+TInt ThreadLogon();
+/**
+* Releases stored buffer, when sink is stopped.
+*/
+void SinkStoppedL();
+/**
+* Deques from protocol thread's active scheduler.
+*/
+void ThreadLogoff();
+/**
+* Stores buffer & supplier.
+*/
+void Store( MVTVideoSource& aSupplier, CMMFDataBuffer* aBuffer, TSize aFrameSize, TPtr8& aPtr );
+/**
+* Returns ETrue if buffer is being stored, EFalse otherwise.
+*/
+TBool IsStored() const;
+/**
+* Returns stored buffer.
+*/
+TVtMMFDataBuffer Buffer();
+/**
+* Releases stored buffer. Supplier's BufferEmptiedL() is called. Call
+* is executed in protocol thread's context.
+*/
+void Release();
+private:
+/**
+* Calls BufferEmptiedL() for supplier. This call always happens in protocol
+* thread context.
+* @param aBuffer Pointer reference to a buffer to be released.
+*/
+void DoReleaseBufferL( CMMFDataBuffer*& aBuffer );
+private: // from CActive
+/**
+* @see CActive::RunL
+*/
+void RunL();
+/**
+* @see CActive::DoCancel
+*/
+void DoCancel();
+private:
+// Stored supplier
+MVTVideoSource* iSupplier;
+// Stored buffer
+CMMFDataBuffer* iBuffer;
+TSize iFrameSize;
+TPtr8* iPtr;
+// Pre-opened thread object that is used for signalling the delayed
+// BufferEmptiedL() call
+RThread iThread;
+// Buffer to be released on next RunL()
+CMMFDataBuffer* iReleaseBuffer;
+};
+/**
+* CVtCallback
+*
+*
+*  @lib DisplaySink.lib
+*/
+NONSHARABLE_CLASS( CVtCallback ) : public CActive
+{
+private:
+/**
+* Callback type. Currently only size changes are supported. If new callback
+* types are needed, add them here.
+*/
+enum TCallBackType
+{
+EVideoFrameSizeChanged
+};
+public:
+/**
+* C++ constructor.
+*/
+CVtCallback( MDisplaySinkObserver& aObserver );
+/**
+* C++ destructor.
+*/
+~CVtCallback();
+/**
+* Video frame size has been changed. Old and new size are given as
+* parameter.
+*/
+void VideoFrameSizeChangedL( const TSize& aFrom, const TSize& aTo );
+/**
+* Returns callback result.
+*/
+TInt Result() const;
+/**
+* Boolean variable that tells wether or not call back has been served.
+*/
+TBool Completed() const;
+private:
+/**
+* Issues callback. Because callback receiver can be in same or different
+* thread this is made as own function that checks whether or not other
+* thread needs to be signalled.
+*/
+void IssueCallbackL();
+private: // from CActive
+/**
+* See CActive documentation.
+*/
+void RunL();
+/**
+* See CActive documentation.
+*/
+void DoCancel();
+/**
+* See CActive documentation.
+*/
+TInt RunError( TInt aError );
+private:
+// Owner thread's id
+TThreadId iOwnThreadId;
+// Pointer to observer
+MDisplaySinkObserver* iObserver;
+// Callback type
+TCallBackType iCallBackType;
+// Old size
+TSize iFrom;
+// New size
+TSize iTo;
+// Callback result
+TInt iResult;
+// Has callback been completed?
+TBool iCompleted;
+};
+/**
+*  MVTVideoSink interface implementation
+*
+*  @lib DisplaySink.lib
+*/
+NONSHARABLE_CLASS( CDisplaySink ) : public CBase, public MDisplaySink,
+public MVTVideoSink
+{
+protected: // inner classes
+// Structure containing bitmap related data
+class TBitmapEntry
+{
+public: // data
+// ETrue if this bitmap entry is free
+TBool iIsFree;
+};
+private:  // from MDisplaySink
+/**
+* @see MDisplaySink::Destroy
+*/
+void Destroy();
+/**
+* @see MDisplaySink::SetBitmapAvailable
+*/
+void SetBitmapAvailable( TBitmapNo aBitmapNo );
+/**
+* @see MDisplaySink::Release
+*/
+void Release();
+/**
+* @see MDisplaySink::UpdateSinkParamsL
+*/
+void UpdateSinkParamsL( const TDisplaySinkParams& aParams, TBool& aUpdated );
+/**
+* @see MDisplaySink::Pause
+*/
+void Pause();
+/**
+* @see MDisplaySink::Resume
+*/
+void Resume();
+/**
+* @see MDisplaySink::operator MVTVideoSink&
+*/
+operator MVTVideoSink&();
+/**
+* @see MDisplaySink::NextFrame
+*/
+void NextFrame();
+private:  // from MVTVideoSink
+/**
+* From MVTVideoOutput. See MVTVideoOutput for description.
+*/
+virtual void SetFormatL( const TDesC8& aFormat );
+/**
+* From MVTVideoOutput. See MVTVideoOutput for description.
+*/
+virtual void SetVideoFrameSizeL( const TSize& aSize );
+/**
+* From MVTVideoOutput. See MVTVideoOutput for description.
+*/
+virtual void GetVideoFrameSizeL( TSize& aSize ) const;
+/**
+* From MVTVideoSink. See MVTVideoSink for description.
+*/
+virtual void EmptyBufferL(
+TVtMMFDataBuffer aDataBuffer,
+MVTVideoSource* aSupplier,
+TMediaId aMediaId );
+/**
+* From MVTVideoSink. See MVTVideoSink for description.
+*/
+virtual void BufferFilledL( CMMFBuffer* aBuffer );
+/**
+* From MVTVideoSink. See MVTVideoSink for description.
+*/
+virtual TBool CanCreateSinkBuffer();
+/**
+* From MVTVideoSink. See MVTVideoSink for description.
+*/
+virtual CMMFBuffer* CreateSinkBufferL(
+TMediaId aMediaId,
+TBool &aReference );
+/**
+* From MVTVideoSink. See MVTVideoSink for description.
+*/
+virtual TInt SinkThreadLogon( MAsyncEventHandler& aEventHandler );
+/**
+* From MVTVideoSink. See MVTVideoSink for description.
+*/
+virtual void SinkThreadLogoff();
+/**
+* From MVTVideoSink. See MVTVideoSink for description.
+*/
+virtual TInt SinkPrimeL();
+/**
+* From MVTVideoSink. See MVTVideoSink for description.
+*/
+virtual TInt SinkPlayL();
+/**
+* From MVTVideoSink. See MVTVideoSink for description.
+*/
+virtual TInt SinkPauseL();
+/**
+* From MVTVideoSink. See MVTVideoSink for description.
+*/
+virtual TInt SinkStopL();
+private:
+const RArray<TDesC8* >& GetMultimediaTypesL() const;
+protected: // Constructors and destructor
+/**
+* C++ default constructor.
+*/
+CDisplaySink();
+/**
+* Destructor.
+*/
+~CDisplaySink();
+protected:    // New functions
+/**
+* By default Symbian 2nd phase constructor is private.
+* @param "aParams" Initialization parameters.
+* @param "aInitData" Initialization parameters. Not used.
+* @exception Can leave with one of the system wide error codes.
+*/
+void ConstructL( TDisplaySinkParams& aParams, const TDesC8& aInitData );
+/**
+* Thread logon that may leave. This will be trapped and possible
+* error code is returned to the caller of SinkThreadLogon().
+* @exception Can leave with one of the system wide error codes.
+*/
+void SinkThreadLogonL();
+/**
+* Sets limit for displaysink frame rate.
+*/
+void SetFrameRateLimit(
+TDisplaySinkParams::TFrameRateLimit aFrameRateLimit );
+/**
+* Resets frame rate limitter.
+*/
+void ResetFrameRateLimitter();
+/**
+* Does frame rate limitter validation and also checks if sink is paused.
+*/
+TBool IsOkToSendFrame();
+/**
+* Opens fbs session and sets flag, if open succeeds.
+*/
+void FbsConnectL();
+/**
+* Opens VT engine thread.
+*/
+void ThreadOpenL();
+/**
+* Closes fbs session (if open succeeded earlier).
+*/
+void FbsDisconnect();
+/**
+* Closes VT thread (if open succeeded earlier).
+*/
+void ThreadClose();
+/**
+* Cleanup operation for SinkThradLogon.
+*/
+static void SinkThreadLogonCleanup( TAny* aPtr );
+private: // new methods implemented in derived classes
+/**
+* Called from ConstructL() to allow inherited classes to do their own
+* construction.
+*/
+virtual void BaseConstructL( TDisplaySinkParams& aParams,
+const TDesC8& aInitData ) = 0;
+/**
+* Converts image. Calls DoConvertL() to do the task.
+* @return KErrNone or one of the system wide error codes.
+*/
+virtual TBool BaseConvert( const TVtMMFDataBuffer& aBuffer ) = 0;
+/**
+* Called from SinkThreadLogonL().
+*/
+virtual void BaseSinkThreadLogonL() = 0;
+/**
+* Called from SinkThreadLogogg().
+*/
+virtual void BaseSinkThreadLogoff() = 0;
+/**
+* Called from UpdateSinkParamsL().
+*/
+virtual void BaseUpdateSinkParamsL( const TDisplaySinkParams& aParams ) = 0;
+/**
+* Updates sink params.
+* @exception May leave with one of the system wide error codes (e.g. in
+* out of memory situaton).
+*/
+virtual void BaseDoUpdateParamsL() = 0;
+/**
+* Called when video frame size is set.
+* @exception May leave with one of the system wide error codes (e.g. in
+* out of memory situaton).
+*/
+virtual void BaseSetVideoFrameSizeL( const TSize& aSize ) = 0;
+/**
+* Returns ETrue if given frame size matches with expected frame size.
+* Implemented in derived classes because in some cases (e.g. when rotation
+* is enabled), size calculation is more complicated.
+*/
+virtual TBool BaseSizesMatch( const TSize& aSize ) = 0;
+/**
+* Returns reference to TBitmapEntry.
+*/
+virtual TBitmapEntry& BitmapEntry( TInt aIndex ) = 0;
+/**
+* EmptyBuffer handling.
+*/
+virtual void BaseEmptyBufferL( TVtMMFDataBuffer& aVTMMFBuffer ) = 0;
+/**
+* Bitmap availability handling.
+*/
+virtual void BaseSetBitmapAvailable( TBitmapNo aBitmapNo ) = 0;
+/**
+* Called when source frame size changes.
+*/
+virtual void BaseVideoFrameSizeChangedL( const TSize& aNewSize ) = 0;
+protected:    // Data
+// Video source that provides buffer filled with video frame(s)
+MVTVideoSource* iSupplier;
+// Event handler to notify events
+MAsyncEventHandler* iEventHandler;
+// Buffer containing video frame(s) and to be converted
+CMMFBuffer* iBuffer;
+// Sink data type code as fourCC code
+TFourCC iSinkFourCC;
+// Sink state enumeration
+enum TState
+{
+EStopped,
+EPrimed,
+EPlaying
+};
+// Sink state
+TState iState;
+// Array of MIME types supported by sink
+RArray<TDesC8* > iVTMimeTypes;
+// Video frame size
+TSize iFrameSize;
+// Thread ID of thread to notify after video frame is converted
+TThreadId iThreadId;
+// Handle to thread to notify after video frame is converted
+RThread iThread;
+// Pointer to iStatus member of the Active Object to notify
+// after video frame is converted
+TRequestStatus* iRequestStatusPtr;
+// Critical section to serialize access to iBitmapTable
+RCriticalSection iBitmapCS;
+// Semaphore to force thread context switch after video frame
+// is converted
+RSemaphore iSync;
+// This is set to ETrue when new params are set, this pointer
+// is also used as flag when parameter update is requested.
+TBool* iParamsUpdated;
+// This flag variable will be set to ETrue when sink parameters
+// need to be updated (e.g. when frame size changes from QCIF
+// to Sub QCIF or vice versa)
+TBool iWaitingForUpdate;
+// Contains expected frame size (this is taken from given bitmaps).
+TSize iExpectedFrameSize;
+// Active object that will call callbacks to VT engine in VT
+// engine's thread context.
+CVtCallback* iVTSignaller;
+// If ETrue, sink does not convert data that is given to it
+TBool iReleased;
+// Output MIME type holder
+TBuf8< 128 > iYuv420PlanarDesc;
+// Frame rate interval in milliseconds
+TInt iFrameRateInterval;
+// Time since last frame was sent (in milliseconds)
+TInt iMilliSecondsSinceLastFrame;
+// Time stamp for last frame sent
+TTime iLastFrameTime;
+// When paused remote video will no be sent to VT engine
+TBool iPaused;
+// DisplaySink params flags
+TUint32 iDSFlags;
+// Is set to ETrue when SinkThreadLogon() is called.
+TUint32 iInitFlags;
+// Initialization flags
+enum TInitFlags
+{
+// This flag is set, when SinkThreadLogon() is called
+ESinkThreadLogonCalled = ( 1 << 0 ),
+// This flag is set, when FbsSession has been connected
+EFbsSessionConnected = ( 1 << 1 ),
+// This flag is set, when handle to Sink Thread has been opened
+EThreadOpened = ( 1 << 2 )
+};
+// Frame queue for holding for holding frames until target conversion
+// buffer is ready.
+CVtFrameQueue* iVideoFrameQueue;
+// friend classes
+};
+/**
+*  Safe cleanup for synchronization primitives.
+*
+*  @lib DisplaySink.lib
+*/
+template < class T >
+class CleanupSignal
+	{
+public:
+static void PushL( T& aPtr );
+private:
+static void Signal( TAny *aPtr );
+	};
+template < class T >
+void CleanupSignal< T >::PushL( T& aRef )
+	{
+CleanupStack::PushL( TCleanupItem( &Signal, &aRef ) );
+}
+template < class T >
+void CleanupSignal< T >::Signal( TAny *aPtr )
+	{
+static_cast< T* >( aPtr )->Signal();
+}
+/**
+* Pushes signalable object into cleanup stack.
+*/
+template < class T >
+void CleanupSignalPushL( T& aRef )
+{
+CleanupSignal< T >::PushL( aRef );
+}
+#endif      // CDISPLAYSINK_H
+// End of File