Doubango RTP包传输使用UDT可靠传输协议，解决RTP丢包问题

最新推荐文章于 2024-01-21 00:15:47 发布
最新推荐文章于 2024-01-21 00:15:47 发布
阅读量1.2k 收藏 2
点赞数 1
分类专栏： 流媒体 文章标签： udt
使用SIP做过VOIP通话的同学，肯定被RTP丢包弄的焦头烂额，必定尝试过不少的办法，比方：
1、丢包重传(NACK)
2、前向纠错(FEC)
3、丢帧处理
但效果往往不尽如人意，那有没有一劳永逸的方法？确实，网络发展到现在，家庭带宽随随便便都是百兆的今天，为什么还有让人困扰不已的丢包问题？为何不换成TCP传输，假如延时容许的情况下，UDT就是为了解决这个问题的。

UDT建立于UDP之上，并引入新的拥塞控制和数据可靠性控制机制。UDT是面向连接的双向的应用层协议。它同时支持可靠的数据流传输和部分可靠的数据报传输，UDT的特点是不用进行开发，直接利用库的发送函数就可以实现可靠的数据传输。

Doubango rtp接收和发送函数修改：

[cpp]  view plain  copy
  1. /* use transport udt*/  
  2. #include "udt_api.h"  
  3.   
  4. void *udt_transport_mainthread(void *param)  
  5. {  
  6.     trtp_manager_t *self = param;  
  7.   
  8.   
  9.     if(!self){  
  10.         TSK_DEBUG_ERROR("udt_transport_mainthread Invalid parameter");  
  11.         return 0;  
  12.     }  
  13.     TSK_DEBUG_INFO("ii udt_transport_mainthread enter, self->is_originated:%d", self->is_originated);  
  14.   
  15.     int rcv_buf = (int)tmedia_defaults_get_rtpbuff_size();  
  16.     int snd_buf = (int)tmedia_defaults_get_rtpbuff_size();  
  17.   
  18.     int clientFD = -1;                 
  19.     int socketfDUDT = -1;           
  20.     int clientSocket = -1;   
  21.     if (self->is_originated){  
  22.         //first listen  
  23.         int ret = init_udt(&socketfDUDT, (self->rtp.public_port), 0);  
  24.         self->serverSocket = socketfDUDT;  
  25.         TSK_DEBUG_INFO("socketfDUDT:%d listent", socketfDUDT);  
  26.   
  27.         set_connect_buff_udt(&socketfDUDT, rcv_buf, snd_buf);//set buff size  
  28.           
  29.         listen_udt(&socketfDUDT);          
  30.         clientFD = accept_udt(&socketfDUDT);  
  31.         if (clientFD == -1){  
  32.             TSK_DEBUG_ERROR("clientFd is failed");  
  33.             tsk_safeobj_lock(self);  
  34.             self->mainThreadId[0] = NULL;  
  35.             tsk_safeobj_unlock(self);//lyz@xdja.com add for crash.  
  36.   
  37.             goto FAILED;  
  38.         }   
  39.         TSK_DEBUG_INFO("clientFD:%d enter", clientFD);  
  40.   
  41.         if (!tmedia_defaults_get_single_connect()){  
  42.             //after connect 2 user  
  43.             ret = init_udt(&clientSocket, (self->rtp.public_port + 3), 0);  
  44.             set_connect_buff_udt(&clientSocket, rcv_buf, snd_buf);//set buff size  
  45.           
  46.             if (0 != ret || clientSocket == -1){  
  47.                 TSK_DEBUG_ERROR("clientSocket connect init is failed");  
  48.                 tsk_safeobj_lock(self);  
  49.                 self->mainThreadId[0] = NULL;  
  50.                 tsk_safeobj_unlock(self);//lyz@xdja.com add for crash.  
  51.   
  52.                 goto FAILED;  
  53.             }  
  54.             ret = connect_udt(&clientSocket, self->rtp.remote_ip, self->rtp.remote_port);  
  55.             if (-1 == ret){  
  56.                 TSK_DEBUG_ERROR("clientSocket connect is failed");  
  57.                 tsk_safeobj_lock(self);  
  58.                 self->mainThreadId[0] = NULL;  
  59.                 tsk_safeobj_unlock(self);//lyz@xdja.com add for crash.  
  60.   
  61.                 goto FAILED;  
  62.             }          
  63.             TSK_DEBUG_INFO("clientSocket:%d enter", clientSocket);  
  64.   
  65.             self->clientSocket = clientSocket;  
  66.         }  
  67.     }else{  
  68.         //first connect 2 user  
  69.         int ret = init_udt(&clientSocket, (self->rtp.public_port + 3), 0);  
  70.         if (0 != ret || clientSocket == -1){  
  71.             TSK_DEBUG_ERROR("ii clientSocket connect init is failed");  
  72.             tsk_safeobj_lock(self);  
  73.             self->mainThreadId[0] = NULL;  
  74.             tsk_safeobj_unlock(self);//lyz@xdja.com add for crash.  
  75.   
  76.             goto FAILED;  
  77.         }  
  78.         set_connect_buff_udt(&clientSocket, rcv_buf, snd_buf);//set buff size  
  79.         ret = connect_udt(&clientSocket, self->rtp.remote_ip, self->rtp.remote_port);  
  80.         if (-1 == ret){  
  81.             TSK_DEBUG_ERROR("clientSocket connect is failed");  
  82.             tsk_safeobj_lock(self);  
  83.             self->mainThreadId[0] = NULL;  
  84.             tsk_safeobj_unlock(self);//lyz@xdja.com add for crash.  
  85.   
  86.             goto FAILED;  
  87.         }  
  88.         self->clientSocket = clientSocket;  
  89.         TSK_DEBUG_INFO("ii clientSocket:%d enter", clientSocket);  
  90.           
  91.         if (!tmedia_defaults_get_single_connect()){  
  92.             //second listen  
  93.             ret = init_udt(&socketfDUDT, (self->rtp.public_port), 0);  
  94.             self->serverSocket = socketfDUDT;  
  95.             TSK_DEBUG_INFO("ii socketfDUDT:%d listent", socketfDUDT);  
  96.               
  97.             set_connect_buff_udt(&socketfDUDT, rcv_buf, snd_buf);//set buff size  
  98.             listen_udt(&socketfDUDT);  
  99.             clientFD = accept_udt(&socketfDUDT);  
  100.             if (clientFD == -1){  
  101.                 TSK_DEBUG_ERROR("clientFd is failed");  
  102.                 tsk_safeobj_lock(self);  
  103.                 self->mainThreadId[0] = NULL;  
  104.                 tsk_safeobj_unlock(self);//lyz@xdja.com add for crash.  
  105.   
  106.                 goto FAILED;  
  107.             }           
  108.             TSK_DEBUG_INFO("ii clientFD:%d enter", clientFD);  
  109.         }else{  
  110.                 tsk_safeobj_lock(self);  
  111.                 self->mainThreadId[0] = NULL;  
  112.                 tsk_safeobj_unlock(self);//lyz@xdja.com add for crash.  
  113.         }   
  114.     }  
  115.   
  116.     if (tmedia_defaults_get_single_connect()){  
  117.         if (self->is_originated){  
  118.             char buffer[4096];  
  119.             while(self->is_started){  
  120.                 int received = recvdata_udt(&clientFD, buffer, sizeof(buffer), 0);  
  121.   
  122.                 if (received <= -1) {  
  123.                     continue;  
  124.                 }  
  125.   
  126.                 _trtp_manager_recv_data(self, buffer, received, -1, NULL);  
  127.             }  
  128.         }  
  129.   
  130.     }else{  
  131.             char buffer[4096];  
  132.             while(self->is_started){  
  133.                 int received = recvdata_udt(&clientFD, buffer, sizeof(buffer), 0);  
  134.   
  135.                 if (received <= -1) {  
  136.                     continue;  
  137.                 }  
  138.   
  139.                 _trtp_manager_recv_data(self, buffer, received, -1, NULL);  
  140.             }  
  141.     }  
  142.   
  143. FAILED:          
  144.     if (-1 !=clientFD){  
  145.         close_udt(clientFD);  
  146.     }  
  147.     if (-1 !=socketfDUDT){  
  148.         close_udt(socketfDUDT);  
  149.     }  
  150.       
  151.     TSK_DEBUG_INFO("udt_transport_mainthread end.");  
  152.     return 0;  
  153. }  
  154.   
  155. int udt_transport_send(trtp_manager_t* self, char* encodedData, int encodedDataLen){  
  156.     TSK_DEBUG_INFO("senddata_udt START:%d", encodedDataLen);  
  157.   
  158.     int ret = senddata_udt(&self->clientSocket, encodedData, encodedDataLen, 0);  
  159.     if (-1 == ret){  
  160.     TSK_DEBUG_ERROR("senddata_udt failed");  
  161.         return -1;  
  162.     }  
  163.     TSK_DEBUG_INFO("senddata_udt ret:%d", ret);  
  164.       
  165.     return ret;  
  166. }  
  167. /* add end */  

