程序博客网 > 用流量看淘宝费流量吗?

Qt调用jrtplib实现单播、多播和广播

来源：互联网 发布：用流量看淘宝费流量吗? 编辑：程序博客网 时间：2024/06/05 06:34

【来源】http://blog.csdn.net/caoshangpa/article/details/52571183


jrtplib简介可参考：http://blog.csdn.net/caoshangpa/article/details/51151942

RTP协议分析可参考：http://blog.csdn.net/caoshangpa/article/details/51149007

windows下编译jrtplib可参考：http://blog.csdn.net/caoshangpa/article/details/51152541

Linux下编译jrtplib可参考：http://blog.csdn.net/caoshangpa/article/details/51416822

linux下交叉编译jrtplib可参考：http://blog.csdn.net/caoshangpa/article/details/51416997

1.单播


单播是一种“一对一”模式，在单播通信方式下，当一端发送数据报到一个指定的主机时，首先可能会引发ARP把目的IP地址映射为MAC地址，然而ARP就是基于广播模式的实现。当以太网帧到达一个主机时，以太网接口便会把自己的MAC地址与帧中的MAC地址相比较，如果相符，以太网接口便会接收该帧，并按协议栈向上递交，如果不想符，该帧将会忽略该帧。其他的以太网接口做同样的操作，最后接收该帧的只有一个主机。在此之后，然后以太网帧向上递交到IP层目的主机会核对IP分组中的目的IP与本机IP(多宿主机），符合，根据协议类型向上递交到传输层相应的协议处理这即时单播通信的过程。典型的TCP通信就是单播模式的。

单播在网络中得到了广泛的应用，网络上绝大部分的数据都是以单播的形式传输的，只是一般网络用户不知道而已。例如，你在收发电子邮件、浏览网页时，必须与邮件服务器、Web服务器建立连接，此时使用的就是单播数据传输方式。但是通常使用“点对点通信”（Point to Point）代替“单播”，因为“单播”一般与“多播”和“广播”相对应使用。

[cpp] view plain copy
print?
  1. #include "crtpthread.h"  
  2. #include <QDebug>                                                                                                                                                                                   
  3. CRtpThread::CRtpThread():  
  4.     m_runFlag(true)  
  5. {  
  6. #ifdef RECEIVER  
  7.     uint8_t destIP[]={192,168,1,168};  
  8. #else  
  9.     uint8_t destIP[]={192,168,1,183};  
  10. #endif  
  11.     initialRTP(destIP);  
  12. }  
  13.   
  14. CRtpThread::~CRtpThread()  
  15. {  
  16.     m_session.BYEDestroy(RTPTime(10,0),0,0);  
  17.     m_runFlag=false;  
  18. #ifdef WIN32  
  19.     WSACleanup();  
  20. #endif // WIN32  
  21. }  
  22.   
  23. void CRtpThread::run()  
  24. {  
  25.     while(m_runFlag)  
  26.     {  
  27.         usleep(1);  
  28.         m_session.BeginDataAccess();  
  29.         if (m_session.GotoFirstSourceWithData())  
  30.         {  
  31.             do  
  32.             {  
  33.                 RTPPacket *pack;  
  34.                 while ((pack = m_session.GetNextPacket()) != NULL)  
  35.                 {  
  36.                     int recvSize = pack->GetPayloadLength();  
  37.                     uint8_t * recvData=pack->GetPayloadData();  
  38.                     dispatch(recvData, recvSize);  
  39.                     m_session.DeletePacket(pack);  
  40.                 }  
  41.             } while (m_session.GotoNextSourceWithData());  
  42.         }  
  43.   
  44.         m_session.EndDataAccess();  
  45.   
  46. #ifndef RTP_SUPPORT_THREAD  
  47.         int status = m_session.Poll();  
  48.         if (status < 0)  
  49.         {  
  50.             qDebug()<< RTPGetErrorString(status).c_str();  
  51.         }  
  52. #endif  
  53.     }  
  54. }  
  55.   
  56. void CRtpThread::dispatch(uchar *dataBuf, int dataLen)  
  57. {  
  58.    emit signalRtpData(dataBuf,dataLen);  
  59. #ifdef RECEIVER  
  60.    //将收到的数据转发  
  61.    rtpSendData(dataBuf, dataLen);  
  62. #endif  
  63. }  
  64.   
  65. void::CRtpThread::initialRTP(uint8_t *ip)  
  66. {  
  67. #ifdef WIN32  
  68.     WSADATA dat;  
  69.     WSAStartup(MAKEWORD(2,2),&dat);  
  70. #endif // WIN32  
  71.     //每秒发送10个样本  
  72.     m_sessionparams.SetOwnTimestampUnit(1.0/10.0);  
  73.     //设置本地端口  
  74.     m_transparams.SetPortbase(27000);  
  75.   
  76.     int status = m_session.Create(m_sessionparams,&m_transparams);  
  77.   
  78.     if (status < 0)  
  79.     {  
  80.         qDebug()<< RTPGetErrorString(status).c_str();  
  81.     }  
  82.     //设置目的IP和端口  
  83.     RTPIPv4Address addr(ip,27000);  
  84.     status = m_session.AddDestination(addr);  
  85.     if (status < 0)  
  86.     {  
  87.        qDebug()<< RTPGetErrorString(status).c_str();  
  88.     }  
  89.     //这里设置了默认值，发送的时候只用指定数据和长度SendPacket((void *)dataBuf,dataLen)。  
  90.     //否则发送时需指定后三个参数，例如SendPacket((void *)dataBuf,dataLen,0,false,10)。  
  91.     m_session.SetDefaultPayloadType(0);  
  92.     m_session.SetDefaultMark(false);  
  93.     m_session.SetDefaultTimestampIncrement(10.0);  
  94.     m_session.SetMaximumPacketSize(65535);  
  95. }  
  96.   
  97. void CRtpThread::rtpSendData(uchar *dataBuf, int dataLen)  
  98. {  
  99.     int status = m_session.SendPacket((void *)dataBuf,dataLen);  
  100.     if (status < 0)  
  101.     {  
  102.         qDebug() << RTPGetErrorString(status).c_str();  
  103.     }  
  104. }  
通过注释或放开.pro中的DEFINES +=RECEIVER来控制是发送端还是接收端，接收端会把收到的数据\n转发给发送端。因为是单播，所以在构造函数中需要指定两个IP地址，然后调用initialRTP函数进行RTP的初始化。
发送端和接收端分别如下图所示：



2.多播


多播是一种“一对一组”的模式，也就时加入同一个组的主机才会接收到数据，他综合了单播和广播的优点，可以只对特定的主机进行通信，其他的主机通信不受影响。多播通常被指IP多播，IP多播是一种通过使用一个多播地址将数据在同一时间以高效的方式发往处于TCP/IP网络上的多个接收者的协议。但是对于IP多播，扩容不容易。

“多播”也可以称为“组播”，在网络技术的应用并不是很多，网上视频会议、网上视频点播特别适合采用多播方式。因为如果采用单播方式，逐个节点传输，有多少个目标节点，就会有多少次传送过程，这种方式显然效率极低，是不可取的；如果采用不区分目标、全部发送的广播方式，虽然一次可以传送完数据，但是显然达不到区分特定数据接收对象的目的。采用多播方式，既可以实现一次传送所有目标节点的数据，也可以达到只对特定对象传送数据的目的。IP网络的多播一般通过多播IP地址来实现。多播IP地址就是D类IP地址，即224.0.0.0至239.255.255.255之间的IP地址。Windows 2000中的DHCP管理器支持多播IP地址的自动分配。

[cpp] view plain copy
print?
  1. #include "crtpthread.h"  
  2. #include <QDebug>                                                                                                                                                                                   
  3. CRtpThread::CRtpThread():  
  4.     m_runFlag(true)  
  5. {  
  6.     uint8_t destIP[]={224,212,118,99};  
  7.     initialRTP(destIP);  
  8. }  
  9.   
  10. CRtpThread::~CRtpThread()  
  11. {  
  12.     m_session.BYEDestroy(RTPTime(10,0),0,0);  
  13.     m_runFlag=false;  
  14. #ifdef WIN32  
  15.     WSACleanup();  
  16. #endif // WIN32  
  17. }  
  18.   
  19. void CRtpThread::run()  
  20. {  
  21.     while(m_runFlag)  
  22.     {  
  23.         usleep(1);  
  24.         m_session.BeginDataAccess();  
  25.         if (m_session.GotoFirstSourceWithData())  
  26.         {  
  27.             do  
  28.             {  
  29.                 RTPPacket *pack;  
  30.                 while ((pack = m_session.GetNextPacket()) != NULL)  
  31.                 {  
  32.                     int recvSize = pack->GetPayloadLength();  
  33.                     uint8_t * recvData=pack->GetPayloadData();  
  34.                     dispatch(recvData, recvSize);  
  35.                     m_session.DeletePacket(pack);  
  36.                 }  
  37.             } while (m_session.GotoNextSourceWithData());  
  38.         }  
  39.   
  40.         m_session.EndDataAccess();  
  41.   
  42. #ifndef RTP_SUPPORT_THREAD  
  43.         int status = m_session.Poll();  
  44.         if (status < 0)  
  45.         {  
  46.             qDebug()<< RTPGetErrorString(status).c_str();  
  47.         }  
  48. #endif  
  49.     }  
  50. }  
  51.   
  52. void CRtpThread::dispatch(uchar *dataBuf, int dataLen)  
  53. {  
  54.    emit signalRtpData(dataBuf,dataLen);  
  55. }  
  56.   
  57. void::CRtpThread::initialRTP(uint8_t *ip)  
  58. {  
  59. #ifdef WIN32  
  60.     WSADATA dat;  
  61.     WSAStartup(MAKEWORD(2,2),&dat);  
  62. #endif // WIN32  
  63.     //每秒发送10个样本  
  64.     m_sessionparams.SetOwnTimestampUnit(1.0/10.0);  
  65.     //设置本地端口  
  66.     m_transparams.SetPortbase(27000);  
  67.     //设置网络接口IP地址  
  68. //    uint8_t interfaceIP[]={114,212,118,99};  
  69. //    m_transparams.SetMulticastInterfaceIP(*interfaceIP);  
  70.     //设置多播组数据的TTL值，范围为0～255之间的任何值  
  71.     m_transparams.SetMulticastTTL(255);  
  72.   
  73.     int status = m_session.Create(m_sessionparams,&m_transparams);  
  74.     if (status < 0)  
  75.     {  
  76.         qDebug()<< RTPGetErrorString(status).c_str();  
  77.     }  
  78.     //是否支持多播  
  79.     bool iscast = m_session.SupportsMulticasting();  
  80.     if(!iscast)  
  81.     {  
  82.        m_session.Destroy();  
  83.        qDebug()<<"Do not support multicast";  
  84.        return;  
  85.     }  
  86.     //多播地址  
  87.     RTPIPv4Address addr(ip,27000);  
  88. #ifdef RECEIVER  
  89.     //加入多播  
  90.     status = m_session.JoinMulticastGroup(addr);  
  91.     if (status < 0)  
  92.     {  
  93.         qDebug()<< RTPGetErrorString(status).c_str();  
  94.     }  
  95. #else  
  96.     status = m_session.AddDestination(addr);  
  97.     if (status < 0)  
  98.     {  
  99.         qDebug()<< RTPGetErrorString(status).c_str();  
  100.     }  
  101. #endif  
  102.     //这里设置了默认值，发送的时候只用指定数据和长度SendPacket((void *)dataBuf,dataLen)。  
  103.     //否则发送时需指定后三个参数，例如SendPacket((void *)dataBuf,dataLen,0,false,10)。  
  104.     m_session.SetDefaultPayloadType(0);  
  105.     m_session.SetDefaultMark(false);  
  106.     m_session.SetDefaultTimestampIncrement(10.0);  
  107.     m_session.SetMaximumPacketSize(65535);    
  108. }  
  109.   
  110. void CRtpThread::rtpSendData(uchar *dataBuf, int dataLen)  
  111. {  
  112.     int status = m_session.SendPacket((void *)dataBuf,dataLen);  
  113.     if (status < 0)  
  114.     {  
  115.         qDebug() << RTPGetErrorString(status).c_str();  
  116.     }  
  117. }  
对于发送端，需要将多播地址当做目的地址加入会话；对于接收端，需要调用函数JoinMuticastGroup加入多播组，这样所有加入到多播组的接收端都可以接收到发送端发送的数据。

发送端和接收端分别如下图所示：


3.广播


广播时一种“一对所有”模式，在广播模式下，该以太网帧被局域网中所有的以太网接口接收，并向上递交到传输层，如果指定的端口开启并绑定相应的应用进程时，应用进程就会处理该数据报，如果端口没有任何进程绑定，传输层就会丢弃该数据报。该主机并不会发送一个ICMP数据不可达的消息，否则会导致广播风暴。

广播风暴就是网络长时间被大量的广播数据包所占用，正常的点对点通信无法正常进行，外在表现为网络速度奇慢无比。出现广播风暴的原因有很多，一块有故障的网卡，就可能长时间向网络上发送广播包而导致广播风暴。“广播”在网络中的应用较多，如客户机通过DHCP自动获得IP地址的过程就是通过广播来实现的。

[cpp] view plain copy
print?
  1. #include "crtpthread.h"  
  2. #include <QDebug>                                                                                                                                                                                   
  3. CRtpThread::CRtpThread():  
  4.     m_runFlag(true)  
  5. {  
  6. #ifdef RECEIVER  
  7.     uint8_t destIP[]={192,168,1,168};  
  8. #else  
  9.     uint8_t destIP[]={192,168,1,255};  
  10. #endif  
  11.     initialRTP(destIP);  
  12. }  
  13.   
  14. CRtpThread::~CRtpThread()  
  15. {  
  16.     m_session.BYEDestroy(RTPTime(10,0),0,0);  
  17.     m_runFlag=false;  
  18. #ifdef WIN32  
  19.     WSACleanup();  
  20. #endif // WIN32  
  21. }  
  22.   
  23. void CRtpThread::run()  
  24. {  
  25.     while(m_runFlag)  
  26.     {  
  27.         usleep(1);  
  28.         m_session.BeginDataAccess();  
  29.         if (m_session.GotoFirstSourceWithData())  
  30.         {  
  31.             do  
  32.             {  
  33.                 RTPPacket *pack;  
  34.                 while ((pack = m_session.GetNextPacket()) != NULL)  
  35.                 {  
  36.                     int recvSize = pack->GetPayloadLength();  
  37.                     uint8_t * recvData=pack->GetPayloadData();  
  38.                     dispatch(recvData, recvSize);  
  39.                     m_session.DeletePacket(pack);  
  40.                 }  
  41.             } while (m_session.GotoNextSourceWithData());  
  42.         }  
  43.   
  44.         m_session.EndDataAccess();  
  45.   
  46. #ifndef RTP_SUPPORT_THREAD  
  47.         int status = m_session.Poll();  
  48.         if (status < 0)  
  49.         {  
  50.             qDebug()<< RTPGetErrorString(status).c_str();  
  51.         }  
  52. #endif  
  53.     }  
  54. }  
  55.   
  56. void CRtpThread::dispatch(uchar *dataBuf, int dataLen)  
  57. {  
  58.    emit signalRtpData(dataBuf,dataLen);  
  59. }  
  60.   
  61. void::CRtpThread::initialRTP(uint8_t *ip)  
  62. {  
  63. #ifdef WIN32  
  64.     WSADATA dat;  
  65.     WSAStartup(MAKEWORD(2,2),&dat);  
  66. #endif // WIN32  
  67.     //每秒发送10个样本  
  68.     m_sessionparams.SetOwnTimestampUnit(1.0/10.0);  
  69.     //设置本地端口  
  70.     m_transparams.SetPortbase(27000);  
  71.   
  72.     int status = m_session.Create(m_sessionparams,&m_transparams);  
  73.     if (status < 0)  
  74.     {  
  75.         qDebug()<< RTPGetErrorString(status).c_str();  
  76.     }  
  77.     //设置目的IP和端口  
  78.     RTPIPv4Address addr(ip,27000);  
  79.     status = m_session.AddDestination(addr);  
  80.     if (status < 0)  
  81.     {  
  82.         qDebug()<< RTPGetErrorString(status).c_str();  
  83.     }  
  84.     //这里设置了默认值，发送的时候只用指定数据和长度SendPacket((void *)dataBuf,dataLen)。  
  85.     //否则发送时需指定后三个参数，例如SendPacket((void *)dataBuf,dataLen,0,false,10)。  
  86.     m_session.SetDefaultPayloadType(0);  
  87.     m_session.SetDefaultMark(false);  
  88.     m_session.SetDefaultTimestampIncrement(10.0);  
  89.     m_session.SetMaximumPacketSize(65535);    
  90. }  
  91.   
  92. void CRtpThread::rtpSendData(uchar *dataBuf, int dataLen)  
  93. {  
  94.     int status = m_session.SendPacket((void *)dataBuf,dataLen);  
  95.     if (status < 0)  
  96.     {  
  97.         qDebug() << RTPGetErrorString(status).c_str();  
  98.     }  
  99. }  

RTP协议一般用于单播和多播，如果开发中有广播的需求，广播与单播的唯一区别就是将发送端目标IP的最后字段设置为255，比如本例中的192.168.1.255，这样的话该网段的接收端都能收到发送端发送的数据。
发送端和接收端运行效果与多播相同。


使用jrtplib的一个具体例子： 基于RTP协议的H.264视频传输系统：实现


参考链接：http://blog.csdn.net/wye213/article/details/9896547

参考链接：http://blog.csdn.net/maopig/article/details/6863253

参考链接：https://docs.oracle.com/cd/E38902_01/html/E38880/sockets-137.html

源码链接：见http://blog.csdn.net/caoshangpa/article/details/52571183的评论



顶
5
踩
0
 
 

  相关文章推荐
  • • 什么是单播、多播和广播、广播机制、组播
  • • 单播，广播和多播
  • • 转发：什么是单播、多播和广播
  • • 通过live555实现H264 RTSP直播（Windows版）
  • • linux 调用jrtplib 实现单播，多播，广播
  • • 单播、多播（组播）和广播的区别
  • • 单播、多播、广播
  • • JAVA 单播、多播（组播）、广播
  • • 关于计算机网络中的单播，多播，广播（粘贴）
  • • 单播、多播与广播
阅读全文
0 0
用流量看淘宝费流量吗? 用流量看淘宝费流量吗?
原创粉丝点击
热门IT博客
snmp 端口snmp 端口
淘宝查优惠券插件淘宝查优惠券插件
乎乎合适的词
网络监控软件哪个好用
python 频域
做淘宝直播如何赚钱
057188157858是淘宝网
python编程入门到实践
基于模型的推荐算法
sql数据库2000
笔记本看电视软件
查成绩的软件
深入理解linux内核4.4
grace评分软件下载
淘宝怎么查看退货率
java哈希算法
淘宝克隆宝贝软件
淘宝买的电影票能退吗
php参考手册下载
科比个赛季数据统计
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 港股休市2019时间表 股票休市时间表 2019股市交易日休市日期 国庆休息 休息 中午休息 休息图片 国庆节休息 休息拼音 休息反义词 休息近义词 休息时间 休息英文 今天休息 休息的拼音 休息一下 休息的英文 休息下 卧床休息 十一休息 休息英语 瑜伽休息术 中场休息 休息的读音 休息休息休息 休息读音 休息休息的图片 休息中图片 休息休息休息休息 休息吧图片 休息的图片 休息休息 休息图 休息的英语 休息怎么读 休息的意思 休息天 周末休息 多休息 银行中午休息吗 银行中午休息

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里