/*

* Copyright (c) 2006 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:  Display Sink subsystem.

*

*/

// INCLUDE FILES

#include "CDisplaySink.h"

#include "CDisplaySinkDP.h"

#include "CDisplaySinkDSA.h"

#include "CDisplaySinkNGA.h"

#include <mmffourcc.h>

#include <featmgr.h>

// CONSTANTS

// MACROS

#ifdef _DEBUG

    #include <e32debug.h>

    #define PRINT RDebug::Print

    #define _IFDBG(a) a

#else

    #define PRINT

    #define _IFDBG(a)

#endif

// ============================ MEMBER FUNCTIONS ===============================

// ============================= CVtFrameQueue =================================

// -----------------------------------------------------------------------------

// CVtFrameQueue::CVtFrameQueue

// -----------------------------------------------------------------------------

//

CVtFrameQueue::CVtFrameQueue() : CActive( EPriorityNormal )

    {

    _IFDBG(PRINT( _L( "CVtFrameQueue::CVtFrameQueue<" ) ));

    _IFDBG(PRINT( _L( "CVtFrameQueue::CVtFrameQueue>" ) ));

    }

// -----------------------------------------------------------------------------

// CVtFrameQueue::ThreadLogon

// -----------------------------------------------------------------------------

//

TInt CVtFrameQueue::ThreadLogon()

    {

    _IFDBG(PRINT( _L( "CVtFrameQueue::ThreadLogon<" ) ));

    if ( !IsAdded() )

        {

        CActiveScheduler::Add( this );

        }

    TInt result( iThread.Open( RThread().Id() ) );

    _IFDBG(PRINT( _L( "CVtFrameQueue::ThreadLogon %d >" ), result ));

    return result;

    }

// -----------------------------------------------------------------------------

// CVtFrameQueue::SinkStoppedL

// -----------------------------------------------------------------------------

//

void CVtFrameQueue::SinkStoppedL()

    {

    _IFDBG(PRINT( _L( "CVtFrameQueue::SinkStoppedL<" ) ));

    DoReleaseBufferL( iBuffer );

    DoReleaseBufferL( iReleaseBuffer );

    _IFDBG(PRINT( _L( "CVtFrameQueue::SinkStoppedL>" ) ));

    }

// -----------------------------------------------------------------------------

// CVtFrameQueue::ThreadLogoff

// -----------------------------------------------------------------------------

//

void CVtFrameQueue::ThreadLogoff()

    {

    _IFDBG(PRINT( _L( "CVtFrameQueue::ThreadLogoff<" ) ));

    if ( IsAdded() )

        {

        Deque();

        }

    _IFDBG(PRINT( _L( "CVtFrameQueue::ThreadLogoff>" ) ));

    }

// -----------------------------------------------------------------------------

// CVtFrameQueue::Store

// -----------------------------------------------------------------------------

//

void CVtFrameQueue::Store( MVTVideoSource& aSupplier,

    CMMFDataBuffer* aBuffer,

    TSize aFrameSize, 

    TPtr8& aPtr )

    {

    _IFDBG(PRINT( _L( "CVtFrameQueue::Store<" ) ));

    iSupplier = &aSupplier;

    iBuffer = aBuffer;

    iFrameSize = aFrameSize;

    iPtr = &aPtr;

    _IFDBG(PRINT( _L( "CVtFrameQueue::Store>" ) ));

    }

// -----------------------------------------------------------------------------

// CVtFrameQueue::IsStored

// -----------------------------------------------------------------------------

//

TBool CVtFrameQueue::IsStored() const

    {

    _IFDBG(PRINT( _L( "CVtFrameQueue::IsStored<" ) ));

    _IFDBG(PRINT( _L( "CVtFrameQueue::IsStored %d>" ),

        ( iBuffer != NULL ) ));

    return ( iBuffer != NULL );

    }

// -----------------------------------------------------------------------------

// CVtFrameQueue::Buffer

// -----------------------------------------------------------------------------

//

