/*

* Copyright (c) 2004-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:  Class for NGA Drawer.

*

*/

// INCLUDE FILES

#include "CVtEngDrawNGA.h"

#include "CVtEngEventManager.h"

#include "VtEngPanic.h"

#include "MVtEngFrameObserver.h"

#include "CVtEngSettings.h"

#include "VtEngUtils.h"

#include <videotelephonyvariant.hrh>

#include <tdisplaysinkparamsnga.h>

#include <cvtlogger.h>

#include <graphics/surfaceconfiguration.h>

#include <graphics/suerror.h>

// Reversed enumeration for the bitmaps.

static const MDisplaySink::TBitmapNo KVtEngBitmapNoReversed[] =

        {

        MDisplaySink::ESecondBitmap,

        MDisplaySink::EFirstBitmap

        };

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

// CVtEngDrawNGA::TVTSurfaceBuffer::TVTSurfaceBuffer

//

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

//

TVTSurfaceBuffer::TVTSurfaceBuffer( TUint8* aBuffer, TInt aSurfaceNo )

    : iBuffer( aBuffer ), iSurfaceBufferNo(aSurfaceNo)

    {

    __VTPRINTENTER( "RVD(NGA).TVTSurfaceBuffer.Ctor" )

    __VTPRINTEXIT( "RVD(NGA).TVTSurfaceBuffer.Ctor" )

    }

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

// CVtEngDrawNGA::TVTSurfaceBuffer::Buffer

//

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

//

TUint8*& TVTSurfaceBuffer::Buffer()

    {

    return iBuffer;

    }

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

// CVtEngDrawNGA::TVTSurfaceBuffer::SurfaceNo

//

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

//

TInt TVTSurfaceBuffer::SurfaceNo()

    {

    return iSurfaceBufferNo;

    }

void TVTSurfaceBuffer::Set( TUint8* aBuffer, TInt aSurfaceNo )

    {

    iBuffer = aBuffer;

    iSurfaceBufferNo = aSurfaceNo;

    }

void TVTSurfaceBuffer::UnSet()

    {

    iBuffer = NULL;

    iSurfaceBufferNo = KErrNotFound;

    }

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

// CVtEngDrawNGA::NewL

// Symbian 2nd phase constructor can leave.

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

//

CVtEngDrawNGA* CVtEngDrawNGA::NewL(

    MDisplaySinkObserver* aObserver )

    {

    CVtEngDrawNGA* self = new ( ELeave ) CVtEngDrawNGA( aObserver );

    CleanupStack::PushL( self );

    self->ConstructL( );

    CleanupStack::Pop();

    return self;

    }

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

// CVtEngDrawNGA::~CVtEngDrawNGA

// Destructor. Cannot leave.

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

//

CVtEngDrawNGA::~CVtEngDrawNGA()

    {

    __VTPRINTENTER( "RVD(NGA).~" )

    Cancel();   

    if(iSurfaceCreated)

        {

        if (iSurfaceManager)

            {

            iConfig.iRemoteWindow->RemoveBackgroundSurface(ETrue);

            iConfig.iWsSession->UnregisterSurface(0, iSurfaceId);

            delete iSurfaceChunk;

            iSurfaceChunk = NULL;

            iSurfaceManager->CloseSurface(iSurfaceId);

            iSurfaceUpdateSession.CancelAllUpdateNotifications();

            iSurfaceUpdateSession.Close();

             /* Close the surface manager handle */

            delete iSurfaceManager;

            }

        for ( TInt i = KVtEngMaxSurfaceBuffers-1; i >= 0 ; i-- )

            {

            if (iCallBackTable[i])

                {

                iCallBackTable[i]->Cancel();

                delete iCallBackTable[i];

                iCallBackTable[i] = NULL;

                }

            }

        iSurfaceBuffers[ 0 ].UnSet();

        iSurfaceBuffers[ 1 ].UnSet();

        iSurfaceBuffer0.UnSet();

        iSurfaceBuffer1.UnSet();

        }

    delete iBufferWaiter;   

    iWaitingBuffers.Reset();

    __VTPRINTEXIT( "RVD(NGA).~" )

    }

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

// CVtEngDrawNGA::CVtEngDrawNGA

