/*

* Copyright (c) 2003 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:    

*

*/

// INCLUDES FILES

#include <w32std.h>

#include <AudioPreference.h> 

#include <mmcccodecinformationfactory.h>

#include <mmcccodecinformation.h>

#include "mccvideosinkimpl.h"

#include "mmcccodech263.h"

#include "mccvideosourcesinklogs.h"

#include "mccinternalevents.h"

#include "CXPSPacketSink.h"

#include "mmcccodecamr.h"

#include "mccvideosinkuser.h"

#include "mccdef.h"

#include "mccredrawhandler.h"

#include "mccinternaldef.h"

#include <videoplayer2.h>

// CONSTANTS

_LIT8( KMccSdpInboundStart,

"v=0\r\n\

o=- 63327476467155000 63327476467155000 IN IP4 0.0.0.0\r\n\

s=-\r\n\

c=IN IP4 0.0.0.0\r\n\

t=0 0\r\n" );

_LIT8( KMccSdpInboundAudio,

"m=audio 25001 RTP/AVP %d\r\n\

a=rtpmap:%d %S/8000\r\n\

a=ptime:%d\r\n\

a=maxptime:%d\r\n\

a=fmtp:%d octet-align=%d; mode-set=%S\r\n" );

_LIT8( KMccSdpInboundVideo,

"m=video 25002 RTP/AVP %d\r\n\

a=rtpmap:%d %S/90000\r\n\

a=fmtp:%d %S\r\n\

a=XpsPyldBufSize:integer;%d\r\n\

a=FrameWidth:integer;%d\r\n\

a=FrameHeight:integer;%d\r\n" );

_LIT8( KMccSdpInboundPreroll, "a=DisableMinPrerollCheck:integer;1\r\n\

a=Preroll:integer;%d\r\n" );

_LIT8( KMccSdpInboundDisableVideoClock, "a=DisableVideoClock:integer;1\r\n" );

_LIT( KMccWindowGroupName,"32MccVideoWindow" );

_LIT( KMccHelixSource,"MccDataSource%d");

// NOTE: filepath separator changed to unix style because of problem at Helix side

_LIT( KMccPacketSource, "file://c:/notinuse.xps?XPSServer=%S" );

// MACROS

#define MCC_BITRATE_IN_MASK( bitratemask, bitrate ) bitrate == ( bitratemask & bitrate )

// ================= MEMBER FUNCTIONS =======================

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

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CMccVideoSinkImpl::CMccVideoSinkImpl( TUint32 aEndpointId ) :

    iEndpointId( aEndpointId ),

    iVolumeAdaptation( 0 ),

    iPreroll( 0 ), 

    iPrerollSet( EFalse )

    {

    	__V_SOURCESINK_CONTROLL( "CMccVideoSinkImpl::CMccVideoSinkImpl" ) 

    iSettings.iVideoFrameRate = KMccDefaultVideoFrameRate;

    }

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

// Symbian 2nd phase constructor can leave.

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

//

void CMccVideoSinkImpl::ConstructL( const TMccVideoSinkSetting& aSettings )

    {

    __V_SOURCESINK_CONTROLL( "CMccVideoSinkImpl::ConstructL" ) 

    iSettings = aSettings;

    SetVideoFrameRate( aSettings.iVideoFrameRate );

    const TInt KMccVideoSinkMaxSdpLen = 800;

    iSdp = HBufC8::NewL( KMccVideoSinkMaxSdpLen );

    __V_SOURCESINK_CONTROLL( "CMccVideoSinkImpl::ConstructL, init Helix" ) 

	iPacketSink = CXPSPacketSink::New();

	__ASSERT_ALWAYS(iPacketSink, User::Leave( KErrNotReady ) );

	const TInt KMaxTUintAsDesLen = 12;

	iServerName  = 

	    HBufC::NewL( KMccHelixSource().Length() + KMaxTUintAsDesLen );

	iServerName->Des().AppendFormat( KMccHelixSource, (TUint32)this );

	iPacketSink->Init( *iServerName, this );

    __V_SOURCESINK_CONTROLL( "CMccVideoSinkImpl::ConstructL, init Helix complete" ) 

    iSearchTermUser = CMccVideoSinkUser::NewL( 

        NULL, KNullUid, 0, iSettings.iVideoFrameRate, *iPacketSink );

    User::LeaveIfError( iRwSession.Connect() );

	__V_SOURCESINK_CONTROLL( "CMccVideoSinkImpl::ConstructL connected to ws" )

    __V_SOURCESINK_CONTROLL_INT2( "CMccVideoSinkImpl window pos:", 

                                  iSettings.iLocation.iX, " ", iSettings.iLocation.iY ) 

    __V_SOURCESINK_CONTROLL_INT2( "CMccVideoSinkImpl window size (w,h):", 

                                  iSettings.iSize.iWidth, " ", iSettings.iSize.iHeight ) 

    __V_SOURCESINK_CONTROLL_INT1( "CMccVideoSinkImpl window ordinal pos:", 

                                  iSettings.iWindowOrdinalPosition )

    __V_SOURCESINK_CONTROLL_INT1( "CMccVideoSinkImpl window ordinal priority:", 

                                  iSettings.iWindowOrdinalPriority )

    __V_SOURCESINK_CONTROLL_INT1( "CMccVideoSinkImpl rotation:", 

                                  iSettings.iRotation )

	// Create window group

	TInt groupId = iRwSession.GetFocusWindowGroup();

    iRwGroup = new (ELeave) RWindowGroup( iRwSession );	

	User::LeaveIfError( iRwGroup->Construct( groupId, EFalse ) );	

    iRwGroup->SetName( KMccWindowGroupName );

    // TBD: use also iWindowOrdinalPriority

    iRwGroup->SetOrdinalPosition( iSettings.iWindowOrdinalPosition );

    // Create screen device

	iDev = new (ELeave) CWsScreenDevice( iRwSession );

	User::LeaveIfError( iDev->Construct( iSettings.iDeviceIndex ) ); 

	// Create window

	iRw = new (ELeave) RWindow( iRwSession );

    User::LeaveIfError( iRw->Construct( *iRwGroup, (TUint32)iRw ) );

    iRw->SetPosition( iSettings.iLocation );

    iRw->SetSize( iSettings.iSize );

    iRw->SetOrdinalPosition( iSettings.iWindowOrdinalPosition );

	__V_SOURCESINK_CONTROLL( "CMccVideoSinkImpl: creating graphics context ..." )

    User::LeaveIfError( iDev->CreateContext( iGc ) );

	__V_SOURCESINK_CONTROLL( "CMccVideoSinkImpl: graphics context created!" )

    iRw->Activate();

    iRwSession.Flush();

    __V_SOURCESINK_CONTROLL( "CMccVideoSinkImpl: creating redraw handler" )

    iRedrawHandler = CMccRedrawHandler::NewL( iRwSession, *iRw, *iGc );

    __V_SOURCESINK_CONTROLL( "CMccVideoSinkImpl: created redraw handler" )

    // Videoplayer needs to be created last, otherwise destruction

    // order causes problems

    iVideoPlayer = CVideoPlayerUtility2::NewL( 

            *this,

            iSettings.iPriority.iPriority,

            iSettings.iPriority.iPref );

    __V_SOURCESINK_CONTROLL( "CMccVideoSinkImpl: created CVideoPlayerUtility2" )

    // Wait for MvpuoOpenComplete before adding display window

    RegisterForVideoLoadingNotification( *this );

    }

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

// Two-phased constructor.

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

//

CMccVideoSinkImpl* CMccVideoSinkImpl::NewL( 

    const TMccVideoSinkSetting& aSettings,

    TUint32 aEndpointId )

    {

    __V_SOURCESINK_CONTROLL( "CMccVideoSinkImpl::NewL" ) 

    CMccVideoSinkImpl* self = new ( ELeave ) CMccVideoSinkImpl( aEndpointId );

    CleanupStack::PushL( self );

    self->ConstructL( aSettings );

    CleanupStack::Pop( self ); // self 

    return self;

    }

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

// Destructor

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

//

CMccVideoSinkImpl::~CMccVideoSinkImpl()

    {

    __V_SOURCESINK_CONTROLL( "CMccVideoSinkImpl::~CMccVideoSinkImpl" )

    SetCurrentUser( NULL );

    delete iSdp;

    if ( iPacketSink )

        {

        for ( TInt i = 0; i < iUsers.Count(); i++ )

            {

            iPacketSink->StreamEnd( iUsers[ i ]->iStreamId );

            }

        iPacketSink->Reset();

        }

	iUsers.ResetAndDestroy();

    delete iPacketSink;

    if( iVideoPlayer )

		{

		Stop();

		iVideoPlayer->Close();	

		}

	delete iVideoPlayer;

	delete iRedrawHandler;

	delete iGc;

	delete iDev;

    delete iRw;

    delete iRwGroup;	

	iRwSession.Close();

	delete iServerName;

	delete iSearchTermUser;

    __V_SOURCESINK_CONTROLL( "CMccVideoSinkImpl::~CMccVideoSinkImpl, exit" )

    }

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

// CMccVideoSinkImpl::SinkThreadLogon()

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

//

TInt CMccVideoSinkImpl::SinkThreadLogon( MAsyncEventHandler& aEventHandler )

	{

	// Give zero stream id at beginning, correct id is set later

	TRAPD( err, AddUserL( aEventHandler ) );

	return err;

	}

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

// CMccVideoSinkImpl::SinkThreadLogoff()

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

//     

TBool CMccVideoSinkImpl::SinkThreadLogoff()

	{

	if ( iCurrentUser )

	    {

	    TUint streamId( 0 );

	    if ( ResolveStreamId( iCurrentUser, streamId ) == KErrNone )

	        {

            RemoveVideoSinkUser( iCurrentUser, streamId );

	        }

	    iCurrentUser = NULL;

	    }	

	return ( iUsers.Count() == 0 );

	}

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

// CMccVideoSinkImpl::SetCurrentUser()

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

// 	

void CMccVideoSinkImpl::SetCurrentUser( MAsyncEventHandler* aEventHandler )

    {

    iCurrentUser = aEventHandler;

    }

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

// CMccVideoSinkImpl::OpenL()

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

//

void CMccVideoSinkImpl::OpenL()

    {

    __V_SOURCESINK_CONTROLL( "CMccVideoSinkImpl::OpenL" )

    if ( SetVideoSinkState( EOpening ) )

        {

        __V_SOURCESINK_CONTROLL( "CMccVideoSinkImpl::OpenL, doing setup" )

        RemoteSetupL();

        __V_SOURCESINK_CONTROLL( "CMccVideoSinkImpl::OpenL, opening" )

        __ASSERT_ALWAYS( iVideoPlayer, User::Leave( KErrArgument ) );

        __ASSERT_ALWAYS( iPacketSink, User::Leave( KErrArgument ) );

        const TUid KUidController = { 0x101F8514 };  //RNAVCONTROLLER.DLL

        HBufC* url = 

            HBufC::NewLC( KMccPacketSource().Length() + iServerName->Length() );

        url->Des().AppendFormat( KMccPacketSource, &*iServerName );

        iVideoPlayer->OpenUrlL( *url, 0, KNullDesC8, KUidController );

        CleanupStack::PopAndDestroy( url );

        }

    else if ( iState == EOpened )

        {

        // If already opened, prepare can be called immediately

        Prepare();

        }

    else

        {

        __V_SOURCESINK_CONTROLL( 

            "CMccVideoSinkImpl::OpenL, waiting for opening" )

        }

    __V_SOURCESINK_CONTROLL( "CMccVideoSinkImpl::OpenL, exit" )

    }

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

// CMccVideoSinkImpl::Prepare()

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

//

void CMccVideoSinkImpl::Prepare()

    {

    __V_SOURCESINK_CONTROLL( "CMccVideoSinkImpl::Prepare" )

    if ( SetVideoSinkState( EPrepared ) && iVideoPlayer )

        {

	    iVideoPlayer->Prepare();

	    // Wait for async completion	

	    }

    }

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

// CMccVideoSinkImpl::RemoteSetupL()

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

//

void CMccVideoSinkImpl::RemoteSetupL()

    {

    __V_SOURCESINK_CONTROLL( "CMccVideoSinkImpl::RemoteSetup" )

    __ASSERT_ALWAYS( iVideoPlayer && iPacketSink, User::Leave( KErrNotReady ) );

    ConstructSdpL();

    __V_SOURCESINK_CONTROLL_INT1( "Sending SDP to helix, len= ", iSdp->Length() )

    TUint numStreams( iUsers.Count() );

    __V_SOURCESINK_CONTROLL_INT1( 

        "CMccVideoSinkImpl::RemoteSetup, num streams:", numStreams );

    User::LeaveIfError( iPacketSink->SetSessionDescription( *iSdp, numStreams ) );

    for ( TInt i = 0;  i < iUsers.Count(); i++ )

        {

        CMccVideoSinkUser& entry = *iUsers[ i ];

        __V_SOURCESINK_CONTROLL_INT1( 

            "CMccVideoSinkImpl::RemoteSetup, stream:", entry.iStreamId );

        __V_SOURCESINK_CONTROLL_INT1( 

            "CMccVideoSinkImpl::RemoteSetup, queuesize defined:", 

            entry.IsQueueSizeDefined() );

        __V_SOURCESINK_CONTROLL_INT1( 

            "CMccVideoSinkImpl::RemoteSetup, queuesize:", entry.QueueSize() );

        User::LeaveIfError( 

            iPacketSink->ConfigStream( entry.iStreamId, entry.QueueSize() ) );

        }

    __V_SOURCESINK_CONTROLL( "CMccVideoSinkImpl::RemoteSetup, exit" )

    }

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

// CMccVideoSinkImpl::StartL()

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

//

void CMccVideoSinkImpl::StartL()

    {

    __V_SOURCESINK_CONTROLL( "CMccVideoSinkImpl::StartL" )

    if ( SetVideoSinkState( EPlaying ) )

        { 

        __V_SOURCESINK_CONTROLL( "CMccVideoSinkImpl::StartL, playing" )

        CMccVideoSinkUser* userEntry = FindVideoSinkUserEntryForCurrent();

        UpdateSettingsL( iSettings, ETrue );

        DoPlay();

        // No need to wait any async completion

        if ( IsStartedOnce( userEntry ) )

            {

            SendStreamEventToClient( KMccStreamResumed, iCurrentUser );

            }

        else

            {

            iRedrawHandler->BlackDrawingL( ETrue );

            SendStreamEventToClient( KMccStreamStarted, iCurrentUser );

            SetStartedOnce( userEntry, ETrue );

            }   

        }

    __V_SOURCESINK_CONTROLL( "CMccVideoSinkImpl::StartL, exit" )

    }

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

// CMccVideoSinkImpl::Stop()

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

//

void CMccVideoSinkImpl::Stop()

    {

    __V_SOURCESINK_CONTROLL( "CMccVideoSinkImpl::Stop" )

    TBool playerOpened( IsPlayerOpened() );

    if ( SetVideoSinkState( EStopped ) && iVideoPlayer ) 

	    {

        __V_SOURCESINK_CONTROLL( "CMccVideoSinkImpl::Stop, hiding window disabled" )

        // Stopping the player before opening has completed can cause crash

        if ( playerOpened )

            {

            iVideoPlayer->Stop();

            }

	    // No need to wait any async completion

	    SendStreamEventToClient( KMccStreamStopped, iCurrentUser );

	    CMccVideoSinkUser* userEntry = FindVideoSinkUserEntryForCurrent();

	    SetStartedOnce( userEntry, EFalse );

	    DoPauseForUser( userEntry );

	    }

    __V_SOURCESINK_CONTROLL( "CMccVideoSinkImpl::Stop, exit" )

    }

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

// CMccVideoSinkImpl::Pause()

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

//

void CMccVideoSinkImpl::PauseL()

    {

    __V_SOURCESINK_CONTROLL( "CMccVideoSinkImpl::PauseL" )

    __ASSERT_ALWAYS( iVideoPlayer, User::Leave( KErrArgument ) );

    if ( SetVideoSinkState( EPaused ) )

        {

        __V_SOURCESINK_CONTROLL( "CMccVideoSinkImpl::PauseL, pausing" )

        DoPauseL();

        DoResetL();

        // No need to wait any async completion

        SendStreamEventToClient( KMccStreamPaused, iCurrentUser );

        }

    __V_SOURCESINK_CONTROLL( "CMccVideoSinkImpl::PauseL, exit" )

    }

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

// CMccVideoSinkImpl::Close()

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

//

void CMccVideoSinkImpl::Close()

    {

    __V_SOURCESINK_CONTROLL( "CMccVideoSinkImpl::Close" )

    if ( iVideoPlayer ) 

	    {

	    iVideoPlayer->Close();

	    }

    }

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

// CMccVideoSinkImpl::SetDisplayWindowL()

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

//

void CMccVideoSinkImpl::SetDisplayWindowL( 

    RWsSession& aWs, 

    CWsScreenDevice& aScreenDevice,

    RWindow& aWindow )

    {

    __V_SOURCESINK_CONTROLL( "CMccVideoSinkImpl::SetDisplayWindowL" ) 

    __ASSERT_ALWAYS( iVideoPlayer, User::Leave( KErrArgument ) );

    iVideoPlayer->RemoveDisplayWindow( aWindow );

    __V_SOURCESINK_CONTROLL( "CMccVideoSinkImpl::SetDisplayWindowL, removed old" )

    iVideoPlayer->AddDisplayWindowL( aWs, aScreenDevice, aWindow );

    iVideoPlayer->SetAutoScaleL( aWindow, EAutoScaleBestFit );

    __V_SOURCESINK_CONTROLL( "CMccVideoSinkImpl::SetDisplayWindowL, added new" )

    }

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

// CMccVideoSinkImpl::Priority()

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

//

void CMccVideoSinkImpl::Priority( TInt& aPriority, 

                                  TInt& aPreference )

    {

    __V_SOURCESINK_CONTROLL( "CMccVideoSinkImpl::Priority" )