TVtMMFDataBuffer CVtFrameQueue::Buffer()

    {

    _IFDBG(PRINT( _L( "CVtFrameQueue::Buffer<" ) ));

    _IFDBG(PRINT( _L( "CVtFrameQueue::Buffer %d>" ),

        reinterpret_cast< TUint >( iBuffer ) ));

    return TVtMMFDataBuffer(iBuffer, iFrameSize, *iPtr);

    }

// -----------------------------------------------------------------------------

// CVtFrameQueue::Release

// -----------------------------------------------------------------------------

//

void CVtFrameQueue::Release()

    {

    _IFDBG(PRINT( _L( "CVtFrameQueue::Release<" ) ));

    if ( !IsActive() && IsStored() )

        {

        iReleaseBuffer = iBuffer;

        iBuffer = NULL;

        iStatus = KRequestPending;

        TRequestStatus* pStatus = &iStatus;

        SetActive();

        iThread.RequestComplete( pStatus, KErrNone );

        _IFDBG(PRINT( _L( "CVtFrameQueue::Release -done-" ) ));

        }

    _IFDBG(PRINT( _L( "CVtFrameQueue::Release>" ) ));

    }

// -----------------------------------------------------------------------------

// CVtFrameQueue::RunL

// -----------------------------------------------------------------------------

//

void CVtFrameQueue::RunL()

    {

    _IFDBG(PRINT( _L( "CVtFrameQueue::RunL<" ) ));

    DoReleaseBufferL( iReleaseBuffer );

    _IFDBG(PRINT( _L( "CVtFrameQueue::RunL>" ) ));

    }

// -----------------------------------------------------------------------------

// CVtFrameQueue::DoReleaseBufferL

// -----------------------------------------------------------------------------

//

void CVtFrameQueue::DoReleaseBufferL( CMMFDataBuffer*& aBuffer )

    {

    _IFDBG(PRINT( _L( "CVtFrameQueue::DoReleaseBufferL<" ) ));

    if ( aBuffer && iSupplier )

        {

        iSupplier->BufferEmptiedL( aBuffer );

        aBuffer = NULL;

        }

    _IFDBG(PRINT( _L( "CVtFrameQueue::DoReleaseBufferL>" ) ));

    }

// -----------------------------------------------------------------------------

// CVtFrameQueue::DoCancel

// -----------------------------------------------------------------------------

//

void CVtFrameQueue::DoCancel()

    {

    // nothing to do

    }

// ============================ CVtCallback =================================

// -----------------------------------------------------------------------------

// CVtCallback::CVtCallback( MDisplaySinkObserver& aObserver )

// -----------------------------------------------------------------------------

//

CVtCallback::CVtCallback( MDisplaySinkObserver& aObserver )

: CActive( EPriorityStandard ), iObserver( &aObserver )

    {

	_IFDBG(PRINT(_L("VideoSource[%d]: CVtCallback::CVtCallback()<"), RThread().Id().operator TUint()));

    CActiveScheduler::Add( this );

    iOwnThreadId = RThread().Id();

	_IFDBG(PRINT(_L("VideoSource[%d]: CVtCallback::CVtCallback()>"), RThread().Id().operator TUint()));

    }

// -----------------------------------------------------------------------------

// CVtCallback::~CVtCallback()

// -----------------------------------------------------------------------------

//

CVtCallback::~CVtCallback()

    {

    Cancel();

    }

// -----------------------------------------------------------------------------

// CVtCallback::VideoFrameSizeChangedL( const TSize& aFrom, const TSize& aTo )

// -----------------------------------------------------------------------------

//

void CVtCallback::VideoFrameSizeChangedL( const TSize& aFrom, const TSize& aTo )

    {

	_IFDBG(PRINT(_L("VideoSource[%d]: CVtCallback::VideoFrameSizeChangedL()<"), RThread().Id().operator TUint()));

    iCallBackType = EVideoFrameSizeChanged;

    iFrom = aFrom;

    iTo = aTo;

    IssueCallbackL();

	_IFDBG(PRINT(_L("VideoSource[%d]: CVtCallback::VideoFrameSizeChangedL()>"), RThread().Id().operator TUint()));

    }

