jrtplib中组播代码发送端和接收端的实现

</pre>文章里面主要是把发送端课接收端代码的实现提了出来,和重要函数里的源码贴出来辅助学习,看到网上有人说好久做不出来,建议看看对应加入组播的源码,注意细节,话不多说,代码直接贴出来,各位朋友有意见多多交流。<p></p><p>发送端:</p><pre code_snippet_id="1677192" snippet_file_name="blog_20160510_2_5720022" name="code" class="cpp">#include "rtpsession.h"
#include "rtpudpv4transmitter.h"
#include "rtpipv4address.h"
#include "rtpsessionparams.h"
#include "rtperrors.h"
#include "rtppacket.h"
#ifndef WIN32
	#include <netinet/in.h>
	#include <arpa/inet.h>
#else
	#include <winsock2.h>
	#include<windows.h>
#endif // WIN32
#include <stdlib.h>
#include <stdio.h>
#include <iostream>
#include <string>

using namespace jrtplib;
using namespace std;

void checkerror(int rtperr)
{
	if(rtperr<0)
	{
		cout<<"ERROR:"<<RTPGetErrorString(rtperr)<<endl;
		exit(-1);
	}
}
int main()
{

	#ifdef WIN32
	WSADATA dat;
	WSAStartup(MAKEWORD(2,2),&dat);
	#endif // WIN32

	list<uint32_t> localip;

	RTPSession sess;
	uint16_t portbase=6666,destport=8888;
	uint32_t destip,srcip;
	string ipstr="239.255.0.1";
	string ipsrc="114.212.118.99";
	int status,i,num;
	destip=inet_addr(ipstr.c_str());//将字符串转换为32位网络字节序。
	srcip=inet_addr(ipsrc.c_str());

	if(destip==INADDR_NONE)
	{
		cout<<"bad destip address"<<endl;
		exit(-1);
	}
	destip=ntohl(destip);//将32位网络字节序转换成主机字节序
	srcip=ntohl(srcip);
	localip.push_back(srcip);
	//设置传输参数和会话参数
	RTPUDPv4TransmissionParams transparams;
	RTPSessionParams sessparams;

	// IMPORTANT: The local timestamp unit MUST be set, otherwise
	//            RTCP Sender Report info will be calculated wrong
	// In this case, we'll be sending 10 samples each second, so we'll
	// put the timestamp unit to (1.0/10.0)
	sessparams.SetOwnTimestampUnit(1.0/8000);

	sessparams.SetAcceptOwnPackets(true);
	transparams.SetPortbase(portbase);
	transparams.SetLocalIPList(localip);
	transparams.SetMulticastInterfaceIP(srcip);
	transparams.SetMulticastTTL(255);
	status = sess.Create(sessparams,&transparams);
	checkerror(status);

	RTPIPv4Address addr(destip,destport);

	status=sess.AddDestination(addr);
	checkerror(status);

	if(sess.SupportsMulticasting())
	{
		cout<<"支持组播"<<endl;
	}
	char *p=new char[100];
	i=0;
	sess.SetDefaultPayloadType(96);
	sess.SetDefaultMark(false);
	sess.SetDefaultTimestampIncrement(160);
	while(1)
	{
		i++;
		memset(p,0,100);
		sprintf(p,"bababba:%d",i);
		status=sess.SendPacket(p,100);
		cout<<i<<endl;;
	}

	sess.BYEDestroy(RTPTime(10,0),0,0);
	return 0;
}
</pre><pre code_snippet_id="1677192" snippet_file_name="blog_20160510_4_7431889" name="code" class="cpp">接收端:
<pre name="code" class="cpp">
#include "rtpsession.h"
#include "rtpudpv4transmitter.h"
#include "rtpipv4address.h"
#include "rtpsessionparams.h"
#include "rtperrors.h"
#include "rtppacket.h"
#ifndef WIN32
	#include <netinet/in.h>
	#include <arpa/inet.h>
#else
	#include <winsock2.h>
	#include<windows.h>
