multimediacommscontroller/mmccsubcontroller/src/mccrtpmanager.cpp
changeset 0 1bce908db942
child 18 817c922b90eb
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/multimediacommscontroller/mmccsubcontroller/src/mccrtpmanager.cpp	Tue Feb 02 01:04:58 2010 +0200
@@ -0,0 +1,745 @@
+/*
+* Copyright (c) 2004-2007 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:    RTP Manager
+*
+*/
+
+
+
+
+// INCLUDE FILES
+#include <srtpsession.h>
+#include "mccrtpmanager.h"
+#include "mccinternalcodecs.h"
+#include "mccrtpdatasink.h"
+#include "mccrtpdatasource.h"
+#include "mmccevents.h"
+#include "mccsubcontrollerlogs.h"
+#include "mccrtcpreceiver.h"
+#include "mccrtpkeepalivecontainer.h"
+#include "mccresources.h"
+#include "mccqoshandler.h"
+#include "mccinternaldef.h"
+
+// LOCAL CONSTANTS AND MACROS
+
+// Default IP type-of-service value.
+const TInt KDefaultIpTOS = 184;
+
+// ============================= LOCAL FUNCTIONS ===============================
+
+// ============================ MEMBER FUNCTIONS ===============================
+
+// -----------------------------------------------------------------------------
+// CMccRtpManager::CMccRtpManager
+// C++ default constructor can NOT contain any code, that
+// might leave.
+// -----------------------------------------------------------------------------
+//
+CMccRtpManager::CMccRtpManager( 
+    MAsyncEventHandler& aHandler, 
+    MMccResources& aMccResources,
+    TUint32 aMccSessionId ) : 
+    iRtpSessionId( KNullId ), 
+    iStreamArray( RArray<TRtpId>() ), 
+    iEventHandler( aHandler ),
+    iMccResources( aMccResources ),
+    iIpTOS( KDefaultIpTOS ), 
+    iLocalPort( KDefaultRtpPort ),
+    iMccSessionId( aMccSessionId ),
+    iDummyRcvStreamId( KNullId )
+    {
+
+    }
+
+// -----------------------------------------------------------------------------
+// CMccRtpManager::ConstructL
+// Symbian 2nd phase constructor can leave.
+// -----------------------------------------------------------------------------
+//
+void CMccRtpManager::ConstructL()
+    {
+    __SUBCONTROLLER( "CMccRtpManager::ConstructL" )
+
+    iRtpApi = CRtpAPI::NewL( *this );
+    iRtcpReceiver = CMccRtcpReceiver::NewL( this, iEventHandler, iMccResources, *iRtpApi );
+    iQosHandler = CMccQosHandler::NewL( *this );
+    
+    __SUBCONTROLLER( "CMccRtpManager::ConstructL exit" )
+    }
+
+// -----------------------------------------------------------------------------
+// CMccRtpManager::NewL
+// Static constructor.
+// -----------------------------------------------------------------------------
+//
+CMccRtpManager* CMccRtpManager::NewL( 
+    MAsyncEventHandler& aHandler,
+    MMccResources& aMccResources,
+    TUint32 aMccSessionId
+    )
+    {
+    CMccRtpManager* self = new (ELeave) CMccRtpManager( aHandler, aMccResources, 
+                                                        aMccSessionId );
+    CleanupStack::PushL( self );      
+    self->ConstructL();           
+    CleanupStack::Pop( self );
+    return self;
+    }
+
+// -----------------------------------------------------------------------------
+// CMccRtpManager::~CMccRtpManager
+// Destructor
+// -----------------------------------------------------------------------------
+//
+CMccRtpManager::~CMccRtpManager()
+    {
+    __SUBCONTROLLER( "CMccRtpManager::~CMccRtpManager" )
+    
+    delete iRtcpReceiver;
+    delete iRtpKeepaliveMechanism;
+    
+    if ( KNullId != iDummyRcvStreamId && iRtpApi )
+        {
+        iRtpApi->CloseStream( iDummyRcvStreamId );
+        }
+            
+    if( KNullId != iRtpSessionId && iRtpApi )
+        {
+        iRtpApi->CloseSession( iRtpSessionId );
+        iRtpApi->Close();
+        }
+    
+    delete iSecSession;
+    delete iRtpApi;
+    delete iQosHandler;
+    
+    iStreamArray.Close();
+    
+    delete iCName;
+    __SUBCONTROLLER( "CMccRtpManager::~CMccRtpManager, exit" )
+    }
+
+// -----------------------------------------------------------------------------
+// CMccRtpManager::CreateSessionL
+// Creates RTP session and adds session to SessionArray
+// -----------------------------------------------------------------------------
+//
+void CMccRtpManager::CreateSessionL( 
+    TUint& aPort, 
+    TBool aEnableRTCP,
+    TBool aSecurity, 
+    TBool aIncreaseDefaultSocketSize )
+    {
+    __SUBCONTROLLER( "CMccRtpManager::CreateSessionL" )
+    
+    if( KNullId != iRtpSessionId )
+        {
+        User::Leave( KErrAlreadyExists );
+        }
+
+    TCreateSessionParams params;    
+    params.iPriority = TCreateSessionParams::EPriorityStandard;    
+    aEnableRTCP = ETrue;
+    
+    if ( aIncreaseDefaultSocketSize )
+        {
+        params.iSocketBufSize = KMccIncreasedRtpSocketSize;
+        }
+    __SUBCONTROLLER_INT1( "CMccRtpManager::CreateSessionL, socket size:", 
+                          params.iSocketBufSize )
+    
+    TInetAddr localAddress = iRtpApi->GetLocalIPAddressL();
+    
+    if ( aSecurity )
+        {
+        iSecSession = CSRTPSession::NewL( localAddress );
+        iRtpSessionId = iRtpApi->CreateSessionL( params, aPort, aEnableRTCP,
+                                                 NULL, *iSecSession );
+        }
+    else
+        {
+        iRtpSessionId = iRtpApi->CreateSessionL( params, aPort, aEnableRTCP, NULL );
+        }
+        
+    if( KNullId == iRtpSessionId )
+        {
+        User::Leave( KErrCouldNotConnect );
+        }
+    
+    __ASSERT_ALWAYS( !iRtpKeepaliveMechanism, User::Leave( KErrAlreadyExists ) );     
+    iRtpKeepaliveMechanism = 
+        CMccRtpKeepaliveContainer::NewL( iEventHandler, 
+                                         *iRtpApi, 
+                                         iRtpSessionId );
+    
+    iLocalPort = aPort;
+    iRtcpEnabled = aEnableRTCP;
+    
+    __SUBCONTROLLER( "CMccRtpManager::CreateSessionL, keepalive initialized" )
+    
+    iRtcpReceiver->HandleReceiving( iRtpSessionId, iRtcpEnabled );
+    
+    __SUBCONTROLLER( "CMccRtpManager::CreateSessionL, exit" )
+    }
+
+// -----------------------------------------------------------------------------
+// CMccRtpManager::CloseSession
+// Closes RTP session
+// -----------------------------------------------------------------------------
+//
+void CMccRtpManager::CloseSession()
+    {
+    __SUBCONTROLLER( "CMccRtpManager::CloseSession" )
+    if ( KNullId != iRtpSessionId ) 
+        {
+        if ( iRtpKeepaliveMechanism )
+            {
+            iRtpKeepaliveMechanism->StopAll();
+            }
+        
+        iRtpApi->CloseSession( iRtpSessionId );
+        iRtpApi->Close();
+        iStreamArray.Reset();
+        
+        iRtpSessionId = KNullId;
+        
+        if ( iQosHandler->QoSEnabled() )
+            {
+            iQosHandler->DisableQoS();
+            }
+        }
+    __SUBCONTROLLER( "CMccRtpManager::CloseSession, exit" )
+    }
+
+// -----------------------------------------------------------------------------
+// CMccRtpManager::GetRtpReference
+// Returns RTPApi reference
+// -----------------------------------------------------------------------------
+//
+CRtpAPI* CMccRtpManager::GetRtpReferenceL( )
+    {
+    if ( !IsOpen() ) 
+        {
+        User::Leave( KErrNotFound );
+        }
+    return iRtpApi;
+    }
+
+// -----------------------------------------------------------------------------
+// CMccRtpManager::SetRemoteAddress
+// Sets RTP Remote Address
+// -----------------------------------------------------------------------------
+//
+TInt CMccRtpManager::SetRemoteAddress( const TInetAddr& aRemoteAddress )
+    {
+    __SUBCONTROLLER( "CMccRtpManager::SetRemoteAddress" )
+    TInt err( KErrNotFound );
+    if ( KNullId != iRtpSessionId ) 
+        {   
+        // Do only if address has changed
+        err =( iRemoteAddress.Address() == aRemoteAddress.Address() && 
+               iRemoteAddress.Port() == aRemoteAddress.Port() ) ? KErrNone : err;
+        if ( err )
+            { 
+            __SUBCONTROLLER_INT1( "CMccRtpManager::SetRemoteAddress, setting addr:", 
+                                  aRemoteAddress.Address() )
+            __SUBCONTROLLER_INT1( "CMccRtpManager::SetRemoteAddress, setting port:", 
+                                  aRemoteAddress.Port() )
+            
+            err = iRtpApi->SetRemoteAddress( iRtpSessionId, aRemoteAddress );
+            if ( !err )
+                {
+                iRemoteAddress.SetAddress( aRemoteAddress.Address() );
+                iRemoteAddress.SetPort( aRemoteAddress.Port() );
+                if ( iRtpKeepaliveMechanism )
+                    {
+                    err = iRtpKeepaliveMechanism->RemoteAddressSet();
+                    }
+                }
+            }
+        }
+    __SUBCONTROLLER_INT1( "CMccRtpManager::SetRemoteAddress, exit with err", err )
+    return err;
+    }
+
+// -----------------------------------------------------------------------------
+// CMccRtpManager::SetRemoteRtcpAddress
+// Sets RTP Remote Address
+// -----------------------------------------------------------------------------
+//
+TInt CMccRtpManager::SetRemoteRtcpAddr( const TInetAddr& aRemoteAddress )
+    {
+    __SUBCONTROLLER( "CMccRtpManager::SetRemoteRtcpAddress" )
+    TInt err( KErrNotFound );
+    if ( KNullId != iRtpSessionId ) 
+        {   
+        // Do only if address has changed
+        err =( iRemoteRtcpAddr.Address() == aRemoteAddress.Address() && 
+               iRemoteRtcpAddr.Port() == aRemoteAddress.Port() ) ? KErrNone : err;
+        __SUBCONTROLLER_INT1( "Remote RtcpPort", aRemoteAddress.Port() )
+        __SUBCONTROLLER_INT1( "Saved Remote RtcpPort", iRemoteAddress.Port() )
+        if ( err )
+            { 
+            __SUBCONTROLLER_INT1( "CMccRtpManager::SetRemoteAddress, setting addr:", 
+                                  aRemoteAddress.Address() )
+            __SUBCONTROLLER_INT1( "CMccRtpManager::SetRemoteAddress, setting port:", 
+                                  aRemoteAddress.Port() )
+            
+            err = iRtpApi->SetRemoteRtcpAddress( iRtpSessionId, aRemoteAddress );
+            if ( !err )
+                {
+                iRemoteRtcpAddr.SetAddress( aRemoteAddress.Address() );
+                iRemoteRtcpAddr.SetPort( aRemoteAddress.Port() );
+                __SUBCONTROLLER_INT1( "Remote RtcpPort", aRemoteAddress.Port() )
+                }
+            }
+        }
+    __SUBCONTROLLER_INT1( "CMccRtpManager::SetRemoteAddress, exit with err", err )
+    return err;
+    }
+// -----------------------------------------------------------------------------
+// CMccRtpManager::SetIpTOS
+// Sets TOS flag, must be called before StartSession
+// -----------------------------------------------------------------------------
+//
+void CMccRtpManager::SetIpTOS( TInt aIpTOS ) 
+    {
+    iIpTOS = aIpTOS;
+    }
+
+// -----------------------------------------------------------------------------
+// CMccRtpManager::StartSession
+// Starts RTP session
+// -----------------------------------------------------------------------------
+//
+void CMccRtpManager::StartSessionL()
+    {
+    __SUBCONTROLLER( "CMccRtpManager::StartSessionL" )
+    if ( KNullId != iRtpSessionId ) 
+        {
+        __SUBCONTROLLER( "CMccRtpManager::StartSessionL, session exists" )
+        
+		RSocket* socketPtr = iRtpApi->GetRtpSocket( iRtpSessionId );
+		
+		if( !socketPtr )
+		    {
+		    __SUBCONTROLLER( "CMccRtpManager::StartSessionL, no socket!" )
+            #ifdef TEST_EUNIT            
+            // The stub for RTP API returns a NULL socket pointer. Just pretend
+            // everything is fine.
+            return;            
+            #else
+		    User::Leave( KErrNotReady );
+            #endif
+		    }
+		else
+		    {
+            User::LeaveIfError( iRtpApi->StartSession( iRtpSessionId ) );      
+            
+            __SUBCONTROLLER_INT1( "CMccRtpManager::StartSessionL, iptos:", iIpTOS )
+             
+            User::LeaveIfError( socketPtr->SetOpt( KSoIpTOS, KSolInetIp, iIpTOS ) );
+            User::LeaveIfError( socketPtr->SetOpt( KSoUdpReceiveICMPError, KSolInetUdp, 1 ) );
+            
+            if ( !iQosHandler->QoSEnabled() )
+                {
+                // These has to be set before enabling QoS
+                iQosHandler->SetSubConnectionParams( iConnection,
+                                             iSocketServ,
+                                             *socketPtr );
+                                                
+                // If we cannot enable QoS for some reason, we should not
+                // consider it as a fatal error. If error happens, then
+                // disable qos. This will clean up some unneeded resources.
+                // Also this leads to retries when streams are created.
+                TRAPD( err, iQosHandler->EnableQosL() );
+                if ( KErrNone != err )
+                    {
+                    __SUBCONTROLLER_INT1( "CMccRtpManager::StartSessionL QOS:", err )
+            
+                    iQosHandler->DisableQoS();
+                    }
+                }
+		    }
+        }
+    else
+        {
+        User::Leave( KErrNotFound );
+        }
+    
+    __SUBCONTROLLER( "CMccRtpManager::StartSessionL, exit" ) 
+    }
+
+// -----------------------------------------------------------------------------
+// CMccRtpManager::Initialize
+// Opens RTPApi and starts connection
+// -----------------------------------------------------------------------------
+//
+void CMccRtpManager::InitializeL( TRequestStatus& aStatus, TInt aIapId )
+    {
+    TInt err = iRtpApi->OpenL( iRtpSdes, NULL, &iSocketServ, &iConnection );
+    if ( KErrNone == err ) 
+        {
+        User::LeaveIfError( iRtpApi->StartConnection( aStatus, aIapId ) );
+        }
+    else
+        {
+        User::Leave( err );
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CMccRtpManager::CheckStreamExists
+// Checks that stream exists
+// -----------------------------------------------------------------------------
+//
+TBool CMccRtpManager::CheckStreamExists( const TRtpId& aStreamId ) const
+    {
+    TInt index = iStreamArray.Find( aStreamId );
+    
+    if( KErrNotFound == index )
+        {
+        return EFalse;
+        }
+    else
+        {
+        return ETrue;
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CMccRtpManager::IsOpen
+// Checks that RTPApi is opened
+// -----------------------------------------------------------------------------
+//
+TBool CMccRtpManager::IsOpen() const
+    {
+    if ( iRtpApi->GetRtpSocket( iRtpSessionId ) ) 
+        {
+        return ETrue;
+        }
+    else 
+        {
+        return EFalse;
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CMccRtpManager::RemoveStreamFromArray
+// Removes RTP stream from stream array
+// -----------------------------------------------------------------------------
+//
+void CMccRtpManager::RemoveStreamFromArray( const TRtpId& aStreamId )
+    {
+    const TInt index( iStreamArray.Find( aStreamId ) );
+    if( KErrNotFound != index )
+        {
+        iStreamArray.Remove( index );
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CMccRtpManager::SessionId
+// Returns the Session ID for this object
+// -----------------------------------------------------------------------------
+//
+TRtpId CMccRtpManager::SessionId() const
+    {
+    return iRtpSessionId;
+    }
+
+// -----------------------------------------------------------------------------
+// CMccRtpManager::ErrorNotify
+// Error callback.
+// -----------------------------------------------------------------------------
+//
+void CMccRtpManager::ErrorNotify( TInt aErrCode )
+    {
+    if ( KErrNone != aErrCode )
+        {
+        __SUBCONTROLLER_INT1( "CMccRtpManager::ErrorNotify, error", aErrCode )
+        
+        // Report all errors coming from here as rtp category stream errors
+        // In HW when remote end drops from network, this function will be
+        // called with KErrHostUnreach (-191) and in some cases this will return
+        // as KErrGeneral with DTMF's. KErrCouldNotConnect error is received in
+        // ICMP port unreachable situation. In these cases, handle just the 
+        // KErrHostUnreach and KErrCouldNotConnect.
+        if ( KErrHostUnreach == aErrCode || KErrCouldNotConnect == aErrCode )
+            {
+            TMccEvent event;
+            event.iErrorCode = KErrHostUnreach;
+            event.iEventCategory = KMccEventCategoryRtp;
+            event.iEventType = KMccStreamError;
+            
+            // Use whatever internal uid
+            TMccInternalEvent internalEvent( KMccRtpSourceUid, 
+                                     EMccInternalEventNone,
+                                     event );
+            
+            iEventHandler.SendEventToClient( internalEvent );
+            }
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CMccRtpManager::CreateTransmitStreamL
+// Creates a new transmit stream based on given parameters
+// -----------------------------------------------------------------------------
+//
+TUint32 CMccRtpManager::CreateTransmitStreamL( MDataSink& aSink, 
+    const TMccCodecInfo& aCodecInfo )
+    {
+    TUint32 streamId( 0 );
+
+    if( aCodecInfo.iPayloadType < KMccPayloadTypeMax )
+        {
+        CMccRtpDataSink& dSink = static_cast<CMccRtpDataSink&>( aSink );
+        TMccRtpSessionParams sessParams( iRtpApi, 
+                                         iRtpSessionId, 
+                                         iRtcpEnabled, 
+                                         iRtpKeepaliveMechanism,
+                                         iSecSession );
+        
+        dSink.SetSessionParamsL( sessParams );
+        
+        TMccCodecInfoBuffer infoBuffer( aCodecInfo );
+        dSink.ConfigureL( infoBuffer );
+        
+        UpdateL( &aCodecInfo );
+        }
+    else
+        {
+        User::Leave( KErrArgument );
+        }
+    return streamId;
+    }
+
+// -----------------------------------------------------------------------------
+// CMccRtpManager::CreateReceiveStreamL
+// Creates a new receive stream based on given parameters
+// -----------------------------------------------------------------------------
+//
+TUint32 CMccRtpManager::CreateReceiveStreamL( MDataSource& aSource, 
+    const TMccCodecInfo& aCodecInfo )
+    {
+    TUint32 streamId( 0 );
+
+    if( aCodecInfo.iPayloadType < KMccPayloadTypeMax )
+        {
+        CMccRtpDataSource& dSource = static_cast<CMccRtpDataSource&>( aSource );
+        TMccRtpSessionParams sessParams( iRtpApi, 
+                                         iRtpSessionId, 
+                                         iRtcpEnabled,
+                                         iRtpKeepaliveMechanism,
+                                         iSecSession );
+        
+        dSource.SetSessionParamsL( sessParams );
+        
+        TMccCodecInfoBuffer infoBuffer( aCodecInfo );
+        dSource.ConfigureL( infoBuffer );
+        
+        UpdateL( &aCodecInfo );
+        }
+    else
+        {
+        User::Leave( KErrArgument );
+        }
+
+    return streamId;
+    }
+
+// -----------------------------------------------------------------------------
+// CMccRtpManager::SetRTCPSendReceive
+// Enables/disables automatic transmission and receiving of RTCP packets
+// in a session.
+// -----------------------------------------------------------------------------
+//
+TInt CMccRtpManager::SetRTCPSendReceive( TBool aEnableRtcp )
+    {
+    __SUBCONTROLLER( "CMccRtpManager::SetRTCPSendReceive" )
+    
+    // Check that session exists
+    TInt err( KErrNotFound );
+    if ( iRtpSessionId != KNullId ) 
+        {    
+        __SUBCONTROLLER_INT1( "CMccRtpManager::SetRTCPSendReceive, enable:", aEnableRtcp )
+        
+        iRtcpEnabled = aEnableRtcp;
+        
+        err = iRtcpReceiver->HandleReceiving( iRtpSessionId, iRtcpEnabled );
+        if ( !err )
+            {
+            __SUBCONTROLLER( "CMccRtpManager::SetRTCPSendReceive, calling rtp api" )
+            err = iRtpApi->SuspendRtcpSending( iRtpSessionId, aEnableRtcp );
+            }
+        }
+    return err;
+    }
+
+// -----------------------------------------------------------------------------
+// CMccRtpManager::SetLinkId
+// -----------------------------------------------------------------------------
+//
+void CMccRtpManager::SetLinkId( TUint32 aLinkId )
+    {
+    iLinkId = aLinkId;
+    }
+    
+// -----------------------------------------------------------------------------
+// CMccRtpManager::UpdateL
+// Creates dummy receive stream if rtp session does not have any receive
+// stream (RTP source) or removes the dummy receive stream if RTP source
+// exists.
+// -----------------------------------------------------------------------------
+//    
+void CMccRtpManager::UpdateL( const TMccCodecInfo* aCodecInfo )
+    {
+    __SUBCONTROLLER( "CMccRtpManager::UpdateL" )
+    
+    MDataSource* source = 0;
+    MDataSink* sink = 0;
+    TInt err = 
+        iMccResources.FindResource( iLinkId, 0, KMccRtpSourceUid, &source, &sink );
+        
+    if ( !err && source )
+        {
+        if ( iDummyRcvStreamId != KNullId )
+            {
+            __SUBCONTROLLER( "CMccRtpManager::UpdateL, dummy rcv stream not needed" )
+            
+            iRtpApi->CloseStream( iDummyRcvStreamId );
+            iDummyRcvStreamId = KNullId;
+            }
+        }
+    else
+        {
+        if ( iDummyRcvStreamId == KNullId && aCodecInfo )
+            {
+            __SUBCONTROLLER( "CMccRtpManager::UpdateL, dummy rcv stream needed" )
+            
+            TRcvStreamParams rcvParams;
+            rcvParams.iPayloadType = aCodecInfo->iPayloadType;
+            iDummyRcvStreamId = iRtpApi->CreateReceiveStreamL( iRtpSessionId, rcvParams );
+            if ( KNullId == iDummyRcvStreamId )
+                {
+                __SUBCONTROLLER( "CMccRtpDataSource::UpdateL, could not create dummy rcv stream" )
+                
+                User::Leave( KErrCouldNotConnect );
+                }
+            }
+        }
+        
+    __SUBCONTROLLER( "CMccRtpManager::UpdateL, exit" )
+    }
+    
+// -----------------------------------------------------------------------------
+// CMccRtpManager::GetLocalIpAddressesL
+// -----------------------------------------------------------------------------
+//
+void CMccRtpManager::GetLocalIpAddressesL( TMccCreateLink& aClientData )
+    {
+    __SUBCONTROLLER( "CMccRtpManager::GetLocalIpAddressesL" )
+    
+    __ASSERT_ALWAYS( KNullId != iRtpSessionId && iRtpApi, User::Leave( KErrNotReady ) );
+    
+    RSocket* rtpSocket( iRtpApi->GetRtpSocket( iRtpSessionId ) );
+    RSocket* rtcpSocket( iRtpApi->GetRtcpSocket( iRtpSessionId ) );
+    TInetAddr localAddr( iRtpApi->GetLocalIPAddressL() );
+    
+    if ( rtpSocket )
+        {
+        if ( KAfInet6 == localAddr.Family() )
+            {
+            aClientData.iLocalAddress.SetAddress( localAddr.Ip6Address() );
+            }
+        else
+            {
+            aClientData.iLocalAddress.SetAddress( localAddr.Address() );
+            }
+        
+        aClientData.iLocalAddress.SetPort( rtpSocket->LocalPort() );
+        }
+    else
+        {
+        User::Leave( KErrGeneral );
+        }
+    
+    if ( iRtcpReceiver && rtcpSocket )
+        {
+        if ( KAfInet6 == localAddr.Family() )
+            {
+            aClientData.iLocalRtcpAddress.SetAddress( localAddr.Ip6Address() );
+            }
+        else
+            {
+            aClientData.iLocalRtcpAddress.SetAddress( localAddr.Address() );
+            }
+        
+        aClientData.iLocalRtcpAddress.SetPort( rtcpSocket->LocalPort() );
+        }
+    
+    __SUBCONTROLLER( "CMccRtpManager::GetLocalIpAddressesL, exit" )
+    }
+
+// -----------------------------------------------------------------------------
+// CMccRtpManager::SetCNameL
+// -----------------------------------------------------------------------------
+//
+void CMccRtpManager::SetCNameL( const TDesC8& aCName )
+    {
+    HBufC8* cname = aCName.AllocLC();
+    delete iCName;
+    iCName = cname;
+    CleanupStack::Pop( cname );
+        
+    iRtpSdes.iCName.Set( *iCName );
+        
+    iRtpApi->SetLocalSdes( iRtpSdes );
+    }
+
+// -----------------------------------------------------------------------------
+// CMccRtpManager::MccSessionId
+// -----------------------------------------------------------------------------
+//
+TUint32 CMccRtpManager::MccSessionId() const
+    {
+    return iMccSessionId;
+    }
+
+// -----------------------------------------------------------------------------
+// CMccRtpManager::QoSParamEvent()
+// From MMccQosEventObserver
+// -----------------------------------------------------------------------------
+//
+void CMccRtpManager::QoSParamEvent( TInt aError, TUint32 /*aEvent*/ )
+    {
+    __SUBCONTROLLER_INT1( "CMccRtpManager::QoSParamEvent aError:", aError )
+    
+    aError = aError;
+    }
+
+// -----------------------------------------------------------------------------
+// CMccRtpManager::QoSConnEvent()
+// From MMccQosEventObserver
+// -----------------------------------------------------------------------------
+//
+void CMccRtpManager::QoSConnEvent( TInt aError, TUint32 /*aEvent*/ )
+    {
+    __SUBCONTROLLER_INT1( "CMccRtpManager::QoSConnEvent aError:", aError )
+    
+    aError = aError;
+    }
+