rtpsession.cpp

symbian平台S60_2nd_FP2_SC rtp实现

        default:
        cpLog (LOG_ERR, "Unknown state: %d", (int)state);
        assert (0);
    }

    if (recv) recv->emptyNetwork();
}


RtpSessionState RtpSession::getSessionState ()
{
    return sessionState;
}



int
RtpSession::setTransmiter ( const char* remoteHost, int remotePort,
                            int rtcpRemotePort,
                            RtpPayloadType apiFormat,
                            RtpPayloadType networkFormat )
{
   /*
	if ( !(sessionState == rtp_session_sendrecv
            || sessionState == rtp_session_sendonly) )
    {
        cpLog(LOG_ERR, "wrong state of RTP stack.");
        return -1;
    }

    if (remotePort != 0)
    {
        if (tran)
        {
            tran->getUdpStack()->setDestination(remoteHost, remotePort);
            NetworkAddress netAddress;
            if ( remoteHost )
            {
                netAddress.setPort(remotePort);
				TBuf8<64> ahost;
				Str2TBuf1V1(ahost,(char*)remoteHost);
                netAddress.setHostName(ahost);
            }
            tran->setRemoteAddr(netAddress);
        }
        else
            tran = new RtpTransmitter ( remoteHost, remotePort, apiFormat,
                                        networkFormat, recv);
    }

    if (rtcpRemotePort != 0)
    {
        if (rtcpTran)
        {
            rtcpTran->getUdpStack()->setDestination( remoteHost,
                    rtcpRemotePort);
            NetworkAddress netAddress1;
            if ( remoteHost )
            {
                netAddress1.setPort(rtcpRemotePort);
				TBuf8<64> ahost;
				Str2TBuf1V1(ahost,(char*)remoteHost);
                netAddress1.setHostName(ahost);
            }
            rtcpTran->setRemoteAddr(netAddress1);
        }
        else
            rtcpTran = new RtcpTransmitter ( remoteHost,
                                             rtcpRemotePort, rtcpRecv);
    }

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

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

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

    if (tran) cpLog (LOG_DEBUG_STACK, "RTP Tran Port: %d",
                         tran->getUdpStack()->getDestinationPort());
    if (rtcpTran) cpLog (LOG_DEBUG_STACK, "RTCP Tran Port: %d",
                             rtcpTran->getUdpStack()->getDestinationPort());
*/
    return 0;
}


/* --- Send and Receive RTP Functions ------------------------------ */

RtpPacket* RtpSession::createPacket (int npadSize, int csrcCount)
{
    assert (tran);
    if (npadSize != 0)
        cpLog(LOG_DEBUG, "Nonzero npadSize not supported");
    return tran->createPacket(npadSize, csrcCount);
}



RtpSeqNumber RtpSession::getPrevSequence ()
{
    assert (tran);
    return tran->getPrevSequence ();
}



RtpTime RtpSession::getPrevRtpTime ()
{
    assert (tran);
    return tran->getPrevRtpTime();
}



void RtpSession::setMarkerOnce()
{
    if( tran )
    {
        tran->setMarkerOnce();
    }
}


int RtpSession::transmit (RtpPacket* p)
{
    if ( !( sessionState == rtp_session_sendrecv
            || sessionState == rtp_session_sendonly ) )
    {
        sessionError = session_wrongState;
        cpLog (LOG_ERR, "RTP stack can't transmit. Wrong state");
        return -1;
    }

    assert (tran);
    sessionError = session_success;
    return tran->transmit(p);
}


int RtpSession::transmitRaw (char* inbuffer, int len)
{
    if ( !( sessionState == rtp_session_sendrecv
            || sessionState == rtp_session_sendonly ) )
    {
        sessionError = session_wrongState;
        cpLog (LOG_ERR, "RTP stack can't transmit. Wrong state");
        return -1;
    }

    assert (tran);
    sessionError = session_success;
    return tran->transmitRaw(inbuffer, len);
}


