diff -r 000000000000 -r 1bce908db942 multimediacommsengine/mmcecli/src/mcemediastream.cpp --- /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( 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& 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 serial( *this, _FLAT_DATA ); + serial.InternalizeL( aSerCtx ); + } + +// ----------------------------------------------------------------------------- +// CMceMediaStream::ExternalizeL +// ----------------------------------------------------------------------------- +// +void CMceMediaStream::ExternalizeL( MMceComSerializationContext& aSerCtx ) + { + + TMceMediaStreamSerializer 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( 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( 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* updateMsg = + static_cast*>( 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* updateMsg = + static_cast*>( 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* updateMsg = + static_cast*>( 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( aEvent.ActionData() ); + Updated(); + status = KMceEventConsumed; + } + else if ( aEvent.Action() == EMceItcInProgress ) + { + MCECLI_DEBUG("CMceMediaStream::HandleEvent, media state changed"); + SetState( static_cast( 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& 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& 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