diff -r 000000000000 -r ed9695c8bcbe vtprotocolplugins/DisplaySink/inc/CDisplaySink.h
--- /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
+
+