/*

* 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 for Direct Screen Access.

*

*/

// INCLUDES

#include <cvtimageconverter.h>

#include <cvtimageiyuv.h>

#include "CDisplaySinkDSA.h"

#include "TDisplaySinkParamsDSA.h"

// MACROS

#ifdef _DEBUG

    #include <e32debug.h>

    #define PRINT RDebug::Print

    #define _IFDBG(a) a

#else

    #define PRINT

    #define _IFDBG(a)

#endif

// ======================== CDisplaySinkDSA ==============================

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

// CDisplaySinkDSA::NewL

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

//

CDisplaySinkDSA* CDisplaySinkDSA::NewL( TDisplaySinkParams& aParams,

        const TDesC8& aInitData )

    {

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

    CDisplaySinkDSA* self = new ( ELeave ) CDisplaySinkDSA();

    CleanupStack::PushL( self );

    self->ConstructL( aParams, aInitData );

    CleanupStack::Pop(); // self

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

    return self;

    }

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

// CDisplaySinkDSA::CDisplaySinkDSA

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

//

CDisplaySinkDSA::CDisplaySinkDSA()

    {

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

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

    }

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

// CDisplaySinkDSA::~CDisplaySinkDSA

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

//

CDisplaySinkDSA::~CDisplaySinkDSA()

    {

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

    delete iRotator;

    delete iYUVBitmapConverterVT;

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

    }

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

// CDisplaySinkDSA::BaseConstructL

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

//

void CDisplaySinkDSA::BaseConstructL( TDisplaySinkParams& aParams,

    const TDesC8& )

    {

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

	iNewParams = static_cast< TDisplaySinkParamsDSA& > ( aParams );

	if ( !iNewParams.iBitmap1Handle || !iNewParams.iBitmap2Handle )

	    {

        _IFDBG(PRINT(_L("VideoSource[%d]: CDisplaySinkDSA::BaseConstructL() bitmap handle NULL!") ));

	    User::Leave( KErrArgument );

	    }

    iBitmapTable[EFirstBitmap].iHandle = iNewParams.iBitmap1Handle;

	iBitmapTable[ESecondBitmap].iHandle = iNewParams.iBitmap2Handle;

    iRotator = CVtImageRotator::NewL( *this );

    iRotationAngle = iNewParams.iRotationAngle;

    iYUVBitmapConverterVT = CVTIYUVFbsBitmapConverter::NewL(

        QCIF, iBitmapTable[EFirstBitmap].iHandle );

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

    }

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

// CDisplaySinkDSA::BaseConvert

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

//

TBool CDisplaySinkDSA::BaseConvert( const TVtMMFDataBuffer& aBuffer )

    {

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

    TBool converted( EFalse );

    TRAPD( err, ConvertL( aBuffer.Data(), converted ) );

    if ( err != KErrNone )

        {

        _IFDBG(PRINT(_L("VideoSource[%d]: CDisplaySinkDSA::BaseConvert() err=%d"), RThread().Id().operator TUint(), err));

        converted = EFalse;

        }

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

    return converted;

    }

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

// CDisplaySinkDSA::BaseSinkThreadLogonL

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

//

void CDisplaySinkDSA::BaseSinkThreadLogonL()

    {

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

    CVTYUVFbsBitmapConverter* converter1 =

	    CVTIYUVFbsBitmapConverter::NewL(

	        QCIF,

	        iBitmapTable[EFirstBitmap].iHandle );

    _IFDBG(PRINT(_L("VideoSource[%d]: CDisplaySinkDSA::BaseSinkThreadLogonL() 1"), RThread().Id().operator TUint()));

	CleanupStack::PushL( converter1 );

    CVTYUVFbsBitmapConverter* converter2 =

	    CVTIYUVFbsBitmapConverter::NewL(

	        QCIF,

	        iBitmapTable[ESecondBitmap].iHandle );

    _IFDBG(PRINT(_L("VideoSource[%d]: CDisplaySinkDSA::BaseSinkThreadLogonL() 2"), RThread().Id().operator TUint()));

	CleanupStack::PushL( converter2 );

    CleanupStack::Pop( 2 ); // converter1, converter2

    iYUVBitmapConverter1 = converter1;

	iYUVBitmapConverter2 = converter2;

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

    }

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

