/*

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

*

*/

#include "mcecommediastream.h"

#include "mceserial.h"

#include "mceevents.h"

#include "mcecommediasource.h"

#include "mcecommediasink.h"

#include "mcertpsource.h"

#include "mcertpsink.h"

#include "mcecomcodec.h"

#include "cleanupresetanddestroy.h"

#include "mceclient.pan"

#ifdef MCE_COMMON_SERVER_SIDE

#include <sdpcodecstringconstants.h>

#include "mcesrvstream.h"

#include "mcemediaobserver.h"

#include "mcepreconditions.h"

#include "mcesdpsession.h"

#endif

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

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

// CMceComMediaStream::~CMceMediaStream

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

//

CMceComMediaStream::~CMceComMediaStream()

    {

    if ( iSource )

        {

        DeleteSource();

        }

    if ( iLinkOwner )

	    {

    	delete iLinkedStream;

    	iLinkedStream = NULL;

	    }

	while( iSinks.Count() > 0 )

	    {

	    DeleteSink( 0 );

	    }

    iSinks.Reset();

    iSinks.Close();

    if ( iEmptySink )

    	{

    	delete iEmptySink;

    	iEmptySink = NULL;

    	}

    if ( iEmptySource )

    	{

    	delete iEmptySource;

    	iEmptySource = NULL;

    	}

    if	( iLocalMediaSDPLines )

    	{

    	delete iLocalMediaSDPLines;

    	iLocalMediaSDPLines = NULL;

    	}

    if ( iRemoteMediaSDPLines )

    	{

    	delete iRemoteMediaSDPLines;

    	iRemoteMediaSDPLines = NULL;

    	}

#ifdef MCE_COMMON_SERVER_SIDE

    iPreconditions.ResetAndDestroy();

#endif// MCE_COMMON_SERVER_SIDE

    }

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

// CMceComMediaStream::SetSourceL

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

//

void CMceComMediaStream::SetSourceL( CMceComMediaSource* aSource )

    {

    if ( aSource )

        {

        aSource->ReferenceCount()++;

        }

    if ( iSource )

        {

        DeleteSource();            

        }

    iSource = aSource;

    }

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

// CMceComMediaStream::AddSinkL

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

//

void CMceComMediaStream::AddSinkL( CMceComMediaSink* aSink )

    {

    iSinks.AppendL( aSink );

    aSink->ReferenceCount()++;

    }

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

// CMceComMediaStream::DeleteSink

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

//

void CMceComMediaStream::DeleteSink( TInt aIndex )

    {

    iSinks[ aIndex ]->ReferenceCount()--;

    if ( iSinks[ aIndex ]->ReferenceCount() == 0 )

        {

        delete iSinks[ aIndex ];

        }

    else

        {

        iSinks[ aIndex ]->UnInitialize( *this );

        }

    iSinks.Remove( aIndex );

    }

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

// CMceComMediaStream::DeleteSource

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

//

void CMceComMediaStream::DeleteSource()

    {

    iSource->ReferenceCount()--;

    if ( iSource->ReferenceCount() == 0 )

        {

        delete iSource;

        }

    else

        {

        iSource->UnInitialize( *this );

        }

    iSource = NULL;

    }

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

// CMceComMediaStream::Source

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

//

CMceComMediaSource* CMceComMediaStream::Source()

    {

    return iSource;

    }

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

// CMceComMediaStream::Sinks

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

//

RPointerArray<CMceComMediaSink>& CMceComMediaStream::Sinks()

    {

    return iSinks;

    }    

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

// CMceComMediaStream::BindL

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

//

void CMceComMediaStream::BindL( CMceComMediaStream* aStream )

    {

    __ASSERT_ALWAYS( !(!iLinkOwner && iLinkedStream ) , User::Leave( KErrArgument ) );

    if ( aStream )

        {

        iLinkOwner = ETrue;

        aStream->DoBind( this );

        DoBind( aStream );

        }

    else

        {

        iLinkOwner = EFalse;

    	delete iLinkedStream;

    	iLinkedStream = NULL;

    	if ( iSession )

    		{

			InitializeL( *iSession );

    		}

        }

    }

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

// CMceComMediaStream::DoBind

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

//

