diff -r 000000000000 -r 1bce908db942 multimediacommsengine/mmcesrv/mmcemediamanager/src/mcemediamanager.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/multimediacommsengine/mmcesrv/mmcemediamanager/src/mcemediamanager.cpp Tue Feb 02 01:04:58 2010 +0200 @@ -0,0 +1,4784 @@ +/* +* 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 FILES +#include + +#include +#include +#include + +#include +#include + +#include "mcemediasource.h" +#include "mcemediastream.h" +#include "mceaudiostream.h" +#include "mcemicsource.h" +#include "mcertpsource.h" +#include "mcertpsink.h" +#include "mcecamerasource.h" +#include "mcefilesource.h" +#include "mcedisplaysink.h" +#include "mceaudiocodec.h" +#include "mceamrcodec.h" +#include "mcenatpluginmanager.h" + +#include "mcecssessionimplementation.h" +#include "mcemediamanager.h" +#include "mcemediaobserver.h" +#include "mcesdpsession.h" +#include "mcemediadefs.h" + +#include "mcecommediastream.h" +#include "mcecomaudiostream.h" +#include "mcecomsession.h" +#include "mcecomaudiocodec.h" +#include "mcecomvideocodec.h" +#include "mcecommediasource.h" +#include "mcecommediasink.h" +#include "mcecomrtpsource.h" +#include "mcecomdisplaysink.h" +#include "mcecomcamerasource.h" +#include "mcecomrtpsink.h" +#include "mcecomspeakersink.h" + +#include "mcemmlogs.h" + +#include "mcecomfactory.h" +#include "mcesrvstreamiterator.h" +#include "mcesrvsink.h" +#include "mcesrvsource.h" +#include "mceevents.h" +#include "mcemediastate.h" + +#include "mceaudiosdpcodec.h" +#include "mcevideosdpcodec.h" +#include "cleanupresetanddestroy.h" +#include "mcedtmfhandler.h" +#include "mcecomendpointproxy.h" + +#define MCE_HEAP_CONSTRUCT_LC( type, variable ) \ +type* variable = new ( ELeave ) type; \ +CleanupStack::PushL( variable ); + +#define MCE_HEAP_CONSTRUCT_WITH_PARAM_LC( type, variable, param ) \ +type* variable = new ( ELeave ) type( param ); \ +CleanupStack::PushL( variable ); + +const TInt KMceMaxFileName8 = KMceMaxFileNameLength * 4; + + +// ================ MEMBER FUNCTIONS ======================= + +// --------------------------------------------------------- +// CMceMediaManager::CMceMediaManager +// --------------------------------------------------------- +CMceMediaManager::CMceMediaManager() + { + } + +// --------------------------------------------------------- +// CMceMediaManager::ConstructL +// --------------------------------------------------------- +void CMceMediaManager::ConstructL( MMceMediaGeneralObserver& aObserver ) + { + iObserver = &aObserver; + iMccInterface = CMccInterface::NewL( *this ); + iMccSecureInterface = CMccSecureInterface::NewL( *iMccInterface ); + + SdpCodecStringPool::OpenL(); + + iNatPluginManager = CMceNatPluginManager::NewL(); + + CMceSdpCodec* sdpCodec = NULL; + + //audio SDP codec + sdpCodec = CMceAudioSdpCodec::NewL(); + CleanupStack::PushL( sdpCodec ); + iSdpCodecs.AppendL( sdpCodec ); + CleanupStack::Pop( sdpCodec ); + + + //video SDP codec + sdpCodec = CMceVideoSdpCodec::NewL(); + CleanupStack::PushL( sdpCodec ); + iSdpCodecs.AppendL( sdpCodec ); + CleanupStack::Pop( sdpCodec ); + + } + + +// --------------------------------------------------------- +// CMceMediaManager::SdpCodec +// --------------------------------------------------------- +CMceSdpCodec* CMceMediaManager::SdpCodec( const CSdpMediaField& aMedia ) + { + CMceSdpCodec* sdpCodec = NULL; + TInt index = 0; + while( !sdpCodec && index < iSdpCodecs.Count() ) + { + sdpCodec = iSdpCodecs[ index++ ]; + sdpCodec = sdpCodec->Decodes( aMedia ) ? sdpCodec : NULL; + } + + return sdpCodec; + + } + + +// --------------------------------------------------------- +// CMceMediaManager::SdpCodec +// --------------------------------------------------------- +CMceSdpCodec* CMceMediaManager::SdpCodec( CMceComMediaStream& aStream ) + { + CMceSdpCodec* sdpCodec = NULL; + TInt index = 0; + while( !sdpCodec && index < iSdpCodecs.Count() ) + { + sdpCodec = iSdpCodecs[ index++ ]; + sdpCodec = sdpCodec->Encodes( aStream ) ? sdpCodec : NULL; + } + + return sdpCodec; + + } + + +// --------------------------------------------------------- +// CMceMediaManager::NewL +// --------------------------------------------------------- + CMceMediaManager* CMceMediaManager::NewL( + MMceMediaGeneralObserver& aObserver ) + { + CMceMediaManager* self = NewLC( aObserver ); + CleanupStack::Pop( self ); + return self; + } + + +// --------------------------------------------------------- +// CMceMediaManager::NewLC +// --------------------------------------------------------- + CMceMediaManager* CMceMediaManager::NewLC( + MMceMediaGeneralObserver& aObserver ) + { + CMceMediaManager* self = new ( ELeave ) CMceMediaManager; + CleanupStack::PushL( self ); + self->ConstructL( aObserver ); + return self; + } + + +// --------------------------------------------------------- +// CMceMediaManager::~CMceMediaManager +// --------------------------------------------------------- + CMceMediaManager::~CMceMediaManager() + { + MCEMM_DEBUG("CMceMediaManager::~CMceMediaManager(), Entry "); + + delete iMccSecureInterface; + iMccSecureInterface=NULL; + + delete iNatPluginManager; + iNatPluginManager = NULL; + + delete iMccInterface; + iMccInterface = NULL; + iMceSdpSessions.ResetAndDestroy(); + iSdpCodecs.ResetAndDestroy(); + iTranscodeSessions.ResetAndDestroy(); + SdpCodecStringPool::Close(); + MCEMM_DEBUG("CMceMediaManager::~CMceMediaManager(), Exit "); + + } + + + +// --------------------------------------------------------- +// CMceMediaManager::CreateSessionL +// --------------------------------------------------------- +CMceSdpSession& CMceMediaManager::CreateSessionL( CMceComSession& aSession ) + { + MCEMM_DEBUG("CMceMediaManager::CreateSessionL(), Entry "); + + CMceSdpSession* sdpSession = CMceSdpSession::NewL( aSession, *this ); + CleanupStack::PushL( sdpSession ); + + aSession.AttachSDPSessionL( *sdpSession ); + User::LeaveIfError (iMceSdpSessions.Append( sdpSession )); + CleanupStack::Pop( sdpSession ); + + MCEMM_DEBUG("CMceMediaManager::CreateSessionL(), Exit "); + + return *sdpSession; + } + +// --------------------------------------------------------- +// CMceMediaManager::NatMediaManager +// --------------------------------------------------------- +CMceNatPluginManager& CMceMediaManager::NatPluginManager() + { + return *iNatPluginManager; + } + +// --------------------------------------------------------- +// CMceMediaManager::EncodeL +// --------------------------------------------------------- +CSdpDocument* CMceMediaManager::EncodeL( CMceComSession& aSession ) + { + + MCEMM_DEBUG("CMceMediaManager::EncodeL(), Entry "); + + if ( !SdpSession( aSession ) ) + { + CreateSessionL( aSession ); + } + + TMceMMState negotationStateId = aSession.NegotiationState().Id(); + MCEMM_DEBUG_STATE( "current state", + negotationStateId ); + CSdpDocument* sdp = aSession.NegotiationState().EncodeL(); + + MCEMM_DEBUG("CMceMediaManager::EncodeL(), Exit "); + + return sdp; + + } + +// --------------------------------------------------------- +// CMceMediaManager::DecodeL +// --------------------------------------------------------- +TMceSipWarningCode CMceMediaManager::DecodeL( + CMceComSession& aSession, + CSdpDocument& aSdpDocument ) + { + MCEMM_DEBUG("CMceMediaManager::DecodeL(), Entry "); + + if ( !SdpSession( aSession ) ) + { + CreateSessionL( aSession ); + } + TMceMMState negotationStateId = aSession.NegotiationState().Id(); + MCEMM_DEBUG_STATE( "CMceMediaManager::DecodeL(): current state", + negotationStateId ); + TMceSipWarningCode result = + aSession.NegotiationState().DecodeL( aSdpDocument ); + + MCEMM_DEBUG("CMceMediaManager::DecodeL(), Exit "); + + return result; + + } + +// --------------------------------------------------------- +// CMceMediaManager::UpdateL +// --------------------------------------------------------- +TMceReturnStatus CMceMediaManager::UpdateL( CMceComSession& aSession ) + { + MCEMM_DEBUG("CMceMediaManager::UpdateL(), Entry "); + + TMceReturnStatus status = KMceAsync; + + if ( !SdpSession( aSession ) ) + { + CreateSessionL( aSession ); + } + TMceMMState negotationStateId = aSession.NegotiationState().Id(); + MCEMM_DEBUG_STATE( "CMceMediaManager::UpdateL(): current state", + negotationStateId ); + aSession.NegotiationState().UpdateL(); + status = !aSession.NegotiationState().CallbackAllowed() ? + KMceReady : KMceAsync; + MCEMM_DEBUG("CMceMediaManager::UpdateL(), Exit "); + return status; + } + +// --------------------------------------------------------- +// CMceMediaManager::ReserveL +// --------------------------------------------------------- + +TMceReturnStatus CMceMediaManager::ReserveL( CMceComSession& aSession, + const TDesC8& /*aToken*/ ) + { + MCEMM_DEBUG("CMceMediaManager::ReserveL(), Entry "); + + TMceReturnStatus status = KMceReady; + + CMceSdpSession* sdpSession = SdpSession( aSession ); + __ASSERT_ALWAYS( sdpSession, User::Leave( KErrNotFound ) ); + + MCEMM_DEBUG_STATE_1( "CMceMediaManager::ReserveL(): current state", + aSession ); + if ( sdpSession ) + { + status = aSession.NegotiationState().ReserveL(); + } + + + MCEMM_DEBUG("CMceMediaManager::ReserveL(), Exit "); + + return status; + + } + +// --------------------------------------------------------- +// CMceMediaManager::ReservationNeeded +// --------------------------------------------------------- +TBool CMceMediaManager::ReservationNeeded( CMceComSession& aSession ) + { + MCEMM_DEBUG("CMceMediaManager::ReservationNeeded(), Entry "); + TBool reservationNeeded = EFalse; + CMceSdpSession* sdpSession = SdpSession( aSession ); + + MCEMM_DEBUG_STATE_1( "CMceMediaManager::ReservationNeeded(): current state", + aSession ); + if ( sdpSession ) + { + reservationNeeded = aSession.NegotiationState().ReservationNeeded(); + } + + MCEMM_DEBUG("CMceMediaManager::ReservationNeeded(), Exit "); + return reservationNeeded; + + } + +// --------------------------------------------------------- +// CMceMediaManager::NeedToNegotiate +// --------------------------------------------------------- +TBool CMceMediaManager::NeedToNegotiate( CMceComSession& aSession, + CSdpDocument* aSdpDocument ) + { + MCEMM_DEBUG("CMceMediaManager::NeedToNegotiate(), Entry "); + TBool needToNegotiate = EFalse; + CMceSdpSession* sdpSession = SdpSession( aSession ); + + MCEMM_DEBUG_STATE_1( "CMceMediaManager::NeedToNegotiate(): current state", + aSession ); + if ( sdpSession ) + { + needToNegotiate = aSession.NegotiationState().NeedToNegotiate( aSdpDocument ); + } + + MCEMM_DEBUG("CMceMediaManager::NeedToNegotiate(), Exit "); + return needToNegotiate; + + } + + +// --------------------------------------------------------- +// CMceMediaManager::ConfirmationNeeded +// --------------------------------------------------------- +// +TBool CMceMediaManager::ConfirmationNeeded( CMceComSession& aSession ) + { + MCEMM_DEBUG("CMceMediaManager::ConfirmationNeeded(), Entry "); + TBool needToNegotiate = EFalse; + CMceSdpSession* sdpSession = SdpSession( aSession ); + + MCEMM_DEBUG_STATE_1( "CMceMediaManager::ConfirmationNeeded(): current state", + aSession); + if ( sdpSession ) + { + needToNegotiate = aSession.NegotiationState().ConfirmationNeeded(); + } + + MCEMM_DEBUG("CMceMediaManager::ConfirmationNeeded(), Exit "); + return needToNegotiate; + } + + +// --------------------------------------------------------- +// CMceMediaManager::GetRole +// --------------------------------------------------------- +// + +TMceNegotiationRole CMceMediaManager::GetRole( CMceComSession& aSession ) + { + MCEMM_DEBUG("CMceMediaManager::GetRole()"); + + return aSession.NegotiationState().Role(); + } + + +// --------------------------------------------------------- +// CMceMediaManager::CreateRejectedAnswer +// --------------------------------------------------------- +// + void CMceMediaManager::CreateRejectedAnswer( CMceComSession& aSession ) + { + MCEMM_DEBUG("CMceMediaManager::CreateRejectedAnswer(), Entry "); + + CMceSdpSession* sdpSession = SdpSession( aSession ); + if( !sdpSession ) + { + return; + } + TRAPD( err, sdpSession->CreateAnswerL( aSession, ETrue ) ); + if( err != KErrNone ) + { + MCEMM_DEBUG_DVALUE( "CMceMediaManager::CreateRejectedAnswer(): \ +ERROR: Creating rejected answer", err ); + iObserver->MediaError( err ); + } + MCEMM_DEBUG("CMceMediaManager::CreateRejectedAnswer(), Exit "); + } + + +// --------------------------------------------------------- +// CMceMediaManager::PauseL +// --------------------------------------------------------- +// + void CMceMediaManager::PauseL( CMceComMediaSink& aSink ) + { + MCEMM_DEBUG("CMceMediaManager::PauseL() - sink, Entry "); + CMceComSession* session = aSink.MediaStream()->Session(); + + TMceSrvStreamIterator streams( session->MccStreams(), aSink ); + CMceSrvStream* stream = NULL; + + while( streams.Next( stream ) ) + { + if ( !stream->Sink().DisableL( *stream ) ) + { + SynchronizeMccStreamL( *stream, 0, stream->Sink().Id() ); + } + } + + MCEMM_DEBUG("CMceMediaManager::PauseL() - sink, Exit "); + } + +// --------------------------------------------------------- +// CMceMediaManager::PauseL +// --------------------------------------------------------- +// + void CMceMediaManager::PauseL( CMceComMediaSource& aSource ) + { + MCEMM_DEBUG("CMceMediaManager::PauseL() - source, Entry "); + CMceComSession* session = aSource.MediaStream()->Session(); + + TMceSrvStreamIterator streams( session->MccStreams(), aSource ); + CMceSrvStream* stream = NULL; + + while( streams.Next( stream ) ) + { + if ( !stream->Source().DisableL( *stream ) ) + { + SynchronizeMccStreamL( *stream, 0, stream->Source().Id() ); + } + } + + MCEMM_DEBUG("CMceMediaManager::PauseL() - source, Exit "); + } + + +// --------------------------------------------------------- +// CMceMediaManager::ResumeL +// --------------------------------------------------------- +// + void CMceMediaManager::ResumeL( CMceComMediaSink& aSink ) + { + MCEMM_DEBUG("CMceMediaManager::ResumeL() - sink, Entry "); + CMceComSession* session = aSink.MediaStream()->Session(); + + TMceSrvStreamIterator streams( session->MccStreams(), aSink ); + CMceSrvStream* stream = NULL; + + while( streams.Next( stream ) ) + { + if ( !stream->Sink().EnableL( *stream ) ) + { + MCEMM_DEBUG_STREAM( "CMceMediaManager::ResumeL() - sink: \ +synchronize stream", *stream ); + SynchronizeMccStreamL( *stream, stream->Sink().Id(), 0 ); + } + } + + MCEMM_DEBUG("CMceMediaManager::ResumeL() - sink, Exit "); + } + + +// --------------------------------------------------------- +// CMceMediaManager::ResumeL +// --------------------------------------------------------- +// + void CMceMediaManager::ResumeL( CMceComMediaSource& aSource ) + { + MCEMM_DEBUG("CMceMediaManager::ResumeL() - source, Entry "); + CMceComSession* session = aSource.MediaStream()->Session(); + + TMceSrvStreamIterator streams( session->MccStreams(), aSource ); + CMceSrvStream* stream = NULL; + + while( streams.Next( stream ) ) + { + if ( !stream->Source().EnableL( *stream ) ) + { + MCEMM_DEBUG_STREAM( "CMceMediaManager::ResumeL() - source: \ +synchronize stream", *stream ); + SynchronizeMccStreamL( *stream, stream->Source().Id(), 0 ); + } + } + + MCEMM_DEBUG("CMceMediaManager::ResumeL() - source, Exit "); + } + + +// --------------------------------------------------------- +// CMceMediaManager::StartInactivityTimerL +// --------------------------------------------------------- +// +void CMceMediaManager::StartInactivityTimerL( + const CMceComRtpSource& aRtpSource, + TUint32 aInactivityTimeout ) + { + MCEMM_DEBUG("CMceMediaManager::StartInactivityTimerL(), Entry "); + + CMceComSession* session = aRtpSource.MediaStream()->Session(); + + TMceSrvStreamIterator streams( session->MccStreams(), aRtpSource ); + CMceSrvStream* stream = NULL; + + while( streams.Next( stream ) ) + { + MCEMM_DEBUG_STREAM( "CMceMediaManager::StartInactivityTimerL(): \ +start inactivity timer for stream", *stream ); + User::LeaveIfError( + iMccInterface->StartInactivityTimer( + stream->SessionId(), + stream->LinkId(), + stream->Id(), + aInactivityTimeout ) ); + + } + + MCEMM_DEBUG("CMceMediaManager::StartInactivityTimerL(), Exit "); + + } + +// --------------------------------------------------------- +// CMceMediaManager::StopInactivityTimerL +// --------------------------------------------------------- +// +void CMceMediaManager::StopInactivityTimerL( + const CMceComRtpSource& aRtpSource ) + { + + MCEMM_DEBUG("CMceMediaManager::StopInactivityTimerL(), Entry "); + + CMceComSession* session = aRtpSource.MediaStream()->Session(); + + TMceSrvStreamIterator streams( session->MccStreams(), aRtpSource ); + CMceSrvStream* stream = NULL; + + while( streams.Next( stream ) ) + { + MCEMM_DEBUG_STREAM( "CMceMediaManager::StopInactivityTimerL(): \ +stop inactivity timer for stream", *stream ); + User::LeaveIfError( + iMccInterface->StopInactivityTimer( + stream->SessionId(), + stream->LinkId(), + stream->Id() ) ); + + } + + MCEMM_DEBUG("CMceMediaManager::StopInactivityTimerL(), Exit "); + + } + +// --------------------------------------------------------- +// CMceMediaManager::SendRTCPAnyDataL +// --------------------------------------------------------- +// +void CMceMediaManager::SendRTCPAnyDataL( const CMceComMediaStream& aMediaStream, + const TDesC8& aData ) + { + MCEMM_DEBUG("CMceMediaManager::SendRTCPAnyDataL(), Entry "); + + CMceComMediaSink* rtpSink = NULL; + TInt index = 0; + while( !rtpSink && index < aMediaStream.iSinks.Count() ) + { + rtpSink = aMediaStream.iSinks[ index++ ]; + rtpSink = rtpSink->iType != KMceRTPSink ? NULL : rtpSink; + } + + if ( !rtpSink ) + { + MCEMM_DEBUG("No target!"); + return; + } + + CMceComSession* session = aMediaStream.Session(); + + TMceSrvStreamIterator streams( session->MccStreams(), *rtpSink ); + CMceSrvStream* stream = NULL; + + // Taking some precautions to avoid stack memory overuse + // + TMccEvent* event = new ( ELeave ) TMccEvent; + CleanupStack::PushL( event ); + + event->iEventCategory = KMccEventCategoryRtcp; + event->iEventType = KMccRtcpControl; + + { + TMccRtcpEventData eventData; + eventData.iRtcpPacketType = KRtcpAnyPacket; + eventData.iRtcpPacketData.Copy( aData ); + TMccRtcpEventDataPackage eventDataBuf( eventData ); + event->iEventData.Copy( eventDataBuf ); + } + + while( streams.Next( stream ) ) + { + + MCEMM_DEBUG_STREAM( "CMceMediaManager::SendRTCPAnyDataL(): \ +send rtcp any data to stream", *stream ); + event->iSessionId = stream->SessionId(); + event->iLinkId = stream->LinkId(); + event->iStreamId = stream->Id(); + event->iEndpointId = stream->Sink().Id(); + + iMccInterface->SendMediaSignalL( *event ); + + } + + CleanupStack::PopAndDestroy( event ); + + MCEMM_DEBUG("CMceMediaManager::SendRTCPAnyDataL(), Exit "); + + } + + + +// --------------------------------------------------------- +// CMceMediaManager::SendRTCPReceiverReportL +// --------------------------------------------------------- +// +void CMceMediaManager::SendRTCPReceiverReportL( + const CMceComRtpSource& aRtpSource ) + { + MCEMM_DEBUG("CMceMediaManager::SendRTCPReceiverReportL(), Entry "); + + CMceComSession* session = aRtpSource.MediaStream()->Session(); + + TMceSrvStreamIterator streams( session->MccStreams(), aRtpSource ); + CMceSrvStream* stream = NULL; + + // Taking some precautions to avoid stack memory overuse + // + TMccEvent* event = new ( ELeave ) TMccEvent; + CleanupStack::PushL( event ); + + event->iEventCategory = KMccEventCategoryRtcp; + event->iEventType = KMccRtcpControl; + + { + TMccRtcpEventData eventData; + eventData.iRtcpPacketType = KRtcpRrPacket; + TMccRtcpEventDataPackage eventDataBuf( eventData ); + event->iEventData.Copy( eventDataBuf ); + } + + while( streams.Next( stream ) ) + { + + MCEMM_DEBUG_STREAM( "CMceMediaManager::SendRTCPReceiverReportL(): \ +send rtcp receiver report to stream", *stream ); + event->iSessionId = stream->SessionId(); + event->iLinkId = stream->LinkId(); + event->iStreamId = stream->Id(); + event->iEndpointId = stream->Source().Id(); + + iMccInterface->SendMediaSignalL( *event ); + + } + + CleanupStack::PopAndDestroy( event ); + + MCEMM_DEBUG("CMceMediaManager::SendRTCPReceiverReportL(), Exit "); + + } + +// --------------------------------------------------------- +// CMceMediaManager::SendRTCPSenderReportL +// --------------------------------------------------------- +// +void CMceMediaManager::SendRTCPSenderReportL( + const CMceComRtpSink& aRtpSink ) + { + MCEMM_DEBUG("CMceMediaManager::SendRTCPSenderReportL(), Entry "); + + CMceComSession* session = aRtpSink.MediaStream()->Session(); + + TMceSrvStreamIterator streams( session->MccStreams(), aRtpSink ); + CMceSrvStream* stream = NULL; + + // Taking some precautions to avoid stack memory overuse + // + TMccEvent* event = new ( ELeave ) TMccEvent; + CleanupStack::PushL( event ); + + event->iEventCategory = KMccEventCategoryRtcp; + event->iEventType = KMccRtcpControl; + + { + TMccRtcpEventData eventData; + eventData.iRtcpPacketType = KRtcpSrPacket; + TMccRtcpEventDataPackage eventDataBuf( eventData ); + event->iEventData.Copy( eventDataBuf ); + } + + while( streams.Next( stream ) ) + { + + MCEMM_DEBUG_STREAM( "CMceMediaManager::SendRTCPSenderReportL(): \ +send rtcp sender report to stream", *stream ); + event->iSessionId = stream->SessionId(); + event->iLinkId = stream->LinkId(); + event->iStreamId = stream->Id(); + event->iEndpointId = stream->Sink().Id(); + + iMccInterface->SendMediaSignalL( *event ); + + } + + CleanupStack::PopAndDestroy( event ); + + MCEMM_DEBUG("CMceMediaManager::SendRTCPSenderReportL(), Exit "); + + } + + +// --------------------------------------------------------- +// CMceMediaManager::GetMaxVolumeL +// --------------------------------------------------------- +// +void CMceMediaManager::GetMaxVolumeL( TInt& aMaxVolume ) + { + MCEMM_DEBUG("CMceMediaManager::GetMaxVolumeL(), Entry "); + + TPckgBuf maxVolume( aMaxVolume ); + + // Max volume can be asked always after MCC creation + User::LeaveIfError( iMccInterface->GetParameter( + 0, 0, 0, 0, KMccSpeakerMaxVolume, maxVolume ) ); + + aMaxVolume = maxVolume(); + + MCEMM_DEBUG("CMceMediaManager::GetMaxVolumeL(), Exit "); + + } + +// --------------------------------------------------------- +// CMceMediaManager::GetVolumeL +// --------------------------------------------------------- +// +void CMceMediaManager::GetVolumeL( const CMceComMediaSink& aSink, + TInt& aVolume ) + { + MCEMM_DEBUG("CMceMediaManager::GetVolumeL(), Entry "); + + TPckgBuf volume( aVolume ); + + GetMccParameterL( aSink, KMccSpeakerVolume, volume ); + aVolume = volume(); + + MCEMM_DEBUG("CMceMediaManager::GetVolumeL(), Exit "); + + } + +// --------------------------------------------------------- +// CMceMediaManager::SetVolumeL +// --------------------------------------------------------- +// +void CMceMediaManager::SetVolumeL( const CMceComMediaSink& aSink, + TInt aVolume ) + { + MCEMM_DEBUG("CMceMediaManager::SetVolumeL(), Entry "); + + TPckgBuf volume( aVolume ); + + if ( aSink.EndpointProxy() ) + { + aSink.EndpointProxy()->SetParameterL( aSink, KMccSpeakerVolume, volume ); + } + else + { + SetMccParameterL( aSink, KMccSpeakerVolume, volume ); + } + + MCEMM_DEBUG("CMceMediaManager::SetVolumeL(), Exit "); + + } + + +// --------------------------------------------------------- +// CMceMediaManager::GetAudioRoutingL +// --------------------------------------------------------- +// +void CMceMediaManager::GetAudioRoutingL( + const CMceComSpeakerSink& aSpeaker, + TInt& aRoutingDestination ) + { + MCEMM_DEBUG("CMceMediaManager::GetAudioRoutingL(), Entry "); + + TPckgBuf routingDestination( aRoutingDestination ); + + GetMccParameterL( aSpeaker, KMccSpeakerRouting, + routingDestination ); + + aRoutingDestination = routingDestination(); + + MCEMM_DEBUG("CMceMediaManager::GetAudioRoutingL(), Exit "); + + } + +// --------------------------------------------------------- +// CMceMediaManager::SetAudioRoutingL +// --------------------------------------------------------- +// + void CMceMediaManager::SetAudioRoutingL( + const CMceComSpeakerSink& aSpeaker, + TInt aRoutingDestination ) + { + MCEMM_DEBUG("CMceMediaManager::SetAudioRoutingL(), Entry "); + + TPckgBuf routingDestination( aRoutingDestination ); + + SetMccParameterL( aSpeaker, KMccSpeakerRouting, + routingDestination ); + + MCEMM_DEBUG("CMceMediaManager::SetAudioRoutingL(), Exit "); + + } + +// --------------------------------------------------------- +// CMceMediaManager::SetBalanceL +// --------------------------------------------------------- +// +void CMceMediaManager::SetBalanceL( + const CMceComMediaSink& aSink, + TInt aBalance ) + { + MCEMM_DEBUG("CMceMediaManager::SetBalanceL(), Entry "); + + TPckgBuf balance( aBalance ); + + SetMccParameterL( aSink, KMccSpeakerBalance, balance ); + + MCEMM_DEBUG("CMceMediaManager::SetBalanceL(), Exit "); + + } + + +// --------------------------------------------------------- +// CMceMediaManager::SetBalanceL +// --------------------------------------------------------- +// +void CMceMediaManager::SetBalanceL( + const CMceComMediaSource& aSource, + TInt aBalance ) + { + MCEMM_DEBUG("CMceMediaManager::SetBalanceL(), Entry "); + + TPckgBuf balance( aBalance ); + + SetMccParameterL( aSource, KMccMicBalance, balance ); + + MCEMM_DEBUG("CMceMediaManager::SetBalanceL(), Exit "); + + } + +// --------------------------------------------------------- +// CMceMediaManager::GetGainL +// --------------------------------------------------------- +// +void CMceMediaManager::GetGainL( + const CMceComMediaSource& aSource, + TInt& aGain ) + { + MCEMM_DEBUG("CMceMediaManager::GetGainL(), Entry "); + + TPckgBuf gain( aGain ); + + GetMccParameterL( aSource, KMccMicGain, gain ); + + aGain = gain(); + + MCEMM_DEBUG("CMceMediaManager::GetGainL(), Exit "); + + } + +// --------------------------------------------------------- +// CMceMediaManager::GetMaxGainL +// --------------------------------------------------------- +// +void CMceMediaManager::GetMaxGainL( TInt& aMaxGain ) + { + MCEMM_DEBUG("CMceMediaManager::GetMaxGainL(), Entry "); + + TPckgBuf maxGain( aMaxGain ); + + // Max gain can be asked always after MCC creation + User::LeaveIfError( iMccInterface->GetParameter( + 0, 0, 0, 0, KMccMicMaxGain, maxGain ) ); + + aMaxGain = maxGain(); + + MCEMM_DEBUG("CMceMediaManager::GetMaxGainL(), Exit "); + } + + +// --------------------------------------------------------- +// CMceMediaManager::SetGainL +// --------------------------------------------------------- +// +void CMceMediaManager::SetGainL( + const CMceComMediaSource& aSource, + TInt aGain ) + { + MCEMM_DEBUG("CMceMediaManager::SetGainL(), Entry "); + + TPckgBuf gain( aGain ); + + SetMccParameterL( aSource, KMccMicGain, gain ); + + MCEMM_DEBUG("CMceMediaManager::SetGainL(), Exit "); + + } + + +// --------------------------------------------------------- +// CMceMediaManager::GetDisplaysAvailableL +// --------------------------------------------------------- +// +void CMceMediaManager::GetDisplaysAvailableL( + TInt& aDisplaysAvailable ) + { + MCEMM_DEBUG("CMceMediaManager::GetDisplaysAvailableL(), Entry "); + + const TInt KMceDefDisplaysAvailable = 1; + + aDisplaysAvailable = KMceDefDisplaysAvailable; + + MCEMM_DEBUG_DVALUE("Default value", aDisplaysAvailable ); + + MCEMM_DEBUG("CMceMediaManager::GetDisplaysAvailableL(), Exit "); + + + } + +// --------------------------------------------------------- +// CMceMediaManager::GetDisplayRectL +// --------------------------------------------------------- +// +void CMceMediaManager::GetDisplayRectL( CMceComDisplaySink& aSink, + TRect& aDisplayRect ) + { + MCEMM_DEBUG("CMceMediaManager::GetDisplayRectL(), Entry "); + + TMccVideoSinkSetting display; + TMccVideoSinkSettingBuf displayBuf( display ); + + GetMccParameterL( aSink, aSink.MccParameterName(), + displayBuf ); + + display = displayBuf(); + aDisplayRect = TRect( display.iLocation, display.iSize ); + + aSink.SetDisplayRect( aDisplayRect ); + + MCEMM_DEBUG("CMceMediaManager::GetDisplayRectL(), Exit "); + + } + +// --------------------------------------------------------- +// CMceMediaManager::SetDisplayRectL +// --------------------------------------------------------- +// +void CMceMediaManager::SetDisplayRectL( CMceComDisplaySink& aSink, + TRect aDisplayRect ) + { + MCEMM_DEBUG("CMceMediaManager::SetDisplayRectL(), Entry "); + + aSink.SetDisplayRect( aDisplayRect ); + + TMccVideoSinkSetting display; + TMccVideoSinkSettingBuf displayBuf( display ); + GetMccParameterL( aSink, aSink.MccParameterName(), + displayBuf ); + + display = displayBuf(); + CMceComDisplaySink::ToPointAndSize( aDisplayRect, + display.iLocation, + display.iSize ); + TMccVideoSinkSettingBuf updateBuf( display ); + SetMccParameterL( aSink, aSink.MccParameterName(), + updateBuf ); + + + MCEMM_DEBUG("CMceMediaManager::SetDisplayRectL(), Exit "); + + } + +// --------------------------------------------------------- +// CMceMediaManager::GetDisplayPriorityL +// --------------------------------------------------------- +// +void CMceMediaManager::GetDisplayPriorityL( CMceComDisplaySink& aSink, + TInt& aDisplayPriority ) + { + + MCEMM_DEBUG("CMceMediaManager::GetDisplayPriorityL(), Entry "); + + TMccVideoSinkSetting display; + TMccVideoSinkSettingBuf displayBuf( display ); + + GetMccParameterL( aSink, aSink.MccParameterName(), + displayBuf ); + + display = displayBuf(); + aDisplayPriority = display.iPriority.iPriority; + + aSink.iPriority = aDisplayPriority; + + MCEMM_DEBUG("CMceMediaManager::GetDisplayPriorityL(), Exit "); + + } + + +// --------------------------------------------------------- +// CMceMediaManager::SetDisplayPriorityL +// --------------------------------------------------------- +// +void CMceMediaManager::SetDisplayPriorityL( CMceComDisplaySink& aSink, + TInt aDisplayPriority ) + { + MCEMM_DEBUG("CMceMediaManager::SetDisplayPriorityL(), Entry "); + + aSink.iPriority = aDisplayPriority; + + TMccVideoSinkSetting display; + TMccVideoSinkSettingBuf displayBuf( display ); + GetMccParameterL( aSink, aSink.MccParameterName(), + displayBuf ); + + display = displayBuf(); + display.iPriority.iPriority = aSink.iPriority; + + SetMccParameterL( aSink, aSink.MccParameterName(), + displayBuf ); + + + MCEMM_DEBUG("CMceMediaManager::SetDisplayPriorityL(), Exit "); + } + + +// --------------------------------------------------------- +// CMceMediaManager::GetDisplayRotationL +// --------------------------------------------------------- +// +void CMceMediaManager::GetDisplayRotationL( CMceComDisplaySink& aSink, + TInt& aDisplayRotation ) + { + MCEMM_DEBUG("CMceMediaManager::GetDisplayRotationL(), Entry "); + + User::LeaveIfError( aSink.MccParameterName() == KMccCamLocalVideo + ? KErrNotSupported : KErrNone ); + + TMccVideoSinkSetting display; + TMccVideoSinkSettingBuf displayBuf( display ); + + GetMccParameterL( aSink, aSink.MccParameterName(), + displayBuf ); + + display = displayBuf(); + aDisplayRotation = display.iRotation; + + aSink.iRotation = + static_cast( aDisplayRotation ); + + MCEMM_DEBUG("CMceMediaManager::GetDisplayRotationL(), Exit "); + } + +// --------------------------------------------------------- +// CMceMediaManager::SetDisplayRotationL +// --------------------------------------------------------- +// +void CMceMediaManager::SetDisplayRotationL( CMceComDisplaySink& aSink, + TInt aDisplayRotation ) + { + MCEMM_DEBUG("CMceMediaManager::SetDisplayRotationL(), Entry "); + + User::LeaveIfError( aSink.MccParameterName() == KMccCamLocalVideo + ? KErrNotSupported : KErrNone ); + + aSink.iRotation = + static_cast( aDisplayRotation ); + + TMccVideoSinkSetting display; + TMccVideoSinkSettingBuf displayBuf( display ); + GetMccParameterL( aSink, aSink.MccParameterName(), + displayBuf ); + + display = displayBuf(); + display.iRotation = static_cast( aSink.iRotation ); + displayBuf = display; + + SetMccParameterL( aSink, aSink.MccParameterName(), + displayBuf ); + + MCEMM_DEBUG("CMceMediaManager::SetDisplayRotationL(), Exit "); + } + +// --------------------------------------------------------- +// CMceMediaManager::SetDisplayIndexL +// --------------------------------------------------------- +// +void CMceMediaManager::SetDisplayIndexL( CMceComDisplaySink& aSink, + TInt aDisplayIndex ) + { + + MCEMM_DEBUG("CMceMediaManager::SetDisplayIndexL(), Entry "); + + aSink.iDisplayIndex = aDisplayIndex; + + TMccVideoSinkSetting display; + TMccVideoSinkSettingBuf displayBuf( display ); + GetMccParameterL( aSink, aSink.MccParameterName(), + displayBuf ); + + display = displayBuf(); + display.iDeviceIndex = static_cast( aSink.iDisplayIndex ); + + SetMccParameterL( aSink, aSink.MccParameterName(), + displayBuf ); + + + MCEMM_DEBUG("CMceMediaManager::SetDisplayIndexL(), Exit "); + + } + + +// --------------------------------------------------------- +// CMceMediaManager::GetCameraInfoL +// --------------------------------------------------------- +// +void CMceMediaManager::GetCameraInfoL( TInt aCameraIndex, + TCameraInfo& aCameraInfo ) + { + MCEMM_DEBUG("CMceMediaManager::GetCameraInfoL(), Entry "); + + TMccVideoInfo2 info; + info.iCameraIndex = aCameraIndex; + + TMccVideoInfoBuf2 videoInfo( info ); + GetMccParameterL( KMccCamInfo, videoInfo ); + + aCameraInfo = videoInfo().iInfo; + + MCEMM_DEBUG("CMceMediaManager::GetCameraInfoL(), Exit "); + + + } + +// --------------------------------------------------------- +// CMceMediaManager::GetCamerasAvailableL +// --------------------------------------------------------- +// +void CMceMediaManager::GetCamerasAvailableL( TInt& aCamerasAvailable ) + { + MCEMM_DEBUG("CMceMediaManager::GetCamerasAvailableL(), Entry "); + + TPckgBuf camerasAvailable( aCamerasAvailable ); + + GetMccParameterL( KMccCamCount, camerasAvailable ); + + aCamerasAvailable = camerasAvailable(); + + MCEMM_DEBUG("CMceMediaManager::GetCamerasAvailableL(), Exit "); + + } + +// --------------------------------------------------------- +// CMceMediaManager::GetZoomFactorL +// --------------------------------------------------------- +// +void CMceMediaManager::GetZoomFactorL( CMceComCameraSource& aSource, + TInt& aZoomFactor ) + { + + MCEMM_DEBUG("CMceMediaManager::GetZoomFactorL(), Entry "); + + TPckgBuf zoomFactor( aZoomFactor ); + + GetMccParameterL( aSource, KMccCamZoomFactor, zoomFactor ); + + aZoomFactor = zoomFactor(); + aSource.iZoomFactor = aZoomFactor; + + MCEMM_DEBUG("CMceMediaManager::GetZoomFactorL(), Exit "); + + + } + +// --------------------------------------------------------- +// CMceMediaManager::GetDigitalZoomFactorL +// --------------------------------------------------------- +// +void CMceMediaManager::GetDigitalZoomFactorL( CMceComCameraSource& aSource, + TInt& aDigitalZoomFactor ) + { + MCEMM_DEBUG("CMceMediaManager::GetDigitalZoomFactorL(), Entry "); + + TPckgBuf digitalZoomFactor( aDigitalZoomFactor ); + + GetMccParameterL( aSource, KMccCamDigitZoomFactor, + digitalZoomFactor ); + + aDigitalZoomFactor = digitalZoomFactor(); + aSource.iDigitalZoomFactor = aDigitalZoomFactor; + + MCEMM_DEBUG("CMceMediaManager::GetDigitalZoomFactorL(), Exit "); + + } + + + +// --------------------------------------------------------- +// CMceMediaManager::GetContrastL +// --------------------------------------------------------- +// +void CMceMediaManager::GetContrastL( CMceComCameraSource& aSource, + TInt& aContrast ) + { + MCEMM_DEBUG("CMceMediaManager::GetContrastL(), Entry "); + + TPckgBuf contrast( aContrast ); + + GetMccParameterL( aSource, KMccCamContrast, contrast ); + + aContrast = contrast(); + aSource.iContrast = aContrast; + + MCEMM_DEBUG("CMceMediaManager::GetContrastL(), Exit "); + + } + + +// --------------------------------------------------------- +// CMceMediaManager::GetBrightnessL +// --------------------------------------------------------- +// +void CMceMediaManager::GetBrightnessL( CMceComCameraSource& aSource, + TInt& aBrightness ) + { + MCEMM_DEBUG("CMceMediaManager::GetBrightnessL(), Entry "); + + TPckgBuf brightness( aBrightness ); + + GetMccParameterL( aSource, KMccCamBrightness, + brightness ); + + aBrightness = brightness(); + aSource.iBrightness = aBrightness; + + MCEMM_DEBUG("CMceMediaManager::GetBrightnessL(), Exit "); + + } + +// --------------------------------------------------------- +// CMceMediaManager::GetExposureL +// --------------------------------------------------------- +// +void CMceMediaManager::GetExposureL( + CMceComCameraSource& aSource, + TInt& aExposure ) + { + MCEMM_DEBUG("CMceMediaManager::GetExposureL(), Entry "); + + TPckgBuf exposure( aExposure ); + + GetMccParameterL( aSource, KMccCamExposure, + exposure ); + + aExposure = exposure(); + aSource.iExposure = aExposure; + + MCEMM_DEBUG("CMceMediaManager::GetExposureL(), Exit "); + } + + +// --------------------------------------------------------- +// CMceMediaManager::GetWhiteBalanceL +// --------------------------------------------------------- +// +void CMceMediaManager::GetWhiteBalanceL( CMceComCameraSource& aSource, + TInt& aWhiteBalance ) + { + MCEMM_DEBUG("CMceMediaManager::GetWhiteBalanceL(), Entry "); + + TPckgBuf whiteBalance( aWhiteBalance ); + + GetMccParameterL( aSource, KMccCamWhiteBalance, + whiteBalance ); + + aWhiteBalance = whiteBalance(); + aSource.iWhiteBalance = aWhiteBalance; + + MCEMM_DEBUG("CMceMediaManager::GetWhiteBalanceL(), Exit "); + + } + +// --------------------------------------------------------- +// CMceMediaManager::SetCameraIndexL +// --------------------------------------------------------- +// +void CMceMediaManager::SetCameraIndexL( CMceComCameraSource& aSource, + TInt aCameraIndex, + TCameraInfo& aCameraInfo ) + { + MCEMM_DEBUG("CMceMediaManager::SetCameraIndexL(), Entry "); + + aSource.iCameraIndex = aCameraIndex; + + UpdateMccSourceL( aSource ); + + GetCameraInfoL( aCameraIndex, aCameraInfo ); + + MCEMM_DEBUG("CMceMediaManager::SetCameraIndexL(), Exit "); + + } + +// --------------------------------------------------------- +// CMceMediaManager::SetZoomFactorL +// --------------------------------------------------------- +// +void CMceMediaManager::SetZoomFactorL( CMceComCameraSource& aSource, + TInt aZoomFactor ) + { + MCEMM_DEBUG("CMceMediaManager::SetZoomFactorL(), Entry "); + + aSource.iZoomFactor = aZoomFactor; + TPckgBuf zoomFactor( aSource.iZoomFactor ); + + SetMccParameterL( aSource, KMccCamZoomFactor, + zoomFactor ); + + MCEMM_DEBUG("CMceMediaManager::SetZoomFactorL(), Exit "); + + } + +// --------------------------------------------------------- +// CMceMediaManager::SetDigitalZoomFactorL +// --------------------------------------------------------- +// +void CMceMediaManager::SetDigitalZoomFactorL( CMceComCameraSource& aSource, + TInt aDigitalZoomFactor ) + { + MCEMM_DEBUG("CMceMediaManager::SetDigitalZoomFactorL(), Entry "); + + aSource.iDigitalZoomFactor = aDigitalZoomFactor; + TPckgBuf digitalZoomFactor( aSource.iDigitalZoomFactor ); + + SetMccParameterL( aSource, KMccCamDigitZoomFactor, + digitalZoomFactor ); + + + MCEMM_DEBUG("CMceMediaManager::SetDigitalZoomFactorL(), Exit "); + + } + +// --------------------------------------------------------- +// CMceMediaManager::SetContrastL +// --------------------------------------------------------- +// +void CMceMediaManager::SetContrastL( CMceComCameraSource& aSource, + TInt aContrast ) + { + MCEMM_DEBUG("CMceMediaManager::SetContrastL(), Entry "); + + aSource.iContrast = aContrast; + TPckgBuf contrast( aSource.iContrast ); + + SetMccParameterL( aSource, KMccCamContrast, + contrast ); + + MCEMM_DEBUG("CMceMediaManager::SetContrastL(), Exit "); + + } + +// --------------------------------------------------------- +// CMceMediaManager::SetBrightnessL +// --------------------------------------------------------- +// +void CMceMediaManager::SetBrightnessL( CMceComCameraSource& aSource, + TInt aBrightness ) + { + MCEMM_DEBUG("CMceMediaManager::SetBrightnessL(), Entry "); + + aSource.iBrightness = aBrightness; + TPckgBuf brightness( aSource.iBrightness ); + + SetMccParameterL( aSource, KMccCamBrightness, + brightness ); + + + MCEMM_DEBUG("CMceMediaManager::SetBrightnessL(), Exit "); + + } + +// --------------------------------------------------------- +// CMceMediaManager::SetExposureL +// --------------------------------------------------------- +// +void CMceMediaManager::SetExposureL( + CMceComCameraSource& aSource, + TInt aExposure) + { + MCEMM_DEBUG("CMceMediaManager::SetExposureL(), Entry "); + + aSource.iExposure = aExposure; + TPckgBuf exposure( aSource.iExposure ); + + SetMccParameterL( aSource, KMccCamExposure, + exposure ); + + MCEMM_DEBUG("CMceMediaManager::SetExposureL(), Exit "); + } + +// --------------------------------------------------------- +// CMceMediaManager::SetWhiteBalanceL +// --------------------------------------------------------- +// +void CMceMediaManager::SetWhiteBalanceL( CMceComCameraSource& aSource, + TInt aWhiteBalance ) + { + MCEMM_DEBUG("CMceMediaManager::SetWhiteBalanceL(), Entry "); + + aSource.iWhiteBalance = aWhiteBalance; + TPckgBuf whiteBalance( aSource.iWhiteBalance ); + + SetMccParameterL( aSource, KMccCamWhiteBalance, + whiteBalance ); + + MCEMM_DEBUG("CMceMediaManager::SetWhiteBalanceL(), Exit "); + + } + +// --------------------------------------------------------- +// CMceMediaManager::GetFileInfoL +// --------------------------------------------------------- +// +void CMceMediaManager::GetFileInfoL( CMceComFileSource& aSource, + TMceFileInfo& aFileInfo ) + { + + MCEMM_DEBUG("CMceMediaManager::GetFileInfoL(), Entry "); + + if ( aSource.MediaStream() ) + { + MCE_HEAP_CONSTRUCT_LC( TMccFileSourceSetting, fileInfo ); + MCE_HEAP_CONSTRUCT_WITH_PARAM_LC( TMccFileSourceSettingBuf, fileInfoBuf, *fileInfo ); + + GetMccParameterL( aSource, KMccFileInfo, *fileInfoBuf ); + + FillMceFileInfoL( (*fileInfoBuf)(), aFileInfo ); + + aSource.iFileInfo = aFileInfo; + + CleanupStack::PopAndDestroy( fileInfoBuf ); + CleanupStack::PopAndDestroy( fileInfo ); + } + else + { + GetFileInfoL( aFileInfo ); + } + + MCEMM_DEBUG("CMceMediaManager::GetFileInfoL(), Exit "); + + } + + +// --------------------------------------------------------- +// CMceMediaManager::SetFileInfoL +// --------------------------------------------------------- +// +void CMceMediaManager::SetFileInfoL( CMceComFileSource& aSource, + TMceFileInfo& aFileInfo ) + { + + MCEMM_DEBUG("CMceMediaManager::SetFileInfoL(), Entry "); + + MCE_HEAP_CONSTRUCT_LC( TMccFileSourceSetting, fileInfo ); + + fileInfo->iFileName = aFileInfo.iFileName; + + MCE_HEAP_CONSTRUCT_WITH_PARAM_LC( TMccFileSourceSettingBuf, fileInfoBuf, *fileInfo ); + + SetMccParameterL( aSource, KMccFileName, + *fileInfoBuf ); + + CleanupStack::PopAndDestroy( fileInfoBuf ); + CleanupStack::PopAndDestroy( fileInfo ); + + MCEMM_DEBUG("CMceMediaManager::SetFileInfoL(), Exit "); + } + +// --------------------------------------------------------- +// CMceMediaManager::GetFileInfoL +// --------------------------------------------------------- +// +void CMceMediaManager::GetFileInfoL( TMceFileInfo& aFileInfo ) + { + MCEMM_DEBUG("CMceMediaManager::GetFileInfoL(), Entry "); + + MCE_HEAP_CONSTRUCT_LC( TMccFileSourceSetting, fileInfo ); + + fileInfo->iFileName = aFileInfo.iFileName; + + MCE_HEAP_CONSTRUCT_WITH_PARAM_LC( TMccFileSourceSettingBuf, fileInfoBuf, *fileInfo ); + + GetMccParameterL( KMccFileInfo, *fileInfoBuf ); + + FillMceFileInfoL( (*fileInfoBuf)(), aFileInfo ); + + CleanupStack::PopAndDestroy( fileInfoBuf ); + CleanupStack::PopAndDestroy( fileInfo ); + + MCEMM_DEBUG("CMceMediaManager::GetFileInfoL(), Exit "); + + } + + +// --------------------------------------------------------- +// CMceMediaManager::GetFilePositionL +// --------------------------------------------------------- +// +void CMceMediaManager::GetFilePositionL( CMceComFileSource& aSource, + TTimeIntervalMicroSeconds& aFilePosition ) + { + + MCEMM_DEBUG("CMceMediaManager::GetFilePositionL(), Entry "); + + MCE_HEAP_CONSTRUCT_LC( TMccFileSourceSetting, fileInfo ); + MCE_HEAP_CONSTRUCT_WITH_PARAM_LC( TMccFileSourceSettingBuf, fileInfoBuf, *fileInfo ); + + GetMccParameterL( aSource, KMccFilePosition, + *fileInfoBuf ); + + aFilePosition = (*fileInfoBuf)().iPosition; + + CleanupStack::PopAndDestroy( fileInfoBuf ); + CleanupStack::PopAndDestroy( fileInfo ); + + MCEMM_DEBUG("CMceMediaManager::GetFilePositionL(), Exit "); + + } + +// --------------------------------------------------------- +// CMceMediaManager::SetFilePositionL +// --------------------------------------------------------- +// +void CMceMediaManager::SetFilePositionL( CMceComFileSource& aSource, + TTimeIntervalMicroSeconds& aFilePosition ) + { + + MCEMM_DEBUG("CMceMediaManager::SetFilePositionL(), Entry "); + + MCE_HEAP_CONSTRUCT_LC( TMccFileSourceSetting, fileInfo ); + + fileInfo->iPosition = aFilePosition; + + MCE_HEAP_CONSTRUCT_WITH_PARAM_LC( TMccFileSourceSettingBuf, fileInfoBuf, *fileInfo ); + + SetMccParameterL( aSource, KMccFilePosition, + *fileInfoBuf ); + + CleanupStack::PopAndDestroy( fileInfoBuf ); + CleanupStack::PopAndDestroy( fileInfo ); + + MCEMM_DEBUG("CMceMediaManager::SetFilePositionL(), Exit "); + + } + +// --------------------------------------------------------- +// CMceMediaManager::FastForwardL +// --------------------------------------------------------- +// +void CMceMediaManager::FastForwardL( CMceComFileSource& /*aSource*/, + TBool& /*aOnOff*/ ) + { + MCEMM_DEBUG("CMceMediaManager::FastForwardL(), Entry "); +/* + TMceFileInfo fileInfo; + TTimeIntervalMicroSeconds position; + + GetFileInfoL( aSource, fileInfo ); + GetFilePositionL( aSource, position ); + + TTimeIntervalMicroSeconds newPosition( + position.Int64() + + (TInt64)( KMceOneSecondAsMicros * + KMceFastForwardMultiplier ) ); + + if ( newPosition < fileInfo.iDuration ) + { + SetFilePositionL( aSource, newPosition ); + aSource.iPosition = newPosition; + } + else + { + MCEMM_DEBUG("At the end. No forward"); + } +*/ + MCEMM_DEBUG("CMceMediaManager::FastForwardL(), Exit "); + } + +// --------------------------------------------------------- +// CMceMediaManager::FastRewindL +// --------------------------------------------------------- +// +void CMceMediaManager::FastRewindL( CMceComFileSource& /*aSource*/, + TBool& /*aOnOff*/ ) + { + MCEMM_DEBUG("CMceMediaManager::FastRewindL(), Entry "); +/* + TMceFileInfo fileInfo; + TTimeIntervalMicroSeconds position; + + GetFileInfoL( aSource, fileInfo ); + GetFilePositionL( aSource, position ); + + TTimeIntervalMicroSeconds newPosition( + position.Int64() - + (TInt64)( KMceOneSecondAsMicros * + KMceFastForwardMultiplier ) ); + + if ( newPosition > 0 ) + { + SetFilePositionL( aSource, newPosition ); + aSource.iPosition = newPosition; + } + else + { + MCEMM_DEBUG("At the beginning. No rewind"); + } +*/ + MCEMM_DEBUG("CMceMediaManager::FastRewindL(), Exit "); + } + + +// --------------------------------------------------------- +// CMceMediaManager::TranscodeFileL +// --------------------------------------------------------- +// +TUint32 CMceMediaManager::TranscodeFileL( CMceComFileSource* aFile ) + { + MCEMM_DEBUG("CMceMediaManager::TranscodeFileL(), Entry "); + __ASSERT_ALWAYS( aFile, User::Leave( KErrArgument ) ); + + MCEMM_DEBUG_SVALUE(" from", aFile->iFileInfo.iFileName ); + MCEMM_DEBUG_SVALUE(" to", aFile->iTranscodeInfo.iFileName ); + + HBufC8* sourceFileBuf = HBufC8::NewLC( KMceMaxFileName8 ); + TPtr8 sourceFile = sourceFileBuf->Des(); + HBufC8* destFileBuf = HBufC8::NewLC( KMceMaxFileName8 ); + TPtr8 destFile = destFileBuf->Des(); + + TInt cnvRet = + CnvUtfConverter::ConvertFromUnicodeToUtf8( sourceFile, + aFile->iFileInfo.iFileName ); + + MCEMM_DEBUG_DVALUE( "CMceMediaManager::TranscodeFileL(), source name converted: ", + cnvRet ) + __ASSERT_ALWAYS( !cnvRet, User::Leave( KErrGeneral ) ); + + cnvRet = CnvUtfConverter::ConvertFromUnicodeToUtf8( destFile, + aFile->iTranscodeInfo.iFileName ); + + MCEMM_DEBUG_DVALUE( "CMceMediaManager::TranscodeFileL(), dest name converted: ", + cnvRet ) + __ASSERT_ALWAYS( !cnvRet, User::Leave( KErrGeneral ) ); + + CMccCodecInformation* audioCodec = NULL; + CMccCodecInformation* videoCodec = NULL; + if ( aFile->MediaStream() && aFile->MediaStream()->Session() ) + { + CreateTranscodingOutputCodecsL( &audioCodec,&videoCodec,aFile ); + } + if ( audioCodec ) + { + CleanupStack::PushL( audioCodec ); + } + if ( videoCodec ) + { + CleanupStack::PushL( videoCodec ); + } + + User::LeaveIfError ( iMccInterface->TranscodeFile( + sourceFile, + destFile, + aFile->iTranscodeInfo.iQuality, + aFile->iTranscodeInfo.iTranscodeSessionId, + videoCodec, + audioCodec ) ); + if ( videoCodec ) + { + CleanupStack::PopAndDestroy(); + } + if ( audioCodec ) + { + CleanupStack::PopAndDestroy(); + } + + CleanupStack::PopAndDestroy( destFileBuf ); + CleanupStack::PopAndDestroy( sourceFileBuf ); + + iTranscodeSessions.AppendL( aFile ); + + MCEMM_DEBUG_DVALUE(" sessionid", aFile->iTranscodeInfo.iTranscodeSessionId ); + MCEMM_DEBUG("CMceMediaManager::TranscodeFileL(), Exit "); + + return aFile->iTranscodeInfo.iTranscodeSessionId; + } + + +// --------------------------------------------------------- +// CMceMediaManager::CreateTranscodingOutputCodecsL +// --------------------------------------------------------- +// +void CMceMediaManager::CreateTranscodingOutputCodecsL( + CMccCodecInformation** aAudioCodec , + CMccCodecInformation** aVideoCodec , + CMceComFileSource* aFile ) + { + MCEMM_DEBUG("CMceMediaManager::CreateTranscodingOutputCodecsL(),entry "); + CMceComSession* tempSession = aFile->MediaStream()->Session(); + RPointerArray& streams = tempSession->Streams(); + CMceSrvStream* audioSrvStream = NULL; + CMceSrvStream* videoSrvStream = NULL; + TInt cleanitems = 0; + CMceComAudioStream* audioStream = NULL; + CMceComVideoStream* videoStream = NULL; + + for ( int i = 0; i < streams.Count();i++ ) + { + if ( streams[i]->iType == KMceAudio && !audioSrvStream ) + { + audioStream = static_cast( + tempSession->Streams()[ i ] ); + if ( audioStream->Codecs().Count() ) + { + audioSrvStream = CMceSrvStream::NewL( *this, *aFile->MediaStream(), + *aFile->MediaStream()->Source(), + *aFile->MediaStream()->Sinks()[0], + *(audioStream->Codecs()[0]) ); + CleanupStack::PushL( audioSrvStream ); + cleanitems++; + MCEMM_DEBUG("CMceMediaManager::CreateTranscodingOutputCodecsL(), AudioCodec found "); + } + } + + if ( streams[i]->iType == KMceVideo && !videoSrvStream ) + { + videoStream = static_cast( + tempSession->Streams()[ i ] ); + if ( videoStream->Codecs().Count() ) + { + videoSrvStream = CMceSrvStream::NewL( *this, *aFile->MediaStream(), + *aFile->MediaStream()->Source(), + *aFile->MediaStream()->Sinks()[0], + *(videoStream->Codecs()[0]) ); + CleanupStack::PushL( videoSrvStream ); + cleanitems++; + MCEMM_DEBUG("CMceMediaManager::CreateTranscodingOutputCodecsL(), VideoCodec found "); + } + } + + + } + if ( audioSrvStream ) + { + *aAudioCodec = CreateMccCodecLC( *audioSrvStream, EMceRoleOfferer ); + cleanitems++; + } + + if ( videoSrvStream ) + { + *aVideoCodec = CreateMccCodecLC( *videoSrvStream, EMceRoleOfferer ); + cleanitems++; + } + CleanupStack::Pop( cleanitems ); + delete audioSrvStream; + audioSrvStream = NULL; + delete videoSrvStream; + videoSrvStream = NULL; + MCEMM_DEBUG("CMceMediaManager::CreateTranscodingOutputCodecsL(),exit "); + } + +// --------------------------------------------------------- +// CMceMediaManager::CancelTranscodeFileL +// --------------------------------------------------------- +// +void CMceMediaManager::CancelTranscodeFileL( TUint32 aSessionId ) + { + + MCEMM_DEBUG("CMceMediaManager::CancelTranscodeFileL(), Entry "); + MCEMM_DEBUG_DVALUE(" sessionid", aSessionId ); + + CMceComFileSource* session = TranscodingSession( aSessionId ); + + if ( session ) + { + MCEMM_DEBUG("CMceMediaManager::CancelTranscodeFileL(), cancelling "); + + User::LeaveIfError ( + iMccInterface->CancelTranscodeFile( + session->iTranscodeInfo.iTranscodeSessionId ) ); + + TInt index = iTranscodeSessions.Find( session ); + + iTranscodeSessions.Remove( index ); + delete session; + } + + MCEMM_DEBUG("CMceMediaManager::CancelTranscodeFileL(), Exit "); + } + + +// --------------------------------------------------------- +// CMceMediaManager::TranscodingSession +// --------------------------------------------------------- +// +CMceComFileSource* CMceMediaManager::TranscodingSession( + const CMceComFileSource& aFile ) const + { + CMceComFileSource* session = NULL; + TInt index = 0; + while( !session && index < iTranscodeSessions.Count() ) + { + session = iTranscodeSessions[ index++ ]; + session = session->Id() == aFile.Id() ? session : NULL; + + } + + return session; + + } + +// --------------------------------------------------------- +// CMceMediaManager::TranscodingSession +// --------------------------------------------------------- +// +CMceComFileSource* CMceMediaManager::TranscodingSession( + TUint32 aTcSessionId ) const + { + CMceComFileSource* session = NULL; + TInt index = 0; + while( !session && index < iTranscodeSessions.Count() ) + { + session = iTranscodeSessions[ index++ ]; + session = + session->iTranscodeInfo.iTranscodeSessionId == + aTcSessionId ? session : NULL; + + } + + return session; + + } + + +// --------------------------------------------------------- +// CMceMediaManager::GetSupportedCodecs +// --------------------------------------------------------- +// + TInt CMceMediaManager::GetSupportedCodecs( RArray& /*aCodecs*/ ) + { + MCEMM_DEBUG("CMceMediaManager::GetSupportedCodecs(), Entry "); + /* + TInt err = iMccInterface->GetSupportedCodecs( aCodecs ); + */ + MCEMM_DEBUG("NO IMPLEMENTATION"); + TInt err = KErrNone; + MCEMM_DEBUG("CMceMediaManager::GetSupportedCodecs(), Exit "); + return err; + } + +// --------------------------------------------------------- +// CMceMediaManager::GetCapabilities +// --------------------------------------------------------- +// +void CMceMediaManager::GetCapabilitiesL( + RPointerArray& aCapabilities ) + { + MCEMM_DEBUG("CMceMediaManager::GetCapabilitiesL() - audio , Entry "); + RPointerArray mccCapabilities; + + TMceComAudioCodecFactory codecFactory; + RStringF audio = MCE_SDP_STRING_AUDIOL(); + + TInt index = 0; + CMceSdpCodec* audioSdpCodec = NULL; + while( !audioSdpCodec && index < iSdpCodecs.Count() ) + { + audioSdpCodec = iSdpCodecs[ index++ ]; + audioSdpCodec = audioSdpCodec->Media() == audio ? audioSdpCodec : NULL; + } + + User::LeaveIfNull ( audioSdpCodec ); + + User::LeaveIfError ( iMccInterface->GetCapabilities( mccCapabilities ) ); + + MceCleanupResetAndDestroyPushL( mccCapabilities ); + + for( int i = 0; i < mccCapabilities.Count(); i++ ) + { + CMccCodecInformation* mccCodec = mccCapabilities[i]; + if ( mccCodec->Type() == KUidMediaTypeAudio ) + { + CMceComAudioCodec* codec = codecFactory.CreateCodecLC( mccCodec->SdpName() ); + if ( codec ) + { + *codec = *mccCodec; + + aCapabilities.AppendL( codec ); + CleanupStack::Pop( codec ); + + MCEMM_DEBUG("audio capabilities"); + MCEMM_DEBUG_SVALUE("codec", codec->iSdpName ); + MCEMM_DEBUG_DVALUE("sampling freq", codec->iSamplingFreq ) + MCEMM_DEBUG_DVALUE("payload type", codec->iPayloadType ) + MCEMM_DEBUG_DVALUE("bitrate", codec->iBitrate ) + MCEMM_DEBUG_DVALUE("max ptime", codec->iMaxPTime ) + MCEMM_DEBUG_DVALUE("ptime", codec->iPTime ) + MCEMM_DEBUG_DVALUE("VAD", codec->iEnableVAD ) + MCEMM_DEBUG_DVALUE("codec mode",codec->iCodecMode ) + MCEMM_DEBUG_DVALUE("fourCC", codec->iFourCC ) + MCEMM_DEBUG_SVALUE("fmtp", *codec->iFmtpAttr ) + + audioSdpCodec->AddCapabilityL( mccCodec->SdpName() ); + audioSdpCodec->AddCapabilityPayloadTypeL( mccCodec->PayloadType() ); + } + else + { + MCEMM_DEBUG_SVALUE("Not supported codec",mccCodec->SdpName() ); + } + } + } + CleanupStack::PopAndDestroy();//mccCapabilities + + MCEMM_DEBUG("CMceMediaManager::GetCapabilitiesL() - audio , Exit "); + + } + + +// --------------------------------------------------------- +// CMceMediaManager::GetCapabilities +// --------------------------------------------------------- +// +void CMceMediaManager::GetCapabilitiesL( + RPointerArray& aCapabilities ) + { + MCEMM_DEBUG("CMceMediaManager::GetCapabilitiesL() - video, Entry "); + + + RPointerArray mccCapabilities; + TMceComVideoCodecFactory codecFactory; + RStringF video = MCE_SDP_STRING_VIDEOL(); + + TInt index = 0; + CMceSdpCodec* videoSdpCodec = NULL; + while( !videoSdpCodec && index < iSdpCodecs.Count() ) + { + videoSdpCodec = iSdpCodecs[ index++ ]; + videoSdpCodec = videoSdpCodec->Media() == video ? videoSdpCodec : NULL; + } + + User::LeaveIfNull ( videoSdpCodec ); + User::LeaveIfError ( iMccInterface->GetCapabilities( mccCapabilities ) ); + + MceCleanupResetAndDestroyPushL( mccCapabilities ); + + for( int i = 0; i < mccCapabilities.Count(); i++ ) + { + CMccCodecInformation* mccCodec = mccCapabilities[i]; + if ( mccCodec->Type() == KUidMediaTypeVideo ) + { + CMceComVideoCodec* codec = codecFactory.CreateCodecLC( mccCodec->SdpName() ); + + if ( codec ) + { + *codec = *mccCodec; + + aCapabilities.AppendL( codec ); + CleanupStack::Pop( codec ); + + MCEMM_DEBUG("video capabilities"); + MCEMM_DEBUG_SVALUE("codec", codec->iSdpName ); + MCEMM_DEBUG_DVALUE("clock rate", codec->iClockRate ) + MCEMM_DEBUG_DVALUE("payload type", codec->iPayloadType ) + MCEMM_DEBUG_DVALUE("bitrate", codec->iBitrate ) + MCEMM_DEBUG_DVALUE("framerate", (TInt)codec->iFrameRate ) + MCEMM_DEBUG_DVALUE("max bitrate", codec->iMaxBitRate ) + MCEMM_DEBUG_DVALUE("resolution width", codec->iResolutionWidth ) + MCEMM_DEBUG_DVALUE("resolution height", codec->iResolutionHeight ) + MCEMM_DEBUG_DVALUE("codec mode",codec->iCodecMode ) + MCEMM_DEBUG_DVALUE("fourCC", codec->iFourCC ) + MCEMM_DEBUG_SVALUE("fmtp", *codec->iFmtpAttr ) + + + videoSdpCodec->AddCapabilityL( mccCodec->SdpName() ); + videoSdpCodec->AddCapabilityPayloadTypeL(mccCodec->PayloadType()); + } + else + { + MCEMM_DEBUG_SVALUE("Not supported codec",mccCodec->SdpName() ); + } + } + } + CleanupStack::PopAndDestroy();//mccCapabilities + + + MCEMM_DEBUG("CMceMediaManager::GetCapabilitiesL() - video, Exit "); + } + +// --------------------------------------------------------- +// CMceMediaManager::DtmfL +// --------------------------------------------------------- +// +void CMceMediaManager::DtmfL( + CMceComMediaSource& aSource, + TMceComEvent& aEvent, + const TDesC8& aSequence ) + { + MCEMM_DEBUG("CMceMediaManager::DtmfL(), Entry "); + + + TBool handled = DoDtmfL( aSource, aEvent, aSequence ); + if ( !handled && aSource.MediaStream()->BoundStream() ) + { + handled = DoDtmfL( aSource, aEvent, aSequence, ETrue ); + } + + __ASSERT_ALWAYS( handled, User::Leave( KErrNotSupported ) ); + + MCEMM_DEBUG("CMceMediaManager::DtmfL(), Exit "); + } + +// --------------------------------------------------------- +// CMceMediaManager::SetCNameL +// --------------------------------------------------------- +// +void CMceMediaManager::SetCNameL( + const CMceComEndpoint& aEndpoint, + const TDesC8& aCName ) + { + MCEMM_DEBUG_SVALUE("CMceMediaManager::SetCNameL(), cname:", aCName ); + + CMceComMediaStream* endpointMediaStream = aEndpoint.MediaStream(); + if ( IS_RECEIVESTREAM( endpointMediaStream ) && + aEndpoint.iType == KMceRTPSource ) + { + SetMccParameterL( static_cast( aEndpoint ), + KMccRtpCName, + aCName, + ETrue ); + } + else if ( IS_SENDSTREAM( endpointMediaStream ) && + aEndpoint.iType == KMceRTPSink ) + { + SetMccParameterL( static_cast( aEndpoint ), + KMccRtpCName, + aCName, + ETrue ); + } + else + { + User::Leave( KErrNotSupported ); + } + + MCEMM_DEBUG("CMceMediaManager::SetCNameL(), Exit "); + } + +// --------------------------------------------------------- +// CMceMediaManager::UpdateConfigKeyL +// --------------------------------------------------------- +// +void CMceMediaManager::UpdateConfigKeyL( const CMceComMediaSource& aSource ) + { + MCEMM_DEBUG("CMceMediaManager::UpdateConfigKeyL(), Entry "); + + if ( aSource.MediaStream() && + aSource.MediaStream()->iType == KMceVideo && + ( aSource.Type() == KMceCameraSource || aSource.Type() == KMceFileSource ) ) + { + TInt err( KErrNone ); + HBufC8* configKey = HBufC8::NewLC( KMaxConfigKeyLen ); + TPtr8 configKeyPtr( configKey->Des() ); + + TMceSrvStreamIterator streams( + aSource.MediaStream()->Session()->MccStreams(), aSource ); + + CMceComMediaStream* mediaStream = NULL; + CMceSrvStream* stream = NULL; + while ( streams.Next( stream ) && !err ) + { + mediaStream = &stream->Data(); + if ( mediaStream->iType != KMceVideo ) + { + // NOP + } + else if ( CMceComVideoCodec::IsConfigKeyValid( configKey ) ) + { + DoConfigKeyUpdateL( *mediaStream, configKey ); + } + else if ( stream->IsMccPrepared() ) + { + err = iMccInterface->GetParameter( stream->SessionId(), + stream->LinkId(), + stream->Id(), + stream->Source().Id(), + KMccConfigKey, + configKeyPtr ); + if ( !err && CMceComVideoCodec::IsConfigKeyValid( configKey ) ) + { + streams.Reset(); + } + } + else + { + // NOP + } + } + + CleanupStack::PopAndDestroy( configKey ); + } + + + MCEMM_DEBUG("CMceMediaManager::UpdateConfigKeyL(), Exit "); + } + +// --------------------------------------------------------- +// CMceMediaManager::GetSSRCL +// --------------------------------------------------------- +// +TUint32 CMceMediaManager::GetSSRCL( CMceSrvStream& aStream ) + { + MCEMM_DEBUG("CMceMediaManager::GetSSRCL(), Entry "); + + TUint32 ssrc = 0; + + User::LeaveIfError( iMccInterface->GetSSRC( + aStream.SessionId(), + aStream.LinkId(), + aStream.Id(), + 0, + ssrc ) ); + + MCEMM_DEBUG("CMceMediaManager::GetSSRCL(), Exit "); + return ssrc; + + } + + + +// --------------------------------------------------------------------------- +// CMceMediaManager::EnableViewFinderL +// --------------------------------------------------------------------------- +// +void CMceMediaManager::EnableViewFinderL( const CMceComMediaSink& /*aMediaSink*/, + const TDesC8& aParam ) + { + MCEMM_DEBUG("CMceMediaManager::EnableViewFinderL(), Entry "); + + SetMccParameterL( KMccCamLocalVideo, aParam ); + + MCEMM_DEBUG("CMceMediaManager::EnableViewFinderL(), Exit "); + + } + + +// --------------------------------------------------------------------------- +// CMceMediaManager::DisableViewFinderL +// --------------------------------------------------------------------------- +// +void CMceMediaManager::DisableViewFinderL( const CMceComMediaSink& /*aMediaSink*/ ) + { + MCEMM_DEBUG("CMceMediaManager::DisableViewFinderL(), Entry "); + + SetMccParameterL( KMccCamLocalVideo, KNullDesC8 ); + + MCEMM_DEBUG("CMceMediaManager::DisableViewFinderL(), Exit "); + + } + + +// --------------------------------------------------------- +// CMceMediaManager::CreateMccSessionL +// --------------------------------------------------------- +// +void CMceMediaManager::CreateMccSessionL( CMceComSession& aSession ) + { + User::LeaveIfError( iMccInterface->CreateSession( aSession.iMccID ) ); + } + + +// --------------------------------------------------------- +// CMceMediaManager::CreateMccLinkL +// --------------------------------------------------------- +// +void CMceMediaManager::CreateMccLinkL( CMceSrvStream& aStream ) + { + MCEMM_DEBUG("CMceMediaManager::CreateMccLinkL(), Entry "); + + __ASSERT_ALWAYS( aStream.State() != CMceSrvStream::EAdopted, + User::Leave( KErrArgument ) ); + __ASSERT_ALWAYS( aStream.State() == CMceSrvStream::ECreated, + User::Leave( KErrArgument ) ); + + TMccNetSettings netSettings; + netSettings.iIapId = aStream.IapId(); + netSettings.iLocalAddress.SetPort( aStream.LocalMediaPort() ); + netSettings.iMediaQosValue = aStream.Data().Session()->iServiceType; + TUint32 linkId = aStream.LinkId(); + + if ( linkId == KMceNotAssigned && + !ReuseLink( aStream ) ) + { + MCEMM_DEBUG("CMceMediaManager::CreateMccLinkL(): no link. creating link"); + User::LeaveIfError( + iMccInterface->CreateLink( aStream.SessionId(), + aStream.LinkType(), + linkId, + netSettings ) ); + + aStream.SetLinkId( linkId ); + + SetPendingState( aStream, 0, CMceSrvStream::ECreatingLink ); + + if ( aStream.Data().Session()->SecureSession() ) + { + aStream.Data().Session()->SecureSession()->iCryptoContextUpdate = ETrue; + } + } + else + { + TMceSrvStreamIterator creatingLink( aStream.Data().Session()->MccStreams() ); + TMceMccComEvent event( KMccEventNone, + aStream.LinkId(), + 0, + 0 ); + + CMceSrvStream* stream = NULL; + TBool creatingLinkCurrently( EFalse ); + while ( creatingLink.Next( stream, event ) && !creatingLinkCurrently ) + { + if ( stream != &aStream && stream->State() == CMceSrvStream::ECreatingLink ) + { + MCEMM_DEBUG("CMceMediaManager::CreateMccLinkL(): link not ready. waiting"); + SetPendingState( aStream, 0, CMceSrvStream::ECreatingLink ); + creatingLinkCurrently = ETrue; + } + } + + if ( !creatingLinkCurrently ) + { + MCEMM_DEBUG("CMceMediaManager::CreateMccLinkL(): link exists"); + SetPendingState( aStream, 0, CMceSrvStream::ELinkCreated ); + } + } + + + MCEMM_DEBUG("CMceMediaManager::CreateMccLinkL(), Exit "); + + } + + + +// --------------------------------------------------------- +// CMceMediaManager::InitializeMccStreamL +// --------------------------------------------------------- +// +void CMceMediaManager::InitializeMccStreamL( CMceSrvStream& aStream ) + { + + MCEMM_DEBUG("CMceMediaManager::InitializeMccStreamL(), Entry "); + + __ASSERT_ALWAYS( aStream.State() != CMceSrvStream::EAdopted, + User::Leave( KErrArgument ) ); + + //create codec information + CMccCodecInformationFactory* codecFactory = + CMccCodecInformationFactory::NewL(); + CleanupStack::PushL( codecFactory ); + + CMccCodecInformation* codec = + codecFactory->CreateCodecInformationL( aStream.Codec().iSdpName ); + + CleanupStack::PushL( codec ); + aStream.Codec().MccDecodeL( *codec ); + + CleanupStack::PopAndDestroy( codec ); + CleanupStack::PopAndDestroy( codecFactory ); + + MCEMM_DEBUG("CMceMediaManager::InitializeMccStreamL(), Exit "); + } + + +// --------------------------------------------------------- +// CMceMediaManager::CreateMccCodecLC +// --------------------------------------------------------- +// +CMccCodecInformation* CMceMediaManager::CreateMccCodecLC( + CMceSrvStream& aStream, + TMceNegotiationRole aRole ) + { + + //create codec information + CMccCodecInformationFactory* codecFactory = + CMccCodecInformationFactory::NewL(); + CleanupStack::PushL( codecFactory ); + + CMccCodecInformation* codec = + codecFactory->CreateCodecInformationL( aStream.Codec().iSdpName ); + + CleanupStack::PopAndDestroy( codecFactory ); + + CleanupStack::PushL( codec ); + aStream.Codec().MccPopulateL( *codec, aStream, aRole ); + + return codec; + + } + +// --------------------------------------------------------- +// CMceMediaManager::CreateMccStreamL +// --------------------------------------------------------- +// +void CMceMediaManager::CreateMccStreamL( + CMceSrvStream& aStream, + TMceNegotiationRole aRole ) + { + + MCEMM_DEBUG("CMceMediaManager::CreateMccStreamL(), Entry "); + + __ASSERT_ALWAYS( aStream.State() != CMceSrvStream::EAdopted, + User::Leave( KErrArgument ) ); + + // Create mcc codec even if mcc prepare is not needed in order to + // construct fmtp info also for local codecs. That information might + // be needed in some stream matching cases later on. + CMccCodecInformation* mccCodec = CreateMccCodecLC( aStream, aRole ); + + if ( !aStream.PrepareL() ) + { + CMceComCodec& codec = aStream.Codec(); + + if ( ReuseSource( aStream ) ) + { + MCEMM_DEBUG("CMceMediaManager::CreateMccStreamL(): resuing source "); + + //reuse source + iMccInterface->Reuse( aStream.SessionId(), + aStream.Id(), + aStream.LinkId(), + aStream.Source().Id() ); + } + else + { + MCEMM_DEBUG("CMceMediaManager::CreateMccStreamL(): adding source "); + //add source + iMccInterface->AddDataSource( aStream.Source().Type(), + aStream.Source().Data().InitParamL( codec ), + aStream.Source().Id() ); + } + + if ( ReuseSink( aStream ) ) + { + MCEMM_DEBUG("CMceMediaManager::CreateMccStreamL(): resuing sink "); + //reuse sink + iMccInterface->Reuse( aStream.SessionId(), + aStream.Id(), + aStream.LinkId(), + aStream.Sink().Id() ); + } + else + { + MCEMM_DEBUG("CMceMediaManager::CreateMccStreamL(): adding sink "); + //add sink + iMccInterface->AddDataSink( aStream.Sink().Type(), + aStream.Sink().Data().InitParamL( codec ), + aStream.Sink().Id() ); + } + + MCEMM_DEBUG_STREAM( "CMceMediaManager::CreateMccStreamL(): creating stream", aStream ); + //create stream + User::LeaveIfError( iMccInterface->CreateStream( + aStream.SessionId(), + aStream.LinkId(), + aStream.Id(), + aStream.MccStreamType(), + *mccCodec ) ); + + aStream.Source().Data().InitializedL(); + aStream.Sink().Data().InitializedL(); + + } + + CleanupStack::PopAndDestroy( mccCodec ); + + MCEMM_DEBUG("CMceMediaManager::CreateMccStreamL(), Exit "); + } + + +// --------------------------------------------------------- +// CMceMediaManager::PrepareMccStreamL +// --------------------------------------------------------- +// +void CMceMediaManager::PrepareMccStreamL( + CMceSrvStream& aStream, + TMceNegotiationRole /*aRole*/ ) + { + + MCEMM_DEBUG("CMceMediaManager::PrepareMccStreamL(), Entry "); + + __ASSERT_ALWAYS( aStream.State() != CMceSrvStream::EAdopted, + User::Leave( KErrArgument ) ); + + if ( !aStream.PrepareL() ) + { + //prepare stream + TUint32 endpointId = 0; + User::LeaveIfError( iMccInterface->PrepareStream( + aStream.SessionId(), + aStream.LinkId(), + aStream.Id(), + endpointId ) ); + + SetPendingState( aStream, endpointId, CMceSrvStream::EPreparing ); + + aStream.MccPrepareCalledL(); + + } + MCEMM_DEBUG_STREAM( "CMceMediaManager::PrepareMccStreamL(): after prepare", aStream ); + + MCEMM_DEBUG("CMceMediaManager::PrepareMccStreamL(), Exit "); + } + + +// --------------------------------------------------------- +// CMceMediaManager::SetRemoteAddressL +// --------------------------------------------------------- +// +void CMceMediaManager::SetRemoteAddressL( CMceSrvStream& aStream ) + { + TInetAddr remoteIpAddress = aStream.RemoteIpAddress(); + + MCEMM_DEBUG_DVALUE( "CMceMediaManager::SetRemoteAddressL address", + remoteIpAddress.Address() ) + MCEMM_DEBUG_DVALUE( "CMceMediaManager::SetRemoteAddressL port", + remoteIpAddress.Port() ) + + //for rtp + if ( !remoteIpAddress.IsUnspecified() && + remoteIpAddress.Port() != 0 && + aStream.IsMccPrepared() ) + { + User::LeaveIfError( + iMccInterface->SetRemoteAddress( + aStream.SessionId(), + aStream.LinkId(), + remoteIpAddress ) ); + + // for rtcp + if ( aStream.Data().RemoteMediaPort() != 0 && + aStream.Data().iRemoteRtcpPort != 0 ) + { + if ( !aStream.Data().iRemoteRtcpAddress.IsUnspecified() ) + { + //copy address + remoteIpAddress = aStream.Data().iRemoteRtcpAddress; + } + + remoteIpAddress.SetPort( + aStream.Data().iRemoteRtcpPort ); + + User::LeaveIfError( + iMccInterface->SetRemoteAddress( + aStream.SessionId(), + aStream.LinkId(), + remoteIpAddress, + aStream.Data().iRemoteRtcpPort ) ); + } + } + } + + +// --------------------------------------------------------- +// CMceMediaManager::StartMccStreamL +// --------------------------------------------------------- +// +void CMceMediaManager::StartMccStreamL( CMceSrvStream& aStream ) + { + + MCEMM_DEBUG("CMceMediaManager::StartMccStreamL(), Entry "); + + __ASSERT_ALWAYS( aStream.State() != CMceSrvStream::EAdopted, + User::Leave( KErrArgument ) ); + __ASSERT_ALWAYS( aStream.State() == CMceSrvStream::EPrepared, + User::Leave( KErrArgument ) ); + + if ( !aStream.StartL() ) + { + //set remote address for link + SetRemoteAddressL( aStream ); + + if ( !DoStartEndpointsL( aStream, 0, 0 ) && + aStream.Sink().State() == CMceSrvStream::EPrepared && + aStream.Source().State() == CMceSrvStream::EPrepared ) + + { + SetPendingState( aStream, 0, CMceSrvStream::EPending ); + } + } + + MCEMM_DEBUG_STREAM( "CMceMediaManager::StartMccStreamL(): after start", aStream ); + + MCEMM_DEBUG("CMceMediaManager::StartMccStreamL(), Exit "); + } + + +// --------------------------------------------------------- +// CMceMediaManager::StopMccStream +// --------------------------------------------------------- +// +void CMceMediaManager::StopMccStream( CMceSrvStream& aStream ) + { + MCEMM_DEBUG("CMceMediaManager::StopMccStream(), Entry "); + + if ( !aStream.Stop() ) + { + + TMccNetSettings netSettings; + netSettings.iIapId = aStream.IapId(); + netSettings.iLocalAddress.SetPort( aStream.LocalMediaPort() ); + TUint32 linkId = aStream.LinkId(); + + iMccInterface->StopStream( aStream.SessionId(), + linkId, + aStream.Id() ); + + aStream.Cleanup(); + + iMccInterface->DeleteStream( aStream.SessionId(), + linkId, + aStream.Id() ); + + if ( !iMccInterface->StreamsExists( aStream.SessionId(), + linkId ) ) + { + MCEMM_DEBUG("CMceMediaManager::StopMccStream(): closing link "); + iMccInterface->CloseLink( aStream.SessionId(), + linkId ); + aStream.SetLinkId( KMceNotAssigned ); + } + + } + + aStream.Invalidate(); + + MCEMM_DEBUG_STREAM( "CMceMediaManager::StopMccStream(): after stop", aStream ); + MCEMM_DEBUG("CMceMediaManager::StopMccStream(), Exit "); + + } + + +// --------------------------------------------------------- +// CMceMediaManager::CanReleaseEndpoint +// --------------------------------------------------------- +// +TBool CMceMediaManager::CanReleaseEndpoint( CMceSrvStream& aStream, + TUint32 aEndpointId ) + { + TBool remove = EFalse; + TUint referenceCount = 0; + if ( iMccInterface->ReferenceCount( aStream.SessionId(), + aStream.LinkId(), + aStream.Id(), + aEndpointId, + referenceCount ) == KErrNone ) + { + MCEMM_DEBUG_DVALUE("CMceMediaManager::CanReleaseEndpoint(): \ +reference count", referenceCount ); + remove = referenceCount == 1; + } + + return remove; + + } + + +// --------------------------------------------------------- +// CMceMediaManager::ReleaseSink +// --------------------------------------------------------- +// +TInt CMceMediaManager::ReleaseSink( CMceSrvStream& aStream, + TUint32 aEndpointId ) + { + MCEMM_DEBUG("CMceMediaManager::ReleaseSink(), Entry "); + MCEMM_DEBUG_DVALUE(" SessionID", aStream.SessionId() ); + MCEMM_DEBUG_DVALUE(" LinkID", aStream.LinkId() ); + MCEMM_DEBUG_DVALUE(" StreamID", aStream.Id() ); + MCEMM_DEBUG_DVALUE(" EndpointID", aEndpointId ); + + TInt err = + iMccInterface->RemoveDataSink( aStream.SessionId(), + aStream.LinkId(), + aStream.Id(), + aEndpointId ); + + MCEMM_DEBUG_DVALUE("CMceMediaManager::ReleaseSink(), Exit. ", err ); + + return err; + } + +// --------------------------------------------------------- +// CMceMediaManager::ReleaseSource +// --------------------------------------------------------- +// +TInt CMceMediaManager::ReleaseSource( CMceSrvStream& aStream, + TUint32 aEndpointId ) + { + MCEMM_DEBUG("CMceMediaManager::ReleaseSource(), Entry "); + MCEMM_DEBUG_DVALUE(" SessionID", aStream.SessionId() ); + MCEMM_DEBUG_DVALUE(" LinkID", aStream.LinkId() ); + MCEMM_DEBUG_DVALUE(" StreamID", aStream.Id() ); + MCEMM_DEBUG_DVALUE(" EndpointID", aEndpointId ); + + TInt err = + iMccInterface->RemoveDataSource( aStream.SessionId(), + aStream.LinkId(), + aStream.Id(), + aEndpointId ); + + MCEMM_DEBUG_DVALUE("CMceMediaManager::ReleaseSource(), Exit. ", err ); + + return err; + } + + +// --------------------------------------------------------- +// CMceMediaManager::CleanupL +// --------------------------------------------------------- +// +void CMceMediaManager::CleanupL( CMceComSession& aSession ) + { + + MCEMM_DEBUG("CMceMediaManager::CleanupL(), Entry "); + CMceSrvStream* stream = NULL; + + if ( aSession.AnswerType() == KMceNegotiationAnswerTypeFinal ) + { + // check if non-local media was rejected, if yes then stop the stream + + TMceSrvStreamIterator rejects( aSession.MccStreams(), + TMceSrvStreamIterator::EReceive ); + + //stop all started downgraded receive streams, which are downgraded by the answer + while( rejects.Next( stream, CMceSrvStream::EStarted, + TMceSrvStreamIterator::GreaterOrEqualMatch ) ) + { + if ( !stream->Data().IsEnabled() ) + { + MCEMM_DEBUG_STREAM( "CMceMediaManager::CleanupL(): \ + synchronizing downgraded stream", *stream ); + SynchronizeMccStreamL( *stream, aSession.NegotiationState().Role() ); + } + } + + + TMceSrvStreamIterator iterator( aSession.MccStreams(), + TMceSrvStreamIterator::ELocal ); + + //cleanup rejected media + while( iterator.Next( stream, TMceSrvStreamIterator::ExactReverseMatch ) ) + { + if ( stream->Data().RemoteMediaPort() == 0 ) + { + MCEMM_DEBUG_STREAM( "CMceMediaManager::CleanupL(): \ + stream rejected. Disposing stream", *stream ); + CMceComMediaStream* media = &stream->Data(); + DisposeMediaStreamL( media ); + iterator.Reset(); + } + } + + iterator.Reset(); + + //cleanup rejected codecs + while( iterator.Next( stream, TMceSrvStreamIterator::ExactReverseMatch ) ) + { + if ( !stream->Codec().iIsNegotiated ) + { + MCEMM_DEBUG_STREAM( "CMceMediaManager::CleanupL(): \ + codec rejected. Disposing codec", *stream ); + CMceComCodec* codec = &stream->Codec(); + DisposeCodecL( codec ); + iterator.Reset(); + } + } + } + + for ( TInt i = 0; i < aSession.Streams().Count(); i++ ) + { + // First codec of send streams is always enabled automatically, + // if such codec is removed/changed because of negotiation, first + // one of the selected codecs is enabled. + // + MCEMM_DEBUG("CMceMediaManager::CleanupL(), updating default codecs "); + + CMceComMediaStream* sendStream = aSession.Streams()[ i ]->SendStream(); + if ( sendStream ) + { + sendStream->UpdateDefaultCodecL(); + } + } + + + MCEMM_DEBUG("CMceMediaManager::CleanupL(), Exit "); + + } + + +// --------------------------------------------------------- +// CMceMediaManager::DisposeMediaStreamL +// --------------------------------------------------------- +// +void CMceMediaManager::DisposeMediaStreamL( CMceComMediaStream* aStream ) + { + __ASSERT_ALWAYS( aStream, User::Leave( KErrArgument ) ); + + CMceSrvStream* stream = NULL; + CMceComSession& session = *aStream->Session(); + + //find all mcc streams related to stream and + //and remove mcc streams + TMceSrvStreamIterator removed( session.MccStreams(), + *aStream ); + while( removed.Next( stream ) ) + { + MCEMM_DEBUG_DVALUE("CMceMediaManager::DisposeMediaStreamL(): \ +stopping and removing stream", stream->Id() ); + StopMccStream( *stream ); + removed.Remove( session.MccStreams() ); + delete stream; + stream = NULL; + } + //make it inactive + aStream->Enable( EFalse, ETrue ); + + //if not found strem is bounded stream + TInt streamIndex = session.Streams().Find( aStream ); + + if ( streamIndex >= 0 && !aStream->iLinkedStream ) + { + session.Streams().Remove( streamIndex ); + delete aStream; + } + + } + + +// --------------------------------------------------------- +// CMceMediaManager::DisposeCodecL +// --------------------------------------------------------- +// +void CMceMediaManager::DisposeCodecL( CMceComCodec* aCodec ) + { + if ( aCodec ) + { + CMceSrvStream* stream = NULL; + CMceComSession& session = *aCodec->Stream()->Session(); + + MCEMM_DEBUG_SVALUE("CMceMediaManager::DisposeCodecL(): \ + about to remove codec", aCodec->iSdpName ); + + //find all mcc streams related to stream and + //and remove mcc streams + TMceSrvStreamIterator removed( session.MccStreams(), + *aCodec ); + while( removed.Next( stream ) ) + { + MCEMM_DEBUG_STREAM( "CMceMediaManager::DisposeCodecL(): \ + stopping and removing stream", *stream ); + + StopMccStream( *stream ); + removed.Remove( session.MccStreams() ); + + // dispose also associated local streams + TMceSrvStreamIterator associatedLocalStreams( + session.MccStreams(), stream->Source().Data(), + ETrue, TMceSrvStreamIterator::ELocal, aCodec ); + CMceSrvStream* associatedLocalStream = NULL; + while( associatedLocalStreams.Next( associatedLocalStream ) ) + { + MCEMM_DEBUG_STREAM( "CMceMediaManager::DisposeCodecL(): \ + stopping and removing associated local stream", *associatedLocalStream ); + + StopMccStream( *associatedLocalStream ); + associatedLocalStreams.Remove( session.MccStreams() ); + delete associatedLocalStream; + associatedLocalStream = NULL; + } + delete stream; + stream = NULL; + } + MCEMM_DEBUG_SVALUE("CMceMediaManager::DisposeCodecL(): \ + removing codec", aCodec->iSdpName ); + + CMceComCodec* boundCodec = NULL; + if ( aCodec->Stream()->BoundStream() ) + { + boundCodec = aCodec->Stream()->BoundStreamL().FindCodecL( *aCodec ); + } + + aCodec->Stream()->RemoveCodecL( aCodec ); + + DisposeCodecL( boundCodec ); + + MCEMM_DEBUG("CMceMediaManager::DisposeCodecL(), done "); + } + } + + +// --------------------------------------------------------- +// CMceMediaManager::AdjustMccStreamL +// --------------------------------------------------------- +// +void CMceMediaManager::AdjustMccStreamL( CMceSrvStream& aStream ) + { + + MCEMM_DEBUG("CMceMediaManager::AdjustMccStreamL(), Entry "); + + CMceComCodec* bidirectional = DoAdjustMccStreamL( aStream ); + + if ( bidirectional ) + { + CMceSrvStream* stream = NULL; + TMceSrvStreamIterator streams( aStream.Codec().Stream()->Session()->MccStreams(), + *bidirectional ); + while( streams.Next( stream ) ) + { + DoAdjustMccStreamL( *stream ); + } + } + + MCEMM_DEBUG("CMceMediaManager::AdjustMccStreamL(), Exit "); + + } + + + +// --------------------------------------------------------- +// CMceMediaManager::ValidateMccStreamL +// --------------------------------------------------------- +// +void CMceMediaManager::ValidateMccStreamL( CMceSrvStream& aStream ) + { + + MCEMM_DEBUG("CMceMediaManager::ValidateMccStreamL(), Entry "); + + __ASSERT_ALWAYS( aStream.State() != CMceSrvStream::EAdopted, + User::Leave( KErrArgument ) ); + + //if valid + if ( aStream.Validate() ) + { + return; + } + + TMceNegotiationRole role = EMceRoleOfferer; + + CMccCodecInformation* codec = NULL; + + if ( !aStream.IsMccPrepared() ) + { + role = EMceRoleAnswerer; + //create codec information + CMccCodecInformationFactory* codecFactory = + CMccCodecInformationFactory::NewL(); + CleanupStack::PushL( codecFactory ); + + codec = + codecFactory->CreateCodecInformationL( aStream.Codec().iSdpName ); + + CleanupStack::PopAndDestroy( codecFactory ); + + } + else + { + //get codec + codec = + iMccInterface->CodecL( + aStream.SessionId(), + aStream.LinkId(), + aStream.Id() ); + } + + CleanupStack::PushL( codec ); + + //validate codec + aStream.Codec().MccValidateL( *codec, aStream, role ); + + CleanupStack::PopAndDestroy( codec ); + + MCEMM_DEBUG("CMceMediaManager::ValidateMccStreamL(), Exit "); + } + + + +// --------------------------------------------------------- +// CMceMediaManager::PrepareUpdateL +// --------------------------------------------------------- +// +void CMceMediaManager::PrepareUpdateL( CMceSdpSession& aSession ) + { + MCEMM_DEBUG("CMceMediaManager::PrepareUpdateL(), Entry "); + + CMceComSession* session = aSession.MediaSession(); + CMceComSession* backup = aSession.Backup(); + + TInt action = RequireSignallingL( *session, *backup ); + + //do local update + if ( action != KMceRequiresSignalling ) + { + MCEMM_DEBUG("CMceMediaManager::PrepareUpdateL(): \ +no need for new mcc session. Doing merge"); + session->Merge( *backup ); + } + else if( session ) + { + if( session->iCodecSelection == KMceCodecSelectionMerge ) + { + session->Merge( *backup ); + } + } + + + aSession.SignallingRequired() = action; + + MCEMM_DEBUG("CMceMediaManager::PrepareUpdateL(), Exit "); + + } + + +// --------------------------------------------------------- +// CMceMediaManager::RequireSignallingL +// --------------------------------------------------------- +// +TInt CMceMediaManager::RequireSignallingL( + CMceComSession& aSession, + CMceComSession& aBackup ) + + { + MCEMM_DEBUG("CMceMediaManager::RequireSignallingL(), Entry "); + + TInt action = KMceNoSignalling; + + TMceSrvStreamIterator streams( + aBackup.MccStreams(), + TMceSrvStreamIterator::ESendOrReceive ); + + TMceSrvStreamIterator updates( + aSession.MccStreams(), + TMceSrvStreamIterator::ESendOrReceive ); + + CMceSrvStream* update = NULL; + CMceSrvStream* stream = NULL; + //intersection i.e. streams both in update and original + while( !action && + updates.NextIntersect( update, streams, stream ) ) + { + //current codec + if ( stream->IsMccPrepared() ) + { + + CMccCodecInformation* codec = + iMccInterface->CodecL( stream->SessionId(), + stream->LinkId(), + stream->Id() ); + + CleanupStack::PushL( codec ); + + //updated codec + CMccCodecInformation* codecUpdate = + CreateMccCodecLC( *update, EMceRoleOfferer ); + + action = update->RequireSignalling( *stream, + *codec, + *codecUpdate ); + + CleanupStack::PopAndDestroy( codecUpdate ); + CleanupStack::PopAndDestroy( codec ); + } + else + { + action = stream->RequireSignalling( aSession.MccStreams() ); + } + } + + updates.Reset(); + //added to update + while( !action && + updates.NextComplement( update, streams ) ) + { + action = update->RequireSignalling( aSession.MccStreams() ); + } + + streams.Reset(); + //removed from update + while( !action && + streams.NextComplement( stream, updates ) ) + + { + action = stream->RequireSignalling( aSession.MccStreams() ); + } + + + MCEMM_DEBUG("CMceMediaManager::RequireSignallingL(), Exit "); + return action; + + } + + +// --------------------------------------------------------- +// CMceMediaManager::SynchronizeMccStreamL +// --------------------------------------------------------- +// +void CMceMediaManager::SynchronizeMccStreamL( + CMceSrvStream& aStream, + TMceNegotiationRole aRole, + TBool aSyncCodecOnly ) + { + MCEMM_DEBUG("CMceMediaManager::SynchronizeMccStreamL(), Entry "); + + if ( !aStream.SynchronizeL() ) + { + + CMccCodecInformation* codec = + iMccInterface->CodecL( aStream.SessionId(), + aStream.LinkId(), + aStream.Id() ); + CleanupStack::PushL( codec ); + //re-populate codec with updated values + aStream.Codec().MccPopulateL( *codec, aStream, aRole ); + + MCEMM_DEBUG("CMceMediaManager::SynchronizeMccStreamL(): \ +re-setting codec"); + + User::LeaveIfError( + iMccInterface->SetCodec( + aStream.SessionId(), + aStream.LinkId(), + aStream.Id(), + *codec ) ); + + CleanupStack::PopAndDestroy( codec ); + + if ( !aSyncCodecOnly ) + { + SynchronizeMccStreamL( aStream ); + } + } + + MCEMM_DEBUG("CMceMediaManager::SynchronizeMccStreamL(), Exit "); + } + +// --------------------------------------------------------- +// CMceMediaManager::SynchronizeMccStreamL +// --------------------------------------------------------- +// +void CMceMediaManager::SynchronizeMccStreamL( + CMceSrvStream& aStream, + TUint32 aForceEnableEndpoint, + TUint32 aForceDisableEndpoint ) + { + MCEMM_DEBUG("CMceMediaManager::SynchronizeMccStreamL() two, Entry "); + + if ( !DoStartEndpointsL( aStream, aForceEnableEndpoint, aForceDisableEndpoint ) ) + { + if ( !DoResumeEndpointsL( aStream, aForceEnableEndpoint ) ) + { + DoPauseEndpointsL( aStream, aForceDisableEndpoint ); + } + } + + MCEMM_DEBUG_STREAM( "CMceMediaManager::SynchronizeMccStreamL() two: \ +syncronized stream", aStream ); + + MCEMM_DEBUG("CMceMediaManager::SynchronizeMccStreamL() two, Exit "); + } + +// --------------------------------------------------------- +// CMceMediaManager::ReuseLink +// --------------------------------------------------------- +// +TBool CMceMediaManager::ReuseLink( CMceSrvStream& aStream ) + { + TBool inUse = EFalse; + + CMceComSession* session = aStream.Data().Session(); + CMceSrvStream* stream = NULL; + + TMceSrvStreamIterator + sourceMatchStreams( session->MccStreams(), + aStream.Source().Data(), + KMceComUseProxyMatch ); + + TMceSrvStreamIterator + sinkMatchStreams( session->MccStreams(), + aStream.Sink().Data(), + KMceComUseProxyMatch ); + + while( !inUse && sourceMatchStreams.Next( stream ) ) + { + if ( ( aStream.Data().iStreamType == CMceComMediaStream::ELocalStream || + aStream.Source().Data().Type() == KMceRTPSource ) && + stream->Data().iLinkId != KMceNotAssigned ) + { + inUse = ETrue; + aStream.Data().iLinkId = stream->Data().iLinkId; + } + } + + while( !inUse && sinkMatchStreams.Next( stream ) ) + { + if ( ( aStream.Data().iStreamType == CMceComMediaStream::ELocalStream || + aStream.Sink().Data().Type() == KMceRTPSink ) && + stream->Data().iLinkId != KMceNotAssigned ) + { + inUse = ETrue; + aStream.Data().iLinkId = stream->Data().iLinkId; + } + } + + return inUse; + + } + +// --------------------------------------------------------- +// CMceMediaManager::ReuseSource +// --------------------------------------------------------- +// +TBool CMceMediaManager::ReuseSource( CMceSrvStream& aStream ) + { + TBool inUse = EFalse; + + if ( aStream.Source().Reusable( aStream ) ) + { + CMceComSession* session = aStream.Data().Session(); + CMceSrvStream* stream = NULL; + + TMceSrvStreamIterator streams( session->MccStreams(), + aStream.Source().Data(), + KMceComUseProxyMatch ); + + while( !inUse && streams.Next( stream ) ) + { + if ( stream->Source().Id() != KMceNotAssigned ) + { + inUse = ETrue; + aStream.Id() = stream->Id(); + aStream.Source().Id() = stream->Source().Id(); + } + } + } + + return inUse; + + } + +// --------------------------------------------------------- +// CMceMediaManager::ReuseSink +// --------------------------------------------------------- +// +TBool CMceMediaManager::ReuseSink( CMceSrvStream& aStream ) + { + TBool inUse = EFalse; + + if ( aStream.Sink().Reusable( aStream ) ) + { + CMceComSession* session = aStream.Data().Session(); + CMceSrvStream* stream = NULL; + + TMceSrvStreamIterator streams( session->MccStreams(), + aStream.Sink().Data(), + KMceComUseProxyMatch ); + + while( !inUse && streams.Next( stream ) ) + { + if ( stream->Sink().Id() != KMceNotAssigned ) + { + inUse = ETrue; + aStream.Id() = stream->Id(); + aStream.Sink().Id() = stream->Sink().Id(); + } + } + } + + return inUse; + + } + +// --------------------------------------------------------- +// CMceMediaManager::SetMccParameterL +// --------------------------------------------------------- +// +void CMceMediaManager::SetMccParameterL( TUint32 aParam, + const TDesC8& aValue ) const + { + + User::LeaveIfError( + iMccInterface->SetParameter( 0, 0, 0, 0, aParam, aValue ) ); + + } + +// --------------------------------------------------------- +// CMceMediaManager::GetMccParameterL +// --------------------------------------------------------- +// +void CMceMediaManager::GetMccParameterL( TUint32 aParam, + TDes8& aValue ) const + { + User::LeaveIfError( + iMccInterface->GetParameter( 0, 0, 0, 0, aParam, aValue ) ); + } + + +// --------------------------------------------------------- +// CMceMediaManager::SetMccParameterL +// --------------------------------------------------------- +// +void CMceMediaManager::SetMccParameterL( const CMceComMediaSink& aMediaSink, + TUint32 aParam, + const TDesC8& aValue, + TBool aAllowNonPrepared ) const + + { + CMceComSession* session = aMediaSink.MediaStream()->Session(); + + TMceSrvStreamIterator streams( session->MccStreams(), aMediaSink ); + CMceSrvStream* stream = NULL; + TBool done = EFalse; + + while( !done && streams.Next( stream ) ) + { + if ( stream->IsMccPrepared() || aAllowNonPrepared ) + { + MCEMM_DEBUG_STREAM( "CMceMediaManager::SetMccParameterL(): \ +setting parameter of stream", *stream ); + User::LeaveIfError( + iMccInterface->SetParameter( stream->SessionId(), + stream->LinkId(), + stream->Id(), + stream->Sink().Id(), + aParam, + aValue ) ); + } + else + { + SetMccParameterL( aParam, aValue ); + } + done = ETrue; + } + + } + +// --------------------------------------------------------- +// CMceMediaManager::SetMccParameterL +// --------------------------------------------------------- +// +void CMceMediaManager::SetMccParameterL( const CMceComMediaSource& aMediaSource, + TUint32 aParam, + const TDesC8& aValue, + TBool aAllowNonPrepared ) const + + { + + CMceComSession* session = aMediaSource.MediaStream()->Session(); + + TMceSrvStreamIterator streams( session->MccStreams(), aMediaSource ); + CMceSrvStream* stream = NULL; + TBool done = EFalse; + + while( !done && streams.Next( stream ) ) + { + if ( stream->IsMccPrepared() || aAllowNonPrepared ) + { + MCEMM_DEBUG_STREAM( "CMceMediaManager::SetMccParameterL(): \ +setting parameter of stream", *stream ); + User::LeaveIfError( + iMccInterface->SetParameter( stream->SessionId(), + stream->LinkId(), + stream->Id(), + stream->Source().Id(), + aParam, + aValue ) ); + } + else + { + SetMccParameterL( aParam, aValue ); + } + done = ETrue; + } + + } + + + + +// --------------------------------------------------------- +// CMceMediaManager::GetMccParameterL +// --------------------------------------------------------- +// +void CMceMediaManager::GetMccParameterL( const CMceComMediaSink& aMediaSink, + TUint32 aParam, + TDes8& aValue, + TBool aAllowNonPrepared ) const + + { + + CMceComSession* session = aMediaSink.MediaStream()->Session(); + + TMceSrvStreamIterator streams( session->MccStreams(), aMediaSink ); + CMceSrvStream* stream = NULL; + TBool done = EFalse; + + while( !done && streams.Next( stream ) ) + { + if ( stream->IsMccPrepared() || aAllowNonPrepared ) + { + MCEMM_DEBUG_STREAM( "CMceMediaManager::GetMccParameterL(): \ +getting parameter of stream", *stream ); + User::LeaveIfError( + iMccInterface->GetParameter( stream->SessionId(), + stream->LinkId(), + stream->Id(), + stream->Sink().Id(), + aParam, + aValue ) ); + } + else + { + GetMccParameterL( aParam, aValue ); + } + done = ETrue; + } + } + +// --------------------------------------------------------- +// CMceMediaManager::GetMccParameterL +// --------------------------------------------------------- +// +void CMceMediaManager::GetMccParameterL( const CMceComMediaSource& aMediaSource, + TUint32 aParam, + TDes8& aValue, + TBool aAllowNonPrepared ) const + + { + + CMceComSession* session = aMediaSource.MediaStream()->Session(); + + TMceSrvStreamIterator streams( session->MccStreams(), aMediaSource ); + CMceSrvStream* stream = NULL; + TBool done = EFalse; + + while( !done && streams.Next( stream ) ) + { + if ( stream->IsMccPrepared() || aAllowNonPrepared ) + { + MCEMM_DEBUG_STREAM( "CMceMediaManager::GetMccParameterL(): \ +getting parameter of stream", *stream ); + User::LeaveIfError( + iMccInterface->GetParameter( stream->SessionId(), + stream->LinkId(), + stream->Id(), + stream->Source().Id(), + aParam, + aValue ) ); + + } + else + { + GetMccParameterL( aParam, aValue ); + } + done = ETrue; + } + + } + + +// --------------------------------------------------------- +// CMceMediaManager::UpdateMccSourceL +// --------------------------------------------------------- +// +void CMceMediaManager::UpdateMccSourceL( CMceComCameraSource& aMediaSource ) + { + CMceComSession* session = aMediaSource.MediaStream()->Session(); + + TMceSrvStreamIterator streams( session->MccStreams(), aMediaSource ); + CMceSrvStream* stream = NULL; + TBool done = EFalse; + + while( !done && streams.Next( stream ) ) + { + CMceComCodec& codec = stream->Codec(); + + if ( stream->IsMccPrepared() ) + { + MCEMM_DEBUG_STREAM( "CMceMediaManager::UpdateMccSourceL(): \ +updating data source of stream", *stream ); + User::LeaveIfError( + iMccInterface->UpdateDataSource( stream->SessionId(), + stream->LinkId(), + stream->Id(), + stream->Source().Id(), + aMediaSource.InitParamL( codec ) ) ); + done = ETrue; + } + } + } + +/* +** From MMccCtrlObserver *** +*/ + +// --------------------------------------------------------- +// CMceMediaManager::MccMediaLinkCreated +// --------------------------------------------------------- +// +void CMceMediaManager::MccMediaLinkCreated( TUint32 aSessionId, + TUint32 aLinkId, + const TDesC8& aNetSettings ) + + { + MCEMM_DEBUG("CMceMediaManager::MccMediaLinkCreated(), Entry "); + MCEMM_DEBUG_DVALUE(" SessionID", aSessionId ); + MCEMM_DEBUG_DVALUE(" LinkID", aLinkId ); + + CMceComSession* session = Session( aSessionId ); + if ( session ) + { + TMceMccComEvent event( KMccLinkCreated, + aLinkId, + 0, + 0 ); + + event.SetDataDesC( aNetSettings ); + + TRAPD( err, + session->NegotiationState().MccLinkCreatedL( event ) ); + + if( err != KErrNone ) + { + MCEMM_DEBUG_DVALUE("Error occured!, error", err ); + session->NegotiationState().MccError( err, event ); + } + } + else + { + MCEMM_DEBUG("No Session!"); + iObserver->MediaError( KErrGeneral ); + } + + MCEMM_DEBUG("CMceMediaManager::MccMediaLinkCreated(), Exit "); + + } + + +// --------------------------------------------------------- +// CMceMediaManager::MccMediaPrepared +// --------------------------------------------------------- +// +void CMceMediaManager::MccMediaPrepared( TUint32 aSessionId, + TUint32 aLinkId, + TUint32 aStreamId, + TUint32 aSinkSourceId ) + { + MCEMM_DEBUG("CMceMediaManager::MccMediaPrepared(), Entry "); + MCEMM_DEBUG_DVALUE(" SessionID", aSessionId ); + MCEMM_DEBUG_DVALUE(" LinkID", aLinkId ); + MCEMM_DEBUG_DVALUE(" StreamID", aStreamId ); + MCEMM_DEBUG_DVALUE(" EndpointID", aSinkSourceId ); + + CMceComSession* session = Session( aSessionId ); + if ( session ) + { + TMceMccComEvent event( KMccStreamPrepared, + aLinkId, + aStreamId, + aSinkSourceId ); + + TRAPD( err, + session->NegotiationState().MccMediaPreparedL( event ) ); + + if( err != KErrNone ) + { + MCEMM_DEBUG_DVALUE("CMceMediaManager::MccMediaPrepared(): \ +Error occured!, error", err ); + session->NegotiationState().MccError( err, event ); + } + } + else + { + MCEMM_DEBUG("No Session!"); + iObserver->MediaError( KErrGeneral ); + } + + MCEMM_DEBUG("CMceMediaManager::MccMediaPrepared(), Exit "); + + } + +// --------------------------------------------------------- +// CMceMediaManager::MccMediaStarted +// --------------------------------------------------------- +// +void CMceMediaManager::MccMediaStarted( TUint32 aSessionId, + TUint32 aLinkId, + TUint32 aStreamId, + TUint32 aSinkSourceId ) + { + MCEMM_DEBUG("CMceMediaManager::MccMediaStarted(), Entry "); + MCEMM_DEBUG_DVALUE(" SessionID", aSessionId ); + MCEMM_DEBUG_DVALUE(" LinkID", aLinkId ); + MCEMM_DEBUG_DVALUE(" StreamID", aStreamId ); + MCEMM_DEBUG_DVALUE(" EndpointID", aSinkSourceId ); + + CMceComSession* session = Session( aSessionId ); + if ( session ) + { + TMceMccComEvent event( KMccStreamStarted, + aLinkId, + aStreamId, + aSinkSourceId ); + + TRAPD( err, + session->NegotiationState().MccMediaStartedL( event ) ); + if( err != KErrNone ) + { + MCEMM_DEBUG_DVALUE("CMceMediaManager::MccMediaStarted(): \ +Error occured!, error", err ); + session->NegotiationState().MccError( err, event ); + } + } + else + { + MCEMM_DEBUG("No Session!"); + iObserver->MediaError( KErrGeneral ); + } + MCEMM_DEBUG("CMceMediaManager::MccMediaStarted(), Exit "); + } + + +// --------------------------------------------------------- +// CMceMediaManager::MccMediaStopped +// --------------------------------------------------------- +// +void CMceMediaManager::MccMediaStopped( TUint32 aSessionId, + TUint32 aLinkId, + TUint32 aStreamId, + TUint32 aSinkSourceId ) + { + MCEMM_DEBUG("CMceMediaManager::MccMediaStopped(), Entry "); + MCEMM_DEBUG_DVALUE(" SessionID", aSessionId ); + MCEMM_DEBUG_DVALUE(" LinkID", aLinkId ); + MCEMM_DEBUG_DVALUE(" StreamID", aStreamId ); + MCEMM_DEBUG_DVALUE(" EndpointID", aSinkSourceId ); + + CMceComSession* session = Session( aSessionId ); + if ( session ) + { + TMceMccComEvent event( KMccStreamStopped, + aLinkId, + aStreamId, + aSinkSourceId ); + + CMceSrvStream::EventReceived( session->MccStreams(), event ); + + } + else + { + MCEMM_DEBUG("No Session!"); + iObserver->MediaError( KErrGeneral ); + } + MCEMM_DEBUG("CMceMediaManager::MccMediaStopped(), Exit "); + + } + + +// --------------------------------------------------------- +// CMceMediaManager::MccMediaPaused +// --------------------------------------------------------- +// +void CMceMediaManager::MccMediaPaused( TUint32 aSessionId, + TUint32 aLinkId, + TUint32 aStreamId, + TUint32 aSinkSourceId ) + { + MCEMM_DEBUG("CMceMediaManager::MccMediaPaused(), Entry "); + MCEMM_DEBUG_DVALUE(" SessionID", aSessionId ); + MCEMM_DEBUG_DVALUE(" LinkID", aLinkId ); + MCEMM_DEBUG_DVALUE(" StreamID", aStreamId ); + MCEMM_DEBUG_DVALUE(" EndpointID", aSinkSourceId ); + + CMceComSession* session = Session( aSessionId ); + if ( session ) + { + TMceMccComEvent event( KMccStreamPaused, + aLinkId, + aStreamId, + aSinkSourceId ); + + TRAPD( err, + session->NegotiationState().MccMediaPausedL( event ) ); + if( err != KErrNone ) + { + MCEMM_DEBUG_DVALUE("CMceMediaManager::MccMediaPaused(): \ +Error occured!, error", err ); + session->NegotiationState().MccError( err, event ); + } + } + else + { + MCEMM_DEBUG("No Session!"); + iObserver->MediaError( KErrGeneral ); + } + MCEMM_DEBUG("CMceMediaManager::MccMediaPaused(), Exit "); + } + + + +// --------------------------------------------------------- +// CMceMediaManager::MccMediaResumed +// --------------------------------------------------------- +// +void CMceMediaManager::MccMediaResumed( TUint32 aSessionId, + TUint32 aLinkId, + TUint32 aStreamId, + TUint32 aSinkSourceId ) + { + MCEMM_DEBUG("CMceMediaManager::MccMediaResumed(), Entry "); + MCEMM_DEBUG_DVALUE(" SessionID", aSessionId ); + MCEMM_DEBUG_DVALUE(" LinkID", aLinkId ); + MCEMM_DEBUG_DVALUE(" StreamID", aStreamId ); + MCEMM_DEBUG_DVALUE(" EndpointID", aSinkSourceId ); + + CMceComSession* session = Session( aSessionId ); + if ( session ) + { + TMceMccComEvent event( KMccStreamResumed, + aLinkId, + aStreamId, + aSinkSourceId ); + + TRAPD( err, + session->NegotiationState().MccMediaResumedL( event ) ); + if( err != KErrNone ) + { + MCEMM_DEBUG_DVALUE("CMceMediaManager::MccMediaResumed(): \ +Error occured!, error", err ); + session->NegotiationState().MccError( err, event ); + } + } + else + { + MCEMM_DEBUG("No Session!"); + iObserver->MediaError( KErrGeneral ); + } + MCEMM_DEBUG("CMceMediaManager::MccMediaResumed(), Exit "); + } + +// --------------------------------------------------------- +// CMceMediaManager::MccMediaInactive +// --------------------------------------------------------- +// + +void CMceMediaManager::MccMediaInactive( TUint32 aSessionId, + TUint32 aLinkId, + TUint32 aStreamId, + TUint32 aSinkSourceId ) + { + MCEMM_DEBUG("CMceMediaManager::MccMediaInactive(), Entry "); + MCEMM_DEBUG_DVALUE(" SessionID", aSessionId ); + MCEMM_DEBUG_DVALUE(" LinkID", aLinkId ); + MCEMM_DEBUG_DVALUE(" StreamID", aStreamId ); + MCEMM_DEBUG_DVALUE(" EndpointID", aSinkSourceId ); + + CMceComSession* session = Session( aSessionId ); + if ( session ) + { + TMceMccComEvent event( KMccInactivityEvent, + aLinkId, + aStreamId, + aSinkSourceId ); + + CMceSrvStream::EventReceived( session->MccStreams(), event ); + + } + else + { + MCEMM_DEBUG("No Session!"); + iObserver->MediaError( KErrGeneral ); + } + MCEMM_DEBUG("CMceMediaManager::MccMediaInactive(), Exit "); + } + + +// --------------------------------------------------------- +// CMceMediaManager::MccMediaActive +// --------------------------------------------------------- +// + +void CMceMediaManager::MccMediaActive( TUint32 aSessionId, + TUint32 aLinkId, + TUint32 aStreamId, + TUint32 aSinkSourceId ) + { + MCEMM_DEBUG("CMceMediaManager::MccMediaActive(), Entry "); + MCEMM_DEBUG_DVALUE(" SessionID", aSessionId ); + MCEMM_DEBUG_DVALUE(" LinkID", aLinkId ); + MCEMM_DEBUG_DVALUE(" StreamID", aStreamId ); + MCEMM_DEBUG_DVALUE(" EndpointID", aSinkSourceId ); + + CMceComSession* session = Session( aSessionId ); + if ( session ) + { + TMceMccComEvent event( KMccActivityEvent, + aLinkId, + aStreamId, + aSinkSourceId ); + + CMceSrvStream* stream = + CMceSrvStream::EventReceived( session->MccStreams(), event ); + + CMceSrvStream* adopted = session->RemoveAdoptedStream( *stream ); + if ( adopted ) + { + MCEMM_DEBUG_DVALUE("CMceMediaManager::MccMediaActive(): \ +stopping adopted stream. id", adopted->Id() ); + StopMccStream( *adopted ); + if ( !session->IsMerged() && session->AdoptedMccStreams().Count() == 0 ) + { + MCEMM_DEBUG_DVALUE("Closing session. id", adopted->SessionId() ); + iMccInterface->CloseSession( adopted->SessionId() ); + } + delete adopted; + } + } + else + { + MCEMM_DEBUG("No Session!"); + iObserver->MediaError( KErrGeneral ); + } + MCEMM_DEBUG("CMceMediaManager::MccMediaActive(), Exit "); + } + +// --------------------------------------------------------- +// CMceMediaManager::MccCtrlError +// --------------------------------------------------------- +// +/*void CMceMediaManager::MccCtrlError( TInt aError ) + { + MCEMM_DEBUG("CMceMediaManager::MccCtrlError(), Entry "); + MCEMM_DEBUG_DVALUE(" aError", aError ); + + iObserver->MediaError( aError ); + MCEMM_DEBUG("CMceMediaManager::MccCtrlError(), Exit "); + }*/ + +// --------------------------------------------------------- +// CMceMediaManager::MccCtrlError +// --------------------------------------------------------- +// +void CMceMediaManager::MccCtrlError( TInt aError, + TUint32 aSessionId, + TUint32 aLinkId, + TUint32 aStreamId, + TUint32 aSinkSourceId ) + { + MCEMM_DEBUG("CMceMediaManager::MccCtrlError(), Entry "); + MCEMM_DEBUG_DVALUE(" SessionID", aSessionId ); + MCEMM_DEBUG_DVALUE(" LinkID", aLinkId ); + MCEMM_DEBUG_DVALUE(" StreamID", aStreamId ); + MCEMM_DEBUG_DVALUE(" EndpointID", aSinkSourceId ); + MCEMM_DEBUG_DVALUE(" error", aError ); + + CMceComSession* session = Session( aSessionId ); + if ( session ) + { + TMceMccComEvent event( KMccStreamError, + aLinkId, + aStreamId, + aSinkSourceId ); + + session->NegotiationState().MccError( aError, event ); + + } + else + { + MCEMM_DEBUG("No Session!"); + iObserver->MediaError( KErrGeneral ); + } + MCEMM_DEBUG("CMceMediaManager::MccCtrlError(), Exit "); + + } + +// --------------------------------------------------------- +// CMceMediaManager::MccEventReceived +// --------------------------------------------------------- +// +void CMceMediaManager::MccEventReceived( const TMccEvent& aEvent ) + { + MCEMM_DEBUG("CMceMediaManager::MccEventReceived(), Entry "); + MCEMM_DEBUG_DVALUE(" SessionID", aEvent.iSessionId ); + MCEMM_DEBUG_DVALUE(" LinkID", aEvent.iLinkId ); + MCEMM_DEBUG_DVALUE(" StreamID", aEvent.iStreamId ); + MCEMM_DEBUG_DVALUE(" EndpointID", aEvent.iEndpointId ); + + MCEMM_DEBUG_DVALUE(" Event category", aEvent.iEventCategory ); + MCEMM_DEBUG_DVALUE(" Event type", aEvent.iEventType ); + + if ( aEvent.iEventCategory == KMccEventCategoryTranscode ) + { + MccTranscodeEventReceived( aEvent ); + } + else if ( aEvent.iEventType == KMccLinkCreated || + aEvent.iEventType == KMccLinkSecure || + aEvent.iEventType == KMccLinkSecureVideo ) + { + MccMediaLinkCreated( aEvent.iSessionId, aEvent.iLinkId, + aEvent.iEventData ); + } + else + { + + CMceComSession* session = Session( aEvent.iSessionId ); + if ( !session ) + { + MCEMM_DEBUG("no session"); + MCEMM_DEBUG("CMceMediaManager::MccEventReceived(), Exit "); + return; + } + + TMceMccComEvent event( aEvent.iEventType, + aEvent.iLinkId, + aEvent.iStreamId, + aEvent.iEndpointId ); + event.SetDataDesC( aEvent.iEventData ); + + TMceSrvStreamIterator iterator( session->MccStreams() ); + CMceSrvStream* stream = NULL; + if ( iterator.Next( stream, event ) ) + { + if ( aEvent.iEventCategory == KMccEventCategoryDtmf ) + { + // CodeScanner can't see properly inside to TRAP + // and in some cases it report Problem: + // Leaving functions called in non-leaving functions. + TRAP_IGNORE( \ + stream->DtmfHandlerL( *iMccInterface ).DtmfReceivedL( \ + aEvent, event ) ); + + // Event destination might have been modified + } + else if( aEvent.iEventType == KMccMasterKeyStaled ) + { + if ( aEvent.iEventNumData > 0 && + session->SecureSession() ) + { + // set up in the session + session->SecureSession()->ContextNeedUpdated( aEvent.iEventNumData ); + } + } + else if ( aEvent.iEventCategory == KMccEventCategoryRtcp ) + { + const TMccRtcpEventData& rtcpEvent = + (*reinterpret_cast( + &aEvent.iEventData ))(); + + event.iEventSubType = rtcpEvent.iRtcpPacketType; + event.SetDataDesC( rtcpEvent.iRtcpPacketData ); + } + else + { + // NOP + } + + // Event might contain only link id (e.g. rtcp rr) but + // we do not want to propagate it to all streams of that link. + CMceSrvStream::EventReceived( session->MccStreams(), event, ETrue ); + } + else + { + MCEMM_DEBUG("CMceMediaManager::MccEventReceived(): \ +ERROR: Unknown stream" ); + } + } + + MCEMM_DEBUG("CMceMediaManager::MccEventReceived(), Exit "); + + } + + + +// --------------------------------------------------------- +// CMceMediaManager::MccTranscodeEventReceived +// --------------------------------------------------------- +// +void CMceMediaManager::MccTranscodeEventReceived( const TMccEvent& aEvent ) + { + MCEMM_DEBUG("CMceMediaManager::MccTranscodeEventReceived(), Entry "); + MCEMM_DEBUG_DVALUE(" SessionID", aEvent.iSessionId ); + + CMceComFileSource* session = TranscodingSession( aEvent.iSessionId ); + if ( !session ) + { + MCEMM_DEBUG("no session"); + MCEMM_DEBUG("CMceMediaManager::MccTranscodeEventReceived(), Exit "); + return; + } + + TMceMccComEvent event( aEvent.iEventType, 0, 0, 0 ); + event.iSource = session; + event.iItcEvent = aEvent.iEventType == KMccTranscodeCompleted ? + EMceItcTranscodingCompleted : EMceItcTranscodingInProgress; + + event.iItcData = aEvent.iEventNumData; + event.iError = aEvent.iErrorCode; + + session->iClient->EventReceived( event ); + + if ( aEvent.iEventType == KMccTranscodeCompleted ) + { + TInt index = iTranscodeSessions.Find( session ); + if ( index >= 0 ) + { + iTranscodeSessions.Remove( index ); + delete session; + } + } + + MCEMM_DEBUG("CMceMediaManager::MccTranscodeEventReceived(), Exit "); + + } + + +/* +* Private functions for internal use +*/ + + + + +// --------------------------------------------------------- +// CMceMediaManager::Session +// --------------------------------------------------------- +// +CMceComSession* CMceMediaManager::Session( TUint32 aSessionId ) + { + MCEMM_DEBUG("CMceMediaManager::Session(), Entry "); + + CMceComSession* session = NULL; + + for ( TInt i=0; i < iMceSdpSessions.Count() && !session; i++ ) + { + CMceSdpSession* sdpSession = iMceSdpSessions[ i ]; + if ( sdpSession->IsMaster() ) + { + session = sdpSession->Consumes( aSessionId ); + } + } + + if ( !session ) + { + MCEMM_DEBUG_DVALUE("Session not found! id", aSessionId ) + iObserver->MediaError( KErrNotFound ); + } + + MCEMM_DEBUG("CMceMediaManager::Session(), Exit "); + return session; + } + +// --------------------------------------------------------- +// CMceMediaManager::SdpSession +// --------------------------------------------------------- +// +CMceSdpSession* CMceMediaManager::SdpSession( CMceComSession& aSession ) + { + + MCEMM_DEBUG("CMceMediaManager::SdpSession(), Entry "); + + TInt error = KErrNone; + + CMceSdpSession* sdpSession = &aSession.SdpSession(); + if ( !sdpSession ) //possible clone + { + sdpSession = aSession.iCloneOrigin ? &aSession.iCloneOrigin->SdpSession() : NULL; + + if ( sdpSession ) + { + sdpSession->SetMediaSession( aSession.iCloneOrigin ); + } + } + + if ( sdpSession ) + { + + if ( &aSession != sdpSession->MediaSession() && + &aSession != sdpSession->Backup() ) + { + TRAP( error, aSession.AttachSDPSessionL( *sdpSession ) ); + } + + if ( MCE_IS_NULL_PTR( sdpSession->Backup() ) && //is not update + !sdpSession->IsMaster() && //is not master + sdpSession->Context() ) // has context + { + sdpSession->ContextSwitch(); + } + } + + + if ( error != KErrNone ) + { + sdpSession = NULL; + } + + MCEMM_DEBUG("CMceMediaManager::SdpSession(), Exit "); + return sdpSession; + } + + +// --------------------------------------------------------- +// CMceMediaManager::CloseSession +// Closes MCC session and removes the internal sdp session +// Status : Draft +// --------------------------------------------------------- +TInt CMceMediaManager::CloseSession( CMceComSession& aSession ) + { + MCEMM_DEBUG("CMceMediaManager::CloseSession(), Entry "); + + TInt error = KErrNone; + + CMceSdpSession* sdpSession = SdpSession( aSession ); + if ( !sdpSession ) + { + MCEMM_DEBUG("No session!"); + MCEMM_DEBUG("CMceMediaManager::CloseSession(), Exit "); + return KErrNotFound; + } + + CMceComSession* backup = aSession.Backup(); + + if ( !backup ) + //no backup => close session + { + if ( sdpSession->IsMaster() ) + { + TRAP( error, CleanupSessionL( aSession ) ); + iMccInterface->CloseSession( aSession.iMccID ); + } + RemoveSession( sdpSession ); + } + else if ( &aSession == backup ) + //update accepted => close backup + { + TRAP( error, UpdateAcceptedL( *sdpSession ) ); + } + else + //update rejected => rollback + { + TRAP( error, UpdateRejectedL( *sdpSession ) ); + } + + MCEMM_DEBUG("CMceMediaManager::CloseSession(), Exit "); + + return error; + + } + + +// --------------------------------------------------------- +// CMceMediaManager::UpdateAcceptedL +// --------------------------------------------------------- +void CMceMediaManager::UpdateAcceptedL( CMceSdpSession& aSdpSession ) + { + MCEMM_DEBUG("CMceMediaManager::UpdateAcceptedL(), Entry "); + + CMceComSession* session = aSdpSession.MediaSession(); + CMceComSession* backup = aSdpSession.Backup(); + __ASSERT_ALWAYS( session && backup, User::Leave( KErrNotFound ) ); + + if ( !session->IsMerged() ) + //if not merged session + { + MCEMM_DEBUG("CMceMediaManager::UpdateAcceptedL(): \ +session is not merged"); + //stop backup's all send streams. + //No local streams or receive streams + TMceSrvStreamIterator + sendStreams( backup->MccStreams(), + TMceSrvStreamIterator::ESend ); + CMceSrvStream* sendStream = NULL; + while( sendStreams.Next( + sendStream, + CMceSrvStream::EPrepared, + TMceSrvStreamIterator::GreaterOrEqualMatch ) ) + { + MCEMM_DEBUG_DVALUE("CMceMediaManager::UpdateAcceptedL(): \ +Stopping send stream. id", sendStream->Id() ); + StopMccStream( *sendStream ); + } + + //adopt backup's all active receive streams to session + TMceSrvStreamIterator + receiveStreams( backup->MccStreams(), + TMceSrvStreamIterator::EReceive ); + CMceSrvStream* receiveStream = NULL; + TBool canClose = ETrue; + while( receiveStreams.Next( + receiveStream, + CMceSrvStream::EPrepared, + TMceSrvStreamIterator::GreaterOrEqualMatch ) ) + { + if ( receiveStream->Data().IsEnabled() ) + { + MCEMM_DEBUG_DVALUE("CMceMediaManager::UpdateAcceptedL(): \ +adopting receive stream. id", receiveStream->Id() ); + session->AdoptStreamL( *receiveStream ); + canClose = EFalse; + } + else + { + MCEMM_DEBUG_DVALUE("CMceMediaManager::UpdateAcceptedL(): \ +stopping receive stream. Id", receiveStream->Id() ); + StopMccStream( *receiveStream ); + } + } + //if no receive streams were adopted, backup can be closed + if ( canClose ) + { + MCEMM_DEBUG_DVALUE("CMceMediaManager::UpdateAcceptedL(): \ +closing session. Id", backup->iMccID ); + iMccInterface->CloseSession( backup->iMccID ); + } + } + else + { + MCEMM_DEBUG("CMceMediaManager::UpdateAcceptedL(): \ +session is merged"); + CleanupSessionL( *backup ); + session->UnMerge(); + } + + backup->DetachSDPSession(); + aSdpSession.SetBackup( NULL ); + } + + +// --------------------------------------------------------- +// CMceMediaManager::UpdateRejectedL +// --------------------------------------------------------- +void CMceMediaManager::UpdateRejectedL( CMceSdpSession& aSdpSession ) + { + MCEMM_DEBUG("CMceMediaManager::UpdateRejected(), Entry "); + + CMceComSession* session = aSdpSession.MediaSession(); + CMceComSession* backup = aSdpSession.Backup(); + __ASSERT_ALWAYS( session && backup, User::Leave( KErrNotFound ) ); + + CleanupSessionL( *session ); + if ( !session->IsMerged() ) + //if not merged session + { + MCEMM_DEBUG_DVALUE("Closing session. Id", session->iMccID ); + iMccInterface->CloseSession( session->iMccID ); + } + else + { + MCEMM_DEBUG_DVALUE("Unmerging session. Id", backup->iMccID ); + backup->UnMergeL( *session ); + } + + session->DetachSDPSession(); + aSdpSession.SetMediaSession( backup ); + aSdpSession.SetBackup( NULL ); + + MCEMM_DEBUG("CMceMediaManager::UpdateRejected(), Exit "); + } + +// --------------------------------------------------------- +// CMceMediaManager::CleanupSessionL +// --------------------------------------------------------- +void CMceMediaManager::CleanupSessionL( CMceComSession& aSession ) + { + MCEMM_DEBUG("CMceMediaManager::CleanupSessionL(), Entry "); + + CMceComSession* session = aSession.SdpSession().MediaSession(); + CMceComSession* backup = aSession.SdpSession().Backup(); + + //close all started unmerged streams + TMceSrvStreamIterator streams( aSession.MccStreams() ); + CMceSrvStream* stream= NULL; + while( streams.Next( + stream, + CMceSrvStream::EPrepared, + TMceSrvStreamIterator::GreaterOrEqualMatch ) ) + { + if ( !stream->IsMerged() )//added or removed + { + MCEMM_DEBUG_DVALUE("CMceMediaManager::CleanupSessionL(): \ +stopping unmerged stream. Id", stream->Id() ); + StopMccStream( *stream ); + } + } + + //close all adopted streams + TUint32 sessionId = KMceNotAssigned; + TMceSrvStreamIterator adopts( aSession.AdoptedMccStreams() ); + CMceSrvStream* adopted = NULL; + while( adopts.Next( adopted ) ) + { + if ( backup && &aSession == backup ) + { + MCEMM_DEBUG_DVALUE("CMceMediaManager::CleanupSessionL(): \ +re-adopting adopted stream. Id", adopted->Id() ); + adopted = aSession.RemoveAdoptedStream( *adopted ); + CleanupStack::PushL( adopted ); + session->AdoptedMccStreams().AppendL( adopted ); + CleanupStack::Pop( adopted ); + } + else + { + MCEMM_DEBUG_DVALUE("CMceMediaManager::CleanupSessionL(): \ +stopping adopted stream. Id", adopted->Id() ); + sessionId = adopted->SessionId(); + StopMccStream( *adopted ); + } + + if ( sessionId != KMceNotAssigned ) + { + MCEMM_DEBUG_DVALUE("CMceMediaManager::CleanupSessionL(): \ +closing session. Id", sessionId ); + iMccInterface->CloseSession( sessionId ); + } + } + + MCEMM_DEBUG("CMceMediaManager::CleanupSessionL(), Exit "); + } + + +// --------------------------------------------------------- +// CMceMediaManager::RemoveSession +// --------------------------------------------------------- +// +void CMceMediaManager::RemoveSession( CMceSdpSession* aSdpSession ) + + { + MCEMM_DEBUG("CMceMediaManager::RemoveSession(), Entry "); + + TUint32 sessionId = aSdpSession->MediaSession()->iMccID; + TBool isMaster = aSdpSession->IsMaster(); + CMceSdpSession* sdpSession = NULL; + CMceSdpSession::TIterator sdpSessions( iMceSdpSessions ); + TBool loop = ETrue; + + // remove all sessions, which does not have media session + while( loop && sdpSessions.Next( sdpSession ) ) + { + if ( sdpSession == aSdpSession || + !sdpSession->MediaSession() || + sdpSession->Consumes( sessionId ) ) + + { + if ( isMaster || sdpSession == aSdpSession ) + { + sdpSessions.Remove(); + delete sdpSession; + MCEMM_DEBUG("SDP session removed"); + } + loop = isMaster; + } + } + + MCEMM_DEBUG("CMceMediaManager::RemoveSession(), Exit "); + } + + + +// --------------------------------------------------------- +// CMceMediaManager::UseRtcp +// --------------------------------------------------------- +// +TBool CMceMediaManager::UseRtcp( CMceSrvStream& aStream ) + { + MCEMM_DEBUG("CMceMediaManager::UseRtcp(), Entry ") + + TBool useRtcp( ETrue ); + TMceSrvStreamIterator streams( aStream.Data().Session()->MccStreams() ); + CMceSrvStream* stream = NULL; + while( streams.Next( stream ) && useRtcp ) + { + if ( aStream.LinkId() == stream->LinkId() ) + { + useRtcp = useRtcp && aStream.Data().Session()->UseRtcp(); + } + } + + MCEMM_DEBUG_DVALUE( "CMceMediaManager::UseRtcp() stream id:", aStream.Id() ) + MCEMM_DEBUG_DVALUE( "CMceMediaManager::UseRtcp() use rtcp:", useRtcp ) + + return useRtcp; + } + +// --------------------------------------------------------- +// CMceMediaManager::FillMceFileInfoL +// --------------------------------------------------------- +// +void CMceMediaManager::FillMceFileInfoL( + TMccFileSourceSetting& aMccFileInfo, + TMceFileInfo& aMceFileInfo ) const + { + CMccCodecInformationFactory* codecFactory = + CMccCodecInformationFactory::NewL(); + CleanupStack::PushL( codecFactory ); + + aMceFileInfo.iAudioCodec = KNullDesC8; + aMceFileInfo.iAudioElementCount = 0; + + if ( aMccFileInfo.iAudioFourCC != KMMFFourCCCodeNULL ) + { + // File might contain unsupported audio, ignore leave + CMccCodecInformation* codec = NULL; + TRAP_IGNORE( + (codec = codecFactory->CreateCodecInformationL( aMccFileInfo.iAudioFourCC ) )) + if ( codec ) + { + aMceFileInfo.iAudioCodec = codec->SdpName(); + aMceFileInfo.iAudioBitRate = aMccFileInfo.iAudioBitRate; + } + + delete codec; + aMceFileInfo.iAudioElementCount = 1; + } + + aMceFileInfo.iVideoCodec = KNullDesC8; + aMceFileInfo.iVideoElementCount = 0; + + if ( aMccFileInfo.iVideoFourCC != KMMFFourCCCodeNULL ) + { + // File might contain unsupported video, ignore leave + CMccCodecInformation* codec = NULL; + TRAP_IGNORE( + (codec = codecFactory->CreateCodecInformationL( aMccFileInfo.iVideoFourCC ) )) + if ( codec ) + { + aMceFileInfo.iVideoCodec = codec->SdpName(); + aMceFileInfo.iVideoFrameRate = aMccFileInfo.iVideoFrameRate; + aMceFileInfo.iVideoBitRate = aMccFileInfo.iVideoBitRate; + aMceFileInfo.iVideoFrameSize = aMccFileInfo.iVideoFrameSize; + } + + delete codec; + aMceFileInfo.iVideoElementCount = 1; + } + + aMceFileInfo.iDuration = aMccFileInfo.iDuration; + + CleanupStack::PopAndDestroy( codecFactory ); + } + +// --------------------------------------------------------- +// CMceMediaManager::DoStartEndpointsL +// --------------------------------------------------------- +// +TBool CMceMediaManager::DoStartEndpointsL( + CMceSrvStream& aStream, + TUint32 aForceEnableEndpoint, + TUint32 aForceDisableEndpoint ) + { + MCEMM_DEBUG("CMceMediaManager::DoStartEndpointsL(), Entry "); + + if ( aForceDisableEndpoint ) + { + // No need to start if explicitly disabling + MCEMM_DEBUG("CMceMediaManager::DoStartEndpointsL(), Exit "); + return EFalse; + } + + TBool sinkForced( aStream.Sink().Id() == aForceEnableEndpoint ); + TBool sourceForced( aStream.Source().Id() == aForceEnableEndpoint ); + + TBool sinkNeedsStart( + aStream.Codec().iIsEnabled && + ( aStream.Sink().State() < CMceSrvStream::EStarted && + aStream.Sink().State() != CMceSrvStream::EStarting ) && + ( aStream.Sink().Data().IsEnabled( KMceEnabledE2e ) || + sinkForced ) && + ( aStream.Sink().State() == CMceSrvStream::EPrepared || + aStream.Sink().State() == CMceSrvStream::EPending ) ); + + TBool sourceNeedsStart( + aStream.Codec().iIsEnabled && + ( aStream.Source().State() < CMceSrvStream::EStarted && + aStream.Source().State() != CMceSrvStream::EStarting ) && + ( aStream.Source().Data().IsEnabled( KMceEnabledE2e ) || + sourceForced ) && + ( aStream.Source().State() == CMceSrvStream::EPrepared || + aStream.Source().State() == CMceSrvStream::EPending ) ); + + MCEMM_DEBUG_DVALUE(" forced (0 means no) endpoint ", aForceEnableEndpoint ); + MCEMM_DEBUG_DVALUE(" start sink", sinkNeedsStart ); + MCEMM_DEBUG_DVALUE(" start source", sourceNeedsStart ); + + TBool startNeeded( sinkNeedsStart || sourceNeedsStart ); + TUint32 startEndpointId = 0; + + // Resolve resumed endpoints + // + if ( sinkNeedsStart ^ sourceNeedsStart ) + { + startEndpointId = sinkNeedsStart ? aStream.Sink().Id() : + aStream.Source().Id(); + } + + if ( startNeeded ) + { + MCEMM_DEBUG_DVALUE("starting (0 means all) endpoint(s) ", startEndpointId ); + User::LeaveIfError( + iMccInterface->StartStream( + aStream.SessionId(), + aStream.LinkId(), + aStream.Id(), + startEndpointId, + EFalse, + UseRtcp( aStream ) ) ); + + SetPendingState( aStream, startEndpointId, CMceSrvStream::EStarting ); + } + else + { + MCEMM_DEBUG("no need to start"); + } + + aStream.UpdateEndpointStates( sinkForced, sourceForced, ETrue ); + + MCEMM_DEBUG("CMceMediaManager::DoStartEndpointsL(), Exit "); + + return startNeeded; + } + +// --------------------------------------------------------- +// CMceMediaManager::DoResumeEndpointsL +// --------------------------------------------------------- +// +TBool CMceMediaManager::DoResumeEndpointsL( + CMceSrvStream& aStream, + TUint32 aForceEnableEndpoint ) + { + MCEMM_DEBUG("CMceMediaManager::DoResumeEndpointsL(), Entry "); + + TBool sinkForced( aStream.Sink().Id() == aForceEnableEndpoint ); + TBool sourceForced( aStream.Source().Id() == aForceEnableEndpoint ); + + // Do not allow resuming streams which have disabled codec + // + TBool sinkNeedsResume( + aStream.Codec().iIsEnabled && + ( aStream.Sink().Data().IsEnabled( KMceEnabledE2e ) || sinkForced ) && + ( aStream.Sink().State() == CMceSrvStream::EPaused || + aStream.Sink().State() == CMceSrvStream::EPausing ) ); + + TBool sourceNeedsResume( + aStream.Codec().iIsEnabled && + ( aStream.Source().Data().IsEnabled( KMceEnabledE2e ) || sourceForced ) && + ( aStream.Source().State() == CMceSrvStream::EPaused || + aStream.Source().State() == CMceSrvStream::EPausing ) ); + + MCEMM_DEBUG_DVALUE(" forced (0 means no) endpoint ", aForceEnableEndpoint ); + MCEMM_DEBUG_DVALUE(" resume sink", sinkNeedsResume ); + MCEMM_DEBUG_DVALUE(" resume source", sourceNeedsResume ); + + TBool resumeNeeded( sinkNeedsResume || sourceNeedsResume ); + TUint32 resumeEndpointId = 0; + + // Resolve resumed endpoints + // + if ( sinkNeedsResume ^ sourceNeedsResume ) + { + resumeEndpointId = sinkNeedsResume ? aStream.Sink().Id() : + aStream.Source().Id(); + } + + if ( resumeNeeded ) + { + MCEMM_DEBUG_DVALUE("resuming (0 means all) endpoint(s) ", resumeEndpointId ); + User::LeaveIfError( + iMccInterface->ResumeStream( + aStream.SessionId(), + aStream.LinkId(), + aStream.Id(), + resumeEndpointId, + UseRtcp( aStream ) ) ); + + SetPendingState( aStream, resumeEndpointId, CMceSrvStream::EStarting ); + } + else + { + MCEMM_DEBUG("no need to resume"); + } + + aStream.UpdateEndpointStates( sinkForced, sourceForced, ETrue ); + + MCEMM_DEBUG("CMceMediaManager::DoResumeEndpointsL(), Exit "); + + return resumeNeeded; + } + +// --------------------------------------------------------- +// CMceMediaManager::DoPauseEndpointsL +// --------------------------------------------------------- +// +TBool CMceMediaManager::DoPauseEndpointsL( + CMceSrvStream& aStream, + TUint32 aForceDisableEndpoint ) + { + MCEMM_DEBUG("CMceMediaManager::DoPauseEndpointsL(), Entry "); + + TBool sinkForced( aStream.Sink().Id() == aForceDisableEndpoint ); + TBool sourceForced( aStream.Source().Id() == aForceDisableEndpoint ); + + // Do not allow streams with disabled codec to run + // + TBool sinkNeedsPause( + ( !aStream.Codec().iIsEnabled || + !aStream.Sink().Data().IsEnabled( KMceEnabledE2e ) || + sinkForced ) && + ( aStream.Sink().State() == CMceSrvStream::EStarted || + aStream.Sink().State() == CMceSrvStream::EStarting ) ); + + TBool sourceNeedsPause( + ( !aStream.Codec().iIsEnabled || + !aStream.Source().Data().IsEnabled( KMceEnabledE2e ) || + sourceForced ) && + ( aStream.Source().State() == CMceSrvStream::EStarted || + aStream.Source().State() == CMceSrvStream::EStarting ) ); + + MCEMM_DEBUG_DVALUE(" forced (0 means no) endpoint ", aForceDisableEndpoint ); + MCEMM_DEBUG_DVALUE(" pause sink", sinkNeedsPause ); + MCEMM_DEBUG_DVALUE(" pasue source", sourceNeedsPause ); + + TBool pauseNeeded( sinkNeedsPause || sourceNeedsPause ); + TUint32 pauseEndpointId = 0; + + // Resolve paused endpoints + // + if ( sinkNeedsPause ^ sourceNeedsPause ) + { + pauseEndpointId = sinkNeedsPause ? aStream.Sink().Id() : + aStream.Source().Id(); + } + + if ( pauseNeeded ) + { + MCEMM_DEBUG_DVALUE("pausing (0 means all) endpoint(s) ", pauseEndpointId ); + User::LeaveIfError( + iMccInterface->PauseStream( + aStream.SessionId(), + aStream.LinkId(), + aStream.Id(), + pauseEndpointId, + UseRtcp( aStream ) ) ); + + SetPendingState( aStream, pauseEndpointId, CMceSrvStream::EPausing ); + } + else + { + MCEMM_DEBUG("no need to pause"); + } + + aStream.UpdateEndpointStates( sinkForced, sourceForced, EFalse ); + + MCEMM_DEBUG("CMceMediaManager::DoPauseEndpointsL(), Exit "); + + return pauseNeeded; + } + +// --------------------------------------------------------- +// CMceMediaManager::SetPendingState +// --------------------------------------------------------- +// +void CMceMediaManager::SetPendingState( + CMceSrvStream& aStream, + TUint32 aEndpointId, + CMceSrvStream::TState aState ) + { + if ( aEndpointId == 0 || aStream.Source().Id() == aEndpointId ) + { + aStream.Source().SetState( aState ); + } + + if ( aEndpointId == 0 || aStream.Sink().Id() == aEndpointId ) + { + aStream.Sink().SetState( aState ); + } + } + +// --------------------------------------------------------- +// CMceMediaManager::DoDtmfL +// --------------------------------------------------------- +// +TBool CMceMediaManager::DoDtmfL( + CMceComMediaSource& aSource, + TMceComEvent& aEvent, + const TDesC8& aSequence, + TBool aUseBoundStream ) + { + CMceComSession* session = aSource.MediaStream()->Session(); + __ASSERT_ALWAYS( session, User::Leave( KErrNotReady ) ); + + CMceComMediaStream* comStream = aSource.MediaStream(); + if ( aUseBoundStream ) + { + comStream = &( comStream->BoundStreamL() ); + __ASSERT_ALWAYS( comStream, User::Leave( KErrNotSupported ) ); + } + // Sending dtmf signals is only possible through dtmf uplink + TBool handled( EFalse ); + if ( IS_RECEIVESTREAM( comStream ) ) + { + return handled; + } + + TMceSrvStreamIterator streams( session->MccStreams(), *comStream ); + CMceSrvStream* stream = NULL; + + + while( streams.Next( stream ) && !handled ) + { + if ( stream->MccStreamType() == KMccDtmfStream ) + { + stream->DtmfHandlerL( *iMccInterface ).DtmfL( aSource, + aEvent, + aSequence ); + handled = ETrue; + } + } + + return handled; + } + +// --------------------------------------------------------- +// CMceMediaManager::DoAdjustMccStreamL +// --------------------------------------------------------- +// +CMceComCodec* CMceMediaManager::DoAdjustMccStreamL( CMceSrvStream& aStream ) + { + MCEMM_DEBUG("CMceMediaManager::DoAdjustMccStreamL(), Entry ") + + __ASSERT_ALWAYS( aStream.State() != CMceSrvStream::EAdopted, + User::Leave( KErrArgument ) ); + __ASSERT_ALWAYS( aStream.State() >= CMceSrvStream::EPrepared, + User::Leave( KErrArgument ) ); + + //get codec + CMccCodecInformation* codec = + iMccInterface->CodecL( + aStream.SessionId(), + aStream.LinkId(), + aStream.Id() ); + + CleanupStack::PushL( codec ); + + //adjust codec + CMceComCodec* bidirectional = + aStream.Codec().MccValidateL( *codec, aStream, EMceRoleOfferer ); + aStream.Codec().MccAdjustL( *codec, aStream ); + + User::LeaveIfError( + iMccInterface->SetCodec( + aStream.SessionId(), + aStream.LinkId(), + aStream.Id(), + *codec ) ); + + CleanupStack::PopAndDestroy( codec ); + + MCEMM_DEBUG("CMceMediaManager::DoAdjustMccStreamL(), Exit ") + + return bidirectional; + } + +// --------------------------------------------------------- +// CMceMediaManager::DoConfigKeyUpdateL +// --------------------------------------------------------- +// +void CMceMediaManager::DoConfigKeyUpdateL( + CMceComMediaStream& aStream, + HBufC8* aConfigKey ) + { + MCEMM_DEBUG("CMceMediaManager::DoConfigKeyUpdateL(), Entry "); + + __ASSERT_ALWAYS( aStream.iType == KMceVideo, User::Leave( KErrArgument ) ); + __ASSERT_ALWAYS( aConfigKey, User::Leave( KErrArgument ) ); + + RPointerArray& sinks = aStream.Sinks(); + for ( TInt i = 0; i < sinks.Count(); i++ ) + { + TMceSrvStreamIterator streams( + aStream.Session()->MccStreams(), aStream ); + CMceSrvStream* stream = NULL; + while( streams.Next( stream ) ) + { + CMceComVideoCodec& videoCodec = + reinterpret_cast( stream->Codec() ); + + MCEMM_DEBUG_STREAM( "updating config key", *stream ); + + if ( videoCodec.SetConfigKeyL( aConfigKey ) ) + { + // Synchronize codec only + SynchronizeMccStreamL( *stream, + aStream.Session()->NegotiationState().Role(), + ETrue ); + } + } + } + + MCEMM_DEBUG("CMceMediaManager::DoConfigKeyUpdateL(), Exit "); + } + +// End of File