jrtplib的简单封装类及使用（一）

使用到了一个辅助类IpPort

#ifndef _IPPORT_H
#define _IPPORT_H

#include <WinSock2.h>

class IpPort
{
public:
unsigned int   m_ip;//网络字节顺序
unsigned short m_port;
public:
IpPort()
{
m_ip   = INADDR_NONE;
m_port = INVALID_SOCKET;
}
~IpPort(){}
char* GetIp(char *ip)
{
if (!ip) return NULL;
struct in_addr *paddr;
paddr->S_un.S_addr = (unsigned long)m_ip;
memcpy(ip,inet_ntoa(*paddr),16);
return ip;
}
void SetIp(unsigned int ip){m_ip=ip;}
void SetIp(char *strip)
{
SetIp(inet_addr((const char*)strip));
}
void SetPort(unsigned int port){m_port=port;}
};

#endif

发送端的封装类RtpSender.h

#ifndef _RTPSENDER_H
#define _RTPSENDER_H

#include <rtpsession.h>
#include <vector>
#include "IpPort.h"

#define LOCAL_SENDER_PORT 15000

#ifndef MAX_PACKET_SIZE
#define MAX_PACKET_SIZE 15000//最大包大小
#endif

#ifndef FRAME_RATE
#define FRAME_RATE 25//帧率
#endif

class RtpSender
{
public:
RtpSender();
~RtpSender();
bool CreateSenderSession(UINT16 port = LOCAL_SENDER_PORT);
bool AddDestAddr(IpPort ipport);
bool SendPacket(void *data,unsigned int len);
void CloseSenderSession();
private:
RTPSession m_session;
public:
IpPort m_localIpPort;
char   m_localName[300];
std::vector<IpPort> m_v_destIpPort;
};

#endif//_RTPSENDER_H

RtpSender.cpp

#include "stdafx.h"
#include "RtpSender.h"

#include <rtpipv4address.h>
#include <rtpsessionparams.h>
#include <rtpudpv4transmitter.h>

#ifdef _DEBUG
#include <string.h>
#endif // _DEBUG

RtpSender::RtpSender()
{
// 	WSADATA dat;
// 	WSAStartup(MAKEWORD(2,2),&dat);

m_localIpPort.SetPort(LOCAL_SENDER_PORT);
m_localIpPort.SetIp(INADDR_NONE);

memset(m_localName,0,300);
if (gethostname(m_localName,300) == 0)
{
PHOSTENT phostinfo;
if ((phostinfo = gethostbyname(m_localName))
!= NULL)
{
struct in_addr *paddr;
paddr = (struct in_addr*)(*(phostinfo->h_addr_list));
m_localIpPort.SetIp((UINT32)(paddr->S_un.S_addr));
}
}
}
RtpSender::~RtpSender()
{
/*	WSACleanup();*/
m_v_destIpPort.clear();
}
bool RtpSender::CreateSenderSession(UINT16 port /* = LOCAL_SENDER_PORT */)
{
m_localIpPort.SetPort(port);

RTPSessionParams sessParams;
RTPUDPv4TransmissionParams transParams;
sessParams.SetMaximumPacketSize(MAX_PACKET_SIZE);
sessParams.SetOwnTimestampUnit(1.0/FRAME_RATE);
sessParams.SetAcceptOwnPackets(true);
transParams.SetPortbase(m_localIpPort.m_port);

int status = m_session.Create(sessParams,
&transParams);

if (status < 0)
{
#ifdef _DEBUG
static bool RtpSender_CreateSenderSession = false;
std::string str = RTPGetErrorString(status);
if (RtpSender_CreateSenderSession)
{
::MessageBox(NULL,/*str.c_str()*/"RtpSender::CreateSender失败!","Error",MB_OK | MB_ICONEXCLAMATION);
}
#endif // _DEBUG
return false;
}

return true;
}

bool RtpSender::AddDestAddr(IpPort ipport)
{
RTPIPv4Address addr(ntohl(ipport.m_ip)/*转为主机字节顺序*/,ipport.m_port);
int status;
status = m_session.AddDestination(addr);

if (status < 0)
{
#ifdef _DEBUG
static bool RTPSender_AddDestAddr = true;
std::string str = RTPGetErrorString(status);
if (RTPSender_AddDestAddr)
{
::MessageBox(NULL,/*str.c_str()*/"RTPSender::AddDestAddr失败!","Error",MB_OK | MB_ICONEXCLAMATION);
RTPSender_AddDestAddr = false;
}
#endif // _DEBUG
return false;
}

m_v_destIpPort.push_back(ipport);
return true;
}

bool RtpSender::SendPacket(void *data,unsigned int len)
{
int status;
status = m_session.SendPacket(/*(const void*)*/data,len,0,false,40);
if (status < 0)
{
#ifdef _DEBUG
static bool RtpSender_SendPacket = true;
std::string str = RTPGetErrorString(status);
if (RtpSender_SendPacket)
{
::MessageBox(NULL,/*str.c_str()*/"RTPSender::SendPacket失败!","Error",MB_OK | MB_ICONEXCLAMATION);
RtpSender_SendPacket = false;
}
#endif // _DEBUG
return false;
}
return true;
}

void RtpSender::CloseSenderSession()
{
RTPTime::Wait(RTPTime(10,0));
m_session.BYEDestroy(RTPTime(10,0),0,0);
}