void CMceComMediaStream::DoBind( CMceComMediaStream* aStream )

    {

    if ( iLinkedStream )

        {

        delete iLinkedStream;

        iLinkedStream = NULL;

        }

    iLinkedStream = aStream;

    }

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

// CMceComMediaStream::BoundStreamL

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

//

CMceComMediaStream& CMceComMediaStream::BoundStreamL()

    {

    return *iLinkedStream;

    }

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

// CMceComMediaStream::BoundStream

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

//

TBool CMceComMediaStream::BoundStream() const

    {

    return iLinkedStream != NULL;

    }

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

// CMceComMediaStream::Binder

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

//

TBool CMceComMediaStream::Binder() const

    {

    return iLinkOwner;

    }

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

// CMceComMediaStream::operator()

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

//

CMceComMediaStream& CMceComMediaStream::operator()()

    {

    CMceComMediaStream* owner = this;

    if ( BoundStream() && !Binder() )

        {

        owner = iLinkedStream;

        }

    return *owner;

    }

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

// CMceComMediaStream::operator()

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

//

const CMceComMediaStream& CMceComMediaStream::operator()() const

    {

    const CMceComMediaStream* owner = this;

    if ( BoundStream() && !Binder() )

        {

        owner = iLinkedStream;

        }

    return *owner;

    }

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

// CMceComMediaStream::SerializationId

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

//

TUint64 CMceComMediaStream::SerializationId() const

    {

    return iID.Uint64();

    }

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

// CMceComMediaStream::InternalizeFlatL

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

//

void CMceComMediaStream::InternalizeFlatL( RReadStream& aReadStream )

    {

    //iType

    iType = static_cast<TMceMediaType>( aReadStream.ReadUint8L() );

    //iID

    MceSerial::DecodeL( iID, aReadStream );

    //iState

    iIsEnabled = static_cast< TBool >( aReadStream.ReadUint8L() );

    //iLocalMediaPort

    iLocalMediaPort = aReadStream.ReadUint16L();

    //iRemoteMediaPort

	iRemoteMediaPort = aReadStream.ReadUint16L();

    //iLocalMediaSDPLines

    MceSerial::DecodeL( iLocalMediaSDPLines, aReadStream ); 

    //iRemoteMediaSDPLines

    MceSerial::DecodeL( iRemoteMediaSDPLines, aReadStream ); 

    //iLinkOwner

    iLinkOwner = static_cast<TBool>( aReadStream.ReadUint8L() );

    //iState

    iState = static_cast<CMceMediaStream::TState>( aReadStream.ReadUint8L() );

    //iIgnoreRemotePort

    iIgnoreRemotePort = static_cast<TBool>( aReadStream.ReadUint8L() );    

    }

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

// CMceComMediaStream::ExternalizeFlatL

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

//

void CMceComMediaStream::ExternalizeFlatL( RWriteStream& aWriteStream )

    {

	aWriteStream.WriteUint8L( iType );

    MceSerial::EncodeL( iID, aWriteStream );

	aWriteStream.WriteUint8L( iIsEnabled );

	aWriteStream.WriteUint16L( iLocalMediaPort );

    aWriteStream.WriteUint16L( iRemoteMediaPort );

	MceSerial::EncodeL( iLocalMediaSDPLines, aWriteStream );

	MceSerial::EncodeL( iRemoteMediaSDPLines, aWriteStream );

	aWriteStream.WriteUint8L( iLinkOwner );

	aWriteStream.WriteUint8L( iState );

	aWriteStream.WriteUint8L( iIgnoreRemotePort );

    }

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

// CMceComMediaStream::InternalizeL

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

//

void CMceComMediaStream::InternalizeL( MMceComSerializationContext& aSerCtx )

    {

    TMceMediaStreamSerializer<CMceComMediaStream> serial( *this );

    serial.InternalizeL( aSerCtx );

    }

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

// CMceComMediaStream::ExternalizeL

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

//

void CMceComMediaStream::ExternalizeL( MMceComSerializationContext& aSerCtx )

    {

    TMceMediaStreamSerializer<CMceComMediaStream> serial( *this );

    serial.ExternalizeL( aSerCtx );

    }

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

// CMceComMediaStream::CMceComMediaStream

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

//

