--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/vtengines/videoteleng/Src/Media/CVtEngDrawNGA.cpp Mon Nov 23 14:47:47 2009 +0200
@@ -0,0 +1,1025 @@
+/*
+* 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();
+ TTimeStamp timeStamp;
+ iSurfaceUpdateSession.NotifyWhenDisplayed(iCallBackTable[surfaceno]->iStatus, timeStamp);
+ 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 );
+ }
+
+ DoSurfaceBuffer0Ready();
+ DoSurfaceBuffer1Ready();
+
+ User::LeaveIfError( iBufferWaiter->FetchBuffer() );
+
+
+ SetFlag( ERemoteVideoDrawing );
+ ClearFlag( EBaseBaseStartDrawCalled );
+ __VTPRINTEXIT( "RVD(NGA).DoBaseStartDrawL" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawNGA::DoCreateSurfaceL
+// Create surface implementation.
+// -----------------------------------------------------------------------------
+//
+void CVtEngDrawNGA::DoCreateSurfaceL()
+ {
+ __VTPRINTENTER( "RVD(NGA).DoCreateSurfaceL" )
+ TInt err;
+
+ if(iSurfaceCreated)
+ {
+
+ if (iSurfaceManager)
+ {
+ return;
+
+ // Last return statement is for fixing an error causes
+ // green screen of remote video when swapping image after
+ // remote peer disabled video.
+ // So we return here to prevent recreate the surface object
+ // at this moment, codes below should NOT be removed due to
+ // potential future uses.
+ 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 );
+
+ iConfig.iWsSession->RegisterSurface(0, iSurfaceId);
+ iConfig.iRemoteWindow->SetBackgroundSurface(iSurfaceId);
+
+ 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 );
+ __VTPRINTEXIT( "RVD(NGA).DoCreateSurfaceL" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawNGA::DoUpdateSinkParamsL
+// Updates sink params
+// -----------------------------------------------------------------------------
+//
+void CVtEngDrawNGA::DoUpdateSinkParamsL()
+ {
+ __VTPRINTENTER( "RVD(NGA).DoUpdateSinkParamsL" )
+ TDisplaySinkParamsNGA params;
+ GetSinkParams( params );
+ DisplaySink().UpdateSinkParamsL( params, iDSUpdated );
+ ClearFlag( ESinkParamUpdateRequired );
+ if ( IsFlag( ESinkResumeRequired ) )
+ {
+ DisplaySink().Resume();
+ ClearFlag( ESinkResumeRequired );
+ }
+ __VTPRINTEXIT( "RVD(DP).DoUpdateSinkParamsL" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawNGA::CreateSurfaceL
+// Create surface.
+// -----------------------------------------------------------------------------
+//
+void CVtEngDrawNGA::CreateSurfaceL()
+ {
+ __VTPRINTENTER( "RVD(NGA).CreateSurfaceL" )
+ if ( IsFlag( EBaseConstructCalled ) )
+ {
+ SetFlag( EInitializePostingSurfaceCalled );
+ }
+ else
+ {
+ DoCreateSurfaceL();
+ }
+ __VTPRINTEXIT( "RVD(NGA).CreateSurfaceL" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawNGA::GetSinkParams
+// -----------------------------------------------------------------------------
+//
+void CVtEngDrawNGA::GetSinkParams( TDisplaySinkParamsNGA& aSinkParams )
+ {
+ __VTPRINTENTER( "RVD(NGA).GetSinkParams" )
+ Mem::FillZ( &aSinkParams, sizeof( TDisplaySinkParamsNGA ) );
+ aSinkParams.iThreadId = RThread().Id();
+ aSinkParams.iRequestStatusPtr = &iStatus;
+ aSinkParams.iObserver = iObserver;
+ aSinkParams.iSurfaceBuffer1 = &iSurfaceBuffers[ 0 ].Buffer();
+ aSinkParams.iSurfaceBuffer2 = &iSurfaceBuffers[ 1 ].Buffer();
+ aSinkParams.iFrameSize = iSourceSize;
+ aSinkParams.iSurfaceFormat = iSurfaceFormat;
+ aSinkParams.iFlags = TDisplaySinkParams::EDisplaySinkNGA;
+ __VTPRINTEXITR( "RVD(NGA).GetSinkParams flags=%d",
+ (TInt) aSinkParams.iFlags )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawNGA::DisplaySink
+// Returns reference to sink.
+// -----------------------------------------------------------------------------
+//
+MDisplaySink& CVtEngDrawNGA::DisplaySink()
+ {
+ return *iDisplaySink;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawNGA::SetToSink
+// Sets posting buffer to sink.
+// -----------------------------------------------------------------------------
+//
+void CVtEngDrawNGA::SetAvailableToSink( TVTSurfaceBuffer* aBuffer )
+ {
+ __VTPRINTENTER( "RVD(NGA).SetAvailableToSink" )
+ for ( TInt i = MDisplaySink::EFirstBitmap;
+ i < MDisplaySink::EFirstBitmap + KVtEngMaxSurfaceBuffers; i++ )
+ {
+ if ( !iSurfaceBuffers[ i ].IsSet() )
+ {
+ iSurfaceBuffers[ i ].Set( aBuffer );
+ Activate();
+ DisplaySink().SetBitmapAvailable(
+ static_cast< MDisplaySink::TBitmapNo >( i ) );
+ break;
+ }
+ }
+ __VTPRINTEXIT( "RVD(NGA).SetAvailableToSink" )
+ }
+
+TInt CVtEngDrawNGA::SurfaceBuffer0Ready( TAny* aAny )
+ {
+ __VTPRINTENTER( "RVD(NGA).SurfaceBuffer0Ready" )
+ __VTPRINTEXIT( "RVD(NGA).SurfaceBuffer0Ready" )
+ return ((CVtEngDrawNGA*)aAny)->DoSurfaceBuffer0Ready();
+ }
+
+TBool CVtEngDrawNGA::DoSurfaceBuffer0Ready()
+ {
+ __VTPRINTENTER( "RVD(NGA).DoSurfaceBuffer0Ready" )
+ if ( iSubmitPending )
+ {
+ iSubmitPending = EFalse;
+ }
+ if (!iWaitingBuffers.IsEmpty())
+ {
+ TVtEngBuffer* buffer = iWaitingBuffers.First();
+ TInt surfaceno = buffer->SurfaceBuffer()->SurfaceNo();
+ __VTPRINT2( DEBUG_MEDIA, "RVD(NGA).DoSurfaceBuffer0Ready, surface buffer %d is in waitingqueue", surfaceno )
+ iCallBackTable[surfaceno]->iStatus = KRequestPending;
+ iCallBackTable[surfaceno]->SetActive();
+ TTimeStamp timeStamp;
+ iSurfaceUpdateSession.NotifyWhenDisplayed(iCallBackTable[surfaceno]->iStatus, timeStamp);
+ iSubmitPending = ETrue;
+ iSurfaceUpdateSession.SubmitUpdate(0, iSurfaceId, surfaceno, NULL);
+ iWaitingBuffers.Remove(*buffer);
+ buffer->UnSet();
+ }
+ iBufferWaiter->BufferAvailable(iSurfaceBuffer0);
+ __VTPRINTEXIT( "RVD(NGA).DoSurfaceBuffer0Ready" )
+ return ETrue;
+ }
+
+TInt CVtEngDrawNGA::SurfaceBuffer1Ready( TAny* aAny )
+ {
+ __VTPRINTENTER( "RVD(NGA).SurfaceBuffer1Ready" )
+ __VTPRINTEXIT( "RVD(NGA).SurfaceBuffer1Ready" )
+ return ((CVtEngDrawNGA*)aAny)->DoSurfaceBuffer1Ready();
+ }
+
+TBool CVtEngDrawNGA::DoSurfaceBuffer1Ready()
+ {
+ __VTPRINTENTER( "RVD(NGA).DoSurfaceBuffer1Ready" )
+ if ( iSubmitPending )
+ {
+ iSubmitPending = EFalse;
+ }
+
+ if (!iWaitingBuffers.IsEmpty())
+ {
+ TVtEngBuffer* buffer = iWaitingBuffers.First();
+ TInt surfaceno = buffer->SurfaceBuffer()->SurfaceNo();
+ __VTPRINT2( DEBUG_MEDIA, "RVD(NGA).DoSurfaceBuffer0Ready, surface buffer %d is in waitingqueue", surfaceno )
+ iCallBackTable[surfaceno]->iStatus = KRequestPending;
+ iCallBackTable[surfaceno]->SetActive();
+ TTimeStamp timeStamp;
+ iSurfaceUpdateSession.NotifyWhenDisplayed(iCallBackTable[surfaceno]->iStatus, timeStamp);
+ iSubmitPending = ETrue;
+ iSurfaceUpdateSession.SubmitUpdate(0, iSurfaceId, surfaceno, NULL);
+ iWaitingBuffers.Remove(*buffer);
+ buffer->UnSet();
+ }
+ iBufferWaiter->BufferAvailable(iSurfaceBuffer1);
+ __VTPRINTEXIT( "RVD(NGA).DoSurfaceBuffer1Ready" )
+ return ETrue;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawNGA::TVtEngBuffer::TVtEngBuffer
+//
+// -----------------------------------------------------------------------------
+//
+CVtEngDrawNGA::TVtEngBuffer::TVtEngBuffer()
+ : iBuffer( 0 ), iSurfaceBuffer(0)
+ {
+ __VTPRINTENTER( "RVD(NGA).Buffer.Ctor" )
+ __VTPRINTEXIT( "RVD(NGA).Buffer.Ctor" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawNGA::TVtEngBuffer::Set
+//
+// -----------------------------------------------------------------------------
+//
+void CVtEngDrawNGA::TVtEngBuffer::Set( TVTSurfaceBuffer* aBuffer )
+ {
+ __VTPRINTENTER( "RVD(NGA).Buffer.Set" )
+ iSurfaceBuffer = aBuffer;
+ iBuffer = aBuffer->Buffer();
+ __VTPRINTEXIT( "RVD(NGA).Buffer.Set" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawNGA::TVtEngBuffer::UnSet
+//
+// -----------------------------------------------------------------------------
+//
+void CVtEngDrawNGA::TVtEngBuffer::UnSet()
+ {
+ __VTPRINTENTER( "RVD(NGA).Buffer.UnSet" )
+ iSurfaceBuffer = 0;
+ iBuffer = 0;
+ __VTPRINTEXIT( "RVD(NGA).Buffer.UnSet" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawNGA::TVtEngBuffer::IsSet
+//
+// -----------------------------------------------------------------------------
+//
+TBool CVtEngDrawNGA::TVtEngBuffer::IsSet() const
+ {
+ return ( iSurfaceBuffer != NULL );
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawNGA::TVtEngBuffer::Buffer
+//
+// -----------------------------------------------------------------------------
+//
+TVTSurfaceBuffer* &CVtEngDrawNGA::TVtEngBuffer::SurfaceBuffer()
+ {
+ return iSurfaceBuffer;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawNGA::TVtEngBuffer::Buffer
+//
+// -----------------------------------------------------------------------------
+//
+TUint8* &CVtEngDrawNGA::TVtEngBuffer::Buffer()
+ {
+ return iBuffer;
+ }
+// -----------------------------------------------------------------------------
+// CVtEngDrawNGA::CVtEngBufferWaiter::CVtEngBufferWaiter
+// -----------------------------------------------------------------------------
+//
+CVtEngDrawNGA::CVtEngBufferWaiter::CVtEngBufferWaiter
+ //( CVideoRenderer& aVideoRenderer, MVtEngNGABufferWaiterObserver& aObserver )
+ ( MVtEngNGABufferWaiterObserver& aObserver )
+ : CActive( CActive::EPriorityStandard ),
+ iObserver( &aObserver )
+ {
+ __VTPRINTENTER( "RVD(NGA).BufferWaiter.Ctor" )
+ for ( TInt i = 0; i < KVtEngMaxSurfaceBuffers; i++ )
+ {
+ this->iBuffers[ i ] = NULL;
+ }
+ CActiveScheduler::Add( this );
+ __VTPRINTEXIT( "RVD(NGA).BufferWaiter.Ctor" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawNGA::CVtEngBufferWaiter::~CVtEngBufferWaiter
+// -----------------------------------------------------------------------------
+//
+CVtEngDrawNGA::CVtEngBufferWaiter::~CVtEngBufferWaiter()
+ {
+ __VTPRINTENTER( "RVD(NGA).BufferWaiter.~" )
+ Cancel();
+ __VTPRINTEXIT( "RVD(NGA).BufferWaiter.~" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawNGA::CVtEngBufferWaiter::Activate
+// -----------------------------------------------------------------------------
+//
+void CVtEngDrawNGA::CVtEngBufferWaiter::Activate()
+ {
+ __VTPRINTENTER( "RVD(NGA).BufferWaiter.Activate" )
+ iStatus = KRequestPending;
+ SetActive();
+ __VTPRINTEXIT( "RVD(NGA).BufferWaiter.Activate" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawNGA::CVtEngBufferWaiter::FetchBuffer
+// -----------------------------------------------------------------------------
+//
+TInt CVtEngDrawNGA::CVtEngBufferWaiter::FetchBuffer()
+ {
+ __VTPRINTENTER( "RVD(NGA).BufferWaiter.FetchBuffer" )
+ if ( IsActive() )
+ {
+ __VTPRINTEXIT( "RVD(NGA).BufferWaiter.FetchBuffer 1" )
+ return KErrNone;
+ }
+
+ Activate();
+ if (iStatus == KRequestPending)
+ {
+ for ( TInt i = 0; i < KVtEngMaxSurfaceBuffers; i++ )
+ {
+ if(this->iBuffers[ i ] != NULL)
+ {
+ TRequestStatus* status = &iStatus;
+ User::RequestComplete( status, KErrNone );
+ break;
+ }
+ }
+ }
+ __VTPRINTEXIT( "RVD(NGA).BufferWaiter.FetchBuffer 2" )
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawNGA::CVtEngBufferWaiter::BufferAvailable
+// -----------------------------------------------------------------------------
+//
+void CVtEngDrawNGA::CVtEngBufferWaiter::BufferAvailable(TVTSurfaceBuffer& aBuffer)
+{
+ __VTPRINTENTER( "RVD(NGA).BufferWaiter.BufferAvailable" )
+ for ( TInt i = 0; i < KVtEngMaxSurfaceBuffers; i++ )
+ {
+ if(this->iBuffers[ i ] == NULL )
+ {
+ this->iBuffers[ i ]= &aBuffer;
+ break;
+ }
+ }
+
+ if(iStatus == KRequestPending )
+ {
+ for ( TInt i = 0; i < KVtEngMaxSurfaceBuffers; i++ )
+ {
+ if(this->iBuffers[ i ] != NULL)
+ {
+ TRequestStatus* status = &iStatus;
+ User::RequestComplete( status, KErrNone );
+ break;
+ }
+ }
+ }
+
+ __VTPRINTEXIT( "RVD(NGA).BufferWaiter.BufferAvailable" )
+}
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawNGA::CVtEngBufferWaiter::RunL
+// -----------------------------------------------------------------------------
+//
+void CVtEngDrawNGA::CVtEngBufferWaiter::RunL()
+ {
+ __VTPRINTENTER( "RVD(NGA).BufferWaiter.RunL" )
+ TInt result( iStatus.Int() );
+ if ( result == KErrNone )
+ {
+ for ( TInt i = 0; i < KVtEngMaxSurfaceBuffers; i++ )
+ {
+ if(this->iBuffers[ i ] != NULL)
+ {
+ TRAP_IGNORE( iObserver->BufferReadyL( this->iBuffers[ i ] ) );
+ this->iBuffers[ i ] = NULL;
+ break;
+ }
+ }
+ }
+ else
+ {
+ iObserver->FetchError( result );
+ }
+ __VTPRINTEXIT( "RVD(NGA).BufferWaiter.RunL" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngDrawNGA::CVtEngBufferWaiter::DoCancel
+// -----------------------------------------------------------------------------
+//
+void CVtEngDrawNGA::CVtEngBufferWaiter::DoCancel()
+ {
+ __VTPRINTENTER( "RVD(NGA).BufferWaiter.DoCancel" )
+
+ if ( iStatus == KRequestPending )
+ {
+ TRequestStatus* status = &iStatus;
+ User::RequestComplete(status, KErrCancel);
+ }
+
+ __VTPRINTEXIT( "RVD(NGA).BufferWaiter.DoCancel" )
+ }
+
+// End of File