// C++ constructor. Cannot leave.

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

//

CVtEngDrawNGA::CVtEngDrawNGA( MDisplaySinkObserver* aObserver ) :

    CVtEngDraw( aObserver ),

    iSurfaceFormat( EUidPixelFormatYUV_420Planar )

    {

    iConfig.iRemoteWindow = NULL;

    iConfig.iWsSession = NULL;

    iSurfaceCreated = EFalse;

    iWaitingBuffers.Reset();

    }

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

// CVtEngDrawNGA::BaseConstructL

// Base construction.

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

//

void CVtEngDrawNGA::BaseConstructL( )

    {

    __VTPRINTENTER( "RVD(NGA).BaseConstructL" )

    DoBaseConstructL();

    __VTPRINTEXIT( "RVD(NGA).BaseConstructL" )

    }

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

// CVtEngDrawNGA::CreateSinkL

// Instantiates display sink.

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

//

MDisplaySink* CVtEngDrawNGA::CreateSinkL()

    {

    __VTPRINTENTER( "RVD(NGA).CreateSinkL" )

    TDisplaySinkParamsNGA params;

    GetSinkParams( params );

    MDisplaySink* sink = ::CreateSinkL( params, KNullDesC8 );

    if ( IsFlag( EBaseConstructCalled ) )

        {

        sink->Pause();

        SetFlag( ESinkParamUpdateRequired | ESinkResumeRequired );

        }    

    __VTPRINTEXITR( "RVD(NGA).CreateSinkL flags=%d", params.iFlags )

    return sink;

    }

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

// CVtEngDrawNGA::BaseRefreshL

// If using scaler, start the scaling otherwise draw a bitmap.

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

//

void CVtEngDrawNGA::BaseRefreshL()

    {

    __VTPRINTENTER( "RVD(NGA).BaseRefreshL" )

    __VTPRINTEXIT( "RVD(NGA).BaseRefreshL" )

    }

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

// CVtEngDrawNGA::BaseRefreshBitmapsL

// Refreshes bitmaps sizes and display mode if needed.

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

//

void CVtEngDrawNGA::BaseRefreshBitmapsL()

    {

    __VTPRINTENTER( "RVD(NGA).BaseRefreshBitmapsL" )

    BaseConstructL();

    CreateSurfaceL();

    // set the params for DS

    UpdateSinkParamsL();

    ClearFlag( EFirstFrameReceived );    

    __VTPRINTEXIT( "RVD(NGA).BaseRefreshBitmapsL" )

    }   

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

// CVtEngDrawNGA::BaseDoCancel

// DoCancel for derived class.

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

//

void CVtEngDrawNGA::BaseDoCancel()

    {

    __VTPRINTENTER( "RVD(NGA).BaseDoCancel" )

    __VTPRINTEXIT( "RVD(NGA).BaseDoCancel" )

    }

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

// CVtEngDrawNGA::BaseVerifyConfigL

// Checks current configuration against DSA implementation.

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

//

void CVtEngDrawNGA::BaseVerifyConfigL()

    {

    __VTPRINTENTER( "RVD(NGA).BaseVerifyConfigL" )

    __VTPRINTEXIT( "RVD(NGA).BaseVerifyConfigL" )

    }

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

// CVtEngDrawNGA::BaseRestartL

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

//

void CVtEngDrawNGA::BaseRestartL()

    {

    __VTPRINTENTER( "RVD(NGA).BaseRestartL" )

    __VTPRINTEXIT( "RVD(NGA).BaseRestartL" )

    }

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

// CVtEngDrawNGA::BaseAbortNow

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

//

void CVtEngDrawNGA::BaseAbortNow()

    {

    __VTPRINTENTER( "RVD(NGA).BaseAbortNow" )

    __VTPRINTEXIT( "RVD(NGA).BaseAbortNow" )

    }

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

// CVtEngDrawNGA::BaseStartDrawL

// Starts the drawing.

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

//

void CVtEngDrawNGA::BaseStartDrawL()

    {

    __VTPRINTENTER( "RVD(NGA).BaseStartDrawL" )  

    if ( IsFlag( EBaseConstructCalled ) )

        {

        SetFlag( EBaseBaseStartDrawCalled );

        }

    else

        {

        DoBaseStartDrawL();

        }

    __VTPRINTEXIT( "RVD(NGA).BaseStartDrawL" )

    }

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