接收端的封装类 RtpReceiver.h

#ifndef _RTPRECEIVER_H
#define _RTPRECEIVER_H

#include <rtpsession.h>
#include <vector>
#include "IpPort.h"

#define LOCAL_RECEIVER_PORT 20000

#ifndef MAX_PACKET_SIZE
#define MAX_PACKET_SIZE 15000//最大包大小
#endif

#ifndef FRAME_RATE
#define FRAME_RATE 25//帧率
#endif

class RtpReceiver;
class RTPSession_Po : public RTPSession
{
public:
RTPSession_Po(){pRtpReceiver=NULL;}
void SetRtpReceiver(RtpReceiver* prtp)
{
pRtpReceiver = prtp;
}
protected:
void OnPollThreadStep();
private:
RtpReceiver *pRtpReceiver;
};
class RtpReceiver
{
public:
RtpReceiver();
~RtpReceiver();
bool CreateReceiverSession(UINT16 port = LOCAL_RECEIVER_PORT);
bool AddSourceAddr(IpPort ipport);
void CloseReceiverSession();
public:
virtual void ProcessReceiveData(RTPSourceData &srcdata, RTPPacket &packet) = 0;
private:
RTPSession_Po m_session;
public:
std::vector<IpPort> m_v_sourIpPort;
IpPort m_localIpPort;
char   m_localName[300];
};

#endif//_RTPRECEIVER_H

RtpReceiver.cpp

#include "stdafx.h"
#include "RtpReceiver.h"

#include <rtpipv4address.h>
#include <rtpsessionparams.h>
#include <rtpudpv4transmitter.h>

#ifdef _DEBUG
#include <string.h>
#endif // _DEBUG

void RTPSession_Po::OnPollThreadStep()
{
BeginDataAccess();
if (GotoFirstSourceWithData())
{
do
{
RTPPacket     *ppacket;
RTPSourceData *psrcdat;
psrcdat = GetCurrentSourceInfo();

while (ppacket = GetNextPacket())
{
pRtpReceiver->ProcessReceiveData(*psrcdat,*ppacket);
DeletePacket(ppacket);
}

} while (GotoNextSourceWithData());
}
EndDataAccess();
}
RtpReceiver::RtpReceiver()
{
// 	WSADATA dat;
// 	WSAStartup(MAKEWORD(2,2),&dat);

m_localIpPort.SetPort(LOCAL_RECEIVER_PORT);
m_localIpPort.SetIp(INADDR_NONE);

m_session.SetRtpReceiver(this);

memset(m_localName,0,300);
if (gethostname(m_localName,300) == 0)
{
PHOSTENT phostinfo;
if ((phostinfo = gethostbyname(m_localName))
!= NULL)
{
struct in_addr *paddr;
paddr = (struct in_addr*)(*(phostinfo->h_addr_list));
m_localIpPort.SetIp((UINT32)(paddr->S_un.S_addr));
}
}
}
RtpReceiver::~RtpReceiver()
{
/*	WSACleanup();*/
m_v_sourIpPort.clear();
}
bool RtpReceiver::CreateReceiverSession(UINT16 port /* = LOCAL_RECEIVER_PORT */)
{
m_localIpPort.SetPort(port);

RTPSessionParams sessParams;
RTPUDPv4TransmissionParams transParams;
sessParams.SetMaximumPacketSize(MAX_PACKET_SIZE);
sessParams.SetOwnTimestampUnit(1.0/FRAME_RATE);
sessParams.SetAcceptOwnPackets(true);
transParams.SetPortbase(m_localIpPort.m_port);

int status = m_session.Create(sessParams,
&transParams);

if (status < 0)
{
#ifdef _DEBUG
static bool RtpReceiver_CreateReceiverSession = true;
std::string str = RTPGetErrorString(status);
if (RtpReceiver_CreateReceiverSession)
{
::MessageBox(NULL,/*str.c_str()*/"RtpReceiver::CreateReceiverSession()失败!","Error",MB_OK | MB_ICONEXCLAMATION);
RtpReceiver_CreateReceiverSession = false;
}
#endif // _DEBUG
return false;
}
return true;
}
bool RtpReceiver::AddSourceAddr(IpPort ipport)
{
RTPIPv4Address addr(ntohl(ipport.m_ip)/*主机字节顺序*/,ipport.m_port);
int status;
status = m_session.AddDestination(addr);

if (status < 0)
{
#ifdef _DEBUG
static bool RtpReceiver_AddSourceAddr = true;
std::string str = RTPGetErrorString(status);
if (RtpReceiver_AddSourceAddr)
{
::MessageBox(NULL,/*str.c_str()*/"RtpReceiver::AddSourceAddr()失败!","Error",MB_OK | MB_ICONEXCLAMATION);
RtpReceiver_AddSourceAddr = false;
}

#endif // _DEBUG
return false;
}

m_v_sourIpPort.push_back(ipport);
return true;
}

void RtpReceiver::CloseReceiverSession()
{
RTPTime::Wait(RTPTime(10,0));
m_session.BYEDestroy(RTPTime(10,0),0,0);
}

以上只是简单的封装了jrtplib开源库里的代码，可以用于发送视频帧数据。使用方法后面再说。