--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/multimediacommsengine/mmcecli/src/mcemediastream.cpp Tue Feb 02 01:04:58 2010 +0200
@@ -0,0 +1,1054 @@
+/*
+* 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 "mcemediastream.h"
+#include "mcesession.h"
+#include "mcemanager.h"
+#include "mcestreamobserver.h"
+#include "mcertpobserver.h"
+#include "mcecommediastream.h"
+#include "mcefactory.h"
+#include "mceserial.h"
+#include "mceevents.h"
+#include "mceclilogs.h"
+#include "mcesessionobserver.h"
+
+#define _FLAT_DATA static_cast<CMceComMediaStream*>( iFlatData )
+#define FLAT_DATA( data ) _FLAT_DATA->data
+
+// ============================ MEMBER FUNCTIONS ===============================
+
+
+// -----------------------------------------------------------------------------
+// CMceMediaStream::~CMceMediaStream
+// -----------------------------------------------------------------------------
+//
+EXPORT_C CMceMediaStream::~CMceMediaStream()
+ {
+
+ MCECLI_DEBUG("CMceMediaStream::~CMceMediaStream, Entry");
+ MCECLI_DEBUG_DVALUE("id", iFlatData ? Id().iId : KMceNotAssigned );
+
+ if ( iSource )
+ {
+ DeleteSource();
+ }
+
+ if ( _FLAT_DATA && FLAT_DATA( iLinkOwner ) )
+ {
+ delete iLinkedStream;
+ }
+
+ while( iSinks.Count() > 0 )
+ {
+ DeleteSink( 0 );
+ }
+
+ iSinks.Reset();
+ iSinks.Close();
+
+ delete iFlatData;
+ MCECLI_DEBUG("CMceMediaStream::~CMceMediaStream, Exit");
+ }
+
+// -----------------------------------------------------------------------------
+// CMceMediaStream::Type
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TMceMediaType CMceMediaStream::Type() const
+ {
+ return FLAT_DATA( iType );
+ }
+
+// -----------------------------------------------------------------------------
+// CMceMediaStream::SetMediaAttributeLinesL
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CMceMediaStream::SetMediaAttributeLinesL(
+ CDesC8Array* aMediaSDPLines )
+ {
+ MCECLI_DEBUG("CMceMediaStream::SetMediaAttributeLinesL, Entry");
+ User::LeaveIfError( !iSession ||
+ ( iSession->State() == CMceSession::EIdle ||
+ iSession->State() == CMceSession::EIncoming ||
+ iSession->State() == CMceSession::EEstablished ) ?
+ KErrNone : KErrNotReady );
+
+ CDesC8Array* lines = NULL;
+ TBool linesPushed = EFalse;
+
+ if ( aMediaSDPLines )
+ {
+ lines = aMediaSDPLines;
+ }
+ else
+ {
+ lines = new (ELeave) CDesC8ArrayFlat( KMceArrayGranularity );
+ CleanupStack::PushL( lines );
+ linesPushed = ETrue;
+ }
+
+ if ( iLinkedStream )
+ {
+ CDesC8Array* copyLines =
+ new (ELeave) CDesC8ArrayFlat( KMceArrayGranularity );
+ CleanupStack::PushL( copyLines );
+ for ( TInt i = 0; i < lines->MdcaCount(); i++ )
+ {
+ copyLines->AppendL( lines->MdcaPoint( i ) );
+ }
+ delete iLinkedStream->iFlatData->iLocalMediaSDPLines;
+ iLinkedStream->iFlatData->iLocalMediaSDPLines = copyLines;
+ CleanupStack::Pop( copyLines );
+ }
+
+ if ( linesPushed )
+ {
+ CleanupStack::Pop( lines );
+ }
+
+ delete FLAT_DATA( iLocalMediaSDPLines );
+ FLAT_DATA( iLocalMediaSDPLines ) = lines;
+ MCECLI_DEBUG("CMceMediaStream::SetMediaAttributeLinesL, Exit");
+ }
+
+// -----------------------------------------------------------------------------
+// CMceMediaStream::MediaAttributeLinesL
+// -----------------------------------------------------------------------------
+//
+EXPORT_C MDesC8Array* CMceMediaStream::MediaAttributeLinesL()
+ {
+ CDesC8Array* lines = new (ELeave) CDesC8ArrayFlat( KMceArrayGranularity );
+ CleanupStack::PushL( lines );
+ for ( TInt i=0; i < FLAT_DATA( iRemoteMediaSDPLines )->Count(); i++ )
+ {
+ lines->AppendL( FLAT_DATA( iRemoteMediaSDPLines )->MdcaPoint( i ) );
+ }
+ CleanupStack::Pop( lines );
+ return lines;
+ }
+
+// -----------------------------------------------------------------------------
+// CMceMediaStream::SetStartMediaPort
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CMceMediaStream::SetLocalMediaPortL( TUint aLocalMediaPort )
+ {
+ MCECLI_DEBUG("CMceMediaStream::SetLocalMediaPortL, Entry");
+ MCECLI_DEBUG_DVALUE("port", aLocalMediaPort );
+
+ FLAT_DATA( iLocalMediaPort ) = aLocalMediaPort;
+
+ MCECLI_DEBUG("CMceMediaStream::SetLocalMediaPortL, Exit");
+
+ }
+
+// -----------------------------------------------------------------------------
+// CMceMediaStream::StartMediaPort
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TUint CMceMediaStream::LocalMediaPort() const
+ {
+ return FLAT_DATA( iLocalMediaPort );
+ }
+
+// -----------------------------------------------------------------------------
+// CMceMediaStream::Session
+// -----------------------------------------------------------------------------
+//
+EXPORT_C CMceSession* CMceMediaStream::Session() const
+ {
+ return iSession;
+ }
+
+// -----------------------------------------------------------------------------
+// CMceMediaStream::EnableL
+// -----------------------------------------------------------------------------
+//
+void CMceMediaStream::EnableL()
+ {
+ MCECLI_DEBUG("CMceMediaStream::EnableL, Entry");
+
+ if ( iSource )
+ {
+ iSource->Enabled( ETrue );
+ }
+
+ for ( TInt i = 0; i < iSinks.Count(); i++ )
+ {
+ iSinks[ i ]->Enabled( ETrue );
+ }
+
+ FLAT_DATA( iIsEnabled ) = ETrue;
+ MCECLI_DEBUG("CMceMediaStream::EnableL, Exit");
+
+ }
+
+// -----------------------------------------------------------------------------
+// CMceMediaStream::DisableL
+// -----------------------------------------------------------------------------
+//
+void CMceMediaStream::DisableL()
+ {
+ MCECLI_DEBUG("CMceMediaStream::DisableL, Entry");
+
+ if ( iSource )
+ {
+ iSource->Enabled( EFalse );
+ }
+
+ for ( TInt i = 0; i < iSinks.Count(); i++ )
+ {
+ iSinks[ i ]->Enabled( EFalse );
+ }
+
+ FLAT_DATA( iIsEnabled ) = EFalse;
+
+ MCECLI_DEBUG("CMceMediaStream::DisableL, Exit");
+
+ }
+
+// -----------------------------------------------------------------------------
+// CMceMediaStream::IsEnabled
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TBool CMceMediaStream::IsEnabled() const
+ {
+ return FLAT_DATA( iIsEnabled );
+ }
+
+// -----------------------------------------------------------------------------
+// CMceMediaStream::SetSourceL
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CMceMediaStream::SetSourceL( CMceMediaSource* aSource )
+ {
+ if ( aSource )
+ {
+ aSource->ReferenceCount()++;
+ }
+
+ if ( iSource )
+ {
+ DeleteSource();
+ }
+ iSource = aSource;
+
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMceMediaStream::AddSinkL
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CMceMediaStream::AddSinkL( CMceMediaSink* aSink )
+ {
+ __ASSERT_ALWAYS( aSink, User::Leave( KErrArgument ) );
+ __ASSERT_ALWAYS( iSinks.Count() == 0, User::Leave( KErrNotSupported ) );
+ iSinks.AppendL( aSink );
+ aSink->ReferenceCount()++;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMceMediaStream::Source
+// -----------------------------------------------------------------------------
+//
+EXPORT_C CMceMediaSource* CMceMediaStream::Source() const
+ {
+ return iSource;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMceMediaStream::Sinks
+// -----------------------------------------------------------------------------
+//
+EXPORT_C const RPointerArray<CMceMediaSink>& CMceMediaStream::Sinks() const
+ {
+ return iSinks;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMceMediaStream::RemoveSinkL
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CMceMediaStream::RemoveSinkL( CMceMediaSink& aSink )
+ {
+ for ( TInt i = 0; i < iSinks.Count(); i++ )
+ {
+ if ( iSinks[i] == &aSink )
+ {
+ DeleteSink( i );
+ iSinks.Compress();
+ return;
+ }
+ }
+ User::Leave( KErrNotFound );
+ }
+
+
+
+// -----------------------------------------------------------------------------
+// CMceMediaStream::BindL
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CMceMediaStream::BindL( CMceMediaStream* aStream )
+ {
+ __ASSERT_ALWAYS( !(! FLAT_DATA( iLinkOwner ) &&
+ FLAT_DATA( iLinkedStream ) ) ,
+ User::Leave( KErrArgument ) );
+
+ if ( aStream )
+ {
+ FLAT_DATA(iLinkOwner) = ETrue;
+ aStream->DoBindL( this );
+ DoBindL( aStream );
+ }
+ else
+ {
+ FLAT_DATA(iLinkOwner) = EFalse;
+ delete iLinkedStream;
+ iLinkedStream = NULL;
+ }
+
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMceMediaStream::BoundStreamL
+// -----------------------------------------------------------------------------
+//
+EXPORT_C CMceMediaStream& CMceMediaStream::BoundStreamL() const
+ {
+ __ASSERT_ALWAYS( iLinkedStream , User::Leave( KErrNotFound ) );
+
+ return *iLinkedStream;
+
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMceMediaStream::BoundStream
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TBool CMceMediaStream::BoundStream() const
+ {
+ return iLinkedStream != NULL;
+ }
+
+// -----------------------------------------------------------------------------
+// CMceMediaStream::State
+// -----------------------------------------------------------------------------
+//
+EXPORT_C CMceMediaStream::TState CMceMediaStream::State() const
+ {
+ return FLAT_DATA( iState );
+ }
+
+// -----------------------------------------------------------------------------
+// CMceMediaStream::InternalizeFlatL
+// -----------------------------------------------------------------------------
+//
+void CMceMediaStream::InternalizeFlatL( RReadStream& aReadStream )
+ {
+ __ASSERT_ALWAYS( iFlatData , User::Leave( KErrNotReady ) );
+ _FLAT_DATA->InternalizeFlatL( aReadStream );
+
+ }
+
+// -----------------------------------------------------------------------------
+// CMceMediaStream::ExternalizeFlatL
+// -----------------------------------------------------------------------------
+//
+void CMceMediaStream::ExternalizeFlatL( RWriteStream& aWriteStream )
+ {
+ __ASSERT_ALWAYS( iFlatData , User::Leave( KErrNotReady ) );
+ _FLAT_DATA->ExternalizeFlatL( aWriteStream );
+
+ }
+
+// -----------------------------------------------------------------------------
+// CMceMediaStream::SerializationId
+// -----------------------------------------------------------------------------
+//
+TUint64 CMceMediaStream::SerializationId() const
+ {
+ return FLAT_DATA( SerializationId() );
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMceMediaStream::InternalizeL
+// -----------------------------------------------------------------------------
+//
+void CMceMediaStream::InternalizeL( MMceComSerializationContext& aSerCtx )
+ {
+ TMceMediaStreamSerializer<CMceMediaStream> serial( *this, _FLAT_DATA );
+ serial.InternalizeL( aSerCtx );
+ }
+
+// -----------------------------------------------------------------------------
+// CMceMediaStream::ExternalizeL
+// -----------------------------------------------------------------------------
+//
+void CMceMediaStream::ExternalizeL( MMceComSerializationContext& aSerCtx )
+ {
+
+ TMceMediaStreamSerializer<CMceMediaStream> serial( *this, _FLAT_DATA );
+ serial.ExternalizeL( aSerCtx );
+
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMceMediaStream::SetSourceL
+// -----------------------------------------------------------------------------
+//
+void CMceMediaStream::SetSourceL( MMceComSerializationContext& aSerCtx )
+ {
+
+ RReadStream& readStream = aSerCtx.ReadStream();
+
+ TBool externalizedReference = readStream.ReadUint8L();
+
+ if ( externalizedReference )
+ {
+ TMceMediaId id;
+ MceSerial::DecodeL( id, readStream );
+ CMceMediaSource* source = NULL;
+ TInt index = 0;
+ MCECLI_DEBUG_DVALUE("CMceMediaStream::SetSourceL, using cached source. id", id.iId );
+
+ while( !source && index < aSerCtx.SourceCache().Count() )
+ {
+ source = static_cast<CMceMediaSource*>( aSerCtx.SourceCache()[ index++ ] );
+ source = source->SerializationId() == id.Uint64() ? source : NULL;
+ }
+ __ASSERT_ALWAYS( source, User::Leave( KErrNotFound ) );
+ SetSourceL( source );
+ }
+ else
+ {
+ CMceMediaSource* source =
+ BaseFactory().SourceFactory().CreateLC( aSerCtx );
+ SetSourceL( source );
+ CleanupStack::Pop( source );
+ aSerCtx.SourceCache().AppendL( source );
+
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CMceMediaStream::AddSinkL
+// -----------------------------------------------------------------------------
+//
+void CMceMediaStream::AddSinkL( MMceComSerializationContext& aSerCtx )
+ {
+
+ RReadStream& readStream = aSerCtx.ReadStream();
+
+ TBool externalizedReference = readStream.ReadUint8L();
+
+ if ( externalizedReference )
+ {
+ TMceMediaId id;
+ MceSerial::DecodeL( id, readStream );
+ CMceMediaSink* sink = NULL;
+ TInt index = 0;
+ MCECLI_DEBUG_DVALUE("CMceMediaStream::AddSinkL, using cached sink. id", id.iId );
+ while( !sink && index < aSerCtx.SinkCache().Count() )
+ {
+ sink = static_cast<CMceMediaSink*>( aSerCtx.SinkCache()[ index++ ] );
+ sink = sink->SerializationId() == id.Uint64() ? sink : NULL;
+ }
+ __ASSERT_ALWAYS( sink, User::Leave( KErrNotFound ) );
+ AddSinkL( sink );
+ }
+ else
+ {
+ CMceMediaSink* sink =
+ BaseFactory().SinkFactory().CreateLC( aSerCtx );
+ AddSinkL( sink );
+ CleanupStack::Pop( sink );
+ aSerCtx.SinkCache().AppendL( sink );
+
+ }
+
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMceMediaStream::BaseFactory
+// -----------------------------------------------------------------------------
+//
+TMceFactory CMceMediaStream::BaseFactory() const
+ {
+ return TMceFactory();
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMceMediaStream::Factory
+// -----------------------------------------------------------------------------
+//
+TMceMediaStreamFactory CMceMediaStream::Factory()
+ {
+ return TMceMediaStreamFactory();
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMceMediaStream::Binder
+// -----------------------------------------------------------------------------
+//
+TBool CMceMediaStream::Binder() const
+ {
+ return _FLAT_DATA->Binder();
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMceMediaStream::Id
+// -----------------------------------------------------------------------------
+//
+TMceMediaId CMceMediaStream::Id() const
+ {
+ return FLAT_DATA( iID );
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMceMediaStream::InitializeL
+// -----------------------------------------------------------------------------
+//
+void CMceMediaStream::InitializeL(
+ CMceSession& aParent,
+ TBool aDiscardUnusedCodecs )
+ {
+ iSession = &aParent;
+
+ if ( !Id().IsAssigned() )
+ {
+ FLAT_DATA( iID ) = iSession->Manager().NextMediaId();
+ }
+
+ ReorderCodecsByPreferenceL( aDiscardUnusedCodecs );
+
+ if ( Binder() && BoundStream() )
+ {
+ iLinkedStream->InitializeL( aParent, aDiscardUnusedCodecs );
+ }
+
+ if ( iSource )
+ {
+ iSource->InitializeL( *this );
+ }
+
+ for( TInt i = 0; i < iSinks.Count();i++)
+ {
+ iSinks[i]->InitializeL( *this );
+ }
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMceMediaStream::InitializeL
+// -----------------------------------------------------------------------------
+//
+void CMceMediaStream::InitializeL( CMceManager* aManager, CMceSession& aSession )
+ {
+ __ASSERT_ALWAYS( aManager, User::Leave( KErrArgument ) );
+ iSession = &aSession;
+
+ if ( Binder() && BoundStream() )
+ {
+ iLinkedStream->InitializeL( aManager, aSession );
+ }
+
+ if ( iSource )
+ {
+ iSource->InitializeL( aManager );
+ }
+
+ for( TInt i = 0; i < iSinks.Count();i++)
+ {
+ iSinks[i]->InitializeL( aManager );
+ }
+
+ if ( State() == EUninitialized )
+ {
+ SetState( EInitialized );
+ }
+
+ }
+
+// -----------------------------------------------------------------------------
+// CMceMediaStream::AddedL
+// -----------------------------------------------------------------------------
+//
+void CMceMediaStream::AddedL()
+ {
+
+ if ( Binder() && BoundStream() )
+ {
+ iLinkedStream->AddedL();
+ }
+
+ if ( iSource )
+ {
+ iSource->StreamAddedL( *this );
+ }
+
+ for( TInt i = 0; i < iSinks.Count();i++)
+ {
+ iSinks[i]->StreamAddedL( *this );
+ }
+
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMceMediaStream::EventReceivedL
+// -----------------------------------------------------------------------------
+//
+TInt CMceMediaStream::EventReceivedL( TMceEvent& aEvent )
+ {
+ MCECLI_DEBUG("CMceMediaStream::EventReceivedL, Entry");
+ MCECLI_DEBUG_DVALUES2("this: type", Type(), "id", Id().iId,
+ "main", ( !BoundStream() || Binder() ) );
+
+ TInt status = KMceEventNotOwner;
+ TBool idMatch = aEvent.Id().iMediaID == Id();
+ if ( idMatch )
+ {
+ if ( aEvent.Id().IsMediaId() )
+ {
+ status = HandleEvent( aEvent );
+ }
+ else
+ {
+ status = KMceEventNotConsumed;
+ }
+ }
+ else
+ {
+ //NOP
+ //might be for linked stream
+ }
+
+ if ( status == KMceEventConsumed || status == KMceEventUpdate )
+ {
+ MCECLI_DEBUG_DVALUE("CMceMediaStream::EventReceivedL, before exit. enabled", IsEnabled() );
+ TState state = State();
+ MCECLI_DEBUG_MEDIASTATE("CMceMediaStream::EventReceivedL, before exit. state", state );
+ MCECLI_DEBUG_DVALUE("CMceMediaStream::EventReceivedL, Exit. status", status );
+ return status;
+ }
+
+ //try binded
+ if ( status == KMceEventNotOwner )
+ {
+ if ( Binder() && BoundStream() )
+ {
+ status = iLinkedStream->EventReceivedL( aEvent );
+ if ( status == KMceEventUpdate )
+ {
+ delete iLinkedStream;
+ iLinkedStream = NULL;
+ CMceMsgObject<CMceMediaStream>* updateMsg =
+ static_cast<CMceMsgObject<CMceMediaStream>*>( aEvent.Message() );
+ CMceMediaStream* updateStream = updateMsg->Object();
+ CleanupStack::PushL( updateStream );
+ BindL( updateStream );
+ CleanupStack::Pop( updateStream );
+ InitializeL( *(Session()), EFalse );
+ updateStream->Updated();
+ status = KMceEventConsumed;
+ }
+ }
+ MCECLI_DEBUG_DVALUE("CMceMediaStream::EventReceivedL, before exit. enabled", IsEnabled() );
+ TState state = State();
+ MCECLI_DEBUG_MEDIASTATE("CMceMediaStream::EventReceivedL, before exit. state", state );
+ MCECLI_DEBUG_DVALUE("CMceMediaStream::EventReceivedL, Entry. status", status );
+ return status;
+ }
+
+ //try source
+ if ( aEvent.Id().IsSourceId() )
+ {
+ if ( iSource )
+ {
+ TInt sourceStatus = iSource->EventReceivedL( aEvent );
+ if ( sourceStatus == KMceEventUpdate )
+ {
+ CMceMsgObject<CMceMediaSource>* updateMsg =
+ static_cast<CMceMsgObject<CMceMediaSource>*>( aEvent.Message() );
+ CMceMediaSource* updateSource = updateMsg->iObject;
+ iSource->UpdateL( *updateSource );
+ iSource->Updated();
+ sourceStatus = KMceEventConsumed;
+ }
+ status = sourceStatus == KMceEventNotOwner ?
+ KMceEventNotConsumed : sourceStatus;
+ }
+ return status;
+ }
+
+ //try sinks
+ if ( aEvent.Id().IsSinkId() )
+ {
+ TInt sinkStatus = status;
+ TInt j = 0;
+ while ( sinkStatus != KMceEventConsumed && j < iSinks.Count() )
+ {
+ CMceMediaSink* sink = iSinks[j];
+ sinkStatus = sink->EventReceivedL( aEvent );
+ if ( sinkStatus == KMceEventUpdate )
+ {
+ CMceMsgObject<CMceMediaSink>* updateMsg =
+ static_cast<CMceMsgObject<CMceMediaSink>*>( aEvent.Message() );
+ CMceMediaSink* updateSink = updateMsg->iObject;
+ sink->UpdateL( *updateSink );
+ sink->Updated();
+ sinkStatus = KMceEventConsumed;
+ }
+ j++;
+ }
+ status = sinkStatus == KMceEventNotOwner ?
+ KMceEventNotConsumed : sinkStatus;
+ }
+
+ MCECLI_DEBUG_DVALUE("CMceMediaStream::EventReceivedL, before exit. enabled", IsEnabled() );
+ TState state = State();
+ MCECLI_DEBUG_MEDIASTATE("CMceMediaStream::EventReceivedL, before exit. state", state );
+ MCECLI_DEBUG_DVALUE("CMceMediaStream::EventReceivedL, Exit. status", status );
+ return status;
+
+
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMceMediaStream::Updated
+// -----------------------------------------------------------------------------
+//
+void CMceMediaStream::Updated()
+ {
+ MMceStreamObserver* observer = iSession->Manager().MediaObserver();
+
+ if ( observer )
+ {
+ observer->StreamStateChanged( *this );
+ }
+
+ }
+
+// -----------------------------------------------------------------------------
+// CMceMediaStream::HandleMediaError
+// -----------------------------------------------------------------------------
+//
+TBool CMceMediaStream::HandleMediaError( TState aState, TBool aIsEnabled, TInt aError )
+ {
+ TBool mediaErrorHandled( EFalse );
+ if ( aState == EDisabled && !aIsEnabled && aError != KErrNone )
+ {
+ MCECLI_DEBUG_DVALUE( "CMceMediaStream::HandleMediaError, fatal error:", aError )
+
+ CMceManager& manager = iSession->Manager();
+
+ TRAPD( err, iSession->TerminateL() )
+ if ( err )
+ {
+ CMceSession::TState state = iSession->State();
+ MCECLI_DEBUG_DVALUES( "CMceMediaStream::HandleMediaError, terminating failed:", err,
+ " at state:", state )
+
+ // Nothing to do if already terminating
+ if ( state != CMceSession::ETerminating &&
+ state != CMceSession::ETerminated )
+ {
+ TRAP_IGNORE( iSession->ErrorOccuredL( aError ) )
+ }
+ }
+ else if ( manager.SessionObserver() )
+ {
+ // Inform client that we are terminating
+ manager.SessionObserver()->SessionStateChanged(
+ *iSession, manager.TransactionContainer() );
+ }
+ else
+ {
+ // NOP
+ }
+
+ mediaErrorHandled = ETrue;
+
+ MCECLI_DEBUG( "CMceMediaStream::HandleMediaError, exit" )
+ }
+ return mediaErrorHandled;
+ }
+
+// -----------------------------------------------------------------------------
+// CMceMediaStream::CMceMediaStream
+// -----------------------------------------------------------------------------
+//
+CMceMediaStream::CMceMediaStream()
+ :iLinkedStream( NULL ),
+ iSource( NULL )
+ {
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMceMediaStream::ConstructL
+// -----------------------------------------------------------------------------
+//
+void CMceMediaStream::ConstructL( CMceComMediaStream* aFlatData )
+ {
+ __ASSERT_ALWAYS( aFlatData , User::Leave( KErrArgument ) );
+ iFlatData = aFlatData;
+ FLAT_DATA( iID ) = TMceMediaId();//as not assigned
+
+ }
+
+// -----------------------------------------------------------------------------
+// CMceMediaStream::DeleteSink
+// -----------------------------------------------------------------------------
+//
+void CMceMediaStream::DeleteSink( TInt aIndex )
+ {
+ MCECLI_DEBUG("CMceMediaStream::DeleteSink, Entry");
+ MCECLI_DEBUG_DVALUE("sink id", iSinks[ aIndex ]->Id().iId );
+
+ iSinks[ aIndex ]->ReferenceCount()--;
+ if ( iSinks[ aIndex ]->ReferenceCount() == 0 )
+ {
+ delete iSinks[ aIndex ];
+ }
+ else
+ {
+ MCECLI_DEBUG("CMceMediaStream::DeleteSink, \
+there are references to sink. Not deleted");
+ iSinks[ aIndex ]->UnInitialize( *this );
+ }
+ iSinks.Remove( aIndex );
+ MCECLI_DEBUG("CMceMediaStream::DeleteSink, Exit");
+
+ }
+
+// -----------------------------------------------------------------------------
+// CMceMediaStream::SetState
+// -----------------------------------------------------------------------------
+//
+TBool CMceMediaStream::SetState( CMceMediaStream::TState aState )
+ {
+ // If in transcoding state, do not allow certain state changes
+ if ( ( FLAT_DATA( iState ) == CMceMediaStream::ETranscodingRequired ||
+ FLAT_DATA( iState ) == CMceMediaStream::ETranscoding ) &&
+ ( aState == EBuffering ||
+ aState == EIdle ||
+ aState == EStreaming ||
+ aState == EDisabled ) )
+ {
+ return EFalse;
+ }
+ FLAT_DATA( iState ) = aState;
+
+ MCECLI_DEBUG_DVALUE("CMceMediaStream::SetState, id", Id().iId );
+ TState state = State();
+ MCECLI_DEBUG_MEDIASTATE("CMceMediaStream::SetState, current state", state );
+ return ETrue;
+ }
+
+// -----------------------------------------------------------------------------
+// CMceMediaStream::DeleteSource
+// -----------------------------------------------------------------------------
+//
+void CMceMediaStream::DeleteSource()
+ {
+ MCECLI_DEBUG("CMceMediaStream::DeleteSource, Entry");
+ MCECLI_DEBUG_DVALUE("source id", iSource->Id().iId );
+
+ iSource->ReferenceCount()--;
+ if ( iSource->ReferenceCount() == 0 )
+ {
+ delete iSource;
+ }
+ else
+ {
+ MCECLI_DEBUG("CMceMediaStream::DeleteSource, \
+there are references to source. Not deleted");
+ iSource->UnInitialize( *this );
+ }
+ iSource = NULL;
+ MCECLI_DEBUG("CMceMediaStream::DeleteSource, Exit");
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMceMediaStream::HandleEvent
+// -----------------------------------------------------------------------------
+//
+TInt CMceMediaStream::HandleEvent( TMceEvent& aEvent )
+ {
+ MCECLI_DEBUG("CMceMediaStream::HandleEvent, Entry");
+ MCECLI_DEBUG_DVALUES2("this: type", Type(), "id", Id().iId,
+ "main", ( !BoundStream() || Binder() ) );
+
+ TInt status = KMceEventNotConsumed;
+
+ if ( aEvent.MessageType() == EMceItcMsgTypeStream )
+ {
+ MCECLI_DEBUG("CMceMediaStream::HandleEvent, content of stream changed");
+ status = KMceEventUpdate;
+ }
+ else if ( aEvent.Action() == EMceItcStateChanged )
+ {
+ MCECLI_DEBUG("CMceMediaStream::HandleEvent, state changed");
+ FLAT_DATA( iIsEnabled ) = static_cast<TBool>( aEvent.ActionData() );
+ Updated();
+ status = KMceEventConsumed;
+ }
+ else if ( aEvent.Action() == EMceItcInProgress )
+ {
+ MCECLI_DEBUG("CMceMediaStream::HandleEvent, media state changed");
+ SetState( static_cast<CMceMediaStream::TState>( aEvent.ActionData() ) );
+
+ if ( !HandleMediaError( FLAT_DATA( iState ),
+ FLAT_DATA( iIsEnabled ),
+ aEvent.Id().iStatus ) )
+ {
+ Updated();
+ }
+
+ status = KMceEventConsumed;
+ }
+ else if ( aEvent.Action() == EMceItcRRReceived )
+ {
+ MCECLI_DEBUG("CMceMediaStream::HandleEvent, RR received");
+ MMceRtpObserver* observer = iSession->Manager().RtpObserver();
+ if ( observer )
+ {
+ observer->RRReceived( *iSession, *this );
+ }
+ status = KMceEventConsumed;
+ }
+ else if ( aEvent.Action() == EMceItcLinkCreated )
+ {
+ MCECLI_DEBUG("CMceMediaStream::HandleEvent, link created");
+ _FLAT_DATA->SetLocalMediaPort( aEvent.ActionData() );
+ status = KMceEventConsumed;
+ }
+ else
+ {
+ //NOP
+ MCECLI_DEBUG("CMceMediaStream::HandleEvent, not consumed");
+ }
+
+ MCECLI_DEBUG_DVALUE("CMceMediaStream::HandleEvent, Exit. status", status );
+
+ return status;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CMceMediaStream::DoBindL
+// -----------------------------------------------------------------------------
+//
+void CMceMediaStream::DoBindL( CMceMediaStream* aStream )
+ {
+ if ( Session() )
+ {
+ aStream->InitializeL( *Session(), EFalse );
+ }
+ delete iLinkedStream;
+ iLinkedStream = aStream;
+ }
+
+// -----------------------------------------------------------------------------
+// CMceMediaStream::Bound
+// -----------------------------------------------------------------------------
+//
+CMceMediaStream* CMceMediaStream::Bound() const
+ {
+ return iLinkedStream;
+ }
+
+// -----------------------------------------------------------------------------
+// CMceMediaStream::FlatData
+// -----------------------------------------------------------------------------
+//
+CMceComMediaStream* CMceMediaStream::FlatData()
+ {
+ return iFlatData;
+ }
+
+// -----------------------------------------------------------------------------
+// CMceMediaStream::FindCodec
+// -----------------------------------------------------------------------------
+//
+CMceCodec* CMceMediaStream::FindCodec(
+ const RPointerArray<CMceCodec>& aCodecs,
+ CMceCodec& aCodec )
+ {
+ CMceCodec* foundCodec = NULL;
+ TInt index = aCodecs.Find( &aCodec );
+ if ( index == KErrNotFound )
+ {
+ TInt boundCodecIndex( KErrNotFound );
+ if ( iLinkedStream != NULL )
+ {
+ // If multiple matches based exist based on SDP, index based match
+ // will be done. Find out index of the codec in bound stream.
+ const RPointerArray<CMceCodec>& boundCodecs = iLinkedStream->BaseCodecs();
+ boundCodecIndex = boundCodecs.Find( &aCodec );
+ }
+
+ for ( TInt i = 0; i < aCodecs.Count(); i++ )
+ {
+ if ( aCodecs[ i ]->SdpName().CompareF( aCodec.SdpName() ) == 0 )
+ {
+ if ( foundCodec )
+ {
+ if ( boundCodecIndex != KErrNotFound && i == boundCodecIndex )
+ {
+ // This codec is selected as it has the same index as
+ // search term codec has in bound stream
+ foundCodec = aCodecs[ i ];
+ }
+ }
+ else
+ {
+ foundCodec = aCodecs[ i ];
+ }
+ }
+ }
+ }
+ else
+ {
+ foundCodec = aCodecs[ index ];
+ }
+
+ return foundCodec;
+ }
+
+// End of file