diff -r 000000000000 -r ed9695c8bcbe vtengines/videoteleng/Src/Media/CVtEngDrawNGA.cpp --- /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 +#include +#include +#include + +// 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