--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/vtprotocolplugins/DisplaySink/inc/CDisplaySink.h Mon Nov 23 14:47:47 2009 +0200
@@ -0,0 +1,671 @@
+/*
+* 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
+
+