int RtpSession::transmitEvent( int event )
{
       if (!( sessionState == rtp_session_sendrecv
            || sessionState == rtp_session_sendonly ) )
    {
        sessionError = session_wrongState;
        cpLog (LOG_ERR, "RTP stack can't transmit event. Wrong state");
        return -1;
    }

    cpLog( LOG_DEBUG_STACK,"Sending DTMF event %d in RTP stream", event );
    assert (tran);
    sessionError = session_success;
    RtpPacket* eventPacket = createPacket(0, 0);
    eventPacket->setPayloadType( rtpPayloadDTMF_RFC2833 ); // rtpPayloadDTMF_RFC2833);  // by zhl
    eventPacket->setPayloadUsage( sizeof( RtpEventDTMFRFC2833 ) );
    RtpEventDTMFRFC2833* eventPayload = reinterpret_cast<RtpEventDTMFRFC2833*>
                                        ( eventPacket->getPayloadLoc() );

    // reset event payload
    eventPayload->event = event; 
    eventPayload->volume = 0x0A;
    eventPayload->reserved = 0;
    eventPayload->edge = 0;
    eventPayload->duration = 0;
	int tmpEventDuration = 0;

   // send onedge packet marker = 1 duration = 0  ,sequence +=1 ,one times
	eventPacket->setMarkerFlag(1);
    tran->transmit( eventPacket, true );
   	
	//begin send inter packet marker = 0 duration +=320 ,sequence +=1 ,loop 6 times
	tmpEventDuration += 320;
	eventPayload->duration = htons(tmpEventDuration);
	eventPacket->setMarkerFlag(0);
	eventPayload->edge = 0;
    tran->transmit( eventPacket, true );
	
	tmpEventDuration += 320;
	eventPayload->duration = htons(tmpEventDuration);	
	eventPacket->setMarkerFlag(0);
    eventPayload->edge = 0;
    tran->transmit( eventPacket, true );

	tmpEventDuration += 320;
	eventPayload->duration = htons(tmpEventDuration);	
	eventPacket->setMarkerFlag(0);
    eventPayload->edge = 0;
    tran->transmit( eventPacket, true );

	tmpEventDuration += 320;
	eventPayload->duration = htons(tmpEventDuration);	
	eventPacket->setMarkerFlag(0);
	eventPayload->edge = 0;
    tran->transmit( eventPacket, true );

	tmpEventDuration += 320;
	eventPayload->duration = htons(tmpEventDuration);	
	eventPacket->setMarkerFlag(0);
	eventPayload->edge = 0;
    tran->transmit( eventPacket, true );

	tmpEventDuration += 320;
	eventPayload->duration = htons(tmpEventDuration);	
	eventPacket->setMarkerFlag(0);
	eventPayload->edge = 0;
    tran->transmit( eventPacket, true );
    //end send inter packet

	//begin send event end packet ,marker = 0 duration +=0 ,sequence +=0 ,loop 3 times
	tmpEventDuration += 320;
	eventPayload->duration = htons(tmpEventDuration);	
	eventPayload->edge = 1;
	eventPacket->setMarkerFlag(0);
    tran->transmit( eventPacket, true );

	eventPacket->sequenceSet = true;
	eventPayload->edge = 1;
	eventPacket->setMarkerFlag(0);
    tran->transmit( eventPacket, true );
	
	eventPacket->sequenceSet = true;
	eventPayload->edge = 1;
	eventPacket->setMarkerFlag(0);
    tran->transmit( eventPacket, true );

    if( eventPacket )
        delete eventPacket;
		eventPacket = NULL;

    return 0;
}

RtpPacket* RtpSession::receive ()
{
    if ( !( sessionState == rtp_session_sendrecv
            || sessionState == rtp_session_recvonly ) )
    {
        if (recv) recv->receive();
        sessionError = session_wrongState;
        cpLog (LOG_ERR, "RTP stack can't receive. Wrong state");
        return NULL;
    }

    assert (recv);
    sessionError = session_success;
    RtpPacket* p=recv->receive();
  
    if(recv->isEvent)
       {
       	isEvent=true;
       	event=recv->m_event;
       	recv->isEvent=false;
       //	printf("\nrtpsession:%d",event);
       	}
   return p;
}