CMceComMediaStream::CMceComMediaStream( TMceMediaType aType )

  : iID( TMceMediaId( (TUint32)&iID ) ),

    iType( aType ),

    iIsEnabled( ETrue ),

    iLocalMediaPort (5000),

    iRemoteRtcpAddress ( KInetAddrAny ),

    iRemoteRtcpPort( 0 ),

    iStreamType( ELocalStream ),

    iState( CMceMediaStream::EUninitialized ),

    iLinkOwner( EFalse ),

    iLinkedStream( NULL ),

    iSource( NULL ),

    iSdpIndex( KErrNotFound ),

    iLinkId( KMceNotAssigned ),

    iDowngradedEnpoints( EFalse )

    {

    }

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

// CMceComMediaStream::ConstructL

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

//

void CMceComMediaStream::ConstructL()

    {

    iLocalMediaSDPLines = new (ELeave) CDesC8ArrayFlat( KMceArrayGranularity );

    iRemoteMediaSDPLines = new (ELeave) CDesC8ArrayFlat( KMceArrayGranularity );

    }

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

// CMceComMediaStream::ConstructL

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

//

void CMceComMediaStream::ConstructL( CMceComMediaStream& aStream )

    {

    iID = aStream.iID;

    iType = aStream.iType;

    iIsEnabled = aStream.iIsEnabled;

    iState = aStream.iState;

    iLocalMediaPort = aStream.iLocalMediaPort;

    iRemoteMediaPort = aStream.iRemoteMediaPort;

    iIgnoreRemotePort = aStream.iIgnoreRemotePort;

    iRemoteRtcpAddress = aStream.iRemoteRtcpAddress;

    iRemoteRtcpPort = aStream.iRemoteRtcpPort;

    iLocalMediaSDPLines = new (ELeave) CDesC8ArrayFlat( KMceArrayGranularity );

    iRemoteMediaSDPLines = new (ELeave) CDesC8ArrayFlat( KMceArrayGranularity );

    iSdpIndex = aStream.iSdpIndex;

    iDowngradedEnpoints = aStream.iDowngradedEnpoints;

    TInt i = 0;

    for( i = 0;i<aStream.iLocalMediaSDPLines->MdcaCount();i++ )

        {

        iLocalMediaSDPLines->AppendL( aStream.iLocalMediaSDPLines->MdcaPoint( i ) );

        }

    for( i = 0;i<aStream.iRemoteMediaSDPLines->MdcaCount();i++ )

        {

        iRemoteMediaSDPLines->AppendL( aStream.iRemoteMediaSDPLines->MdcaPoint( i ) );

        }

    iLinkOwner = aStream.iLinkOwner;

    if ( aStream.Binder() && aStream.BoundStream() )

        {

        iLinkedStream = static_cast<CMceComMediaStream*>( aStream.iLinkedStream->CloneL() );

        iLinkedStream->iLinkedStream = this;

        }

    if ( aStream.iSource )

        {

        CMceComMediaSource* source = aStream.iSource->CloneL();

        CleanupStack::PushL( source );

        SetSourceL( source );

        CleanupStack::Pop( source );

        }

    for( i = 0; i < aStream.iSinks.Count();i++)

        {

        CMceComMediaSink* sink = aStream.iSinks[ i ]->CloneL();

        CleanupStack::PushL( sink );

        AddSinkL( sink );

        CleanupStack::Pop( sink );

        }

    if ( aStream.iEmptySource )

        {

        iEmptySource = aStream.iEmptySource->CloneL();

        }

    if ( aStream.iEmptySink )

        {

        iEmptySink = aStream.iEmptySink->CloneL();

        }

#ifdef MCE_COMMON_SERVER_SIDE

    if ( aStream.iPreconditions.Count() )

        {

        for ( int j = 0; j < aStream.iPreconditions.Count(); j++ )

        	{

        	TMcePreconditions* precondition = 

        				static_cast < TMcePreconditions* > ( aStream.iPreconditions[j] );

        	TMcePreconditions* clone = precondition->CloneL( *this );

        	CleanupStack::PushL( clone );

        	iPreconditions.AppendL( clone );

        	CleanupStack::Pop( clone );

        	}

        }

    else	

        {

        iPreconditions.Reset();

        }

#endif// MCE_COMMON_SERVER_SIDE

    }

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

// CMceComMediaStream::BaseFactory

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

//

TMceComFactory CMceComMediaStream::BaseFactory()

    {

    return TMceComFactory();

    }

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

// CMceComMediaStream::Factory

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