#endif // WIN32
#include <stdlib.h>
#include <stdio.h>
#include <iostream>
#include <string>

using namespace jrtplib;
using namespace std;

void checkerror(int rtperr)
{
	if(rtperr<0)
	{
		cout<<"ERROR:"<<RTPGetErrorString(rtperr)<<endl;
		exit(-1);
	}
}
int main()
{
	#ifdef WIN32
	WSADATA dat;
	WSAStartup(MAKEWORD(2,2),&dat);
	#endif // WIN32
	RTPUDPv4TransmissionParams transparams;
	RTPSessionParams sessparams;
	list<uint32_t> localip;
	RTPSession sess;
	uint16_t portbase=8888;
	uint32_t destip,srcip;
	string ipstr="239.255.0.1";
	string ipsrc="114.212.114.200";
	int status,i,num;
	destip=inet_addr(ipstr.c_str());//将字符串转换为32位网络字节序。
	srcip=inet_addr(ipsrc.c_str());
	destip=ntohl(destip);//将32位网络字节序转换成主机字节序
	srcip=ntohl(srcip);
	localip.push_back(srcip);

	sessparams.SetOwnTimestampUnit(1.0/8000);

	sessparams.SetAcceptOwnPackets(true);
	transparams.SetPortbase(portbase);
	//transparams.SetLocalIPList(localip);
	transparams.SetBindIP(srcip);
	transparams.SetMulticastInterfaceIP(srcip);
	RTPIPv4Address addr(destip,portbase);
	status = sess.Create(sessparams,&transparams);
	checkerror(status);
	status=sess.SupportsMulticasting();
	checkerror(status);
	status=sess.JoinMulticastGroup(addr);
	checkerror(status);
	//sess.SetDefaultPayloadType(96);
	//sess.SetDefaultMark(false);
	//sess.SetDefaultTimestampIncrement(160);

	while(1)
	{
		sess.BeginDataAccess();

		if(sess.GotoFirstSourceWithData())
		{
			do
			{
				RTPPacket *pack;
                uint32_t packetLen;
                uint8_t *packetData;
                uint8_t j = 11;
				 while ((pack = sess.GetNextPacket()) != NULL)
                                {
                                        packetLen = pack->GetPacketLength() - 1;
                                        packetData = pack->GetPacketData();
                                        printf("RECV data: ");
                                        while(j++ < packetLen)
                                        {
                                                printf("%c", *(packetData + j));
                                        }
                                        printf("\n");
                                        sess.DeletePacket(pack);
                                }

			}while(sess.GotoNextSourceWithData());

		}
		sess.EndDataAccess();

	}

	return 0;
}

重要的源码

int RTPUDPv4Transmitter::JoinMulticastGroup(const RTPAddress &addr)
{
                 if (!init)
                                 return ERR_RTP_UDPV4TRANS_NOTINIT;

                MAINMUTEX_LOCK

                 int status;

                 if (!created)
                {
                                MAINMUTEX_UNLOCK
                                 return ERR_RTP_UDPV4TRANS_NOTCREATED;
                }
                 if (addr.GetAddressType() != RTPAddress::IPv4Address)
                {
                                MAINMUTEX_UNLOCK
                                 return ERR_RTP_UDPV4TRANS_INVALIDADDRESSTYPE;
                }

                 const RTPIPv4Address &address = (const RTPIPv4Address &)addr;
                uint32_t mcastIP = address.GetIP();

                 if (!RTPUDPV4TRANS_IS_MCASTADDR(mcastIP))
                {
                                MAINMUTEX_UNLOCK
                                 return ERR_RTP_UDPV4TRANS_NOTAMULTICASTADDRESS;
                }

                status = multicastgroups.AddElement(mcastIP);
                 if (status >= 0)
                {
                                RTPUDPV4TRANS_MCASTMEMBERSHIP(rtpsock,IP_ADD_MEMBERSHIP,mcastIP,status);
                                 if (status != 0)
                                {
                                                multicastgroups.DeleteElement(mcastIP);
                                                MAINMUTEX_UNLOCK
                                                 return ERR_RTP_UDPV4TRANS_COULDNTJOINMULTICASTGROUP;
                                }
                                RTPUDPV4TRANS_MCASTMEMBERSHIP(rtcpsock,IP_ADD_MEMBERSHIP,mcastIP,status);
                                 if (status != 0)
                                {
                                                RTPUDPV4TRANS_MCASTMEMBERSHIP(rtpsock,IP_DROP_MEMBERSHIP,mcastIP,status);
                                                multicastgroups.DeleteElement(mcastIP);
                                                MAINMUTEX_UNLOCK
                                                 return ERR_RTP_UDPV4TRANS_COULDNTJOINMULTICASTGROUP;
                                }
                }
                MAINMUTEX_UNLOCK
                 return status;
}

