/*

* 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