自己动手写RTP服务器——用RTP协议传输TS流

最新推荐文章于 2023-10-02 21:32:37 发布
最新推荐文章于 2023-10-02 21:32:37 发布
阅读量2.2k 收藏 2
点赞数 1
分类专栏： 流媒体 ffmpeg

自己动手写RTP服务器——用RTP协议传输TS流


上一篇文章我们介绍了关于RTP协议的知识，那么我们现在就自己写一个简单的传输TS流媒体的RTP服务器吧。

预备知识

关于TS流的格式：TS流封装的具体格式请参考文档ISO/IEC 13818-1。这里我们只需要了解一些简单的信息就好。首先TS流是有许多的TS Packet组成的，每个TS Packet的长度固定为188 bytes，每个packet都是以sync_byte：0x47开头。

MTU(Maximum Transmission Unit)： 最大传输单元。是指一种通信协议的某一层上面所能通过的最大数据包大小（以字节为单位）。最大传输单元这个参数通常与通信接口有关（网络接口卡、串口等）。例如：以太网无法接收大于1500 字节的数据包。

参考代码

下面我会把自己写的简单的代码贴出来，并且一步步地说明。

新建main.c文件，内容如下：

[cpp]  view plain copy
  1. #include <stdio.h>  
  2. #include <string.h>  
  3. #include <sys/types.h>  
  4. #include <sys/socket.h>  
  5. #include <netinet/in.h>  
  6.   
  7. #define TS_PACKET_SIZE 188  
  8. #define MTU 1500  
说明：包含一些必要的头文件，并且定义了TS Packet的长度(188 bytes)，MTU的限制(1500 bytes)。

[cpp]  view plain copy
  1. struct rtp_header{  
  2.     unsigned char cc:4;  
  3.     unsigned char x:1;  
  4.     unsigned char p:1;  
  5.     unsigned char v:2;  
  6.       
  7.     unsigned char pt:7;  
  8.     unsigned char m:1;  
  9.   
  10.     unsigned short sequence_number;  
  11.     unsigned int timestamp;  
  12.     unsigned int ssrc;  
  13. };  
  14.   
  15. void init_rtp_header(struct rtp_header *h){  
  16.     h->v = 2;  
  17.     h->p = 0;  
  18.     h->x = 0;  
  19.     h->cc = 0;  
  20.     h->m = 0;  
  21.     h->pt = 33;  
  22.     h->sequence_number = 123;  
  23.     h->timestamp = 123;  
  24.     h->ssrc = 123;  
  25. }  
说明：这里定义了RTP Header的结构体，以及初始化的方法。这里用到了位域，这是实现协议的时候常常会用到的方法。

需要注意的是：

你会发现这里定义RTP Header的时候，上一篇讲到的具体顺序不同。原因是本机和网络字节流的顺序相反，如果按照v p x cc的顺序来定义一个byte，在这个byte内部v p x cc就会按照从低位到高位的顺序放置；而在RTP流中，应该是顺序从高位到低位放置的。所以每个byte我都把顺序做了倒置。

初始化RTP Header的函数的初始化值的意义请参考rfc3550。为了实现简单，其中的sequence_number、timestamp、ssrc，都是随意填写的。在发送包的时候需要将sequence_number递增。

[cpp]  view plain copy
  1. void sequence_number_increase(struct rtp_header *header){  
  2.     unsigned short sequence = ntohs(header->sequence_number);  
  3.     sequence++;  
  4.     header->sequence_number = htons(sequence);  
  5. }  
说明：这个函数的目的就是让sequence_number加一，还是由于本机与网络字节序不同的原因，所以显得略微复杂些。