// CVtEngDrawNGA::BaseStopDraw

// Stop the drawing.

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

//

void CVtEngDrawNGA::BaseStopDraw()

    {

    // Cancel the timer in any case.

    __VTPRINTENTER( "RVD(NGA).BaseStopDraw" )

    ClearFlag( EBaseBaseStartDrawCalled );

    iWatcher->Cancel();

    iBufferWaiter->Cancel();

    ClearFlag( ERemoteVideoDrawing | EStarted );

    for ( TInt i = KVtEngMaxSurfaceBuffers-1; i >= 0 ; i-- )

        {

        if (iCallBackTable[i])

            {

            iCallBackTable[i]->Cancel();

            }

        }

    Cancel();

    __VTPRINTEXIT( "RVD(NGA).BaseStopDraw" )

    }

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

// CVtEngDrawNGA::BaseSetConfigL

// Sets new configuration.

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

//

void CVtEngDrawNGA::BaseSetConfigL( const TVtEngRenderConfig& aConfig )

    {

    __VTPRINTENTER( "RVD(NGA).BaseSetConfigL" )

    Mem::FillZ( &iConfig, sizeof( TVtEngRenderConfigNGA ) );

    iConfig = aConfig;

    if ( IsFlag( EBaseConstructCalled ) )

        {

        SetFlag( EBaseSetConfigCalled );

        }

    else

        {

        ConfigUpdatedL();

        }

    __VTPRINTEXIT( "RVD(NGA).BaseSetConfigL" )

    }

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

// CVtEngDrawNGA::BaseSetUIForegroundL

// Sets UI foreground status.

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

//

void CVtEngDrawNGA::BaseSetUIForegroundL( TBool aForeground )

    {

    __VTPRINTENTER( "RVD(NGA).BaseSetUIForegroundL" )

    __VTPRINTEXIT( "RVD(NGA).BaseSetUIForegroundL" )

    }

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

// CVtEngDrawNGA::BaseRequestLastFrame

// Request update last remote video frame through MVtEngFrameObserver::vtSetFrame

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

//

void CVtEngDrawNGA::BaseRequestLastFrame()

    {

    __VTPRINTENTER( "RVD(NGA).BaseRequestLastFrame" )

    __VTPRINTEXIT( "RVD(NGA).BaseRequestLastFrame" )    

    }

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

// CVtEngDrawNGA::BaseVideoFrameSizeChangedL

// Called when incoming frame buffer size changes.

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

//

