rtpsession.cpp

symbian平台S60_2nd_FP2_SC rtp实现

#include "vtypes.h"
#include "cpLog.h"
#include "rtpTypes.h"
#include "RtpSession.h"


/* ----------------------------------------------------------------- */
/* --- rtp session Constructor ------------------------------------- */
/* ----------------------------------------------------------------- */

RtpSession::RtpSession (const char* remoteHost, int remotePort, int localPort,
                        int rtcpRemotePort, int rtcpLocalPort, int portRange,
                        RtpPayloadType apiPayloadType,
                        RtpPayloadType networkPayloadType, int jitterNew)
{

	isEvent=false;
	event=DTMFEventNULL;
    constructRtpSession (remoteHost, remotePort, localPort, rtcpRemotePort,
                         rtcpLocalPort, portRange, apiPayloadType,
                         networkPayloadType, jitterNew);
}

//Test
//RtpSession* stack=new RtpSession(
//"127.0.0.1",  //RTPremoteHost
//7001+i,		//RTPremotePort
//6090+i,		//RTPlocalPort
//9001+i,		//RTCPremotePort
//8090+i,		//RTCPlocalPort
//rtpPayloadPCMU,rtpPayloadPCMU,
//-1);
//stack->setApiFormat (rtpPayloadPCMU,PAYLOADSIZE);
//stack->setNetworkFormat (rtpPayloadPCMU,PAYLOADSIZE);

RtpSession::RtpSession (const char* remoteHost, int remotePort, int localPort,
                        int rtcpRemotePort, int rtcpLocalPort,
                        RtpPayloadType apiPayloadType,
                        RtpPayloadType networkPayloadType, int jitterNew)
{
	
	isEvent=false;
	event=DTMFEventNULL;
    constructRtpSession (remoteHost, remotePort, localPort, rtcpRemotePort,
                         rtcpLocalPort, 0, apiPayloadType,
                         networkPayloadType, jitterNew);
}