// RTP/RTCP receive data
int RtpSession::receive (RtpPacket** rtpPacket,RtcpPacket** rtcpPacket)
{
   *rtpPacket=NULL;
   *rtcpPacket=NULL;

   if(rtcpRecv ==NULL || recv==NULL)
      return 0;
   
   sessionError = session_success;

   *rtcpPacket = rtcpRecv->getPacket();

   *rtpPacket=recv->receive();
   if(recv->isEvent)
   {
      isEvent=true;
      event=recv->m_event;
      recv->isEvent=false;
   }
   return 1;
}


RtpPacket* RtpSession::getPacket()
{
    if ( !( sessionState == rtp_session_sendrecv
            || sessionState == rtp_session_recvonly ) )
    {
        if (recv) recv->getPacket();
        sessionError = session_wrongState;
        cpLog (LOG_ERR, "RTP stack can't receive. Wrong state");
        return NULL;
    }

    assert (recv);
    sessionError = session_success;
    return recv->getPacket();
}



/* --- Send and Receive RTCP Functions ----------------------------- */

void RtpSession::processRTCP ()
{
    if (rtcpTran)
    {
        if (checkIntervalRTCP()) transmitRTCP();
    }
    if (rtcpRecv)
    {
        receiveRTCP();
    }
    return ;
}


int RtpSession::transmitRTCP ()
{
    if ( !( sessionState == rtp_session_sendrecv
            || sessionState == rtp_session_sendonly ) )
    {
        sessionError = session_wrongState;
        cpLog (LOG_ERR, "RTCP stack can't transmit. Wrong state");
        return -1;
    }

    assert (rtcpTran);

    // generate compound packet
    RtcpPacket* p = new RtcpPacket();

    // load with report packet
    rtcpTran->addSR(p);

    // load with SDES information
    // currently only sender sends SDES, recv only receiver doesn't
    if (tran) rtcpTran->addSDES(p);

    // transmit packet
    int ret = rtcpTran->transmit(p);

    if (p) delete p;
    return ret;
}



int RtpSession::transmitRTCPBYE ()
{
    assert (rtcpTran);

    // generate compound packet
    RtcpPacket* p = new RtcpPacket();

    // load with report packet
    rtcpTran->addSR(p);

    // load with SDES CNAME
    if (tran) rtcpTran->addSDES(p, rtcpSdesCname);

    // load with BYE packet
    if (tran)
    {
        char reason[] = "Program Ended.";
        rtcpTran->addBYE(p, reason);
    }

    // transmit packet
    int ret = rtcpTran->transmit(p);

    if (p) delete p;
    return ret;
}

int RtpSession::receiveRTCP ()
{
    if ( !( sessionState == rtp_session_sendrecv
            || sessionState == rtp_session_recvonly ) )
    {
        RtcpPacket* p1 = rtcpRecv->getPacket();
        if (p1) delete p1;
        sessionError = session_wrongState;
        cpLog (LOG_ERR, "RTCP stack can't receive. Wrong state");
        return -1;
    }

    assert (rtcpRecv);

    // generate compound packet
    RtcpPacket* p = rtcpRecv->getPacket();
    if (p == NULL) return -1;

    int ret = 0;

    // read compound packet
    if (rtcpRecv->readRTCP(p) == 1)
    {
       ret = 1;
    }

    if (p) delete p;
    return ret;
}



int RtpSession::checkIntervalRTCP ()
{
    assert (rtcpTran);
    return rtcpTran->checkInterval();
}




/* --- DTMF Callback functions ------------------------------------- */
void RtpSession::setDTMFInterface( DTMFInterface* t )
{
    if ( !recv )
        cpLog(LOG_ERR, "RTP receiver not set, can't set DTMF Interface");
    else
        recv->setDTMFInterface( t );
}

void RtpSession::unsetDTMFInterface( DTMFInterface* t )
{
    if ( !recv )
        cpLog(LOG_ERR, "RTP receiver not set, can't unset DTMF Interface");
    else
        recv->unsetDTMFInterface( t );
}


int RtpSession::setDTMFType(RtpPayloadType dtmfType)
{
	if (!( sessionState == rtp_session_sendrecv
		|| sessionState == rtp_session_sendonly ) )
    {
        return -1;
    }
    assert (tran);
	m_dtmfType = dtmfType;
	return 0;
}