// CDisplaySinkDSA::BaseSinkThreadLogoff

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

//

void CDisplaySinkDSA::BaseSinkThreadLogoff()

    {

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

	delete iYUVBitmapConverter1;

	delete iYUVBitmapConverter2;

    delete iSourceImg; iSourceImg = 0;

    delete iTargetImg; iTargetImg = 0;

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

    }

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

// CDisplaySinkDSA::BaseUpdateSinkParamsL

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

//

void CDisplaySinkDSA::BaseUpdateSinkParamsL( const TDisplaySinkParams& aParams )

    {

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

    iNewParams = static_cast< const TDisplaySinkParamsDSA& >( aParams );

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

    }

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

// CDisplaySinkDSA::BaseDoUpdateParamsL

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

//

void CDisplaySinkDSA::BaseDoUpdateParamsL()

    {

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

    iRotationAngle = iNewParams.iRotationAngle;

    _IFDBG(PRINT(_L("VideoSource[%d]: CDisplaySinkDSA::BaseDoUpdateParamsL() handle1=%d"), RThread().Id().operator TUint(), iNewParams.iBitmap1Handle));

    iBitmapTable[ EFirstBitmap ].iHandle = iNewParams.iBitmap1Handle;

    iBitmapTable[ EFirstBitmap ].iIsFree = ETrue;

    _IFDBG(PRINT(_L("VideoSource[%d]: CDisplaySinkDSA::BaseDoUpdateParamsL() handle2=%d"), RThread().Id().operator TUint(), iNewParams.iBitmap2Handle));

    iBitmapTable[ ESecondBitmap ].iHandle = iNewParams.iBitmap2Handle;

    iBitmapTable[ ESecondBitmap ].iIsFree = EFalse;

    UpdateExpectedFrameSizeL();

    iYUVBitmapConverter1->SetSourceSizeL( iExpectedFrameSize );

    iYUVBitmapConverter1->SetDestinationL( iNewParams.iBitmap1Handle );

    iYUVBitmapConverter2->SetSourceSizeL( iExpectedFrameSize );

    iYUVBitmapConverter2->SetDestinationL( iNewParams.iBitmap2Handle );

    if( iNewParams.iFrameRateLimit != iFrameRateInterval )

        {

        SetFrameRateLimit( iNewParams.iFrameRateLimit );

        ResetFrameRateLimitter();

        }

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

    }

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

// CDisplaySinkDSA::BaseSetVideoFrameSizeL

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

//

void CDisplaySinkDSA::BaseSetVideoFrameSizeL( const TSize& aSize )

    {

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

    TSize size( aSize );

    if( ( iRotationAngle == CVtImageRotator::E90DegreesClockwise ) ||

        ( iRotationAngle == CVtImageRotator::E270DegreesClockwise ) )

        {

        size = TSize( aSize.iHeight, aSize.iWidth );

        }

    iYUVBitmapConverter1->SetSourceSizeL( size );

    iYUVBitmapConverter2->SetSourceSizeL( size );

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

    }

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

// CDisplaySinkDSA::BaseSizesMatch

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

//

TBool CDisplaySinkDSA::BaseSizesMatch( const TSize& aSize )

    {

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

    TBool sizesMatch( iExpectedFrameSize == aSize );

    TBool rotateChangesDimension(

        ( iRotationAngle == CVtImageRotator::E90DegreesClockwise ) ||

        ( iRotationAngle == CVtImageRotator::E270DegreesClockwise ) );

    if( rotateChangesDimension )

        {

        sizesMatch =

            ( iExpectedFrameSize.iWidth == aSize.iHeight ) &&

            ( iExpectedFrameSize.iHeight == aSize.iWidth );

        }

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

    return sizesMatch;

    }

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

// CDisplaySinkDSA::BitmapEntry

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

//

CDisplaySink::TBitmapEntry& CDisplaySinkDSA::BitmapEntry( TInt aIndex )

    {

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

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

    return iBitmapTable[ aIndex ];

    }

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