#define RTPUDPV4TRANS_MCASTMEMBERSHIP(socket,type,mcastip,status) {                                                                                                                                                                struct ip_mreq mreq;                                                                                                                                                                                                                                                                                                                                mreq.imr_multiaddr.s_addr = htonl(mcastip);                                                                                                                                                                mreq.imr_interface.s_addr = htonl(mcastifaceIP);                                                                                                                                                                status = setsockopt(socket,IPPROTO_IP,type,(const char *)&mreq, sizeof(struct ip_mreq));                                                                                                                                                }

里面的mcastifaceIP是由自己提前设定的

在create函数里面

bindIP = params->GetBindIP();
                mcastifaceIP = params->GetMulticastInterfaceIP();

                memset(&addr,0, sizeof(struct sockaddr_in));
                addr.sin_family = AF_INET;
                addr.sin_port = htons(params->GetPortbase());
                addr.sin_addr.s_addr = htonl(bindIP);
                 if (bind(rtpsock,(struct sockaddr *)&addr,sizeof( struct sockaddr_in)) != 0)
                {
                                RTPCLOSE(rtpsock);
                                RTPCLOSE(rtcpsock);
                                MAINMUTEX_UNLOCK
                                 return ERR_RTP_UDPV4TRANS_CANTBINDRTPSOCKET;
                }
                memset(&addr,0, sizeof(struct sockaddr_in));
                addr.sin_family = AF_INET;
                addr.sin_port = htons(params->GetPortbase()+1);
                addr.sin_addr.s_addr = htonl(bindIP);
                 if (bind(rtcpsock,(struct sockaddr *)&addr,sizeof( struct sockaddr_in)) != 0)
                {
                                RTPCLOSE(rtpsock);
                                RTPCLOSE(rtcpsock);
                                MAINMUTEX_UNLOCK
                                 return ERR_RTP_UDPV4TRANS_CANTBINDRTCPSOCKET;
                }

具体的实现好的代码下载地址,希望对各位有用,在vs2012下运行:

http://download.csdn.net/detail/u010289908/9515174

点击打开链接

时间: 2024-10-14 15:02:08

jrtplib中组播代码发送端和接收端的实现的相关文章

UDP及其组播,接收发送封装

