1041 lines
27 KiB
C++
1041 lines
27 KiB
C++
// RTPSink.cpp : Implementation of CRTPSession
|
||
#include "stdafx.h"
|
||
#include <qossp.h>
|
||
#include "irtp.h"
|
||
#include "rtp.h"
|
||
#include "RTPSess.h"
|
||
//#include "rtpsink.h"
|
||
//#include "RTPMS.h"
|
||
//#include "RTPSamp.h"
|
||
#include "thread.h"
|
||
#include <rrcm.h>
|
||
|
||
#define DEFAULT_RTPBUF_SIZE 1500
|
||
|
||
#define IPPORT_FIRST_DYNAMIC 49152
|
||
#define IPPORT_FIRST_DYNAMIC_END (IPPORT_FIRST_DYNAMIC + 200)
|
||
#define IPPORT_FIRST_DYNAMIC_BEGIN (IPPORT_FIRST_DYNAMIC_END + 256)
|
||
|
||
// Port number allocation starts at IPPORT_FIRST_DYNAMIC_BEGIN.
|
||
// Everytime a port number is allocated we decrease g_alport, until
|
||
// we reach IPPORT_FIRST_DYNAMIC_END. We then reset it back to its
|
||
// original value (IPPORT_FIRST_DYNAMIC_BEGIN) and start this process
|
||
// all over again. This way we will avoid reusing the same port
|
||
// numbers between sessions.
|
||
u_short g_alport = IPPORT_FIRST_DYNAMIC_BEGIN;
|
||
void __cdecl RRCMNotification(int,DWORD_PTR,DWORD_PTR,DWORD_PTR);
|
||
|
||
|
||
|
||
#define IsMulticast(p) ((p->sin_addr.S_un.S_un_b.s_b1 & 0xF0) == 0xE0)
|
||
|
||
|
||
BOOL CRTP::m_WSInitialized = 0;
|
||
|
||
|
||
|
||
STDMETHODIMP CRTP::OpenSession(
|
||
UINT sessionId, // client specified unique identifier for the session
|
||
DWORD flags, // SESSIONF_SEND, SESSIONF_RECV, SESSIONF_MULTICAST etc.
|
||
BYTE *localAddr,
|
||
UINT cbAddr,
|
||
IRTPSession **ppIRTP) // [output] pointer to RTPSession
|
||
{
|
||
// the session is named by the sessionId
|
||
|
||
CRTPSession *pRTPSess ;
|
||
HRESULT hr= E_FAIL;
|
||
UINT mediaId = flags & (SESSIONF_AUDIO | SESSIONF_VIDEO);
|
||
|
||
EnterCriticalSection(&g_CritSect);
|
||
for (pRTPSess= CRTPSession::m_pSessFirst; pRTPSess; pRTPSess = pRTPSess->m_pSessNext ) {
|
||
// check for existing session of the same media type
|
||
// if the sessionId is not zero, also check for matching session id
|
||
if (sessionId == pRTPSess->m_sessionId)
|
||
if (mediaId == pRTPSess->m_mediaId)
|
||
break;
|
||
// if the local address or remote address is not NULL, search for an exising RTP session bound to
|
||
// the same address
|
||
// TODO
|
||
|
||
}
|
||
|
||
if (!pRTPSess)
|
||
{
|
||
if (!(flags & SESSIONF_EXISTING)) {
|
||
// create the session
|
||
ObjRTPSession *pObj;
|
||
DEBUGMSG(ZONE_DP,("Creating new RTP session\n"));
|
||
hr = ObjRTPSession::CreateInstance(&pObj);
|
||
if (hr == S_OK) {
|
||
pRTPSess = pObj; // pointer conversion
|
||
hr = pRTPSess->Initialize(sessionId, mediaId,localAddr,cbAddr);
|
||
if (hr != S_OK)
|
||
delete pObj;
|
||
}
|
||
}
|
||
else
|
||
hr = E_FAIL; // matching session does not exist
|
||
|
||
} else {
|
||
DEBUGMSG(ZONE_DP,("Reusing RTP session\n"));
|
||
hr = S_OK;
|
||
}
|
||
if (hr == S_OK) {
|
||
hr = ((IRTPSession *)pRTPSess)->QueryInterface(IID_IRTPSession,(void **) ppIRTP);
|
||
|
||
}
|
||
LeaveCriticalSection(&g_CritSect);
|
||
return hr;
|
||
}
|
||
|
||
|
||
CRTPSession *CRTPSession::m_pSessFirst = NULL;
|
||
/////////////////////////////////////////////////////////////////////////////
|
||
// CRTPSession
|
||
|
||
CRTPSession::CRTPSession()
|
||
: m_hRTPSession(NULL), m_uMaxPacketSize(1500),m_nBufsPosted(0),m_pRTPCallback(NULL),
|
||
m_fSendingSync(FALSE)
|
||
{
|
||
ZeroMemory(&m_sOverlapped,sizeof(m_sOverlapped));
|
||
ZeroMemory(&m_ss, sizeof(m_ss));
|
||
ZeroMemory(&m_rs, sizeof(m_rs));
|
||
m_sOverlapped.hEvent = (WSAEVENT)this;
|
||
}
|
||
|
||
/*
|
||
HRESULT CRTPSession::GetLocalAddress(
|
||
unsigned char *sockaddr,
|
||
UINT *paddrlen)
|
||
{
|
||
if (m_pRTPSess && *paddrlen >= sizeof(SOCKADDR_IN))
|
||
{
|
||
*paddrlen = sizeof(SOCKADDR_IN);
|
||
CopyMemory(sockaddr, m_pRTPSess->GetLocalAddress(), *paddrlen);
|
||
}
|
||
}
|
||
*/
|
||
HRESULT
|
||
CRTPSession::FinalRelease()
|
||
{
|
||
|
||
CRTPPacket1 *pRTPPacket;
|
||
// remove myself from the session list
|
||
EnterCriticalSection(&g_CritSect);
|
||
if (m_pSessFirst == this)
|
||
m_pSessFirst = m_pSessNext;
|
||
else {
|
||
CRTPSession *pRTPSess = m_pSessFirst;
|
||
while (pRTPSess && pRTPSess->m_pSessNext != this) {
|
||
pRTPSess = pRTPSess->m_pSessNext;
|
||
}
|
||
if (pRTPSess)
|
||
pRTPSess->m_pSessNext = m_pSessNext;
|
||
}
|
||
LeaveCriticalSection(&g_CritSect);
|
||
|
||
if (m_rtpsock) {
|
||
delete m_rtpsock;
|
||
m_rtpsock = NULL;
|
||
}
|
||
// BUGBUG: in case the buffers have not been canceled yet (an error case),
|
||
// they should complete now with WSA_OPERATION_ABORTED
|
||
// or WSAEINTR. This happens in the context of the RecvThread
|
||
if (m_nBufsPosted != 0)
|
||
Sleep(500); // time for APCs to be processed in RecvThread
|
||
|
||
// close the RTP session. Also ask RRCM to close the rtcp socket if its WS2
|
||
// because that is a more reliable way of cleaning up overlapped recvs than
|
||
// sending loopback packets.
|
||
CloseRTPSession (m_hRTPSession, NULL, TRUE );
|
||
|
||
if (m_rtcpsock) {
|
||
delete m_rtcpsock;
|
||
m_rtcpsock = NULL;
|
||
}
|
||
m_hRTPSession = 0;
|
||
// free receive buffers
|
||
while (m_FreePkts.Get(&pRTPPacket))
|
||
{
|
||
delete pRTPPacket;
|
||
}
|
||
|
||
|
||
return S_OK;
|
||
}
|
||
|
||
|
||
|
||
HRESULT CRTPSession::CreateRecvRTPStream(DWORD ssrc, IRTPRecv **ppIRTPRecv)
|
||
{
|
||
HRESULT hr;
|
||
Lock();
|
||
if (ssrc != 0)
|
||
return E_NOTIMPL;
|
||
|
||
#if 0
|
||
ObjRTPRecvSource *pRecvS;
|
||
hr = ObjRTPMediaStream::CreateInstance(&pMS);
|
||
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
pMS->AddRef();
|
||
pMS->Init(this, m_mediaId);
|
||
hr = pMS->QueryInterface(IID_IRTPMediaStream, (void**)ppIRTPMediaStream);
|
||
pMS->Release();
|
||
}
|
||
#else
|
||
*ppIRTPRecv = this;
|
||
(*ppIRTPRecv)->AddRef();
|
||
hr = S_OK;
|
||
#endif
|
||
Unlock();
|
||
return hr;
|
||
}
|
||
|
||
|
||
|
||
ULONG GetRandom()
|
||
{
|
||
return GetTickCount();
|
||
}
|
||
|
||
HRESULT CRTPSession::Initialize(UINT sessionId, UINT mediaId, BYTE *pLocalAddr, UINT cbAddr)
|
||
{
|
||
DWORD APIstatus;
|
||
HRESULT hr = E_OUTOFMEMORY;
|
||
char tmpBfr[MAX_COMPUTERNAME_LENGTH + 1];
|
||
DWORD tmpBfrLen = sizeof(tmpBfr);
|
||
SDES_DATA sdesInfo[3];
|
||
ENCRYPT_INFO encryptInfo;
|
||
SOCKADDR_IN *pSockAddr;
|
||
|
||
|
||
m_sessionId = sessionId;
|
||
m_mediaId = mediaId;
|
||
m_rtpsock = new UDPSOCKET();
|
||
m_rtcpsock = new UDPSOCKET();
|
||
|
||
if (!m_rtpsock || !m_rtcpsock)
|
||
goto ERROR_EXIT;
|
||
|
||
|
||
if(!m_rtpsock->NewSock() || !m_rtcpsock->NewSock())
|
||
{
|
||
goto ERROR_EXIT;
|
||
}
|
||
|
||
// if the local address is specified do a bind on the sockets
|
||
if (pLocalAddr) {
|
||
// setup both channels for the current local address
|
||
hr = SetLocalAddress(pLocalAddr,cbAddr);
|
||
|
||
if (hr != S_OK)
|
||
goto ERROR_EXIT;
|
||
}
|
||
/*
|
||
// if the remote address is specified make a note of it
|
||
SetRemoteAddresses(pChanDesc->pRemoteAddr, pChanDesc->pRemoteRTCPAddr);
|
||
*/
|
||
// init send state
|
||
memset (&m_ss.sendStats,0,sizeof(m_ss.sendStats));
|
||
// init RTP send header
|
||
// time stamp and marker bit have to specified per packet
|
||
m_ss.hdr.p = 0; // no padding needed
|
||
m_ss.hdr.x = 0; // no extensions
|
||
m_ss.hdr.cc = 0; // no contributing sources
|
||
m_ss.hdr.seq = (WORD)GetRandom();
|
||
|
||
|
||
m_clockRate = (m_mediaId == SESSIONF_VIDEO ? 90000 : 8000); // typically 8KHz for audio
|
||
m_ss.hdr.pt = 0;
|
||
|
||
|
||
// Initialize list of overlapped structs
|
||
|
||
// build a Cname
|
||
memcpy(tmpBfr,"CName",6);
|
||
GetComputerName(tmpBfr,&tmpBfrLen);
|
||
|
||
// build the SDES information
|
||
sdesInfo[0].dwSdesType = 1;
|
||
memcpy (sdesInfo[0].sdesBfr, tmpBfr, strlen(tmpBfr)+1);
|
||
sdesInfo[0].dwSdesLength = strlen(sdesInfo[0].sdesBfr);
|
||
sdesInfo[0].dwSdesFrequency = 100;
|
||
sdesInfo[0].dwSdesEncrypted = 0;
|
||
|
||
// Build a Name
|
||
tmpBfrLen = sizeof(tmpBfr);
|
||
memcpy(tmpBfr,"UserName",9);
|
||
GetUserName(tmpBfr,&tmpBfrLen);
|
||
sdesInfo[1].dwSdesType = 2;
|
||
memcpy (sdesInfo[1].sdesBfr, tmpBfr, strlen(tmpBfr)+1);
|
||
sdesInfo[1].dwSdesLength = strlen(sdesInfo[1].sdesBfr);
|
||
sdesInfo[1].dwSdesFrequency = 25;
|
||
sdesInfo[1].dwSdesEncrypted = 0;
|
||
|
||
// end of SDES list
|
||
sdesInfo[2].dwSdesType = 0;
|
||
|
||
pSockAddr = m_rtcpsock->GetRemoteAddress();
|
||
#ifdef DEBUG
|
||
if (pSockAddr->sin_addr.s_addr == INADDR_ANY)
|
||
DEBUGMSG(ZONE_DP,("Null dest RTCP addr\n"));
|
||
#endif
|
||
|
||
// Create the RTP/RTCP session
|
||
|
||
m_hRTPSession = CreateRTPSession(
|
||
(m_rtpsock->GetSock()),
|
||
(m_rtcpsock->GetSock()),
|
||
(LPVOID)pSockAddr,
|
||
(pSockAddr->sin_addr.s_addr == INADDR_ANY)? 0 : sizeof(SOCKADDR_IN),
|
||
sdesInfo,
|
||
(DWORD)m_clockRate,
|
||
&encryptInfo,
|
||
0,
|
||
(PRRCM_EVENT_CALLBACK)RRCMNotification, // callback function
|
||
(DWORD_PTR) this, // callback info
|
||
RTCP_ON|H323_CONFERENCE,
|
||
0, //rtp session bandwidth
|
||
&APIstatus);
|
||
|
||
if (m_hRTPSession == NULL)
|
||
{
|
||
DEBUGMSG(ZONE_DP,("Couldnt create RRCM session\n"));
|
||
hr = GetLastError();
|
||
goto ERROR_EXIT;
|
||
}
|
||
|
||
m_Qos.SendingFlowspec.ServiceType = SERVICETYPE_NOTRAFFIC;
|
||
m_Qos.SendingFlowspec.TokenRate = QOS_NOT_SPECIFIED;
|
||
m_Qos.SendingFlowspec.TokenBucketSize = QOS_NOT_SPECIFIED;
|
||
m_Qos.SendingFlowspec.PeakBandwidth = QOS_NOT_SPECIFIED;
|
||
m_Qos.SendingFlowspec.Latency = QOS_NOT_SPECIFIED;
|
||
m_Qos.SendingFlowspec.DelayVariation = QOS_NOT_SPECIFIED;
|
||
m_Qos.SendingFlowspec.MaxSduSize = QOS_NOT_SPECIFIED;
|
||
m_Qos.ReceivingFlowspec = m_Qos.SendingFlowspec;
|
||
m_Qos.ProviderSpecific.buf = NULL;
|
||
m_Qos.ProviderSpecific.len = 0;
|
||
|
||
|
||
// insert RTPSession in global list
|
||
m_pSessNext = m_pSessFirst;
|
||
m_pSessFirst = this;
|
||
|
||
return S_OK;
|
||
|
||
ERROR_EXIT:
|
||
if (m_rtpsock)
|
||
{
|
||
delete m_rtpsock;
|
||
m_rtpsock = NULL;
|
||
}
|
||
if (m_rtcpsock)
|
||
{
|
||
delete m_rtcpsock;
|
||
m_rtcpsock = NULL;
|
||
}
|
||
|
||
return hr;
|
||
|
||
}
|
||
|
||
|
||
|
||
BOOL CRTPSession::SelectPorts()
|
||
{
|
||
|
||
// try port pairs in the dynamic range ( > 49152)
|
||
if (g_alport <= IPPORT_FIRST_DYNAMIC_END)
|
||
g_alport = IPPORT_FIRST_DYNAMIC_BEGIN;
|
||
|
||
|
||
|
||
for (;g_alport >= IPPORT_FIRST_DYNAMIC;)
|
||
{
|
||
m_rtpsock->SetLocalPort(g_alport);
|
||
|
||
if (m_rtpsock->BindMe() == 0)
|
||
{
|
||
/* it worked for the data, try the adjacent port for control*/
|
||
++g_alport;
|
||
|
||
m_rtcpsock->SetLocalPort(g_alport);
|
||
if (m_rtcpsock->BindMe() == 0)
|
||
{
|
||
g_alport-=3;
|
||
return TRUE;
|
||
}
|
||
else // start over at the previous even numbered port
|
||
{
|
||
if( WSAGetLastError() != WSAEADDRINUSE)
|
||
{
|
||
DEBUGMSG(ZONE_DP,("ObjRTPSession::SelectPorts failed with error %d\n",WSAGetLastError()));
|
||
goto ERROR_EXIT;
|
||
}
|
||
m_rtpsock->Cleanup();
|
||
if(!m_rtpsock->NewSock())
|
||
{
|
||
ASSERT(0);
|
||
return FALSE;
|
||
}
|
||
g_alport-=3;
|
||
continue;
|
||
}
|
||
|
||
}
|
||
if (WSAGetLastError() != WSAEADDRINUSE)
|
||
{
|
||
DEBUGMSG(ZONE_DP,("ObjRTPSession::SelectPorts failed with error %d\n",WSAGetLastError()));
|
||
goto ERROR_EXIT;
|
||
}
|
||
g_alport-=2; // try the next lower even numbered port
|
||
}
|
||
|
||
ERROR_EXIT:
|
||
m_rtcpsock->SetLocalPort(0);
|
||
m_rtpsock->SetLocalPort(0);
|
||
return FALSE;
|
||
}
|
||
|
||
STDMETHODIMP CRTPSession::SetLocalAddress(BYTE *pbAddr, UINT cbAddr)
|
||
{
|
||
HRESULT hr;
|
||
SOCKADDR_IN *pAddr = (SOCKADDR_IN *)pbAddr;
|
||
ASSERT(pbAddr);
|
||
|
||
Lock();
|
||
if ( IsMulticast(pAddr))
|
||
hr = SetMulticastAddress(pAddr);
|
||
else
|
||
if (m_rtpsock->GetLocalAddress()->sin_port != 0)
|
||
hr = S_OK; // already bound
|
||
else
|
||
{
|
||
m_rtpsock->SetLocalAddress(pAddr);
|
||
m_rtcpsock->SetLocalAddress(pAddr);
|
||
if (pAddr->sin_port != 0)
|
||
{
|
||
// port already chosen
|
||
m_rtcpsock->SetLocalPort(ntohs(pAddr->sin_port) + 1);
|
||
if (m_rtpsock->BindMe() != 0 || m_rtcpsock->BindMe() != 0)
|
||
{
|
||
hr = HRESULT_FROM_WIN32(GetLastError());
|
||
m_rtpsock->SetLocalPort(0);
|
||
m_rtcpsock->SetLocalPort(0);
|
||
}
|
||
else
|
||
hr = S_OK;
|
||
}
|
||
else
|
||
{
|
||
// client wants us to choose the port
|
||
|
||
if (SelectPorts()) {
|
||
hr = S_OK;
|
||
}
|
||
else
|
||
hr = HRESULT_FROM_WIN32(GetLastError());
|
||
}
|
||
}
|
||
Unlock();
|
||
return hr;
|
||
}
|
||
|
||
HRESULT
|
||
CRTPSession::SetMulticastAddress(PSOCKADDR_IN pAddr)
|
||
{
|
||
SOCKET s ;
|
||
SOCKADDR_IN rtcpAddr = *pAddr;
|
||
s = RRCMws.WSAJoinLeaf( m_rtpsock->GetSock(), (struct sockaddr *)pAddr, sizeof(SOCKADDR_IN), NULL, NULL, NULL, NULL, JL_BOTH);
|
||
if (s == INVALID_SOCKET)
|
||
return E_FAIL;
|
||
else {
|
||
rtcpAddr.sin_port = htons(ntohs(pAddr->sin_port)+1);
|
||
s = RRCMws.WSAJoinLeaf( m_rtcpsock->GetSock(), (struct sockaddr *)&rtcpAddr, sizeof(SOCKADDR_IN), NULL, NULL, NULL, NULL, JL_BOTH);
|
||
|
||
return S_OK;
|
||
}
|
||
}
|
||
|
||
|
||
STDMETHODIMP
|
||
CRTPSession::SetRemoteRTPAddress(BYTE *sockaddr, UINT cbAddr)
|
||
{
|
||
SOCKADDR_IN *pRTPAddr = (SOCKADDR_IN *)sockaddr;
|
||
Lock();
|
||
|
||
if (pRTPAddr) {
|
||
#ifdef DEBUG
|
||
if (m_rtpsock->GetRemoteAddress()->sin_addr.s_addr != INADDR_ANY
|
||
&& m_rtpsock->GetRemoteAddress()->sin_addr.s_addr != pRTPAddr->sin_addr.s_addr) {
|
||
DEBUGMSG(ZONE_DP,("Changing RTP Session remote address (already set)!\n"));
|
||
}
|
||
#endif
|
||
m_rtpsock->SetRemoteAddr(pRTPAddr);
|
||
}
|
||
|
||
Unlock();
|
||
return S_OK;
|
||
}
|
||
|
||
|
||
STDMETHODIMP
|
||
CRTPSession::SetRemoteRTCPAddress(BYTE *sockaddr, UINT cbAddr)
|
||
{
|
||
SOCKADDR_IN *pRTCPAddr = (SOCKADDR_IN *)sockaddr;
|
||
|
||
Lock();
|
||
|
||
if (pRTCPAddr) {
|
||
#ifdef DEBUG
|
||
if (m_rtcpsock->GetRemoteAddress()->sin_addr.s_addr != INADDR_ANY
|
||
&& m_rtcpsock->GetRemoteAddress()->sin_addr.s_addr != pRTCPAddr->sin_addr.s_addr) {
|
||
DEBUGMSG(ZONE_DP,("Changing RTCP Session remote address (already set)!\n"));
|
||
}
|
||
#endif
|
||
m_rtcpsock->SetRemoteAddr(pRTCPAddr);
|
||
if (m_hRTPSession)
|
||
updateRTCPDestinationAddress( m_hRTPSession,
|
||
(SOCKADDR *)m_rtcpsock->GetRemoteAddress(), sizeof(SOCKADDR_IN));
|
||
}
|
||
Unlock();
|
||
return S_OK;
|
||
}
|
||
|
||
STDMETHODIMP
|
||
CRTPSession::GetLocalAddress(const BYTE **sockaddr, UINT *pcbAddr)
|
||
{
|
||
if (sockaddr && pcbAddr)
|
||
{
|
||
Lock();
|
||
*sockaddr = (BYTE *)m_rtpsock->GetLocalAddress();
|
||
*pcbAddr = sizeof(SOCKADDR_IN);
|
||
Unlock();
|
||
return S_OK;
|
||
} else
|
||
{
|
||
return E_INVALIDARG;
|
||
}
|
||
}
|
||
|
||
STDMETHODIMP
|
||
CRTPSession::GetRemoteRTPAddress(const BYTE **sockaddr, UINT *pcbAddr)
|
||
{
|
||
if (sockaddr && pcbAddr )
|
||
{
|
||
Lock();
|
||
*sockaddr = (BYTE *)m_rtpsock->GetRemoteAddress();
|
||
*pcbAddr = sizeof(SOCKADDR_IN);
|
||
Unlock();
|
||
return S_OK;
|
||
} else
|
||
{
|
||
return E_INVALIDARG;
|
||
}
|
||
}
|
||
|
||
STDMETHODIMP
|
||
CRTPSession::GetRemoteRTCPAddress(const BYTE **sockaddr, UINT *pcbAddr)
|
||
{
|
||
if (sockaddr && pcbAddr)
|
||
{
|
||
Lock();
|
||
*sockaddr = (BYTE *)m_rtcpsock->GetRemoteAddress();
|
||
*pcbAddr = sizeof(SOCKADDR_IN);
|
||
Unlock();
|
||
return S_OK;
|
||
} else
|
||
{
|
||
return E_INVALIDARG;
|
||
}
|
||
}
|
||
|
||
STDMETHODIMP
|
||
CRTPSession::SetSendFlowspec(FLOWSPEC *pFlowspec)
|
||
{
|
||
QOS_DESTADDR qosDest;
|
||
DWORD cbRet;
|
||
int optval = pFlowspec->MaxSduSize;
|
||
// Set the RTP socket to not buffer more than one packet
|
||
// This will allow us to influence the packet scheduling.
|
||
if(RRCMws.setsockopt(m_rtpsock->GetSock(),SOL_SOCKET, SO_SNDBUF,(char *)&optval,sizeof(optval)) != 0)
|
||
{
|
||
|
||
RRCM_DBG_MSG ("setsockopt failed ", GetLastError(),
|
||
__FILE__, __LINE__, DBG_ERROR);
|
||
}
|
||
|
||
if (WSQOSEnabled && m_rtpsock)
|
||
{
|
||
|
||
m_Qos.SendingFlowspec = *pFlowspec;
|
||
m_Qos.ProviderSpecific.buf = (char *)&qosDest; // NULL
|
||
m_Qos.ProviderSpecific.len = sizeof (qosDest); // 0
|
||
|
||
// check to see if the receive flowspec has already been
|
||
// set. If it has, specify NOCHANGE for the receive service
|
||
// type. If not, specify NOTRAFFIC. This is done to circumvent
|
||
// a bug in the Win98 QOS/RSVP layer.
|
||
|
||
if (m_Qos.ReceivingFlowspec.TokenRate == QOS_NOT_SPECIFIED)
|
||
{
|
||
m_Qos.ReceivingFlowspec.ServiceType = SERVICETYPE_NOTRAFFIC;
|
||
}
|
||
else
|
||
{
|
||
m_Qos.ReceivingFlowspec.ServiceType = SERVICETYPE_NOCHANGE;
|
||
}
|
||
|
||
qosDest.ObjectHdr.ObjectType = QOS_OBJECT_DESTADDR;
|
||
qosDest.ObjectHdr.ObjectLength = sizeof(qosDest);
|
||
qosDest.SocketAddress = (PSOCKADDR)m_rtpsock->GetRemoteAddress();
|
||
qosDest.SocketAddressLength = sizeof(SOCKADDR_IN);
|
||
if (RRCMws.WSAIoctl(m_rtpsock->GetSock(),SIO_SET_QOS, &m_Qos, sizeof(m_Qos), NULL, 0, &cbRet, NULL,NULL) == 0)
|
||
return S_OK;
|
||
else
|
||
return GetLastError();
|
||
} else
|
||
return E_NOTIMPL;
|
||
|
||
}
|
||
|
||
STDMETHODIMP
|
||
CRTPSession::SetRecvFlowspec(FLOWSPEC *pFlowspec)
|
||
{
|
||
|
||
SOCKADDR_IN *pAddr = NULL;
|
||
|
||
DWORD cbRet;
|
||
if (WSQOSEnabled && m_rtpsock)
|
||
{
|
||
|
||
pAddr = m_rtpsock->GetRemoteAddress();
|
||
|
||
m_Qos.ReceivingFlowspec = *pFlowspec;
|
||
m_Qos.ProviderSpecific.buf = NULL;
|
||
m_Qos.ProviderSpecific.len = 0;
|
||
|
||
// check to see if the send flowspec has already been
|
||
// set. If it has, specify NOCHANGE for the receive service
|
||
// type. If not, specify NOTRAFFIC. This is done to circumvent
|
||
// a bug in the Win98 QOS/RSVP layer.
|
||
|
||
if (m_Qos.SendingFlowspec.TokenRate == QOS_NOT_SPECIFIED)
|
||
{
|
||
m_Qos.SendingFlowspec.ServiceType = SERVICETYPE_NOTRAFFIC;
|
||
}
|
||
else
|
||
{
|
||
m_Qos.SendingFlowspec.ServiceType = SERVICETYPE_NOCHANGE;
|
||
}
|
||
|
||
if (RRCMws.WSAIoctl(m_rtpsock->GetSock(),SIO_SET_QOS, &m_Qos, sizeof(m_Qos), NULL, 0, &cbRet, NULL,NULL) == 0)
|
||
return S_OK;
|
||
else
|
||
return GetLastError();
|
||
} else
|
||
return E_NOTIMPL;
|
||
}
|
||
|
||
// set the size used for receive packet buffers
|
||
STDMETHODIMP
|
||
CRTPSession::SetMaxPacketSize(UINT maxPacketSize)
|
||
{
|
||
m_uMaxPacketSize = maxPacketSize;
|
||
return S_OK;
|
||
}
|
||
|
||
HRESULT CRTPSession::SetRecvNotification(
|
||
PRTPRECVCALLBACK pRTPRecvCB, // pointer to callback function
|
||
DWORD_PTR dwCB, // callback arg
|
||
UINT nBufs // suggested number of receives to post
|
||
)
|
||
{
|
||
CRTPPacket1 *pRTPPacket;
|
||
if (!m_hRTPSession)
|
||
return E_FAIL;
|
||
|
||
m_pRTPCallback = pRTPRecvCB;
|
||
m_dwCallback = dwCB;
|
||
|
||
if (m_nBufsPosted >= nBufs)
|
||
return S_OK; // packets already posted
|
||
|
||
int nBufsToAllocate = nBufs - m_nBufsPosted - m_FreePkts.GetCount();
|
||
// allocate packets if necessary
|
||
while (nBufsToAllocate-- > 0)
|
||
{
|
||
if (pRTPPacket = new CRTPPacket1) {
|
||
if (!SUCCEEDED(pRTPPacket->Init(m_uMaxPacketSize)))
|
||
{
|
||
delete pRTPPacket;
|
||
break;
|
||
}
|
||
m_FreePkts.Put(pRTPPacket);
|
||
}
|
||
else
|
||
break;
|
||
}
|
||
PostRecv();
|
||
return m_nBufsPosted ? S_OK : E_OUTOFMEMORY;
|
||
}
|
||
|
||
HRESULT
|
||
CRTPSession::CancelRecvNotification()
|
||
{
|
||
m_pRTPCallback = NULL;
|
||
if (m_rtpsock) {
|
||
struct sockaddr myaddr;
|
||
int myaddrlen = sizeof(myaddr);
|
||
UINT i;
|
||
char buf = 0;
|
||
WSABUF wsabuf;
|
||
DWORD bytesSent;
|
||
UINT nBufsPosted;
|
||
wsabuf.buf = &buf;
|
||
wsabuf.len = 0;
|
||
BOOL fCanceled = FALSE;
|
||
if (RRCMws.getsockname(m_rtpsock->GetSock(),&myaddr,&myaddrlen)== 0) {
|
||
// send loopback packets (as many as there are recvs outstanding)
|
||
// on this socket to get back our buffers.
|
||
// NOTE: Winsock 2 on Win95 seems to have a bug where we get recv callbacks
|
||
// within sendto() rather than in the subsequent SleepEx, so we
|
||
// have to make a local copy of m_nBufsPosted
|
||
for (i=0, nBufsPosted = m_nBufsPosted;i < nBufsPosted;i++) {
|
||
if (RRCMws.sendTo(m_rtpsock->GetSock(),&wsabuf,1,&bytesSent,0,&myaddr, myaddrlen, NULL, NULL) < 0) {
|
||
DEBUGMSG(ZONE_DP,("CancelRecv: loopback send failed\n"));
|
||
break;
|
||
}
|
||
}
|
||
fCanceled = (i > 0);
|
||
} else {
|
||
DEBUGMSG(ZONE_DP,("RTPState::CancelRecv: getsockname returned %d\n",GetLastError()));
|
||
}
|
||
if (fCanceled)
|
||
while (m_nBufsPosted) {
|
||
DWORD dwStatus;
|
||
dwStatus = SleepEx(200,TRUE);
|
||
ASSERT(dwStatus==WAIT_IO_COMPLETION);
|
||
if (dwStatus !=WAIT_IO_COMPLETION)
|
||
break; // timed out => bail
|
||
}
|
||
|
||
|
||
}
|
||
return S_OK;
|
||
}
|
||
|
||
HRESULT
|
||
CRTPSession::PostRecv()
|
||
{
|
||
HRESULT hr;
|
||
DWORD dwError = 0;
|
||
DWORD dwRcvFlag;
|
||
WSAOVERLAPPED *pOverlapped;
|
||
DWORD nBytesRcvd;
|
||
CRTPPacket1 *pRTPPacket;
|
||
|
||
if (!m_hRTPSession || !m_pRTPCallback)
|
||
return E_FAIL;
|
||
|
||
// post buffers in the free queue
|
||
while (m_FreePkts.Get(&pRTPPacket))
|
||
{
|
||
pOverlapped = (WSAOVERLAPPED *)(pRTPPacket->GetOverlapped());
|
||
pOverlapped->hEvent = (WSAEVENT) this;
|
||
|
||
m_rcvSockAddrLen = sizeof(SOCKADDR);
|
||
|
||
dwRcvFlag = 0;
|
||
pRTPPacket->RestoreSize();
|
||
dwError = RRCMws.recvFrom (m_rtpsock->GetSock(),
|
||
pRTPPacket->GetWSABUF(),
|
||
1,
|
||
&nBytesRcvd,
|
||
&dwRcvFlag,
|
||
&m_rcvSockAddr,
|
||
&m_rcvSockAddrLen,
|
||
pOverlapped,
|
||
(LPWSAOVERLAPPED_COMPLETION_ROUTINE)WS2RecvCB);
|
||
if (dwError == SOCKET_ERROR) {
|
||
dwError = WSAGetLastError();
|
||
if (dwError != WSA_IO_PENDING) {
|
||
DEBUGMSG(ZONE_DP,("RTP recv error %d\n",dwError));
|
||
// m_rs.rcvStats.packetErrors++;
|
||
// return the buffer to the free list
|
||
m_FreePkts.Put(pRTPPacket);
|
||
break;
|
||
}
|
||
|
||
}
|
||
++m_nBufsPosted;
|
||
}
|
||
return m_nBufsPosted ? S_OK : S_FALSE;
|
||
}
|
||
|
||
HRESULT
|
||
CRTPSession::FreePacket(WSABUF *pBuf)
|
||
{
|
||
m_FreePkts.Put(CRTPPacket1::GetRTPPacketFromWSABUF(pBuf));
|
||
PostRecv();
|
||
return S_OK;
|
||
}
|
||
|
||
/*----------------------------------------------------------------------------
|
||
* Function: WS2SendCB
|
||
* Description: Winsock callback provided by the application to Winsock
|
||
*
|
||
* Input:
|
||
*
|
||
* Return: None
|
||
*--------------------------------------------------------------------------*/
|
||
void CALLBACK WS2SendCB (DWORD dwError,
|
||
DWORD cbTransferred,
|
||
LPWSAOVERLAPPED lpOverlapped,
|
||
DWORD dwFlags)
|
||
{
|
||
CRTPSession *pSess;
|
||
//get the RTPSession pointer so that we can mark the
|
||
//IO complete on the object
|
||
pSess= (CRTPSession *)lpOverlapped->hEvent;
|
||
ASSERT (&pSess->m_sOverlapped == lpOverlapped);
|
||
pSess->m_lastSendError = dwError;
|
||
pSess->m_fSendingSync=FALSE;
|
||
}
|
||
|
||
|
||
void CALLBACK WS2RecvCB (DWORD dwError,
|
||
DWORD len,
|
||
LPWSAOVERLAPPED lpOverlapped,
|
||
DWORD dwFlags)
|
||
{
|
||
|
||
CRTPSession *pRTP;
|
||
CRTPPacket1 *pRTPPacket;
|
||
|
||
DWORD ts, ssrc;
|
||
|
||
// GEORGEJ: catch Winsock 2 bug (94903) where I get a bogus callback
|
||
// after WSARecv returns WSAEMSGSIZE.
|
||
if (!dwError && ((int) len < 0)) {
|
||
RRCM_DBG_MSG ("RTP : RCV Callback : bad cbTransferred", len,
|
||
__FILE__, __LINE__, DBG_ERROR);
|
||
return;
|
||
}
|
||
pRTP = (CRTPSession *)lpOverlapped->hEvent; // cached by PostRecv
|
||
ASSERT(pRTP);
|
||
ASSERT(lpOverlapped);
|
||
ASSERT(pRTP->m_nBufsPosted > 0);
|
||
--pRTP->m_nBufsPosted; // one recv just completed
|
||
|
||
// Winsock 2 sometimes chooses to indicate a buffer-too-small
|
||
// error via the dwFlags parameter.
|
||
if (dwFlags & MSG_PARTIAL)
|
||
dwError = WSAEMSGSIZE;
|
||
|
||
pRTPPacket = CRTPPacket1::GetRTPPacketFromOverlapped(lpOverlapped);
|
||
if (!dwError)
|
||
{
|
||
// validate RTP header and update receive stats
|
||
dwError = RTPReceiveCheck(
|
||
pRTP->m_hRTPSession,
|
||
pRTP->m_rtpsock->GetSock(),
|
||
pRTPPacket->GetWSABUF()->buf,
|
||
len,
|
||
&pRTP->m_rcvSockAddr,
|
||
pRTP->m_rcvSockAddrLen
|
||
);
|
||
}
|
||
if (!pRTP->m_pRTPCallback)
|
||
{
|
||
// we have stopped doing notifications
|
||
// return the buffer to the free list
|
||
pRTP->FreePacket(pRTPPacket->GetWSABUF());
|
||
}
|
||
else if (!dwError) {
|
||
// call the callback
|
||
//++pRTP->m_nBufsRecvd;
|
||
// convert the RTP header fields to host order
|
||
pRTPPacket->SetTimestamp(ntohl(pRTPPacket->GetTimestamp()));
|
||
pRTPPacket->SetSeq(ntohs(( u_short)pRTPPacket->GetSeq()));
|
||
pRTPPacket->SetActual(len);
|
||
//LOG((LOGMSG_NET_RECVD,pRTPPacket->GetTimestamp(), pRTPPacket->GetSeq(), GetTickCount()));
|
||
if (!pRTP->m_pRTPCallback(pRTP->m_dwCallback, pRTPPacket->GetWSABUF()))
|
||
pRTP->FreePacket(pRTPPacket->GetWSABUF());
|
||
} else {
|
||
// packet error
|
||
// repost the buffer
|
||
pRTP->PostRecv();
|
||
}
|
||
}
|
||
|
||
// the way its defined now, this Send() method is synchronous or asynchronous
|
||
// depending on whether pOverlapped is NULL or not
|
||
HRESULT CRTPSession::Send(
|
||
WSABUF *pWsabufs,
|
||
UINT nWsabufs,
|
||
WSAOVERLAPPED *pOverlapped,
|
||
LPWSAOVERLAPPED_COMPLETION_ROUTINE pWSAPC )
|
||
{
|
||
DWORD dwError;
|
||
|
||
Lock();
|
||
RTP_HDR_T *pHdr = (RTP_HDR_T *)pWsabufs[0].buf;
|
||
// convert RTP header fields to network-order
|
||
pHdr->ts = htonl (pHdr->ts);
|
||
pHdr->seq = htons(pHdr->seq);
|
||
//*pHdr = m_ss.hdr;
|
||
pHdr->seq = htons(++m_ss.hdr.seq);
|
||
// update send stats
|
||
//m_ss.packetsSent++;
|
||
//m_ss.bytesSent += cbBuf-sizeof(RTP_HDR_MIN_LEN);
|
||
//bIOPending=TRUE; // reset when send completes
|
||
|
||
dwError = RTPSendTo (
|
||
m_hRTPSession,
|
||
(m_rtpsock->GetSock()),
|
||
pWsabufs,
|
||
nWsabufs,
|
||
&m_numBytesSend,
|
||
0,
|
||
(LPVOID)m_rtpsock->GetRemoteAddress(),
|
||
sizeof(SOCKADDR),
|
||
pOverlapped,
|
||
pWSAPC);
|
||
|
||
if (dwError == SOCKET_ERROR) {
|
||
dwError = WSAGetLastError();
|
||
if (dwError != WSA_IO_PENDING) {
|
||
DEBUGMSG(1, ("RTPSendTo error %d\n",dwError));
|
||
m_lastSendError = dwError;
|
||
m_ss.sendStats.packetErrors++;
|
||
m_fSendingSync = FALSE;
|
||
goto ErrorExit;
|
||
}
|
||
dwError = 0; // return success for ERROR_IO_PENDING
|
||
}
|
||
|
||
ErrorExit:
|
||
Unlock();
|
||
return dwError;
|
||
}
|
||
void CRTPSession::RTCPNotify(
|
||
int rrcmEvent,
|
||
DWORD_PTR dwSSRC,
|
||
DWORD_PTR rtcpsock)
|
||
{
|
||
|
||
switch (rrcmEvent) {
|
||
case RRCM_RECV_RTCP_SNDR_REPORT_EVENT:
|
||
GetRTCPReport();
|
||
//DispRTCPReport(rtcpsock);
|
||
break;
|
||
case RRCM_RECV_RTCP_RECV_REPORT_EVENT:
|
||
GetRTCPReport();
|
||
break;
|
||
case RRCM_NEW_SOURCE_EVENT:
|
||
RRCM_DBG_MSG ("RTP : New SSRC", 0,
|
||
__FILE__, __LINE__, DBG_TRACE);
|
||
break;
|
||
default:
|
||
RRCM_DBG_MSG ("RTP : RRCMNotification", rrcmEvent,
|
||
__FILE__, __LINE__, DBG_TRACE);
|
||
break;
|
||
}
|
||
}
|
||
|
||
void RRCMNotification(
|
||
// RRCM_EVENT_T rrcmEvent,
|
||
int rrcmEvent,
|
||
DWORD_PTR dwSSRC,
|
||
DWORD_PTR rtcpsock,
|
||
DWORD_PTR dwUser)
|
||
{
|
||
if (dwUser)
|
||
((CRTPSession *)dwUser)->RTCPNotify(rrcmEvent,dwSSRC,rtcpsock);
|
||
|
||
|
||
}
|
||
|
||
// Get the useful fields from the RTCP report and store them
|
||
// Only works for unicast sessions now (one sender, one receiver)
|
||
BOOL CRTPSession::GetRTCPReport()
|
||
{
|
||
#define MAX_RTCP_REPORT 2
|
||
RTCP_REPORT rtcpReport[MAX_RTCP_REPORT];
|
||
DWORD moreEntries = 0;
|
||
DWORD numEntry = 0;
|
||
DWORD i;
|
||
|
||
ZeroMemory(rtcpReport,sizeof(rtcpReport));
|
||
// Get latest RTCP report
|
||
// for all SSRCs in this session
|
||
if (S_OK != RTCPReportRequest ( m_rtcpsock->GetSock(),
|
||
0, &numEntry,
|
||
&moreEntries, MAX_RTCP_REPORT,
|
||
rtcpReport,
|
||
0,NULL,0))
|
||
return FALSE;
|
||
|
||
for (i = 0; i < numEntry; i++)
|
||
{
|
||
if (rtcpReport[i].status & LOCAL_SSRC_RPT)
|
||
{
|
||
m_ss.sendStats.ssrc = rtcpReport[i].ssrc;
|
||
m_ss.sendStats.packetsSent = rtcpReport[i].dwSrcNumPcktRealTime;
|
||
m_ss.sendStats.bytesSent = rtcpReport[i].dwSrcNumByteRealTime;
|
||
} else {
|
||
m_rs.rcvStats.ssrc = rtcpReport[i].ssrc;
|
||
m_rs.rcvStats.packetsSent = rtcpReport[i].dwSrcNumPckt;
|
||
m_rs.rcvStats.bytesSent = rtcpReport[i].dwSrcNumByte;
|
||
m_rs.rcvStats.packetsLost = rtcpReport[i].SrcNumLost;
|
||
m_rs.rcvStats.jitter = rtcpReport[i].SrcJitter;
|
||
// Get the SR timestamp information
|
||
m_rs.ntpTime = ((NTP_TS)rtcpReport[i].dwSrcNtpMsw << 32) + rtcpReport[i].dwSrcNtpLsw;
|
||
m_rs.rtpTime = rtcpReport[i].dwSrcRtpTs;
|
||
|
||
// check if any feedback information
|
||
if (rtcpReport[i].status & FEEDBACK_FOR_LOCAL_SSRC_PRESENT)
|
||
{
|
||
DWORD prevPacketsLost = m_ss.sendStats.packetsLost;
|
||
|
||
m_ss.sendStats.packetsLost = rtcpReport[i].feedback.cumNumPcktLost;
|
||
/*
|
||
if (prevPacketsLost != m_ss.sendStats.packetsLost) {
|
||
DEBUGMSG(ZONE_DP,("RTCP: fraction Lost=%d/256 , totalLost =%d, StreamClock=%d\n",rtcpReport[i].feedback.fractionLost,m_ss.sendStats.packetsLost,m_clockRate));
|
||
}
|
||
*/
|
||
m_ss.sendStats.jitter = rtcpReport[i].feedback.dwInterJitter;
|
||
}
|
||
}
|
||
|
||
}
|
||
m_ss.sendStats.packetsDelivered = m_ss.sendStats.packetsSent - m_ss.sendStats.packetsLost;
|
||
|
||
return TRUE;
|
||
|
||
}
|
||
|
||
// CRTPPacket1 methods
|
||
|
||
HRESULT CRTPPacket1::Init(UINT uMaxPacketSize)
|
||
{
|
||
m_wsabuf.buf = new char [uMaxPacketSize];
|
||
if (!m_wsabuf.buf)
|
||
return E_OUTOFMEMORY;
|
||
m_wsabuf.len = uMaxPacketSize;
|
||
m_cbSize = uMaxPacketSize;
|
||
|
||
return S_OK;
|
||
}
|
||
|
||
CRTPPacket1::~CRTPPacket1()
|
||
{
|
||
if (m_wsabuf.buf)
|
||
delete [] m_wsabuf.buf;
|
||
}
|
||
|
||
|