启动：在 int trtp_manager_start(trtp_manager_t* self)中：

[cpp]  view plain  copy
  1. if(!self->transport || !self->transport->master){  
  2.              //use other transport --udt:  
  3.              if (tmedia_defaults_get_use_udt_socket() != 0){  
  4.                    //use other transport.  
  5.                    self->clientSocket = -1;  
  6.                    self->serverSocket = -1;  
  7.                    self->is_started = tsk_true;  
  8.   
  9.                    if ((ret = tsk_thread_create(self->mainThreadId, udt_transport_mainthread, self))){ /* More important than "tsk_runnable_start" ==> start it first. */  
  10.                        TSK_DEBUG_FATAL("Failed to create udt main thread [%d]", ret);  
  11.                    }else{             
  12.              TSK_DEBUG_INFO("udt thread create success.");            
  13.                   
  14. if !TNET_UNDER_APPLE  
  15.                        ret = tsk_thread_set_priority(self->mainThreadId[0], TSK_THREAD_PRIORITY_TIME_CRITICAL);  
  16. endif  
  17.                        tsk_safeobj_unlock(self);  
  18.     
  19.                        return 0;  
  20.                    }  
  21.              }  
  22.              //add end.  
  23.                
  24.     TSK_DEBUG_ERROR("RTP/RTCP manager not prepared");  
  25.     ret = -2;  
  26.     goto bail;  
  27. }  
  28.      



