/*

* Copyright (c) 2002-2003 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 "rtpcomm.h"

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

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

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CRtpComm::CRtpComm()

    {

    }

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

// Symbian 2nd phase constructor can leave.

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

// 

void CRtpComm::ConstructL( TUint& aLocalPort,

                           RSocketServ& aSocketServ,

                           RConnection& aRConn, 

                           const TCreateSessionParams& aParams,

                           MRtpErrNotify& aErrNotify,

                           TBool aEnableRtcp )

    {

    RTP_DEBUG_DETAIL_DVALUE( "CRtpComm::ConstructL(), local port = ", aLocalPort );

    TInt  err( 0 );

    TBool bRequiredPortsOpen( EFalse );

    TUint dynLocalPort( aLocalPort );

    if ( ( dynLocalPort % 2 ) != 0 )

        {

        // If an odd number is supplied then the application should replace

        // that number with the next lower (even) number to use as the base

        // of the port pair. (RFC3550)

        dynLocalPort--;

        }

    if ( dynLocalPort == 0 ) // use default port 

        {

        dynLocalPort = KDefaultLocalPort;

        }

    TInetAddr localRtpAddress( dynLocalPort );

    TInetAddr localRtcpAddress( dynLocalPort + 1 );

    // Open RTP socket

    CleanupClosePushL( iSocket[ERTPPort] );

    err = iSocket[ERTPPort].Open( aSocketServ, 

                                  KAfInet,

                                  KSockDatagram, 

                                  KProtocolInetUdp, 

                                  aRConn 

                                );

    User::LeaveIfError( err );

    if ( aEnableRtcp )

        {

        // Open RTCP socket

        CleanupClosePushL( iSocket[ERTCPPort] );

        err = iSocket[ERTCPPort].Open( aSocketServ, 

                                       KAfInet,

                                       KSockDatagram, 

                                       KProtocolInetUdp, 

                                       aRConn             

                                     );

        User::LeaveIfError( err );

        }

   	// Find consecutive ports for RTP and RTCP

    while ( !bRequiredPortsOpen )

        {

        err = iSocket[ERTPPort].SetLocalPort(dynLocalPort);

        if ( err == KErrNone && aEnableRtcp )

            {

         err = iSocket[ERTCPPort].SetLocalPort(dynLocalPort + 1 );

            }

        if ( err == KErrNone )

            {

            bRequiredPortsOpen = ETrue;

            }

        else

            {

            // RTP always uses even ports, so increment by 2 and retry.

            dynLocalPort += 2;

            if ( dynLocalPort >= KMaxLocalPort )

                {

                // Reached maximum port number

                User::LeaveIfError( KErrTooBig );

                }

            }

        }            

    err = iSocket[ERTPPort].SetOpt( KSORecvBuf, KSOLSocket,

                                    aParams.iSocketBufSize );

    User::LeaveIfError( err );

    err = iSocket[ERTPPort].SetOpt( KSOSendBuf, KSOLSocket, aParams.iSocketBufSize );

    User::LeaveIfError( err );  

    err = iSocket[ERTPPort].SetOpt( KSoUdpSynchronousSend, KSolInetUdp,

                                    ETrue );

    User::LeaveIfError( err );          

    if ( aEnableRtcp )

        {

        err = iSocket[ERTCPPort].SetOpt( KSORecvBuf, KSOLSocket,

                                         KSocketBufSize );

        User::LeaveIfError( err );

        err = iSocket[ERTCPPort].SetOpt( KSOSendBuf, KSOLSocket,

                                         KSocketBufSize );

        User::LeaveIfError( err );          

        err = iSocket[ERTCPPort].SetOpt( KSoUdpSynchronousSend, KSolInetUdp,

                                         ETrue );

        User::LeaveIfError( err );          

        }

    // Let the application know what port we ended up using

    aLocalPort = dynLocalPort;

    RTP_DEBUG_DETAIL_DVALUE( "CRtpComm::ConstructL(), local port chosen = ", aLocalPort );

    iPriority = aParams.iPriority;

    iErrNotify = &aErrNotify;

    iRtcpEnabled = aEnableRtcp;

    iSocketSize = aParams.iSocketBufSize;

    // The sender and receiver objects are created separately

    // in ConstructSenderL and ConstructReceiverL

    CleanupStack::Pop(); // iSocket[ERTPPort]

    if ( aEnableRtcp )

        {

        CleanupStack::Pop(); // iSocket[ERTCPPort]

        }

    }

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

// Two-phased constructor.

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

//

CRtpComm* CRtpComm::NewL( TUint& aLocalPort,

                          RSocketServ& aSocketServ,

                          RConnection& aRConn, 

                          const TCreateSessionParams& aParams,

                          MRtpErrNotify& aErrNotify,

                          TBool aEnableRtcp )

    {

    CRtpComm* self = new ( ELeave ) CRtpComm();

    CleanupStack::PushL( self );

    self->ConstructL( aLocalPort, aSocketServ, aRConn, aParams, aErrNotify,

                      aEnableRtcp );

    CleanupStack::Pop(); //self

    return self;

    }

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

// Destructor

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

// 

CRtpComm::~CRtpComm()

     {

     for ( TInt k = 0; k < KMaxPorts; k++ ) 

         {

         if ( iReceiver[ k ] )

         	{

         	delete iReceiver[ k ];

         	}

         if ( iSender[ k ] )

         	{

         	delete iSender[ k ];

         	}

         }

     Close();

     }

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

// CRtpComm::ConstructSenderL()

// 

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

//

void CRtpComm::ConstructSenderL(TInetAddr& aRtpAddr, TInetAddr& aRtcpAddr)

    {

    if ( !iSender[ERTPPort] )

        {

        iSender[ERTPPort] = CRtpCommSend::NewL( iSocket[ERTPPort], *iErrNotify, 

                                                /*KMaxPackets * 1024,*/ aRtpAddr );

        }

    if ( iRtcpEnabled && !iSender[ERTCPPort] )

        {

        iSender[ERTCPPort] = CRtpCommSend::NewL( iSocket[ERTCPPort],

                                                 *iErrNotify,

                                                 /*KMaxPackets * 256,*/ aRtcpAddr );

        // Boost the priority of the RTCP transmission, to make sure those

        // few packets reach their destination.

        iSender[ERTCPPort]->SetPriority( TCreateSessionParams::EPriorityHigh );

        }

    }

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