void RtpSession::constructRtpSession (const char* remoteHost,
                                      int remotePort, int localPort,
                                      int rtcpRemotePort, int rtcpLocalPort,
                                      int portRange, RtpPayloadType apiPayloadType,
                                      RtpPayloadType networkPayloadType,
                                      int jitterNew)
{

	m_dtmfType = rtpPayloadDTMF_RFC2833;  //default
    cpLog(LOG_DEBUG, "Creating RTP session.");
    cpLog(LOG_DEBUG, "Listening on port: %d", localPort);
    cpLog(LOG_DEBUG, "Sending to remote host: %s", remoteHost);
    cpLog(LOG_DEBUG, "Sending to remote port: %d", remotePort);

    recv = NULL; tran = NULL;
    rtcpTran = NULL, rtcpRecv = NULL;
	iSocketEngineRtp = NULL;
	iSocketEngineRtcp = NULL;


	NetworkAddress aAddressRTP;
	aAddressRTP.SetRemoteHost((char *)remoteHost);
	aAddressRTP.SetremotePort(remotePort);
	aAddressRTP.SetlocalPort(localPort);
	aAddressRTP.SetInetAddr();

	iSocketEngineRtp = CSocketUdp::NewL(this);
	if(!iSocketEngineRtp) return;
	else
		iSocketEngineRtp->setDestination(aAddressRTP);

    if (localPort != 0)
    {
        if (portRange != 0)
            recv = new RtpReceiver (iSocketEngineRtp,
									localPort, localPort + portRange,
                                    apiPayloadType, networkPayloadType,
                                    jitterNew);
        else
            recv = new RtpReceiver (iSocketEngineRtp,
									localPort, apiPayloadType,
                                    networkPayloadType, jitterNew);
    }

    if (remotePort != 0)
    {
        if (portRange != 0)
            tran = new RtpTransmitter (iSocketEngineRtp,
									   remoteHost, remotePort,
                                       remotePort + portRange, apiPayloadType,
                                       networkPayloadType, recv);
        else
            tran = new RtpTransmitter (iSocketEngineRtp,
									   remoteHost, remotePort, apiPayloadType,
                                       networkPayloadType, recv);
    }

	//RTCP 
	NetworkAddress aAddressRTCP;
	aAddressRTCP.SetRemoteHost((char *)remoteHost);
	aAddressRTCP.SetremotePort(rtcpRemotePort);
	aAddressRTCP.SetlocalPort(rtcpLocalPort);
	aAddressRTCP.SetInetAddr();

	iSocketEngineRtcp = CSocketUdp::NewL(this);
	if(!iSocketEngineRtcp) return;
	else
		iSocketEngineRtcp->setDestination(aAddressRTCP);

    if (rtcpLocalPort != 0)
    {
        if (portRange != 0)
            rtcpRecv = new RtcpReceiver (iSocketEngineRtcp,
										 rtcpLocalPort,
                                         rtcpLocalPort + portRange);
        else
            rtcpRecv = new RtcpReceiver (iSocketEngineRtcp,rtcpLocalPort);
    }

    if (rtcpRemotePort != 0)
    {
        if (portRange != 0)
            rtcpTran = new RtcpTransmitter (iSocketEngineRtcp,
											remoteHost, rtcpRemotePort,
                                            rtcpRemotePort + portRange, rtcpRecv);
        else
            rtcpTran = new RtcpTransmitter (iSocketEngineRtcp,
											remoteHost,
                                            rtcpRemotePort, rtcpRecv);
    }


    // update interlinks
    if (rtcpTran && tran) rtcpTran->setRTPtran (tran);
    if (rtcpTran && recv) rtcpTran->setRTPrecv (recv);
    if (rtcpTran && rtcpRecv) rtcpTran->setRTCPrecv (rtcpRecv);
    if (rtcpRecv && recv) recv->setRTCPrecv(rtcpRecv);


    // SDES infromation for transmitter
    if (rtcpTran && tran)
    {
        char dummy[2] = "";

        rtcpTran->setSdesCname();
        rtcpTran->setSdesName(dummy);
        rtcpTran->setSdesEmail(dummy);
        rtcpTran->setSdesPhone(dummy);
        rtcpTran->setSdesLoc(dummy);
        rtcpTran->setSdesTool(dummy);
        rtcpTran->setSdesNote(dummy);
    }

    // session states
    // Currently the states are for RTP stack only, not for RTCP
    if (tran && recv)
    {
        sessionState = rtp_session_sendrecv;
        recv->getUdpStack()->setMode(sendrecv);

    }
    else if (tran && !recv)
    {
        sessionState = rtp_session_sendonly;
        tran->getUdpStack()->setMode(sendonly);
    }
    else if (recv && !tran)
    {
        sessionState = rtp_session_recvonly;
        recv->getUdpStack()->setMode(recvonly);
    }
    else
    {
        cpLog (LOG_ERR, "Session undefined");
        sessionState = rtp_session_undefined;
    }


    if (tran) cpLog (LOG_DEBUG_STACK, "RTP Tran Port: %d",
                         tran->getUdpStack()->getDestinationPort());
    if (recv) cpLog (LOG_DEBUG_STACK, "RTP Recv Port: %d", recv->getPort());
    if (rtcpTran) cpLog (LOG_DEBUG_STACK, "RTCP Tran Port: %d",
                             rtcpTran->getUdpStack()->getDestinationPort());
    if (rtcpRecv) cpLog (LOG_DEBUG_STACK, "RTCP Recv Port: %d",
                             rtcpRecv->getPort());

}

RtpSession::~RtpSession ()
{
    if( rtcpTran )
    {
        delete rtcpTran;
        rtcpTran = NULL;
    }
    if( rtcpRecv )
    {
        delete rtcpRecv;
        rtcpRecv = NULL;
    }
    if( tran )
    {
        delete tran;
        tran = NULL;
    }
    if( recv )
    {
        delete recv;
        recv = NULL;
    }

	if(iSocketEngineRtp)
	{
		delete iSocketEngineRtp;
		iSocketEngineRtp =NULL;
	}
	if(iSocketEngineRtcp)
	{
		delete iSocketEngineRtcp;
		iSocketEngineRtcp =NULL;
	}
}

int
RtpSession::reserveRtpPort(int localMin, int localMax)
{

    int port = 0;
	/*
    if ( recv == 0 )
    {
        //let RtpReceiver() automatically generate a port number
        recv = new RtpReceiver(localMin, localMax);
        port = recv->getPort();
    }
    else
    {
       port = recv->getPort();
   }
	*/
    return port;

}

int
RtpSession::releaseRtpPort()
{
    int port = 0;
    if ( recv != 0 )
    {
        port = recv->getPort();
        delete recv;
        recv = 0;
    }
    return port;
}

int
RtpSession::reserveRtcpPort(int rtcpLocalPort, int portRange)
{
    int port = 0;
/* ZHAOSONG
    if ( rtcpRecv == 0 )
    {
        if (rtcpLocalPort != 0)
        {
            if (portRange != 0)
                rtcpRecv = new RtcpReceiver (rtcpLocalPort,
                                             rtcpLocalPort + portRange);
            else
                rtcpRecv = new RtcpReceiver (rtcpLocalPort);
        }

        port = rtcpRecv->getPort();
    }
    else
    {
        port = rtcpRecv->getPort();
    }
*/
    return port;
}