UDT协议封装：

[cpp]  view plain  copy
  1. int init_udt(int *usock, int port, bool rendezvous);  
  2. int connect_udt(void* usocket, char *peerip, int port);  
  3. int set_connect_buff_udt(void* usocket, int send_buf_size, int recv_buf_size);  
  4. int recvdata_udt(void* usocket, char* buf, int size, int flags);  
  5. int senddata_udt(void* usocket, char* buf, int size, int flags);  
  6. int listen_udt(void* usocket);  
  7. int accept_udt(void* usocket);  
  8. int close_udt(int usock);  

实现： 

[cpp]  view plain  copy
  1. #include <winsock2.h>  
  2. #include <ws2tcpip.h>  
  3. #include <wspiapi.h>  
  4. #include <iostream>  
  5. #include <udt.h>  
  6. #include <arpa/inet.h>   
  7. #include <android/log.h>  
  8. #define TAG "UDT_API"  
  9.   
  10. extern "C" int init_udt(int *usock, int port, bool rendezvous);  
  11. extern "C" int connect_udt(void* usocket, char *peerip, int port);  
  12. extern "C" int set_connect_buff_udt(void* usocket, int send_buf_size, int recv_buf_size);  
  13. extern "C" int recvdata_udt(void* usocket, char* buf, int size, int flags);  
  14. extern "C" int senddata_udt(void* usocket, char* buf, int size, int flags);  
  15. extern "C" int listen_udt(void* usocket);  
  16. extern "C" int accept_udt(void* usocket);  
  17. extern "C" int close_udt(int usock);  
  18.   
  19. using namespace std;  
  20.   
  21. const int g_IP_Version = AF_INET;  
  22. const int g_Socket_Type = SOCK_DGRAM;  
  23. const char g_Localhost[] = "127.0.0.1";  
  24.     
  25. int init_udt(int *usock, int port, bool rendezvous){  
  26.     addrinfo hints;  
  27.     addrinfo* res;  
  28.     memset(&hints, 0, sizeof(struct addrinfo));  
  29.     hints.ai_flags = AI_PASSIVE;  
  30.     hints.ai_family = AF_INET;  
  31.     hints.ai_socktype = g_Socket_Type;  
  32.   
  33.     if (usock == NULL){  
  34.         return -1;  
  35.     }  
  36.   
  37.     char service[16];  
  38.     sprintf(service, "%d", port);  
  39.   
  40.     if (0 != getaddrinfo(NULL, service, &hints, &res))  
  41.     {  
  42.         cout << "illegal port number or port is busy.\n" << endl;             
  43.              __android_log_print(ANDROID_LOG_WARN, TAG, "illegal port number or port is busy:%s", UDT::getlasterror().getErrorMessage() );  
  44.   
  45.         return -1;  
  46.     }  
  47.   
  48.     UDTSOCKET retFD = UDT::socket(res->ai_family, res->ai_socktype, res->ai_protocol);  
  49.   
  50.     // since we will start a lot of connections, we set the buffer size to smaller value.  
  51.     int snd_buf = 16000;  
  52.     int rcv_buf = 16000;  
  53.     UDT::setsockopt(retFD, 0, UDT_SNDBUF, &snd_buf, sizeof(int));  
  54.     UDT::setsockopt(retFD, 0, UDT_RCVBUF, &rcv_buf, sizeof(int));   
  55.     //int fc = 16;  
  56.     //UDT::setsockopt(retFD, 0, UDT_FC, &fc, sizeof(int));  
  57.     bool reuse = true;  
  58.     UDT::setsockopt(retFD, 0, UDT_REUSEADDR, &reuse, sizeof(bool));  
  59.     UDT::setsockopt(retFD, 0, UDT_RENDEZVOUS, &rendezvous, sizeof(bool));  
  60.   
  61.     if (UDT::ERROR == UDT::bind(retFD, res->ai_addr, res->ai_addrlen))  
  62.     {  
  63.             __android_log_print(ANDROID_LOG_WARN, TAG, "err, init failed:%s", UDT::getlasterror().getErrorMessage() );  
  64.         cout << "bind: " << UDT::getlasterror().getErrorMessage() << endl;  
  65.         return -1;  
  66.     }   
  67.   
  68.     *usock = retFD;//set output socket fd.  
  69.   
  70.     freeaddrinfo(res);  
  71.     return 0;  
  72. }  
  73.    
  74. int connect_udt(void* usocket, char *peerip, int port){  
  75.     if (usocket == NULL || peerip == NULL){  
  76.         return -1;  
  77.     }  
  78.     UDTSOCKET usock = *(UDTSOCKET*)usocket;  
  79.       
  80.     addrinfo hints, *peer;  
  81.     memset(&hints, 0, sizeof(struct addrinfo));  
  82.     hints.ai_flags = AI_PASSIVE;  
  83.     hints.ai_family =  g_IP_Version;  
  84.     hints.ai_socktype = g_Socket_Type;  
  85.   
  86.     char buffer[16];  
  87.     sprintf(buffer, "%d", port);  
  88.    
  89.     if (0 != getaddrinfo(peerip, buffer, &hints, &peer))  
  90.     {  
  91.         return -1;  
  92.     }  
  93.   
  94.        int newsock = UDT::connect(usock, peer->ai_addr, peer->ai_addrlen);  
  95.   
  96.     freeaddrinfo(peer);  
  97.     return newsock;  
  98. }  
  99.   
  100. int recvdata_udt(void* usocket, char* buf, int size, int flags){      
  101.     if (usocket == NULL){  
  102.         return -1;  
  103.     }  
  104.     UDTSOCKET recver = *(UDTSOCKET*)usocket;    
  105.     int rs;    
  106.     //if (UDT::ERROR == (rs = UDT::recv(recver, buf, size, 0)))  
  107.     if (UDT::ERROR == (rs = UDT::recvmsg(recver, buf, size)))  
  108.     {  
  109.         cout << "recv:" << UDT::getlasterror().getErrorMessage() << endl;  
  110.               if (UDT::getlasterror().getErrorCode() == 2001 || UDT::getlasterror().getErrorCode() == 5004){  
  111.                   return  -1;  
  112.               }  
  113.             __android_log_print(ANDROID_LOG_WARN, TAG, "err, recvdata_udt failed:%s", UDT::getlasterror().getErrorMessage() );  
  114.         return -1;  
  115.     }   
  116.     return rs;  
  117. }  
  118.   
  119. int set_connect_buff_udt(void* usocket, int send_buf_size, int recv_buf_size){  
  120.     if (usocket == NULL){  
  121.         return -1;  
  122.     }  
  123.     UDTSOCKET sock = *(UDTSOCKET*)usocket;     
  124.     UDT::setsockopt(sock, 0, UDT_SNDBUF, &send_buf_size, sizeof(int));  
  125.     UDT::setsockopt(sock, 0, UDT_RCVBUF, &recv_buf_size, sizeof(int));   
  126.       
  127.     return 0;  
  128. }  
  129.   
  130. int senddata_udt(void* usocket, char* buf, int size, int flags){  
  131.          
  132.     if (usocket == NULL){  
  133.        return -1;  
  134.     }  
  135.     UDTSOCKET client = *(UDTSOCKET*)usocket;  
  136.       
  137.     int sent = 0;   
  138.     while (sent < size){  
  139.         //int ret = UDT::send(client, (((const char*)buf) + sent), (int)(size - sent), flags);  
  140.         int ret = UDT::sendmsg(client, (((const char*)buf) + sent), (int)(size - sent), -1, true);  
  141.         if (sent < 0)  
  142.         {             
  143.             __android_log_print(ANDROID_LOG_WARN, TAG, "err, senddata_udt failed:%s", UDT::getlasterror().getErrorMessage() );  
  144.   
  145.             cout << "send: " << UDT::getlasterror().getErrorMessage() << endl;  
  146.             return -1;  
  147.         }   
  148.         else{  
  149.             __android_log_print(ANDROID_LOG_WARN, TAG, " senddata_udt ret:%d, size:%d", ret, size);  
  150.   
  151.             sent += ret;  
  152.         }  
  153.     }  
  154.       
  155.     return sent;  
  156. }  
  157.     
  158. int listen_udt(void* usocket){  
  159.     if (usocket == NULL){  
  160.        return -1;  
  161.     }  
  162.     UDTSOCKET serv = *(UDTSOCKET*)usocket;   
  163.       
  164.     return UDT::listen(serv, 1024);  
  165. }  
  166.   
  167. int accept_udt(void* usocket){  
  168.     if (usocket == NULL){  
  169.        return -1;  
  170.     }  
  171.     UDTSOCKET serv = *(UDTSOCKET*)usocket;   
  172.     sockaddr_in  clientaddr;  
  173.     int addrlen = sizeof(clientaddr);  
  174.     UDTSOCKET new_sock = UDT::accept(serv, (sockaddr*)&clientaddr, &addrlen);   
  175.   
  176.     if (new_sock == UDT::INVALID_SOCK)  
  177.     {  
  178.         return -1;  
  179.     }  
  180.     char ip[16];  
  181.     cout << "new connection: " << inet_ntoa(clientaddr.sin_addr) << ":" << ntohs(clientaddr.sin_port) << endl;  
  182.   
  183.       
  184.     return new_sock;  
  185. }  
  186.   
  187. int close_udt(int usock){  
  188.     UDT::close(usock);  
  189.     return 0;  
  190. }  