// CRtpComm::ConstructReceiverL()

// 

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

//

void CRtpComm::ConstructReceiverL(TBool aNonRtpObserverSet)

    {

    if ( !iReceiver[ERTPPort] )

        {

        iReceiver[ERTPPort] = CRtpCommRecv::NewL( ERTPPort, iSocket[ERTPPort], 

                                                  iPriority, *iErrNotify, aNonRtpObserverSet );

        iReceiver[ERTPPort]->RegisterReceivedNotify( iReceivedNotify );

        }

    if ( iRtcpEnabled && !iReceiver[ERTCPPort] )

        {

        iReceiver[ERTCPPort] = CRtpCommRecv::NewL( ERTCPPort,

                                                   iSocket[ERTCPPort], 

                                                   TCreateSessionParams::EPriorityHigh,

                                                   *iErrNotify, aNonRtpObserverSet );

        iReceiver[ERTCPPort]->RegisterReceivedNotify( iReceivedNotify );

        }

    }

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

// CRtpComm::Close()

// 

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

//

void CRtpComm::Close()

    {

    for ( TInt k = 0; k < KMaxPorts; k++ )

        {

        iSocket[k].Close();

        }

    }

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

// CRtpComm::SetToAddress()

// Return TRequestStatus.Int()

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

//  

TInt CRtpComm::SetToAddress( TPortType aPortType, TInetAddr& aAddr )

    {

    TInt ret = KErrNone;

    CRtpCommSend* aCommSend = iSender[aPortType];

    if (aCommSend)    

        {

        aCommSend->SetToAddress(aAddr);       

        }

    CRtpCommRecv* aCommRecv = iReceiver[aPortType];

    if (aCommRecv)    

        {

        aCommRecv->SetRemoteAddress(aAddr);       

        }

    return ret;

    }

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

// CRtpComm::SetAcceptedFromAddress()

// 

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

//

void CRtpComm::SetAcceptedFromAddress(TInetAddr& aAddr)

    {

     iReceiver[ERTPPort]->SetRemoteAddress(aAddr);                                          

    if ( iRtcpEnabled && iReceiver[ERTCPPort] )

        {

        iReceiver[ERTCPPort]->SetRemoteAddress(aAddr);                                          

        }

    }

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

// CRtpComm::SetNonRtpObserverFlag()

// 

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

//

void CRtpComm::SetNonRtpObserverFlag(TBool aValue)

    {

    if (iReceiver[ERTPPort] )

        {

        iReceiver[ERTPPort]->SetNonRtpObserverFlag(aValue);        

        }

    if (iReceiver[ERTCPPort] )

        {

        iReceiver[ERTCPPort]->SetNonRtpObserverFlag(aValue);        

        }    

    }

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

// CRtpComm::MaxSocketSize()

// 

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

//

TInt CRtpComm::MaxSocketSize()

    {

    return iSocketSize;

    }

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

// CRtpComm::Send()

// 

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

//

TInt CRtpComm::Send( TPortType aPortType, const TDesC8& aSendBuf )

    {

    TInt result( KErrNotReady );

    if ( iSender[aPortType] )

        {

        result = iSender[aPortType]->Send( aSendBuf );

        }

    return result;

    }

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

// CRtpComm::Send()

// 

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

//

void CRtpComm::Send( TPortType aPortType, const TDesC8& aSendBuf, TRequestStatus& aStatus )

    {

    if ( iSender[aPortType] )

        {

        iSender[aPortType]->Send( aSendBuf, aStatus );

        }

    else

        {

        TRequestStatus* status = &aStatus;

        User::RequestComplete( status, KErrNotReady );

        }

    }

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

// CRtpComm::CancelSend()

// 

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

//

void CRtpComm::CancelSend( TPortType aPortType )

    {

    if ( iSender[aPortType] )

        {

        iSender[aPortType]->CancelAsyncSend();

        }

    }

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

// CRtpComm::Receive()

// 

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

//

TInt CRtpComm::Receive( TPortType aPortType, TDes8& aRecvBuf )

    {

    TInt result( KErrNotReady );

    if ( iReceiver[aPortType] )

        {

        result = iReceiver[aPortType]->Recv( aRecvBuf );

        }

    return result;

    }

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

// CRtpComm::RegisterReceivedNotify()

// 

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

//

void CRtpComm::RegisterReceivedNotify( MReceivedNotify* aNotify )

    {

    iReceivedNotify = aNotify;

    if ( iReceiver[ERTPPort] )

        {

        iReceiver[ERTPPort]->RegisterReceivedNotify( aNotify );

        }

    if ( iReceiver[ERTCPPort] )

        {

        iReceiver[ERTCPPort]->RegisterReceivedNotify( aNotify );

        }

    }

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

// RSocket* CRtpComm::GetSocketObject()

// 

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

//

RSocket* CRtpComm::GetSocket( TPortType aPortType )

    {

    return &iSocket[aPortType];

    }

//  End of File