/*

* 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 "mcesrvstream.h"

#include "mcesrvsource.h"

#include "mcesrvsink.h"

#include "mceevents.h"

#include <sdpcodecstringconstants.h>

#include "mcecomsession.h"

#include "mcecomaudiostream.h"

#include "mcecomaudiocodec.h"

#include "mcecommediasource.h"

#include "mcecommediasink.h"

#include "mcecomvideostream.h"

#include "mcecomvideocodec.h"

#include "mcecomdisplaysink.h"

#include "mcecomcamerasource.h"

#include "mcedisplaysink.h"

#include "mcecamerasource.h"

#include "mceaudiostream.h"

#include "mcevideostream.h"

#include "mcesrvstreamiterator.h"

#include "mcemediamanager.h"

#include "mcedtmfcodec.h"

#include "mcemmlogs.h"

#include "mcedtmfhandler.h"

#define MCE_MCC_STREAM_STATE_CHANGE_EVENT( event )\

( aEvent.iEvent == KMccStreamPrepared || \

  aEvent.iEvent == KMccStreamStarted || \

  aEvent.iEvent == KMccStreamPaused || \

  aEvent.iEvent == KMccStreamResumed || \

  aEvent.iEvent == KMccStreamStopped )

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

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

// CMceSrvStream::DecodeL

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

//

void CMceSrvStream::DecodeL( RPointerArray<CMceSrvStream>& aStreams,

                             CMceComMediaStream& aStream,

                             CMceMediaManager& aManager )

    {

    MCEMM_DEBUG("CMceSrvStream::DecodeL(), Entry ");

    switch( aStream.iType )

        {

        case KMceAudio:

            {

            CMceComAudioStream& audio = 

                static_cast<CMceComAudioStream&>( aStream );

            DecodeAudioL( aStreams, audio, aManager );

            break;

            }

        case KMceVideo:

            {

            CMceComVideoStream& video = 

                static_cast<CMceComVideoStream&>( aStream );

            DecodeVideoL( aStreams, video, aManager );

            break;

            }

        default:

            {

            User::Leave( KErrNotSupported );

            break;

            }

        }

    MCEMM_DEBUG("CMceSrvStream::DecodeL(), Exit ");

    }

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

// CMceSrvStream::DecodeAudioL

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

//

void CMceSrvStream::DecodeAudioL( RPointerArray<CMceSrvStream>& aStreams,

                                  CMceComAudioStream& aAudio,

                                  CMceMediaManager& aManager )

    {

    MCEMM_DEBUG("CMceSrvStream::DecodeAudioL(), Entry ");

    // First clear all enabled states, those are affected inside codec

    // specific decoding

    for(  TInt i = 0; i < aAudio.CodecCount(); ++i )

        {

        aAudio.CodecL( i )->SetEnabled( EFalse );

        }

    for ( TInt j = 0; j < aAudio.CodecCount(); ++j )

        {

        aAudio.CodecL( j )->DoDecodeAudioL( j, 

                                              aStreams, 

                                              aAudio, 

                                              aManager );

        }

    if ( aAudio.BoundStream() && aAudio.Binder() )

        {

        DecodeL( aStreams, aAudio.BoundStreamL(), aManager );

        }

    MCEMM_DEBUG("CMceSrvStream::DecodeAudioL(), Exit ");

    }

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

// CMceSrvStream::DecodeVideoL

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

//

void CMceSrvStream::DecodeVideoL( RPointerArray<CMceSrvStream>& aStreams,

                                  CMceComVideoStream& aVideo,

                                  CMceMediaManager& aManager )

    {

    MCEMM_DEBUG("CMceSrvStream::DecodeVideoL(), Entry ");

    for( TInt codecNdx = 0;codecNdx < aVideo.CodecCount();codecNdx++ )

        {

        aVideo.CodecL( codecNdx )->SetEnabled( 

            codecNdx == 0 || IS_RECEIVESTREAM( &aVideo ) );

        for( TInt sinkNdx = 0 ; sinkNdx < aVideo.Sinks().Count() ; sinkNdx++ )

            {

            CMceSrvStream* srvStream = NewL( aManager, aVideo, 

                                             *aVideo.Source(),

                                             *aVideo.Sinks()[ sinkNdx ],

                                             *aVideo.CodecL( codecNdx ) );

                CleanupStack::PushL( srvStream );

                MCEMM_DEBUG_STREAM( "CMceSrvStream::DecodeVideoL(): decoded video", *srvStream );

                aStreams.AppendL( srvStream );

                CleanupStack::Pop( srvStream );

            }

        }

    if ( aVideo.BoundStream() && aVideo.Binder() )

        {

        DecodeL( aStreams, aVideo.BoundStreamL(), aManager );

        }

    MCEMM_DEBUG("CMceSrvStream::DecodeVideoL(), Exit ");

    }

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

// CMceSrvStream::NewL

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

//

CMceSrvStream* CMceSrvStream::NewL( CMceMediaManager& aManager,

                          CMceComMediaStream& aData,

                          CMceComMediaSource& aSource,

                          CMceComMediaSink& aSink,

                          CMceComCodec& aCodec )

    {

    CMceSrvStream* self = new (ELeave) CMceSrvStream( &aManager, &aData, &aCodec );

    CleanupStack::PushL( self );

    self->ConstructL( aSource, aSink );

    CleanupStack::Pop( self );

    return self;

    }

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

// CMceSrvStream::CMceSrvStream

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

//

CMceSrvStream::CMceSrvStream()

    {

    }

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

// CMceSrvStream::CMceSrvStream

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

//

CMceSrvStream::CMceSrvStream( CMceMediaManager* aManager,

                              CMceComMediaStream* aData,

                              CMceComCodec* aCodec )

    : iManager( aManager ),

      iData( aData ),

      iCodec( aCodec ),

      iMerged( EFalse ),

      iID( KMceNotAssigned )

    {

    }

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

// CMceSrvStream::CreateLinkL

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

//

TBool CMceSrvStream::CreateLinkL()

    {

    __ASSERT_ALWAYS( State() == ECreated, User::Leave( KErrArgument ) );

    TBool sequence = KMceSrvStreamDefaultSequence;

    if ( !UseDefaultStartupSequence() )

        {

        sequence = KMceSrvStreamAlternativeSequence;

        }

    return sequence;

    }

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

// CMceSrvStream::PrepareL

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

//

TBool CMceSrvStream::PrepareL()

    {

    __ASSERT_ALWAYS( State() == ELinkCreated, User::Leave( KErrArgument ) );

    TBool sequence = KMceSrvStreamDefaultSequence;

    if ( !UseDefaultStartupSequence() )

        {

        MCEMM_DEBUG("CMceSrvStream::PrepareL(): alternative prepare");

        sequence = KMceSrvStreamAlternativeSequence;

        TMceMccComEvent prepare( KMccStreamPrepared );

        iSource->EventReceived( prepare );

        iSink->EventReceived( prepare );

        MCEMM_DEBUG_STREAM( "CMceSrvStream::PrepareL(): after prepare", *this );

        }

    else if ( IsMccPrepared() )

        {

        iSource->Data().PrepareL();

        iSink->Data().PrepareL();

        }        

    else

        {

        // NOP

        }

    return sequence;

    }

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

// CMceSrvStream::StartL

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

//

TBool CMceSrvStream::StartL()

    {

    if ( IsMccPrepared() )

        {

        return KMceSrvStreamDefaultSequence;

        }

    MCEMM_DEBUG("CMceSrvStream::StartL(): alternative start");

    TMceMccComEvent started( KMccStreamStarted );

    TMceMccComEvent paused( KMccStreamPaused );

    if ( iSource->Data().IsEnabled() )

        {

        iSource->EventReceived( started );

        iSource->EnableL( *this, KMceSrvStreamSync );

        }

    else

        {

        iSource->EventReceived( paused );

        }

    if ( iSink->Data().IsEnabled() )

        {

        iSink->EventReceived( started );

        iSink->EnableL( *this, KMceSrvStreamSync );

        }

    else

        {

        iSink->EventReceived( paused );

        }

    MCEMM_DEBUG_STREAM( "CMceSrvStream::StartL(): after start", *this );

    return KMceSrvStreamAlternativeSequence;

    }

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

// CMceSrvStream::SynchronizeL

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

//

TBool CMceSrvStream::SynchronizeL()

    {    

    if ( IsMccPrepared() )

        {

        return KMceSrvStreamDefaultSequence;

        }

    MCEMM_DEBUG("CMceSrvStream::SynchronizeL(): alternative synchronize");

    if ( iSource->Data().IsEnabled() )

        {

        iSource->EnableL( *this, KMceSrvStreamSync );

        }

    else

        {

        iSource->DisableL( *this, KMceSrvStreamSync );

        }

    if ( iSink->Data().IsEnabled() )

        {

        iSink->EnableL( *this, KMceSrvStreamSync );

        }

    else

        {

        iSink->DisableL( *this, KMceSrvStreamSync );

        }

    MCEMM_DEBUG_STREAM( "CMceSrvStream::SynchronizeL(): after synchronize", *this );

    return KMceSrvStreamAlternativeSequence;

    }

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

// CMceSrvStream::Stop

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

//

TBool CMceSrvStream::Stop()

    {

    if ( IsMccPrepared() )

        {

        return KMceSrvStreamDefaultSequence;

        }

    MCEMM_DEBUG("CMceSrvStream::Stop(): alternative stop, stopping source");

    DoEndpointDisable( *iSource );

    MCEMM_DEBUG("CMceSrvStream::Stop(): alternative stop, stopping sink");

    DoEndpointDisable( *iSink );

    // Generating stopped event must be done after disabling

    TMceMccComEvent stopped( KMccStreamStopped );

    iSink->EventReceived( stopped );

    iSource->EventReceived( stopped );

    MCEMM_DEBUG_STREAM( "CMceSrvStream::Stop(): after stop", *this );

    return KMceSrvStreamAlternativeSequence;

    }

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

// CMceSrvStream::Validate

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

//

TBool CMceSrvStream::Validate()

    {

    return StreamType() == CMceComMediaStream::ELocalStream;

    }

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

// CMceSrvStream::UseDefaultStartupSequence

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

//

TBool CMceSrvStream::UseDefaultStartupSequence()

    {

    TBool defaultSequence = ETrue;

    //special case: local stream, which has camera source and

    //              diaplay sink

    if ( StreamType() == CMceComMediaStream::ELocalStream &&

         iSource->Data().iType == KMceCameraSource &&

         iSink->Data().iType == KMceDisplaySink )

        {

        //try to find stream, which is send stream and it has the

        //same camera source

        TMceSrvStreamIterator streams( 

                Data().Session()->MccStreams(), iSource->Data() );

        CMceSrvStream* pairedStream = NULL;

        CMceSrvStream* stream = NULL;

        while( !pairedStream && streams.Next( stream ) )

            {

            pairedStream = 

                ( stream->StreamType() == CMceComMediaStream::ESendStream ||

                  stream->StreamType() == CMceComMediaStream::ESendOnlyStream ) ?

                  stream : NULL;

            }

        defaultSequence = MCE_IS_NULL_PTR( pairedStream );

        if ( !defaultSequence )

            {

            static_cast<CMceComDisplaySink&>( iSink->Data() ).SetViewFinder( ETrue );

            }

        }

    return defaultSequence;

    }

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

// CMceSrvStream::ConstructL

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

//

void CMceSrvStream::ConstructL( CMceComMediaSource& aSource,

                               CMceComMediaSink& aSink )

    {

    iSource = new (ELeave) CMceSrvSource( *iManager, aSource );

    iSink = new (ELeave) CMceSrvSink( *iManager, aSink );

    }

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

// CMceSrvStream::IsMerged

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

//

TBool CMceSrvStream::IsMerged() const

    {

    return iMerged;

    }

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

// CMceSrvStream::IsMccPrepared

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

//

TBool CMceSrvStream::IsMccPrepared() const

    {

    return iID != KMceNotAssigned;

    }

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

// CMceSrvStream::Merge

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

//

void CMceSrvStream::Merge( CMceSrvStream& aMergeWith, TBool aDeepMerge )

    {

    aMergeWith.iMerged = ETrue;

    iMerged = aMergeWith.iMerged;

    iID = aMergeWith.iID;

    iSource->Merge( aMergeWith.Source() );

    iSink->Merge( aMergeWith.Sink() );

    Data().SetLinkId( aMergeWith.LinkId() );

    if ( aDeepMerge )

        {

        Data().Merge( aMergeWith.Data() );

        iCodec->Merge( aMergeWith.Codec() );

        iSource->Data().Merge( aMergeWith.Source().Data() );

        iSink->Data().Merge( aMergeWith.Sink().Data() );

        }

    }

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

// CMceSrvStream::IsAdopted

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

//

TBool CMceSrvStream::IsAdopted() const

    {

    return EFalse;

    }

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

// CMceSrvStream::UnMerge

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

//

void CMceSrvStream::UnMerge()

    {

    iMerged = EFalse;

    }

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

// CMceSrvStream::UnMergeL

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

//

void CMceSrvStream::UnMergeL( CMceSrvStream& aUnMergeFrom )

    {

    UnMerge();

    if ( !IsAdopted() && !aUnMergeFrom.IsAdopted() )

        {

        iSource->Merge( aUnMergeFrom.Source() );

        iSink->Merge( aUnMergeFrom.Sink() );

        iManager->SynchronizeMccStreamL( *this );

        }

    }

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

// CMceSrvStream::Cleanup

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

//

void CMceSrvStream::Cleanup()

    {

    MCEMM_DEBUG("CMceSrvStream::Cleanup(), Entry ");

    if ( iManager->CanReleaseEndpoint( *this, Source().Id() ) )

        {

        iManager->ReleaseSource( *this, Source().Id() );

        }

    if ( iManager->CanReleaseEndpoint( *this, Sink().Id() ) )