老衲不出家
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
doubango_IMS_compile.zip_doubango_doubango pudn
09-14
文章中详细介绍了IMS协议栈doubango源代码系统的编译方法
RTP协议与实战
椛茶的博客
12-15 7567
在实时音视频通话中，我们通常使用 UDP 作为传输层协议，使用 RTP 协议包荷载音视频数据，RTP（Real-time Transport Protocol）是一种在 Internet 上传输多媒体数据的应用层协议，它通常建立在 UDP 之上（也可以建立在 TCP 上）。UDP 协议没有序号等信息，而 RTP 协议可以补充许多音视频传输必要的信息，让音视频数据到达对端后可以重新组合完整，RTP 本身只保证实时数据的传输，并不能提供可靠传输保证，也没有流量控制，拥塞控制机制，它通常与 RTCP 配合使用以提
实时传输协议---RTP【详解】
王木木
01-29 3万+
目录 一、RTP简介 二、RTP的工作机制 三、RTP协议解析 一、RTP简介 RTP全名是Real-time Transport Protocol（实时传输协议）。RTP用来为IP网上的语音、图像、传真等多种需要实时传输的多媒体数据提供端到端的实时传输服务。RTP为Internet上端到端的实时传输提供时间信息和流同步，但并不保证服务质量，服务质量由RTCP来提供。 RTP是一种运行在传输层的协议，通常基于 UDP 协议，但也支持 TCP 协议。 RTP数据包由两部分组成，一部分是RTP
流媒体基础-RTP协议
键盘敲的劈啪响
12-31 2861
RTP协议是流媒体最常用的协议，在学习的过程中，我建议是把所有头字段都给背出来，而不仅仅是照表操作
流媒体-RTP/RTCP
mm792261167的博客
04-07 723
一、简介       1） RTP（Realtime TransportProtocol）：是针对Internet上多媒体数据流的一个传输协议,工作在一对一或一对多的传输情况下，其目的是提供时间信息和实现流同步。RTP本身只保证实时数据的传输，并不能为按顺序传送数据包提供可靠的传送机制，也不提供流量控制或拥塞控制，它依靠RTCP提供这些服务。     2）RTCP（Realtime T
RTP协议
SimpleForest的博客
04-01 648
RTP协议简介
doubango库
01-14
这是doubango库,见，http://blog.csdn.net/haoyujie/article/details/79058786 boghe需要，telepresence也需要。
libgsm(doubango编译需要）
02-23
如果在doubango中编译，需要的gsm库不对。吾经过一番折腾，终于找到了正确解决办法。具体可以参考： https://blog.csdn.net/quantum7/article/details/104087285 吾已将此代码上传到github： ...
doubango2.0
01-03
doubango2.0 sip sdp http udp tcp
doubango入门
06-21
Doubango 入门，VOIP SIP ,帮助开发SIP客户端，包括PC,ANDROID,IOS等平台。
RTP/RTCP 协议讲解
明天你好的博客
10-02 2999
目前，支持流媒体传输的协议主要有实时传输协议 RTP实时传输控制协议 RTCP（Real-Time Transport Control Protocol）和实时流协议 RTSP（Real-Time Streaming Protocol）等。RTSP协议抓包及讲解。流媒体协议栈如下图所示：本文对 RTP 及 RTCP 协议进行了讲解，以及使用 wireshark 抓包对其抓到的报文进行详细分析。
RTP协议全解析（H264码流和PS流）
热门推荐
对牛乱弹琴
09-12 26万+
1RTP Header解析 2、RTP荷载H264码流 2.1、单个NAL单元包 2.2、分片单元（FU-A） 3、RTP荷载PS流 3.1、PS包头 3.2、系统标题 3.3、节目映射流 3.4、PES分组头部
RTP协议入门基础
crl6的博客
04-05 1007
RTP协议入门基础 （一）RTP身世： 实时传输协议RTP（Real-time Transport Protocol）是一个网络传输协议，它作为因特网标准在 [ RFC 3550 ] 有详细说明。 RTP协议规定了互联网上传递音频和视频的标准数据包格式，可用于多播协议，单播应用中。RTP协议常用于流媒体系统（配合RTSP协议）和RTCP一起使用，它是建立在用户...
RTP协议详解
流媒体巅峰之路
07-23 1万+
1.什么是RTP 数据传输协议RTP，用于实时传输数据。RTP全名是Real-time Transport Protocol（实时传输协议）。它是IETF提出的一个标准，对应的RFC文档为RFC3550。RFC3550不仅定义了RTP，而且定义了配套的相关协议RTCP（Real-time Transport Control Protocol，即实时传输控制协议）。RTP用来为IP网上的语音、图像、传真等多种需要实时传输的多媒体数据提供端到端的实时传输服务。RTP为Internet上端到端的实时传输提..
实时传输协议（RTP）介绍
最新发布
Dontla的博客
01-21 1182
实时传输协议 (RTP) 是一种重要的网络协议，它解决了实时音频和视频数据的网络传输问题。虽然 RTP 本身并不能保证数据的可靠传输，但是在大多数情况下，它都能提供满意的服务质量。同时，RTP 的设计也使得它可以很容易地与其他协议（如 RTCP）一起使用，以提供更完整的解决方案。
RTP协议分析
草上爬的博客
04-14 9767
一、简介 1.RTP和RTCP RTP全名是Real-time Transport Protocol（实时传输协议）。它是IETF提出的一个标准，对应的RFC文档为RFC3550（RFC1889为其过期版本）。RFC3550不仅定义了RTP，而且定义了配套的相关协议RTCP（Real-time Transport Control Protocol，即实时传输控制协议）。RTP被...
RTP实时传输协议
凡事预则立，不预则废
05-10 6579
    RTP协议被定义为一个用于在IP网络上实时传输音视频数据的标准数据包格式，它被广泛应用于通信和娱乐系统中，包括流媒体、视频会议、电视服务等等。    RTP可以提供低延时的数据传送服务，但无法保证数据包到达客户端时仍然保持着发送时的顺序，所以要依靠RTCP来完成流量控制和拥塞监控。    RTP协议时运行在UDP协议之上的，在OSI七层模型种，它们运行在传输层。其他底层协议也可以和RTP协...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值