[cpp]  view plain copy
  1. int main(){  
  2.     // RTP Packet we will send  
  3.     char buf[MTU];  
  4.     unsigned int count = 0;  
  5.   
  6.     // Init RTP Header  
  7.     init_rtp_header((struct rtp_header*)buf);  
  8.     count = sizeof(struct rtp_header);  
  9.   
  10.     // Init socket  
  11.     int sock = socket(AF_INET, SOCK_DGRAM, 0);  
  12.     struct sockaddr_in dest_addr;  
  13.       
  14.     dest_addr.sin_family=AF_INET;  
  15.     dest_addr.sin_port = htons(6666);  
  16.     dest_addr.sin_addr.s_addr = INADDR_ANY;  
  17.     bzero(&(dest_addr.sin_zero),8);  
  18.       
  19.     // Open TS file  
  20.     FILE *ts_file = fopen("/home/baby/Videos/480p.ts", "r+");  
说明：终于到了main函数了，main函数的开始很简单，四个部分的初始化：代表RTP Packet的buffer，RTP Header，Socket，TS流媒体文件。如果你手头没有现成的TS文件，可以用ffmpeg转码得到一个ts文件：“ffmpeg -i video.xxx video.ts”， 其中 video.xxx 表示输入的视频文件，video.ts 为输出的TS文件。

[cpp]  view plain copy
  1. while(!feof(ts_file)){  
  2.     int read_len = fread(buf+count, 1, TS_PACKET_SIZE, ts_file);  
  3.     if(*(buf+count) != 0x47){  
  4.         fprintf(stderr, "Bad sync header!\n");  
  5.         continue;  
  6.     }  
  7.     count += read_len;  
  8.       
  9.     if (count + TS_PACKET_SIZE > MTU){// We should send  
  10.         sequence_number_increase((struct rtp_header*)buf);  
  11.         sendto(sock, buf, count, 0, (const struct sockaddr*)&dest_addr, sizeof(dest_addr));  
  12.         count = sizeof(struct rtp_header);  
  13.         usleep(10000);  
  14.     }  
  15. }  
  16.   
  17. fclose(ts_file);  
说明：一切就绪后就可以不断的用UDP发送RTP Packet了。每次从ts_file中读取188 bytes，附加到buf之后，如果buf的长度还没用到达MTU的限制，那么就继续添加，否则就将buf发送出去。每次发送会将sequence_number加一，并且间隔10000微秒。当然这只是个简单的例子，实际发送视频是要根据时间戳的。

测试

短短几十行代码是否就能完成一个RTP服务器？我们需要用实验来验证。

我的测试环境是Linux，用gcc编译通过，使用VLC(MPlayer 测试也可以通过了)作为接收端。

首先启动我们的发送端程序，然后再执行“vlc rtp://127.0.0.1:6666”，等待几秒后，发现真的可以进行播放啦！


http://blog.csdn.net/baby313/article/details/7363528


二、分享一段H264视频和AAC音频的RTP封包代码

1. H264视频的RTP封包

[c-sharp]  view plain copy
  1. static int h264_parse(Track *tr, uint8_t *data, size_t len) 
  2. { 
  3.     h264_priv *priv = tr->private_data; 
  4. //    double nal_time; // see page 9 and 7.4.1.2 
  5.     size_t nalsize = 0, index = 0; 
  6.     uint8_t *p, *q; 
  7.     if (priv->is_avc) { 
  8.         while (1) { 
  9.             unsigned int i; 
  10.             if(index >= len) break; 
  11.             //get the nal size 
  12.             nalsize = 0; 
  13.             for(i = 0; i < priv->nal_length_size; i++) 
  14.                 nalsize = (nalsize << 8) | data[index++]; 
  15.             if(nalsize <= 1 || nalsize > len) { 
  16.                 if(nalsize == 1) { 
  17.                     index++; 
  18.                     continue; 
  19.                 } else { 
  20.                     fnc_log(FNC_LOG_VERBOSE, "[h264] AVC: nal size %d", nalsize); 
  21.                     break; 
  22.                 } 
  23.             } 
  24.             if (DEFAULT_MTU >= nalsize) { 
  25.                 mparser_buffer_write(tr, 
  26.                                      tr->properties.pts, 
  27.                                      tr->properties.dts, 
  28.                                      tr->properties.frame_duration, 
  29.                                      1, 
  30.                                      data + index, nalsize); 
  31.                 fnc_log(FNC_LOG_VERBOSE, "[h264] single NAL"); 
  32.             } else { 
  33.             // single NAL, to be fragmented, FU-A; 
  34.                 frag_fu_a(data + index, nalsize, DEFAULT_MTU, tr); 
  35.             } 
  36.             index += nalsize; 
  37.         } 
  38.     } else { 
  39.         //seek to the first startcode 
  40.         for (p = data; p<data + len - 3; p++) { 
  41.             if (p[0] == 0 && p[1] == 0 && p[2] == 1) { 
  42.                 break; 
  43.             } 
  44.         } 
  45.         if (p >= data + len) return ERR_PARSE; 
  46.         while (1) { 
  47.         //seek to the next startcode [0 0 1] 
  48.             for (q = p; q<data+len-3;q++) { 
  49.                 if (q[0] == 0 && q[1] == 0 && q[2] == 1) { 
  50.                     break; 
  51.                 } 
  52.             } 
  53.             if (q >= data + len) break; 
  54.             if (DEFAULT_MTU >= q - p) { 
  55.                 fnc_log(FNC_LOG_VERBOSE, "[h264] Sending NAL %d",p[0]&0x1f); 
  56.                 mparser_buffer_write(tr, 
  57.                                      tr->properties.pts, 
  58.                                      tr->properties.dts, 
  59.                                      tr->properties.frame_duration, 
  60.                                      1, 
  61.                                      p, q - p); 
  62.                 fnc_log(FNC_LOG_VERBOSE, "[h264] single NAL"); 
  63.             } else { 
  64.                 //FU-A 
  65.                 fnc_log(FNC_LOG_VERBOSE, "[h264] frags"); 
  66.                 frag_fu_a(p, q - p, DEFAULT_MTU, tr); 
  67.             } 
  68.             p = q; 
  69.         } 
  70.         // last NAL 
  71.         fnc_log(FNC_LOG_VERBOSE, "[h264] last NAL %d",p[0]&0x1f); 
  72.         if (DEFAULT_MTU >= len - (p - data)) { 
  73.             fnc_log(FNC_LOG_VERBOSE, "[h264] no frags"); 
  74.             mparser_buffer_write(tr, 
  75.                                  tr->properties.pts, 
  76.                                  tr->properties.dts, 
  77.                                  tr->properties.frame_duration, 
  78.                                  1, 
  79.                                  p, len - (p - data)); 
  80.         } else { 
  81.             //FU-A 
  82.             fnc_log(FNC_LOG_VERBOSE, "[h264] frags"); 
  83.             frag_fu_a(p, len - (p - data), DEFAULT_MTU, tr); 
  84.         } 
  85.     } 
  86.     fnc_log(FNC_LOG_VERBOSE, "[h264] Frame completed"); 
  87.     return ERR_NOERROR; 
  88. } 
[c-sharp]  view plain copy
  1. static int h264_parse(Track *tr, uint8_t *data, size_t len)  
  2. {  
  3.     h264_priv *priv = tr->private_data;  
  4. //    double nal_time; // see page 9 and 7.4.1.2  
  5.     size_t nalsize = 0, index = 0;  
  6.     uint8_t *p, *q;  
  7.     if (priv->is_avc) {  
  8.         while (1) {  
  9.             unsigned int i;  
  10.             if(index >= len) break;  
  11.             //get the nal size  
  12.             nalsize = 0;  
  13.             for(i = 0; i < priv->nal_length_size; i++)  
  14.                 nalsize = (nalsize << 8) | data[index++];  
  15.             if(nalsize <= 1 || nalsize > len) {  
  16.                 if(nalsize == 1) {  
  17.                     index++;  
  18.                     continue;  
  19.                 } else {  
  20.                     fnc_log(FNC_LOG_VERBOSE, "[h264] AVC: nal size %d", nalsize);  
  21.                     break;  
  22.                 }  
  23.             }  
  24.             if (DEFAULT_MTU >= nalsize) {  
  25.                 mparser_buffer_write(tr,  
  26.                                      tr->properties.pts,  
  27.                                      tr->properties.dts,  
  28.                                      tr->properties.frame_duration,  
  29.                                      1,  
  30.                                      data + index, nalsize);  
  31.                 fnc_log(FNC_LOG_VERBOSE, "[h264] single NAL");  
  32.             } else {  
  33.             // single NAL, to be fragmented, FU-A;  
  34.                 frag_fu_a(data + index, nalsize, DEFAULT_MTU, tr);  
  35.             }  
  36.             index += nalsize;  
  37.         }  
  38.     } else {  
  39.         //seek to the first startcode  
  40.         for (p = data; p<data + len - 3; p++) {  
  41.             if (p[0] == 0 && p[1] == 0 && p[2] == 1) {  
  42.                 break;  
  43.             }  
  44.         }  
  45.         if (p >= data + len) return ERR_PARSE;  
  46.         while (1) {  
  47.         //seek to the next startcode [0 0 1]  
  48.             for (q = p; q<data+len-3;q++) {  
  49.                 if (q[0] == 0 && q[1] == 0 && q[2] == 1) {  
  50.                     break;  
  51.                 }  
  52.             }  
  53.             if (q >= data + len) break;  
  54.             if (DEFAULT_MTU >= q - p) {  
  55.                 fnc_log(FNC_LOG_VERBOSE, "[h264] Sending NAL %d",p[0]&0x1f);  
  56.                 mparser_buffer_write(tr,  
  57.                                      tr->properties.pts,  
  58.                                      tr->properties.dts,  
  59.                                      tr->properties.frame_duration,  
  60.                                      1,  
  61.                                      p, q - p);  
  62.                 fnc_log(FNC_LOG_VERBOSE, "[h264] single NAL");  
  63.             } else {  
  64.                 //FU-A  
  65.                 fnc_log(FNC_LOG_VERBOSE, "[h264] frags");  
  66.                 frag_fu_a(p, q - p, DEFAULT_MTU, tr);  
  67.             }  
  68.             p = q;  
  69.         }  
  70.         // last NAL  
  71.         fnc_log(FNC_LOG_VERBOSE, "[h264] last NAL %d",p[0]&0x1f);  
  72.         if (DEFAULT_MTU >= len - (p - data)) {  
  73.             fnc_log(FNC_LOG_VERBOSE, "[h264] no frags");  
  74.             mparser_buffer_write(tr,  
  75.                                  tr->properties.pts,  
  76.                                  tr->properties.dts,  
  77.                                  tr->properties.frame_duration,  
  78.                                  1,  
  79.                                  p, len - (p - data));  
  80.         } else {  
  81.             //FU-A  
  82.             fnc_log(FNC_LOG_VERBOSE, "[h264] frags");  
  83.             frag_fu_a(p, len - (p - data), DEFAULT_MTU, tr);  
  84.         }  
  85.     }  
  86.     fnc_log(FNC_LOG_VERBOSE, "[h264] Frame completed");  
  87.     return ERR_NOERROR;  
  88. }  

2. AAC的RTP封包

[c-sharp]  view plain copy
  1. static int aac_parse(Track *tr, uint8_t *data, size_t len) 
  2. { 
  3.     //XXX handle the last packet on EOF 
  4.     int off = 0; 
  5.     uint32_t payload = DEFAULT_MTU - AU_HEADER_SIZE; 
  6.     uint8_t *packet = g_malloc0(DEFAULT_MTU); 
  7.     if(!packet) return ERR_ALLOC; 
  8. // trim away extradata 
  9. //    data += AAC_EXTRA; 
  10. //    len -= AAC_EXTRA; 
  11.     packet[0] = 0x00; 
  12.     packet[1] = 0x10; 
  13.     packet[2] = (len & 0x1fe0) >> 5; 
  14.     packet[3] = (len & 0x1f) << 3; 
  15.     if (len > payload) { 
  16.         while (len > payload) { 
  17.             memcpy(packet + AU_HEADER_SIZE, data + off, payload); 
  18.             mparser_buffer_write(tr, 
  19.                                  tr->properties.pts, 
  20.                                  tr->properties.dts, 
  21.                                  tr->properties.frame_duration, 
  22.                                  0, 
  23.                                  packet, DEFAULT_MTU); 
  24.             len -= payload; 
  25.             off += payload; 
  26.         } 
  27.     } 
  28.     memcpy(packet + AU_HEADER_SIZE, data + off, len); 
  29.     mparser_buffer_write(tr, 
  30.                          tr->properties.pts, 
  31.                          tr->properties.dts, 
  32.                          tr->properties.frame_duration, 
  33.                          1, 
  34.                          packet, len + AU_HEADER_SIZE); 
  35.     g_free(packet); 
  36.     return ERR_NOERROR; 
  37. } 
[c-sharp]  view plain copy
  1. static int aac_parse(Track *tr, uint8_t *data, size_t len)  
  2. {  
  3.     //XXX handle the last packet on EOF  
  4.     int off = 0;  
  5.     uint32_t payload = DEFAULT_MTU - AU_HEADER_SIZE;  
  6.     uint8_t *packet = g_malloc0(DEFAULT_MTU);  
  7.     if(!packet) return ERR_ALLOC;  
  8. // trim away extradata  
  9. //    data += AAC_EXTRA;  
  10. //    len -= AAC_EXTRA;  
  11.     packet[0] = 0x00;  
  12.     packet[1] = 0x10;  
  13.     packet[2] = (len & 0x1fe0) >> 5;  
  14.     packet[3] = (len & 0x1f) << 3;  
  15.     if (len > payload) {  
  16.         while (len > payload) {  
  17.             memcpy(packet + AU_HEADER_SIZE, data + off, payload);  
  18.             mparser_buffer_write(tr,  
  19.                                  tr->properties.pts,  
  20.                                  tr->properties.dts,  
  21.                                  tr->properties.frame_duration,  
  22.                                  0,  
  23.                                  packet, DEFAULT_MTU);  
  24.             len -= payload;  
  25.             off += payload;  
  26.         }  
  27.     }  
  28.     memcpy(packet + AU_HEADER_SIZE, data + off, len);  
  29.     mparser_buffer_write(tr,  
  30.                          tr->properties.pts,  
  31.                          tr->properties.dts,  
  32.                          tr->properties.frame_duration,  
  33.                          1,  
  34.                          packet, len + AU_HEADER_SIZE);  
  35.     g_free(packet);  
  36.     return ERR_NOERROR;  
  37. }  

上面的变量 AU_HEADER_SIZE=4

/* au header

      +---------------------------------------+

      |     AU-size                           |

      +---------------------------------------+

      |     AU-Index / AU-Index-delta         |

      +---------------------------------------+

      |     CTS-flag                          |

      +---------------------------------------+

      |     CTS-delta                         |

      +---------------------------------------+

      |     DTS-flag                          |

      +---------------------------------------+

      |     DTS-delta                         |

      +---------------------------------------+

      |     RAP-flag                          |

      +---------------------------------------+

      |     Stream-state                      |

      +---------------------------------------+

*/

http://blog.csdn.net/alangdangjia/article/details/8755608
feixiaku
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
java 服务器 转发_一个在服务器上运行的TCP通信转发服务器[Java]
weixin_28825959的博客
02-21 496
刚刚写了一个简单的服务器转发功能，没什么难的，大概分享一下服务器的代码，以供有需要的人参考。主要思路是这样的：建一个Map存放着ip标示和相应的长连接Socket，需要转发时，从这个Map里获取相应的Socket，然后就可以转发了。至于有关TCP的知识，看这里：http://blog..net/shenpibaipao/article/details/70176038下面是服务器的代码：impor...
VLC 推RTP流
intel1985的专栏
01-12 6184
xx
VS2010用RTP协议传输TS流
07-13
在本资源中，我们将讨论如何在Visual Studio 2010环境下，利用RTP协议在Windows系统中传输TS（Transport Stream）流。 首先，了解RTP协议的基本概念是必要的。RTP是一种应用层协议，由IETF定义在RFC 3550中，其主要...
RTP.rar_rtp_rtp协议_rtp流
09-23
在描述中的“RTP协议演示程序，用传输字条串模拟媒体流”，我们可以理解为这是一个教学或测试工具，它通过发送一串字符（字条串）来模拟RTP协议的媒体数据传输过程。这种方式可以帮助开发者或学生理解RTP如何处理和...
Rtp协议传输Camera视频流
04-18
在本文中，我们将深入探讨如何使用RTP（Real-time Transport Protocol）协议来传输Camera视频流。首先，让我们从基础开始，了解RTP、NV21、NV12、MediaCodec以及SurfaceView等关键概念。 RTP协议是互联网工程任务组...
基于RTP的流媒体协议.docx
12-21
基于RTP的流媒体协议是指在计算机网络中传输流媒体数据的协议，RTP（Real-time Transport Protocol）是一种实时传输协议，用于传输音频、视频等多媒体数据。该协议主要用于流媒体应用，如视频会议、online直播、流...
C++ RTSP/RTP流媒体服务器源码
05-15
C++实现RTSP/RTP流媒体服务器，同时支持Linux和Windows编译环境。使用VLC客户端测试通过。实现RTSP的OPTIONS、DESCRIBE、SETUP、PLAY、PAUSE、TEARDOWN，实现SDP生成，实现RTP打包，实现TS文件解析。有相应的源码...
基于RTSP/RTP的简单流媒体服务器
09-01
一个简单的基于RTSP/RTP的流媒体服务器，是学习流媒体服务器的入门程序。
FFmpeg RTP推流源码分析
qw_stone的博客
09-19 3159
原因：由于需要涉及到RTP的推流分析，故调试查看FFmpeg内部实现流程 文件类型：.264,.aac 概况：FFmpeg首先通过sdp文件的创建，然后主要通过rtpenc.c文件和rtpenc_h264_hevc.c针对264文件进行内部进行格式封装。然后通过udp.c文件中进行发送. 命令行如下： ffmpeg -re -i q.264 -vcodec copy -f rtp rtp...
RTP推送mpegts流及验证方法
samssm的专栏
02-25 2375
RTP推送mpegts流及验证方法 参考了下wiki及ffmpeg源码发现，还有一个rtp_mpegts的muxer，可以支持推送mpeg-ts流（这也是我能找到的RTP唯一支持的容器格式）。 验证下命令如下，首先推流端： ./ffmpeg -re -stream_loop -1 -i zhen_h264+mp2.ts -vcodec copy -acodec copy -f rtp_mpe...
RTP/RTCP 协议讲解
明天你好的博客
10-02 5538
目前，支持流媒体传输的协议主要有实时传输协议 RTP实时传输控制协议 RTCP（Real-Time Transport Control Protocol）和实时流协议 RTSP（Real-Time Streaming Protocol）等。RTSP协议抓包及讲解。流媒体协议栈如下图所示：本文对 RTP 及 RTCP 协议进行了讲解，以及使用 wireshark 抓包对其抓到的报文进行详细分析。
RTP传输TS或PS流的SDP写法
gz_chen的博客
11-27 3087
在网上没有找到RTP传PS流的SDP写法，所以在此记录一下 RTP传PS的SDP写法 m=video 4228 RTP/AVP 32 a=rtpmap:32 MP2P/90000 a=framerate:25 c=IN IP4 127.0.0.14228是UDP的端口号，可以根据实际修改 MP2P代表负载为PS流 25是帧率，可以根据实际修改 RTP传TS的SDP写法 m=video 4228
自己动手写RTP服务器—用RTP协议传输TS流
weixin_34293141的博客
08-26 129
2019独角兽企业重金招聘Python工程师标准>>> ...
常用流媒体协议（HLS/HTTP/RTP组播/RTSP）提取流的方法
myvest的专栏
03-07 5489
记录一下从网络包提取TS的方法，基于RTP协议的。1、首先过滤出对应的UDP流出来 2、选中一包，右键DecodeAs…选择RTP 3、之后会全部变成TS出来，如下图，选择工具栏上的Telephony->RTP->Stream Analysis 4、点 Save Payload，保存为ts即可
大学生创业计划书(47)-两份资料.docx
最新发布
08-20
大学生创业计划书(47)-两份资料.docx
RTP协议在视频流媒体实时传输中的应用
"这篇硕士学位论文主要探讨了基于RTP协议的视频流媒体实时传输系统的设计与实现，作者葛镜，专业为电路与系统，导师为张国平，完成于2007年6月。论文内容涉及多媒体技术、网络协议以及RTP/RTCP在视频流媒体传输中的...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值