// -----------------------------------------------------------------------------

// CVtCallback::Result() const

// -----------------------------------------------------------------------------

//

TInt CVtCallback::Result() const

    {

	_IFDBG(PRINT(_L("VideoSource[%d]: CVtCallback::Result()<"), RThread().Id().operator TUint()));

	_IFDBG(PRINT(_L("VideoSource[%d]: CVtCallback::Result()>"), RThread().Id().operator TUint()));

    return iResult;

    }

// -----------------------------------------------------------------------------

// CVtCallback::Completed() const

// -----------------------------------------------------------------------------

//

TBool CVtCallback::Completed() const

    {

	_IFDBG(PRINT(_L("VideoSource[%d]: CVtCallback::Completed()<"), RThread().Id().operator TUint()));

	_IFDBG(PRINT(_L("VideoSource[%d]: CVtCallback::Completed()>"), RThread().Id().operator TUint()));

    return iCompleted;

    }

// -----------------------------------------------------------------------------

// CVtCallback::IssueCallbackL()

// -----------------------------------------------------------------------------

//

void CVtCallback::IssueCallbackL()

    {

	_IFDBG(PRINT(_L("VideoSource[%d]: CVtCallback::IssueCallbackL()<"), RThread().Id().operator TUint()));

    iCompleted = EFalse;

    TRequestStatus* pStatus = &iStatus;

    RThread thread;

    if( thread.Id() == iOwnThreadId )

        {

        SetActive();

        User::RequestComplete( pStatus, KErrNone );

        }

    else

        {

        User::LeaveIfError( thread.Open( iOwnThreadId ) );

        SetActive();

        *pStatus = KRequestPending;

        thread.RequestComplete( pStatus, KErrNone );

        thread.Close();

        }

	_IFDBG(PRINT(_L("VideoSource[%d]: CVtCallback::IssueCallbackL()>"), RThread().Id().operator TUint()));

    }

// -----------------------------------------------------------------------------

// CVtCallback::RunL()

// -----------------------------------------------------------------------------

//

void CVtCallback::RunL()

    {

	_IFDBG(PRINT(_L("VideoSource[%d]: CVtCallback::RunL()<"), RThread().Id().operator TUint()));

    iResult = KErrNone;

    switch( iCallBackType )

        {

        case EVideoFrameSizeChanged:

            iObserver->VideoFrameSizeChangedL( iFrom, iTo );

            break;

        default:

            User::Leave( KErrArgument );

        }

    iCompleted = ETrue;

    _IFDBG(PRINT(_L("VideoSource[%d]: CVtCallback::RunL()>"), RThread().Id().operator TUint()));

    }

// -----------------------------------------------------------------------------

// CVtCallback::DoCancel()

// -----------------------------------------------------------------------------

//

void CVtCallback::DoCancel()

    {

    // do nothing!

    }

// -----------------------------------------------------------------------------

// CVtCallback::RunError( TInt aError )

// -----------------------------------------------------------------------------

//

TInt CVtCallback::RunError( TInt aError )

    {

    iCompleted = ETrue;

    iResult = aError;

    return KErrNone;

    }

// ========================== TDisplaySinkParams ===============================

// -----------------------------------------------------------------------------

// TDisplaySinkParams::TDisplaySinkParams

// -----------------------------------------------------------------------------

//

EXPORT_C TDisplaySinkParams::TDisplaySinkParams() :

    iFrameRateLimit( EFrameRateLimitNone )

    {

    }

// ============================ CDisplaySink ===================================

// -----------------------------------------------------------------------------

// CDisplaySink::~CDisplaySink

// -----------------------------------------------------------------------------

//

CDisplaySink::~CDisplaySink()

	{

	_IFDBG(PRINT(_L("VideoSource[%d]: CDisplaySink::~CDisplaySink()<"), RThread().Id().operator TUint()));

	delete iVideoFrameQueue;

	iBitmapCS.Close();

    delete iVTSignaller;

    iVTMimeTypes.Reset();

	iVTMimeTypes.Close();

	_IFDBG(PRINT(_L("VideoSource[%d]: CDisplaySink::~CDisplaySink()>"), RThread().Id().operator TUint()));

	}