void CVtEngDrawNGA::BaseVideoFrameSizeChangedL( const TSize& /*aTo*/ )

    {

    __VTPRINTENTER( "RVD(NGA).BaseVideoFrameSizeChangedL" )

    BaseConstructL();

    TInt err;

    iConfig.iRemoteWindow->RemoveBackgroundSurface(ETrue);

    iConfig.iWsSession->UnregisterSurface(0, iSurfaceId);

    iSurfaceChunk->Close();

    delete iSurfaceChunk;

    iSurfaceChunk = NULL;

    iSurfaceManager->CloseSurface(iSurfaceId);

    iSurfaceUpdateSession.CancelAllUpdateNotifications();

    iSurfaceUpdateSession.Close();

    /* Close the surface manager handle */

    iSurfaceManager->Close();

    delete iSurfaceManager;

    iSurfaceManager = 0;

    for ( TInt i = KVtEngMaxSurfaceBuffers-1; i >= 0 ; i-- )

        {

            if (iCallBackTable[i])

                {

                iCallBackTable[i]->Cancel();

                delete iCallBackTable[i];

                iCallBackTable[i] = NULL;

                }

        }

    iSurfaceBuffers[ 0 ].UnSet();

    iSurfaceBuffers[ 1 ].UnSet();

    iSurfaceBuffer0.UnSet();

    iSurfaceBuffer1.UnSet();

    iWaitingBuffers.Reset();

    err = iSurfaceUpdateSession.Connect();    

    User::LeaveIfError(err);

    iSurfaceManager = new RSurfaceManager();

    User::LeaveIfNull(iSurfaceManager); 

    err = iSurfaceManager->Open();

    User::LeaveIfError(err);

    RSurfaceManager::TSurfaceCreationAttributesBuf attributes;

    attributes().iPixelFormat           = iSurfaceFormat; 

    attributes().iSize                  = iSourceSize;

    attributes().iBuffers               = KVtEngMaxSurfaceBuffers;

    //attributes().iStride                = iSourceSize.iWidth*2;

    attributes().iStride                = iSourceSize.iWidth*3/2;

    attributes().iOffsetToFirstBuffer   = 0;

    attributes().iAlignment             = 4;

    attributes().iContiguous            = EFalse;

    attributes().iMappable              = ETrue;

    err = iSurfaceManager->CreateSurface(attributes, iSurfaceId);

    User::LeaveIfError(err);  

    // Map to chunk

    iSurfaceChunk = new RChunk();

    User::LeaveIfNull(iSurfaceChunk);    

    err = iSurfaceManager->MapSurface(iSurfaceId, *iSurfaceChunk);

    User::LeaveIfError(err);    

    // Get the info from the surfaceManager

    RSurfaceManager::TInfoBuf info;

    err = iSurfaceManager->SurfaceInfo(iSurfaceId, info);

    User::LeaveIfError(err);    

    TInt offset;

    iSurfaceManager->GetBufferOffset(iSurfaceId, 0, offset);

    iSurfaceBuffer0.Set(iSurfaceChunk->Base() + offset, 0 );

    iSurfaceManager->GetBufferOffset(iSurfaceId, 1, offset);

    iSurfaceBuffer1.Set(iSurfaceChunk->Base() + offset, 1 );

    iCallBackTable[0] = new(ELeave) CActiveCallBack(

            TCallBack(SurfaceBuffer0Ready, this), 

            CActive::EPriorityStandard-1);

    CActiveScheduler::Add(iCallBackTable[0]);

    iCallBackTable[1] = new(ELeave) CActiveCallBack(

            TCallBack(SurfaceBuffer1Ready, this), 

            CActive::EPriorityStandard-1);

    CActiveScheduler::Add(iCallBackTable[1]);

    iSurfaceCreated = ETrue;    

    ClearFlag( EInitializePostingSurfaceCalled );   

    // set the params for DS

    UpdateSinkParamsL();

    ClearFlag( EFirstFrameReceived );  

    __VTPRINTEXIT( "RVD(NGA).BaseVideoFrameSizeChangedL" )

    }

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

// CVtEngDrawDSA::Config

// Returns current configuration.

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

//

TVtEngRenderConfig& CVtEngDrawNGA::Config()

    {

    return iConfig;

    }

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

// CVtEngDrawNGA::RunL

// CActive heir execution method.

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

//

void CVtEngDrawNGA::RunL()

    {

    __VTPRINTENTER( "RVD(NGA).RunL" )

    TInt bitmapNo( iStatus.Int() );

    if ( bitmapNo < KErrNone )

        {

        __VTPRINT( DEBUG_MEDIA, "RVD(NGA).RunL notify rvd problem" )

        CVtEngEventManager::NotifyEvent( KVtEngRemoteRenderingProblem );

        return;

        }

    TVtEngBuffer& buffer = iSurfaceBuffers[ bitmapNo ];

    if ( !iDSUpdated )

        {

        __VTPRINT( DEBUG_MEDIA, "RVD(NGA).RunL !Updated" )

        __VTPRINTEXIT( "RVD(NGA).RunL" )

        return;

        }

    else if ( buffer.SurfaceBuffer() == NULL )

        {

        __VTPRINT( DEBUG_MEDIA, "RVD(NGA).RunL signalled with NULL buffer" )

        TInt result( iBufferWaiter->FetchBuffer() );

        User::LeaveIfError( result );

        __VTPRINTEXIT( "RVD(NGA).RunL" )

        return;

        }

    // Image received, reset counter.

    iCheckpoint = KVtEngWatcherThreshold;

    __VTPRINT2( DEBUG_MEDIA, "RVD(NGA).RunL flags=%d", iFlags )

    TBool firstFrame( !IsFlag ( EFirstFrameReceived ) );