1.Receiver 1 public class Receiver 2 { 3 public delegate void HeartBeat(byte[] data); 4 public event HeartBeat Heart; 5 6 #region 内部变量 7 private int size = 65535; 8 private UdpClient newsock; 9 private Thread t; 10 private int m_port; 11 private IPEn

UDP发送端&amp;UDP接收端

UDP发送端: import java.io.IOException; import java.net.DatagramPacket; import java.net.DatagramSocket; import java.net.InetAddress; import java.net.SocketException; import java.net.UnknownHostException; public class UdpSendDemo { public static void main

Udp发送端和接收端

//UdpReceive.java /* 定义udp的接收端. 思路: 1.定义udpSocket服务.通常会监听一个端口,其实就是这个接收网络应用程序定义一个数字标示. 2.定义一个数据包,用来存储接收到的字节数据. 因为数据包对象中有特有功能可以提取字节数据中不同数据信息. 3.通过Socket服务的receive方法将收到的数据存入已定义好的数据包中. 4.通过数据包对象的特有功能将这些不同的数据取出,打印到控制台上. 5.关闭资源. */ import java.net.*; publi

如何在AnyChat中使用IP组播接口

AnyChat Platform Core SDK V4.0新增了对IP组播技术的支持,下面介绍如何使用相关的API接口,典型的加入多播组,并向多播组发送数据的代码如下: 1.// 设置本地组播策略 2.DWORD dwMultiCastPolitic = 1; 3.BRAC_SetSDKOption(BRAC_SO_NETWORK_MULTICASTPOLITIC,(const char*)&dwMultiCastPolitic,sizeof(DWORD)); 4.  5.// 加入多播组 6

浅谈Android中的组播(多播)

组播使用UDP对一定范围内的地址发送相同的一组Packet,即一次可以向多个接受者发出信息,其与单播的主要区别是地址的形式.IP协议分配了一定范围的地址空间给多播(多播只能使用这个范围内的IP),IPv4中组播地址范围为224.0.0.0到239.255.255.255. 注意的问题:     1. 在发送组播或则在接收组播的时候,一定要开启一个线程,要不然会出问题.例如在发送组播时候,不要再UI线程中去发,要开启一个子线程去发送.  2. 接收的组播要先加入,然后再能接受到组播发出的的消息.遵

Android开发:组播(多播)与广播

近期由于需要编写能够使同一局域网中的Android客户端与PC端进行自动匹配通信功能的程序,学习并试验了JAVA组播与广播的内容,记录一些理解如下: 一.组播(多播)背景知识:组播使用UDP对一定范围内的地址发送相同的一组Packet,即一次可以向多个接受者发出信息,其与单播的主要区别是地址的形式.IP协议分配了一定范围的地址空间给多播(多播只能使用这个范围内的IP),IPv4中组播地址范围为224.0.0.0到239.255.255.255.JAVA编程:java中通过MulticastSoc

IP组播技术介绍及实现例子

引 言 近年来,随着Internet的迅速普及和爆炸性发展,在Internet上产生了许多新的应用,其中不少是高带宽的多媒体应用,譬如网 络视频会议.网络音频/视频广播.AOD/VOD.股市行情发布.多媒体远程教育.CSCW协同计算.远程会诊.这就带来了带宽的急剧消耗和网络拥挤问 题.为了缓解网络瓶颈,人们提出各种方案,归纳起来,主要包括以下四种: ●增加互连带宽: ●服务器的分散与集群,以改变网络流量结构,减轻主干网的瓶颈: ●应用QoS机制,把带宽分配给一部分应用: ●采用IP Multic

单播,组播(多播),广播以及任播

目录 [+] 单播(unicast): 是指封包在计算机网络的传输中,目的地址为单一目标的一种传输方式.它是现今网络应用最为广泛,通常所使用的网络协议或服务大多采用单播传输,例如一切基于TCP的协议.组播(multicast): 也叫多播, 多点广播或群播. 指把信息同时传递给一组目的地址.它使用策略是最高效的,因为消息在每条网络链路上只需传递一次,而且只有在链路分叉的时候,消息才会被复制.广播(broadcast):是指封包在计算机网络中传输时,目的地址为网络中所有设备的一种传输方式.实际上,

H3C组播系列之IP组播概述

一.组播的基本介绍 组播指发送源将产生的单一IP数据包通过网络发送给一组特定接收者的网络传输方式.组播结合了单播和广播的优点,在进行点到多点传输时,发送源不需要关心接受者的数目,仅需要发送一份报文:路由器仅关心接口下是否有接收者,同样不需要关心接收者的数量,所以在路由器之间的链路上也仅传送一份报告. 和单播相比,组播减轻了发送源的负担,并且提高了链路的有效利用率.此外,发送源可以同时发送报文给多个接收者,可以满足低延时应用的需求. 和广播相比,组播方式下路由器仅在有接收者的接口复制报文,报文最终