// -----------------------------------------------------------------------------

// CDisplaySink::ConstructL

// -----------------------------------------------------------------------------

//

void CDisplaySink::ConstructL( TDisplaySinkParams& aParams,

    const TDesC8& aInitData )

    {

	_IFDBG(PRINT(_L("VideoSource[%d]: CDisplaySink::ConstructL()<"), RThread().Id().operator TUint()));

    iDSFlags = aParams.iFlags;

    iYuv420PlanarDesc.Delete( 0, iYuv420PlanarDesc.Length() );

    iYuv420PlanarDesc.Append( KVtVideoMIMETypeYUV420 );

    User::LeaveIfError( iVTMimeTypes.Append( &iYuv420PlanarDesc ) );

    iVideoFrameQueue = new ( ELeave ) CVtFrameQueue();

    iVTSignaller = new ( ELeave ) CVtCallback( *aParams.iObserver );

	BitmapEntry( EFirstBitmap ).iIsFree = EFalse;

	BitmapEntry( ESecondBitmap ).iIsFree = EFalse;

	iThreadId = aParams.iThreadId;

	iRequestStatusPtr = aParams.iRequestStatusPtr;

    iFrameSize = QCIF;

    SetFrameRateLimit( aParams.iFrameRateLimit );

    User::LeaveIfError( iBitmapCS.CreateLocal() );

	BaseConstructL( aParams, aInitData );

    _IFDBG(PRINT(_L("VideoSource[%d]: CDisplaySink::ConstructL()>"), RThread().Id().operator TUint()));

    }

// -----------------------------------------------------------------------------

// CDisplaySink::Destroy

// -----------------------------------------------------------------------------

//

void CDisplaySink::Destroy()

	{

	_IFDBG(PRINT(_L("VideoSource[%d]: CDisplaySink::Destroy()<"), RThread().Id().operator TUint()));

	delete this;

	_IFDBG(PRINT(_L("VideoSource[%d]: CDisplaySink::Destroy()>"), RThread().Id().operator TUint()));

	}

// -----------------------------------------------------------------------------

// CDisplaySink::SetBitmapAvailable( TBitmapNo aBitmapNo )

// -----------------------------------------------------------------------------

//

void CDisplaySink::SetBitmapAvailable( TBitmapNo aBitmapNo )

	{

	_IFDBG(PRINT(_L("VideoSource[%d]: CDisplaySink::SetBitmapAvailable()<"), RThread().Id().operator TUint()));

	iBitmapCS.Wait();

    BitmapEntry( aBitmapNo ).iIsFree = ETrue;

    BaseSetBitmapAvailable( aBitmapNo );

    iBitmapCS.Signal();

	_IFDBG(PRINT(_L("VideoSource[%d]: CDisplaySink::SetBitmapAvailable()>"), RThread().Id().operator TUint()));

	}

// -----------------------------------------------------------------------------

// CDisplaySink::Release

// -----------------------------------------------------------------------------

//

void CDisplaySink::Release()

	{

	_IFDBG(PRINT(_L("VideoSource[%d]: CDisplaySink::Release()<"), RThread().Id().operator TUint()));

	iBitmapCS.Wait();

	if( !iReleased  )

		{

		iReleased = ETrue;

		if( iRequestStatusPtr != NULL &&

		    (*iRequestStatusPtr) == KRequestPending )

			{

			RThread thread;

			TInt err = thread.Open( iThreadId );

			if( err == KErrNone )

				{

				*iRequestStatusPtr = KRequestPending;

				TRequestStatus* statusP = iRequestStatusPtr;

				thread.RequestComplete( statusP, KErrCancel );

    			thread.Close();

				}

			}

		}

	iVideoFrameQueue->Release();

	iBitmapCS.Signal();

	_IFDBG(PRINT(_L("VideoSource[%d]: CDisplaySink::Release()>"), RThread().Id().operator TUint()));

	}

// -----------------------------------------------------------------------------