// CDisplaySinkDSA::BaseEmptyBufferL

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

//

void CDisplaySinkDSA::BaseEmptyBufferL( TVtMMFDataBuffer& aVTMMFBuffer )

    {

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

    if( iRotationAngle != CVtImageRotator::ERotationNone )

        {

        TSize size( aVTMMFBuffer.GetFrameSize() );

        TInt length( ( size.iWidth * size.iHeight * 12 ) / 8 );

        // Modifiable pointer descriptor needed, we don't want a copy of image!

        TPtr8 ptrData( const_cast< TUint8* >(

            aVTMMFBuffer.Data().Ptr() ), length, length );

        if( iSourceImg == 0 )

            {

            // If source image is not created -> create it

            iSourceImg = CVtImageIYUV::NewL( size, ptrData );

            }

        else

            {

            // otherwise just update the data

            if( iSourceImg->Size() == size )

                {

                iSourceImg->SetImageL( ptrData );

                }

            else

                {

                delete iSourceImg; iSourceImg = 0;

                iSourceImg = CVtImageIYUV::NewL( size, ptrData );

                }

            }

        iRotator->RotateL( *iSourceImg, *iTargetImg, iRotationAngle );

        CleanupStack::PopAndDestroy(); // iBitmapCS.Signal();

        }

    else

        {

        if ( BaseConvert( aVTMMFBuffer ) )

            {

            CleanupStack::PopAndDestroy(); // iBitmapCS.Signal();

            iSupplier->BufferEmptiedL( iBuffer );

            }

        else

            {

            if ( iVideoFrameQueue->IsStored() || !IsOkToSendFrame() )

                {

                CleanupStack::PopAndDestroy(); // iBitmapCS.Signal();

                iSupplier->BufferEmptiedL( iBuffer );

                }

            else

                {

                iVideoFrameQueue->Store( *iSupplier, static_cast<CMMFDataBuffer*>(aVTMMFBuffer.GetMMFBuffer()),  aVTMMFBuffer.GetFrameSize(), aVTMMFBuffer.Data());

                CleanupStack::PopAndDestroy();

                }

            }

        }

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

    }

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

// CDisplaySinkDSA::BaseSetBitmapAvailable( TBitmapNo aBitmapNo )

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

//

void CDisplaySinkDSA::BaseSetBitmapAvailable( TBitmapNo aBitmapNo )

	{

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

    if ( iVideoFrameQueue->IsStored() )

        {

        _IFDBG(PRINT(_L("VideoSource[%d]: CDisplaySinkDSA::BaseSetBitmapAvailable() buffer pending"), RThread().Id().operator TUint()));

        if ( !iReleased && ( *iRequestStatusPtr == KRequestPending ) && IsOkToSendFrame() )

    		{

            TRAPD( result, {

                iYUVBitmapConverterVT->SetDestinationL(

                    iBitmapTable[ aBitmapNo ].iHandle );

                iYUVBitmapConverterVT->SetSourceL(

	                iVideoFrameQueue->Buffer().Data() );

                iYUVBitmapConverterVT->ProcessL();

                } );

            if ( result == KErrNone )

                {

                _IFDBG(PRINT(_L("VideoSource[%d]: CDisplaySinkDSA::BaseSetBitmapAvailable() conversion succeeded!"), RThread().Id().operator TUint()));

        		iBitmapTable[ aBitmapNo ].iIsFree = EFalse;

        		TRequestStatus* statusP = iRequestStatusPtr;

        		iThread.RequestComplete( statusP, aBitmapNo );

        	    }

        	else

        	    {

                _IFDBG(PRINT(_L("VideoSource[%d]: CDisplaySinkDSA::BaseSetBitmapAvailable() conversion failed!"), RThread().Id().operator TUint()));

        	    // Drop frame

        	    }

    		}

        else

            {

            _IFDBG(PRINT(_L("VideoSource[%d]: CDisplaySinkDSA::BaseSetBitmapAvailable() dropping frame"), RThread().Id().operator TUint()));

            // Drop frame

            }

        iVideoFrameQueue->Release();

        }

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

	}

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

