/*

* 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>

// 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);

            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();

        }

    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" )

    __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 ) );

    SetFlag( EFirstFrameReceived );

    if ( firstFrame )

        {

        CVtEngEventManager::NotifyEvent( KVtEngRemoteVideoStarted );

        }

    TInt surfaceno = buffer.SurfaceBuffer()->SurfaceNo();

    __VTPRINT2( DEBUG_MEDIA, "RVD(NGA).RunL received buffer surface id %d", surfaceno )

    if ( iSubmitPending )

        {

        __VTPRINT( DEBUG_MEDIA, "RVD(NGA).RunL submit pending")

        iWaitingBuffers.AddLast(buffer);

        }

    else

        {

        iCallBackTable[surfaceno]->iStatus = KRequestPending;

        iCallBackTable[surfaceno]->SetActive();

        iSubmitPending = ETrue;

        iSurfaceUpdateSession.SubmitUpdate(0, iSurfaceId, surfaceno, NULL); 

        buffer.UnSet();

        }

    if ( iSurfaceBuffers[ KVtEngBitmapNoReversed[ bitmapNo ] ].IsSet() )

        {

        __VTPRINT2( DEBUG_MEDIA, "RVD(NGA).RunL reactivating for buffer %d",

            KVtEngBitmapNoReversed[ bitmapNo ] )

        Activate();

        DisplaySink().NextFrame();

        }    

    TInt result = iBufferWaiter->FetchBuffer();

    User::LeaveIfError( result );    

    __VTPRINTEXIT( "RVD(NGA).RunL" )

    }

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

// CVtEngDrawNGA::BufferReadyL

// BufferReadyL

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

//

void CVtEngDrawNGA::BufferReadyL( TVTSurfaceBuffer* aBuffer )

    {

    __VTPRINTENTER( "RVD(NGA).BufferReadyL" )

    SetAvailableToSink( aBuffer );

    __VTPRINTEXIT( "RVD(NGA).BufferReadyL" )

    }

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

// CVtEngDrawNGA::FetchError

// Buffer fetching error

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

//

void CVtEngDrawNGA::FetchError( TInt )

    {

    __VTPRINTENTER( "RVD(NGA).FetchError" )

    CVtEngEventManager::NotifyEvent( KVtEngRemoteRenderingProblem );

    __VTPRINTEXIT( "RVD(NGA).FetchError" )

    }    

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

// CVtEngDrawNGA::DoBaseConstructL

// Base construction implementation

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

//

void CVtEngDrawNGA::DoBaseConstructL()

    {

    __VTPRINTENTER( "RVD(NGA).DoBaseConstructL" )

    delete iBufferWaiter;

    iBufferWaiter = NULL;

    iBufferWaiter =

        new ( ELeave ) CVtEngBufferWaiter( *this );

    for ( TInt i = MDisplaySink::EFirstBitmap;

          i < MDisplaySink::EFirstBitmap + KVtEngMaxSurfaceBuffers; i++ )

        {

        iSurfaceBuffers[ i ].UnSet();

        }     

    ClearFlag( EBaseConstructCalled );          

    __VTPRINTEXIT( "RVD(NGA).DoBaseConstructL" )

    }

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

// CVtEngDrawNGA::UpdateSinkParamsL

// Updates sink params

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

//

void CVtEngDrawNGA::UpdateSinkParamsL()

    {

    __VTPRINTENTER( "RVD(NGA).UpdateSinkParamsL" )

    if ( IsFlag( EBaseConstructCalled ) )

        {

        SetFlag( ESinkParamUpdateRequired );

        }

    else

        {

        DoUpdateSinkParamsL();

        }

    __VTPRINTEXIT( "RVD(NGA).UpdateSinkParamsL" )

    }

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

// CVtEngDrawNGA::DoBaseStartDrawL

//

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

//

void CVtEngDrawNGA::DoBaseStartDrawL()

    {

    __VTPRINTENTER( "RVD(NGA).DoBaseStartDrawL" )

    SetFlag( EReadyInternal );

    if ( !iWatcher->IsActive() )

       {

       iWatcher->Start( KVtEngWatcherTimeout, KVtEngWatcherTimeout,

             iCallback );

       }