// CDisplaySink::UpdateSinkParamsL( const TDisplaySinkParams& aParams,

//  TBool& aUpdated )

// -----------------------------------------------------------------------------

//

void CDisplaySink::UpdateSinkParamsL(

    const TDisplaySinkParams& aParams, TBool& aUpdated )

    {

	_IFDBG(PRINT(_L("VideoSource[%d]: CDisplaySink::UpdateSinkParamsL()<"), RThread().Id().operator TUint()));

	// This modification was requested by the VT engine team

	iReleased = EFalse;

	// This modification was requested by the VT engine team

    iBitmapCS.Wait();

    BaseUpdateSinkParamsL( aParams );

    aUpdated = EFalse;

    iParamsUpdated = &aUpdated;

    iDSFlags = aParams.iFlags;

    BitmapEntry( EFirstBitmap ).iIsFree = EFalse;

	BitmapEntry( ESecondBitmap ).iIsFree = EFalse;

	iVideoFrameQueue->Release();

    iBitmapCS.Signal();

	_IFDBG(PRINT(_L("VideoSource[%d]: CDisplaySink::UpdateSinkParamsL()>"), RThread().Id().operator TUint()));

    }

// -----------------------------------------------------------------------------

// CDisplaySink::Pause()

// -----------------------------------------------------------------------------

//

void CDisplaySink::Pause()

    {

    iBitmapCS.Wait();

    iPaused = ETrue;

    iVideoFrameQueue->Release();

    iBitmapCS.Signal();

    }

// -----------------------------------------------------------------------------

// CDisplaySink::Resume()

// -----------------------------------------------------------------------------

//

void CDisplaySink::Resume()

    {

    iBitmapCS.Wait();

    iPaused = EFalse;

    iBitmapCS.Signal();

    }

// -----------------------------------------------------------------------------

// CDisplaySink::operator MVTVideoSink&()

// -----------------------------------------------------------------------------

//

CDisplaySink::operator MVTVideoSink&()

    {

	_IFDBG(PRINT(_L("VideoSource[%d]: CDisplaySink::operator MVTVideoSink&()<"), RThread().Id().operator TUint()));

	_IFDBG(PRINT(_L("VideoSource[%d]: CDisplaySink::operator MVTVideoSink&()>"), RThread().Id().operator TUint()));

    return *this;

    }

// -----------------------------------------------------------------------------

// CDisplaySink::NextFrame

// -----------------------------------------------------------------------------

//

void CDisplaySink::NextFrame()

    {

	_IFDBG(PRINT(_L("VideoSource[%d]: CDisplaySink::NextFrame()<"), RThread().Id().operator TUint()));

	_IFDBG(PRINT(_L("VideoSource[%d]: CDisplaySink::NextFrame()>"), RThread().Id().operator TUint()));

    }

// -----------------------------------------------------------------------------

// CDisplaySink::GetMultimediaTypesL() const

// -----------------------------------------------------------------------------

//

const RArray<TDesC8* >& CDisplaySink::GetMultimediaTypesL() const

	{

	_IFDBG(PRINT(_L("VideoSource[%d]: CDisplaySink::GetMultimediaTypeL()<"), RThread().Id().operator TUint()));

	_IFDBG(PRINT(_L("VideoSource[%d]: CDisplaySink::GetMultimediaTypeL()>"), RThread().Id().operator TUint()));

	return iVTMimeTypes;

	}

// -----------------------------------------------------------------------------

// CDisplaySink::SetFormatL

// -----------------------------------------------------------------------------

//

void CDisplaySink::SetFormatL( const TDesC8& aFormat )

	{

	_IFDBG(PRINT(_L("VideoSource[%d]: CDisplaySink::SetFormatL()<"), RThread().Id().operator TUint()));

	if ( aFormat != KVtVideoMIMETypeYUV420 )

		{

		User::Leave( KErrNotSupported );

		}

	_IFDBG(PRINT(_L("VideoSource[%d]: CDisplaySink::SetFormatL()>"), RThread().Id().operator TUint()));

	}

// -----------------------------------------------------------------------------