// CDisplaySinkDSA::BaseVideoFrameSizeChangedL( const TSize& aNewSize )

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

//

void CDisplaySinkDSA::BaseVideoFrameSizeChangedL( const TSize& aNewSize )

	{

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

	iYUVBitmapConverterVT->SetSourceSizeL( aNewSize );

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

	}

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

// CDisplaySinkDSA::UpdateExpectedFrameSizeL()

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

//

void CDisplaySinkDSA::UpdateExpectedFrameSizeL()

    {

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

    CFbsBitmap* bm = new ( ELeave ) CFbsBitmap();

    CleanupStack::PushL( bm );

    User::LeaveIfError( bm->Duplicate( iBitmapTable[ EFirstBitmap ].iHandle ) );

    iExpectedFrameSize = bm->SizeInPixels();

    User::LeaveIfError( bm->Duplicate( iBitmapTable[ ESecondBitmap ].iHandle ) );

    if( iExpectedFrameSize != bm->SizeInPixels() )

        {

    	_IFDBG(PRINT(_L("VideoSource[%d]: CDisplaySinkDSA::UpdateExpectedFrameSizeL(): EFirstBitmap size is different from ESecondBitmap size -> Leave()"), RThread().Id().operator TUint()));

        User::Leave( KErrNotSupported );

        }

    CleanupStack::PopAndDestroy(); // bm

    delete iTargetImg; iTargetImg = 0;

    iTargetImg = CVtImageIYUV::NewL( iExpectedFrameSize );

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

    }

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

// CDisplaySinkDSA::RotationFinished( TInt aError )

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

//

void CDisplaySinkDSA::RotationFinished( TInt aError )

    {

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

    // Rotation finished .. do something

    if( aError == KErrNone )

        {

        iBitmapCS.Wait();

        TBool converted( EFalse );

        TRAP( aError, ConvertL( iTargetImg->Image(), converted ) );

        iBitmapCS.Signal();

        TRAPD( aError2, iSupplier->BufferEmptiedL( iBuffer ) );

        if( ( aError != KErrNone ) || ( aError2 != KErrNone  ) )

            {

            *iRequestStatusPtr = KRequestPending;

		    TRequestStatus* statusP = iRequestStatusPtr;

		    iThread.RequestComplete( statusP, aError );

            }

        }

    else

        {

        *iRequestStatusPtr = KRequestPending;

		TRequestStatus* statusP = iRequestStatusPtr;

		iThread.RequestComplete( statusP, aError );

        }

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

    }

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

// CDisplaySinkDSA::ConvertL

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

//

void CDisplaySinkDSA::ConvertL( const TPtrC8& aBuffer, TBool& aConverted )

    {

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

    TBitmapNo bitmapNo( iBitmapTable[ EFirstBitmap ].iIsFree ? EFirstBitmap : ESecondBitmap );

    if ( iBitmapTable[ bitmapNo ].iIsFree &&

         !iReleased &&

         ( *iRequestStatusPtr == KRequestPending ) )

		{

		DoConvertL( aBuffer, bitmapNo );

    	aConverted = ETrue;

		iBitmapTable[ bitmapNo ].iIsFree = EFalse;

		TRequestStatus* statusP = iRequestStatusPtr;

		iThread.RequestComplete( statusP, bitmapNo );

		}

    else

        {

    	_IFDBG(PRINT(_L("VideoSource[%d]: CDisplaySinkDSA::ConvertL(): could not find free bitmap"), RThread().Id().operator TUint()));

    	aConverted = EFalse;

        }

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

    }

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

// CDisplaySinkDSA::DoConvert

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

//

void CDisplaySinkDSA::DoConvertL( const TPtrC8& aBuffer, TBitmapNo aBitmapNo )

	{

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

	CVTYUVFbsBitmapConverter* c = 0;

	switch( aBitmapNo )

		{

		case EFirstBitmap:

			c = iYUVBitmapConverter1;

			break;

		case ESecondBitmap:

			c = iYUVBitmapConverter2;

			break;

        default:

            User::Leave( KErrArgument );

		};

	c->SetSourceL( aBuffer );

	c->ProcessL();

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

	}

// End of File