int
RtpSession::releaseRtcpPort()
{
    int port = 0;
    if ( rtcpRecv != 0 )
    {
        port = rtcpRecv->getPort();
        delete rtcpRecv;
        rtcpRecv = 0;
    }
    return port;
}

/* --- Send and Receive RTP Functions ------------------------------ */
void RtpSession::setNetworkFormat (RtpPayloadType type, int no_samples, int packetSize)
{
    if (tran) tran->setNetworkFormat (type, no_samples, packetSize);
    if (recv) recv->setNetworkFormat (type, no_samples, packetSize);
}

void RtpSession::setApiFormat (RtpPayloadType type, int no_samples, int packetSize)
{
    if (tran) tran->setApiFormat (type, no_samples, packetSize);
    if (recv) recv->setApiFormat (type, no_samples, packetSize);
}

void RtpSession::setCodecString (const char* codecStringInput)
{
    if (tran) tran->setCodecString (codecStringInput);
    if (recv) recv->setCodecString (codecStringInput);
}

void RtpSession::setNetworkPktSize (int no_samples)
{
    setNetworkPktSampleSize (no_samples);
}

void RtpSession::setNetworkPktSampleSize (int no_samples)
{
    if (tran) tran->setNetworkPktSize (no_samples);
    if (recv) recv->setNetworkPktSize (no_samples);
}


void RtpSession::setApiPktSize (int no_samples)
{
    setApiPktSampleSize (no_samples);
}

void RtpSession::setApiPktSampleSize (int no_samples)
{
    if (tran) tran->setApiPktSize (no_samples);
    if (recv) recv->setApiPktSize (no_samples);
}


int RtpSession::getNetworkPktSampleSize ()
{
    if (tran)
        return tran->getNetworkPktSampleSize ();
    else
        return 0;
}

int RtpSession::getApiPktSampleSize ()
{
    if (recv)
        return recv->getApiPktSampleSize();
    else
        return 0;
}

// If there are multiple dests, the return will be the total
// of all dests. - ?
int RtpSession::getPacketSent ()
{
    if (tran)
        return tran->getPacketSent ();
    else
        return 0;
}

// If there are multiple dests, the return will be the total
// of all dests. - ?
int RtpSession::getByteSent ()
{
    if (tran)
        return tran->getPayloadSent ();
    else
        return 0;
}

// If there are multiple srcs, the return will be the total
// of all srcs. - ?
int RtpSession::getPacketReceived ()
{
    if (recv)
        return recv->getPacketReceived ();
    else
        return 0;
}

// If there are multiple srcs, the return will be the total
// of all srcs. - ?
int RtpSession::getByteReceived ()
{
    if (recv)
        return recv->getPayloadReceived ();
    else
        return 0;
}

// If there are multiple srcs, this func returns the packect lost
// for all the srcs
int RtpSession::getPacketLost ()
{
    if (rtcpTran)
    {
        if (rtcpRecv)
        {
            int lost = 0;
            for (int i = 0; i < (rtcpRecv->getTranInfoCount()); i++)
            {
                lost += rtcpTran->calcLostCount(rtcpRecv->getTranInfoList(i));
            }
            return lost;
        }
    }
    return 0;
}

// If there are multiple srcs, this func returns the jitter
// calculation results accumulated by all srcs
int RtpSession::getJitter ()
{
    if (recv)
    {
        return (recv->getJitter() >> 4);
    }
    return 0;
}

// If there are multiple srcs, what this func returns
// is not clear - ?
int RtpSession::getLatency ()
{
    if (rtcpRecv)
    {
        return (rtcpRecv->getAvgOneWayDelay());
        //        return (rtcpRecv->getAvgRoundTripDelay());
    }

    return 0;
}

void RtpSession::setSessionState (RtpSessionState state)
{
    switch (state)
    {
        case (rtp_session_inactive):
                    if (recv) recv->getUdpStack()->setMode(inactive);
            else if (tran) tran->getUdpStack()->setMode(inactive);
        sessionState = state;
        break;
        case (rtp_session_sendonly):
                    if (recv) recv->getUdpStack()->setMode(sendonly);
            else if (tran) tran->getUdpStack()->setMode(sendonly);
        sessionState = state;
        break;
        case (rtp_session_recvonly):
                    if (recv) recv->getUdpStack()->setMode(recvonly);
            else if (tran) tran->getUdpStack()->setMode(recvonly);
        sessionState = state;
        break;
        case (rtp_session_sendrecv):
                    if (recv) recv->getUdpStack()->setMode(sendrecv);
            else if (tran) tran->getUdpStack()->setMode(sendrecv);
        sessionState = state;
        break;
        case (rtp_session_undefined):
                    sessionState = state;
        break;