将H264码流打包成RTP包

末蓝、 2022-06-14 06:29 293阅读 0赞

H264码流打包成RTP包的代码如下：

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  \#include <stdio.h>  
2.  \#include <stdlib.h>  
3.  \#include <conio.h>  
4.  \#include <string.h>  
5.    
6.  \#include <winsock2.h>  
7.  \#include <winsock2.h>  
8.    
9.  //\#include "mem.h"  
10.   
11.   
12. \#define PACKET\_BUFFER\_END            (unsigned int)0x00000000  
13.   
14.   
15. \#define MAX\_RTP\_PKT\_LENGTH     1400  
16.   
17. \#define DEST\_IP                "180.101.59.185"  
18. \#define DEST\_PORT            1234  
19.   
20. \#define H264                    96  
21.   
22. **typedef** **struct**   
23. \{  
24.     /\*\*//\* byte 0 \*/  
25.     unsigned **char** csrc\_len:4;        /\*\*//\* expect 0 \*/  
26.     unsigned **char** extension:1;        /\*\*//\* expect 1, see RTP\_OP below \*/  
27.     unsigned **char** padding:1;        /\*\*//\* expect 0 \*/  
28.     unsigned **char** version:2;        /\*\*//\* expect 2 \*/  
29.     /\*\*//\* byte 1 \*/  
30.     unsigned **char** payload:7;        /\*\*//\* RTP\_PAYLOAD\_RTSP \*/  
31.     unsigned **char** marker:1;        /\*\*//\* expect 1 \*/  
32.     /\*\*//\* bytes 2, 3 \*/  
33.     unsigned **short** seq\_no;              
34.     /\*\*//\* bytes 4-7 \*/  
35.     unsigned  **long** timestamp;          
36.     /\*\*//\* bytes 8-11 \*/  
37.     unsigned **long** ssrc;            /\*\*//\* stream number is used here. \*/  
38. \} RTP\_FIXED\_HEADER;  
39.   
40. **typedef** **struct** \{  
41.     //byte 0  
42.     unsigned **char** TYPE:5;  
43.     unsigned **char** NRI:2;  
44.     unsigned **char** F:1;      
45.   
46. \} NALU\_HEADER; /\*\*//\* 1 BYTES \*/  
47.   
48. **typedef** **struct** \{  
49.     //byte 0  
50.     unsigned **char** TYPE:5;  
51.     unsigned **char** NRI:2;   
52.     unsigned **char** F:1;      
53.   
54.   
55. \} FU\_INDICATOR; /\*\*//\* 1 BYTES \*/  
56.   
57. **typedef** **struct** \{  
58.     //byte 0  
59.     unsigned **char** TYPE:5;  
60.     unsigned **char** R:1;  
61.     unsigned **char** E:1;  
62.     unsigned **char** S:1;      
63. \} FU\_HEADER; /\*\*//\* 1 BYTES \*/  
64.   
65. **BOOL** InitWinsock();

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  \#include <stdio.h>  
2.  \#include <stdlib.h>  
3.  \#include <string.h>  
4.  \#include <memory.h>  
5.  \#include "h264.h"  
6.    
7.  \#pragma comment(lib,"ws2\_32.lib")  
8.    
9.  **typedef** **struct**  
10. \{  
11.     **int** startcodeprefix\_len;      //! 4 for parameter sets and first slice in picture, 3 for everything else (suggested)  
12.     unsigned len;                 //! Length of the NAL unit (Excluding the start code, which does not belong to the NALU)  
13.     unsigned max\_size;            //! Nal Unit Buffer size  
14.     **int** forbidden\_bit;            //! should be always FALSE  
15.     **int** nal\_reference\_idc;        //! NALU\_PRIORITY\_xxxx  
16.     **int** nal\_unit\_type;            //! NALU\_TYPE\_xxxx      
17.     **char** \*buf;                    //! contains the first byte followed by the EBSP  
18.     unsigned **short** lost\_packets;  //! true, if packet loss is detected  
19. \} NALU\_t;  
20.   
21. **FILE** \*bits = NULL;                //!< the bit stream file  
22. **static** **int** FindStartCode2 (unsigned **char** \*Buf);//查找开始字符0x000001  
23. **static** **int** FindStartCode3 (unsigned **char** \*Buf);//查找开始字符0x00000001  
24. //static bool flag = true;  
25. **static** **int** info2=0, info3=0;  
26. RTP\_FIXED\_HEADER        \*rtp\_hdr;  
27.   
28. NALU\_HEADER     \*nalu\_hdr;  
29. FU\_INDICATOR    \*fu\_ind;  
30. FU\_HEADER       \*fu\_hdr;  
31.   
32. **BOOL** InitWinsock()  
33. \{  
34.     **int** Error;  
35.     **WORD** VersionRequested;  
36.     WSADATA WsaData;  
37.     VersionRequested=MAKEWORD(2,2);  
38.     Error=WSAStartup(VersionRequested,&WsaData); //启动WinSock2  
39.     **if**(Error!=0)    
40.     \{  
41.         **return** FALSE;  
42.     \}  
43.     **else**  
44.     \{  
45.         **if**(LOBYTE(WsaData.wVersion)!=2||HIBYTE(WsaData.wHighVersion)!=2)  
46.         \{  
47.             WSACleanup();  
48.             **return** FALSE;  
49.         \}  
50.   
51.     \}  
52.     **return** TRUE;  
53. \}  
54.   
55. //为NALU\_t结构体分配内存空间  
56. NALU\_t \*AllocNALU(**int** buffersize)  
57. \{  
58.     NALU\_t \*n;  
59.   
60.     **if** ((n = (NALU\_t\*)calloc (1, **sizeof** (NALU\_t))) == NULL)  
61.     \{  
62.         printf("AllocNALU: n");  
63.         exit(0);  
64.     \}  
65.   
66.     n->max\_size=buffersize;  
67.   
68.     **if** ((n->buf = (**char**\*)calloc (buffersize, **sizeof** (**char**))) == NULL)  
69.     \{  
70.         free (n);  
71.         printf ("AllocNALU: n->buf");  
72.         exit(0);  
73.     \}  
74.   
75.     **return** n;  
76. \}  
77. //释放  
78. **void** FreeNALU(NALU\_t \*n)  
79. \{  
80.     **if** (n)  
81.     \{  
82.         **if** (n->buf)  
83.         \{  
84.             free(n->buf);  
85.             n->buf=NULL;  
86.         \}  
87.         free (n);  
88.     \}  
89. \}  
90.   
91. **void** OpenBitstreamFile (**char** \*fn)  
92. \{  
93.     **if** (NULL == (bits=fopen(fn, "rb")))  
94.     \{  
95.         printf("open file error\\n");  
96.         exit(0);  
97.     \}  
98. \}  
99. //这个函数输入为一个NAL结构体，主要功能为得到一个完整的NALU并保存在NALU\_t的buf中，获取他的长度，填充F,IDC,TYPE位。  
100. //并且返回两个开始字符之间间隔的字节数，即包含有前缀的NALU的长度  
101. **int** GetAnnexbNALU (NALU\_t \*nalu)  
102. \{  
103.     **int** pos = 0;  
104.     **int** StartCodeFound, rewind;  
105.     unsigned **char** \*Buf;  
106.   
107.     **if** ((Buf = (unsigned **char**\*)calloc (nalu->max\_size , **sizeof**(**char**))) == NULL)   
108.     \{  
109.        printf ("GetAnnexbNALU: Could not allocate Buf memory\\n");  
110.     \}  
111.           
112.   
113.     nalu->startcodeprefix\_len=3;//初始化码流序列的开始字符为3个字节  
114.   
115.     **if** (3 != fread (Buf, 1, 3, bits))//从码流中读3个字节  
116.     \{  
117.         free(Buf);  
118.         **return** 0;  
119.     \}  
120.     info2 = FindStartCode2 (Buf);//判断是否为0x000001   
121.     **if**(info2 != 1)   
122.     \{  
123.         //如果不是，再读一个字节  
124.         **if**(1 != fread(Buf+3, 1, 1, bits))//读一个字节  
125.         \{  
126.             free(Buf);  
127.             **return** 0;  
128.         \}  
129.         info3 = FindStartCode3 (Buf);//判断是否为0x00000001  
130.         **if** (info3 != 1)//如果不是，返回-1  
131.         \{   
132.             free(Buf);  
133.             **return** -1;  
134.         \}  
135.         **else**   
136.         \{  
137.             //如果是0x00000001,得到开始前缀为4个字节  
138.             pos = 4;  
139.             nalu->startcodeprefix\_len = 4;  
140.         \}  
141.     \}  
142.   
143.     **else**  
144.     \{  
145.         //如果是0x000001,得到开始前缀为3个字节  
146.         nalu->startcodeprefix\_len = 3;  
147.         pos = 3;  
148.     \}  
149.   
150.     //查找下一个开始字符的标志位  
151.     StartCodeFound = 0;  
152.     info2 = 0;  
153.     info3 = 0;  
154.   
155.     **while** (!StartCodeFound)  
156.     \{  
157.         **if** (feof (bits))//判断是否到了文件尾，文件结束，则返回非0值，否则返回0  
158.         \{  
159.             nalu->len = (pos-1)-nalu->startcodeprefix\_len;  //NALU单元的长度。  
160.             memcpy (nalu->buf, &Buf\[nalu->startcodeprefix\_len\], nalu->len);       
161.             nalu->forbidden\_bit = nalu->buf\[0\] & 0x80; //1 bit  
162.             nalu->nal\_reference\_idc = nalu->buf\[0\] & 0x60; // 2 bit  
163.             nalu->nal\_unit\_type = (nalu->buf\[0\]) & 0x1f;// 5 bit  
164.             free(Buf);  
165.             **return** pos-1;  
166.         \}  
167.         Buf\[pos++\] = fgetc (bits);//读一个字节到BUF中  
168.         info3 = FindStartCode3(&Buf\[pos-4\]);//判断是否为0x00000001  
169.         **if**(info3 != 1)  
170.         \{  
171.            info2 = FindStartCode2(&Buf\[pos-3\]);//判断是否为0x000001  
172.         \}  
173.               
174.         StartCodeFound = (info2 == 1 || info3 == 1);  
175.     \}  
176.   
177.     // Here, we have found another start code (and read length of startcode bytes more than we should  
178.     // have.  Hence, go back in the file  
179.     rewind = (info3 == 1)? -4 : -3;  
180.   
181.     **if** (0 != fseek (bits, rewind, SEEK\_CUR))//把文件指针指向前一个NALU的末尾，在当前文件指针位置上偏移 rewind。  
182.     \{  
183.         free(Buf);  
184.         printf("GetAnnexbNALU: Cannot fseek in the bit stream file");  
185.     \}  
186.   
187.     // Here the Start code, the complete NALU, and the next start code is in the Buf.    
188.     // The size of Buf is pos, pos+rewind are the number of bytes excluding the next  
189.     // start code, and (pos+rewind)-startcodeprefix\_len is the size of the NALU excluding the start code  
190.   
191.     nalu->len = (pos+rewind)-nalu->startcodeprefix\_len;    //NALU长度，不包括头部。  
192.     memcpy (nalu->buf, &Buf\[nalu->startcodeprefix\_len\], nalu->len);//拷贝一个完整NALU，不拷贝起始前缀0x000001或0x00000001  
193.     nalu->forbidden\_bit = nalu->buf\[0\] & 0x80; //1 bit  
194.     nalu->nal\_reference\_idc = nalu->buf\[0\] & 0x60; // 2 bit  
195.     nalu->nal\_unit\_type = (nalu->buf\[0\]) & 0x1f;// 5 bit  
196.     free(Buf);  
197.   
198.     **return** (pos+rewind);//返回两个开始字符之间间隔的字节数，即包含有前缀的NALU的长度  
199. \}  
200. //输出NALU长度和TYPE  
201. **void** dump(NALU\_t \*n)  
202. \{  
203.     **if** (!n)**return**;  
204.     //printf("a new nal:");  
205.     printf(" len: %d  ", n->len);  
206.     printf("nal\_unit\_type: %x\\n", n->nal\_unit\_type);  
207. \}  
208.   
209. **int** main(**int** argc, **char**\* argv\[\])  
210. \{  
211.     OpenBitstreamFile("./test2.264");//打开264文件，并将文件指针赋给bits,在此修改文件名实现打开别的264文件。  
212.     NALU\_t \*n;  
213.     **char**\* nalu\_payload;    
214.     **char** sendbuf\[1500\];  
215.   
216.     unsigned **short** seq\_num =0;  
217.     **int** bytes=0;  
218.     InitWinsock(); //初始化套接字库  
219.     SOCKET    socket1;  
220.     **struct** sockaddr\_in server;  
221.     **int** len =**sizeof**(server);  
222.     **float** framerate=15;  
223.     unsigned **int** timestamp\_increse=0,ts\_current=0;  
224.     timestamp\_increse=(unsigned **int**)(90000.0 / framerate); //+0.5);  //时间戳，H264的视频设置成90000  
225.   
226.     server.sin\_family=AF\_INET;  
227.     server.sin\_port=htons(DEST\_PORT);            
228.     server.sin\_addr.s\_addr=inet\_addr(DEST\_IP);   
229.     socket1=socket(AF\_INET,SOCK\_DGRAM,0);  
230.     connect(socket1, (**const** sockaddr \*)&server, len) ;//申请UDP套接字  
231.     n = AllocNALU(8000000);//为结构体nalu\_t及其成员buf分配空间。返回值为指向nalu\_t存储空间的指针  
232.   
233.     **while**(!feof(bits))   
234.     \{  
235.         GetAnnexbNALU(n);//每执行一次，文件的指针指向本次找到的NALU的末尾，下一个位置即为下个NALU的起始码0x000001  
236.         dump(n);//输出NALU长度和TYPE  
237.   
238.     //（1）一个NALU就是一个RTP包的情况： RTP\_FIXED\_HEADER（12字节）  + NALU\_HEADER（1字节） + EBPS  
239.         //（2）一个NALU分成多个RTP包的情况： RTP\_FIXED\_HEADER （12字节） + FU\_INDICATOR （1字节）+  FU\_HEADER（1字节） + EBPS(1400字节)  
240.   
241.         memset(sendbuf,0,1500);//清空sendbuf；此时会将上次的时间戳清空，因此需要ts\_current来保存上次的时间戳值  
242.         //rtp固定包头，为12字节,该句将sendbuf\[0\]的地址赋给rtp\_hdr，以后对rtp\_hdr的写入操作将直接写入sendbuf。  
243.         rtp\_hdr =(RTP\_FIXED\_HEADER\*)&sendbuf\[0\];   
244.         //设置RTP HEADER，  
245.         rtp\_hdr->payload     = H264;  //负载类型号，  
246.         rtp\_hdr->version     = 2;  //版本号，此版本固定为2  
247.         rtp\_hdr->marker    = 0;   //标志位，由具体协议规定其值。  
248.         rtp\_hdr->ssrc        = htonl(10);    //随机指定为10，并且在本RTP会话中全局唯一  
249.   
250.         //  当一个NALU小于1400字节的时候，采用一个单RTP包发送  
251.         **if**(n->len <= 1400)  
252.         \{     
253.             //设置rtp M 位；  
254.             rtp\_hdr->marker = 1;  
255.             rtp\_hdr->seq\_no  = htons(seq\_num ++); //序列号，每发送一个RTP包增1，htons，将主机字节序转成网络字节序。  
256.             //设置NALU HEADER,并将这个HEADER填入sendbuf\[12\]  
257.             nalu\_hdr =(NALU\_HEADER\*)&sendbuf\[12\]; //将sendbuf\[12\]的地址赋给nalu\_hdr，之后对nalu\_hdr的写入就将写入sendbuf中；  
258.             nalu\_hdr->F = n->forbidden\_bit;  
259.             nalu\_hdr->NRI=n->nal\_reference\_idc>>5;//有效数据在n->nal\_reference\_idc的第6，7位，需要右移5位才能将其值赋给nalu\_hdr->NRI。  
260.             nalu\_hdr->TYPE=n->nal\_unit\_type;  
261.   
262.             nalu\_payload=&sendbuf\[13\];//同理将sendbuf\[13\]赋给nalu\_payload  
263.             memcpy(nalu\_payload,n->buf+1,n->len-1);//去掉nalu头的nalu剩余内容写入sendbuf\[13\]开始的字符串。  
264.   
265.             ts\_current = ts\_current + timestamp\_increse;  
266.             rtp\_hdr->timestamp=htonl(ts\_current);  
267.             bytes=n->len + 12 ;  //获得sendbuf的长度,为nalu的长度（包含NALU头但除去起始前缀）加上rtp\_header的固定长度12字节  
268.             send(socket1, sendbuf, bytes, 0);//发送rtp包  
269.             //  Sleep(100);  
270.   
271.         \}  
272.   
273.         **else** **if**(n->len > 1400)  //这里就要分成多个RTP包发送了。  
274.         \{  
275.             //得到该nalu需要用多少长度为1400字节的RTP包来发送  
276.             **int** k = 0, last = 0;  
277.             k = n->len / 1400;//需要k个1400字节的RTP包，这里为什么不加1呢？因为是从0开始计数的。  
278.             last = n->len % 1400;//最后一个RTP包的需要装载的字节数  
279.             **int** t = 0;//用于指示当前发送的是第几个分片RTP包  
280.             ts\_current = ts\_current + timestamp\_increse;  
281.             rtp\_hdr->timestamp = htonl(ts\_current);  
282.             **while**(t <= k)  
283.             \{  
284.                 rtp\_hdr->seq\_no = htons(seq\_num++); //序列号，每发送一个RTP包增1  
285.                 **if**(!t)//发送一个需要分片的NALU的第一个分片，置FU HEADER的S位,t = 0时进入此逻辑。  
286.                 \{  
287.                     //设置rtp M 位；  
288.                     rtp\_hdr->marker = 0;  //最后一个NALU时，该值设置成1，其他都设置成0。  
289.                     //设置FU INDICATOR,并将这个HEADER填入sendbuf\[12\]  
290.                     fu\_ind =(FU\_INDICATOR\*)&sendbuf\[12\]; //将sendbuf\[12\]的地址赋给fu\_ind，之后对fu\_ind的写入就将写入sendbuf中；  
291.                     fu\_ind->F = n->forbidden\_bit;  
292.                     fu\_ind->NRI = n->nal\_reference\_idc >> 5;  
293.                     fu\_ind->TYPE = 28;  //FU-A类型。  
294.   
295.                     //设置FU HEADER,并将这个HEADER填入sendbuf\[13\]  
296.                     fu\_hdr =(FU\_HEADER\*)&sendbuf\[13\];  
297.                     fu\_hdr->E = 0;  
298.                     fu\_hdr->R = 0;  
299.                     fu\_hdr->S = 1;  
300.                     fu\_hdr->TYPE = n->nal\_unit\_type;  
301.   
302.                     nalu\_payload = &sendbuf\[14\];//同理将sendbuf\[14\]赋给nalu\_payload  
303.                     memcpy(nalu\_payload,n->buf+1,1400);//去掉NALU头，每次拷贝1400个字节。  
304.   
305.                     bytes = 1400 + 14;//获得sendbuf的长度,为nalu的长度（除去起始前缀和NALU头）加上rtp\_header，fu\_ind，fu\_hdr的固定长度                                                            14字节  
306.                     send( socket1, sendbuf, bytes, 0 );//发送rtp包  
307.                     t++;  
308.   
309.                 \}  
310.                 //发送一个需要分片的NALU的非第一个分片，清零FU HEADER的S位，如果该分片是该NALU的最后一个分片，置FU HEADER的E位  
311.                 **else** **if**(k == t)//发送的是最后一个分片，注意最后一个分片的长度可能超过1400字节（当 l> 1386时）。  
312.                 \{  
313.   
314.                     //设置rtp M 位；当前传输的是最后一个分片时该位置1  
315.                     rtp\_hdr->marker=1;  
316.                     //设置FU INDICATOR,并将这个HEADER填入sendbuf\[12\]  
317.                     fu\_ind =(FU\_INDICATOR\*)&sendbuf\[12\]; //将sendbuf\[12\]的地址赋给fu\_ind，之后对fu\_ind的写入就将写入sendbuf中；  
318.                     fu\_ind->F=n->forbidden\_bit;  
319.                     fu\_ind->NRI=n->nal\_reference\_idc>>5;  
320.                     fu\_ind->TYPE=28;  
321.   
322.                     //设置FU HEADER,并将这个HEADER填入sendbuf\[13\]  
323.                     fu\_hdr = (FU\_HEADER\*)&sendbuf\[13\];  
324.                     fu\_hdr->R = 0;  
325.                     fu\_hdr->S = 0;  
326.                     fu\_hdr->TYPE = n->nal\_unit\_type;  
327.                     fu\_hdr->E = 1;  
328.   
329.                     nalu\_payload = &sendbuf\[14\];//同理将sendbuf\[14\]的地址赋给nalu\_payload  
330.                     memcpy(nalu\_payload,n->buf + t\*1400 + 1,last-1);//将nalu最后剩余的l-1(去掉了一个字节的NALU头)字节内容写入sendbuf\[14\]开始的字符串。  
331.                     bytes = last - 1 + 14;      //获得sendbuf的长度,为剩余nalu的长度l-1加上rtp\_header，FU\_INDICATOR,FU\_HEADER三个包头共14字节  
332.                     send(socket1, sendbuf, bytes, 0);//发送rtp包  
333.                     t++;  
334.                     //Sleep(100);  
335.                 \}  
336.                 //既不是第一个分片，也不是最后一个分片的处理。  
337.                 **else** **if**(t < k && 0 != t)  
338.                 \{  
339.                     //设置rtp M 位；  
340.                     rtp\_hdr->marker = 0;  
341.                     //设置FU INDICATOR,并将这个HEADER填入sendbuf\[12\]  
342.                     fu\_ind = (FU\_INDICATOR\*)&sendbuf\[12\]; //将sendbuf\[12\]的地址赋给fu\_ind，之后对fu\_ind的写入就将写入sendbuf中；  
343.                     fu\_ind->F = n->forbidden\_bit;  
344.                     fu\_ind->NRI = n->nal\_reference\_idc>>5;  
345.                     fu\_ind->TYPE = 28;  
346.   
347.                     //设置FU HEADER,并将这个HEADER填入sendbuf\[13\]  
348.                     fu\_hdr =(FU\_HEADER\*)&sendbuf\[13\];  
349.       
350.                     fu\_hdr->R = 0;  
351.                     fu\_hdr->S = 0;  
352.                     fu\_hdr->E = 0;  
353.                     fu\_hdr->TYPE = n->nal\_unit\_type;  
354.   
355.                     nalu\_payload=&sendbuf\[14\];//同理将sendbuf\[14\]的地址赋给nalu\_payload  
356.                     memcpy(nalu\_payload, n->buf + t \* 1400 + 1,1400);//去掉起始前缀的nalu剩余内容写入sendbuf\[14\]开始的字符串。  
357.                     bytes=1400 + 14;                        //获得sendbuf的长度,为nalu的长度（除去原NALU头）加上rtp\_header，fu\_ind，fu\_hdr的固定长度14字节  
358.                     send(socket1, sendbuf, bytes, 0);//发送rtp包  
359.                     t++;  
360.                 \}  
361.             \}  
362.         \}  
363.     \}  
364.     FreeNALU(n);  
365.     **return** 0;  
366. \}  
367.   
368. **static** **int** FindStartCode2 (unsigned **char** \*Buf)  
369. \{  
370.     **if**(Buf\[0\]!=0 || Buf\[1\]!=0 || Buf\[2\] !=1) **return** 0; //判断是否为0x000001,如果是返回1  
371.     **else** **return** 1;  
372. \}  
373.   
374. **static** **int** FindStartCode3 (unsigned **char** \*Buf)  
375. \{  
376.     **if**(Buf\[0\]!=0 || Buf\[1\]!=0 || Buf\[2\] !=0 || Buf\[3\] !=1) **return** 0;//判断是否为0x00000001,如果是返回1  
377.     **else** **return** 1;  
378. \}

** RTP header格式**，见下图：

![20140410092432406][]

各个字段代表含义如下：

V:版本号，一般为2;  
P：填充字段标识；  
X：扩展头标识；

CC：CSRC计数，4比特

M：标志 1bit，在传输h264时表示h264 nalu的最后一包  
PT：负载类型 7 bits, H264类型为96,荷载类型的赋值或者通过profile或者通过动态方式  
SN：序列号16 bits  
Timestamp：时间戳32bits，如果为视频的话，应该设置为1/9000,音频为1/8000，如果NAL单元没有他自己的时间属性(即,parameter set and SEI NAL units)，RTP时戳设置成访问单元主编码图像的RTP时戳。  
SSRC：32bits，用以识别同步源。  
CSRC列表：0到15项，每项32比特，CSRC列表识别在此包中负载的所有贡献源。识别符的数目在CC域中给定。若有贡献源多于15个，仅识别15个。CSRC识别符由混合器插入，并列出所有贡献源的SSRC识别符。例如语音包，混合产生新包的所有源的SSRC标识符都被列出，这样可以在接收端正确指示参与者。

**RTP payload**格式：

H.264Payload 格式定义了三种不同的基本的负载(Payload)结构，接收端可能通过RTP Payload的第一个字节来识别它们。这一个字节类似NALU 头的格式，而这个头结构的NAL 单元类型字段则指出了代表的是哪一种结构，这个字节的结构如下：

F        1比特  
NRI      2比特  
Type     5比特

可以看出它和H.264 的NALU 头结构是一样的。

字段Type：这个RTP payload 中 NAL 单元的类型。 这个字段和 H.264 中类型字段的区别是，当type的值为24-31表示这是一个特别格式的 NAL 单元，而H.264中，只取1-23是有效的值。

**关于NALU使用RTP包进行发送可能的类型有**：

1. 单一 NAL 单元模式  
       即一个 RTP 包仅由一个完整的 NALU 组成。这种情况下 RTP NAL 头类型字段和原始的H.264的NALU 头类型字段是一样的。  
对于 NALU的长度小于 MTU 大小的包，一般采用单一 NAL 单元模式。对于一个原始的H.264 NALU 单元常由 \[StartCode\] \[NALU Header\] \[NALU Payload\] 三部分组成，其中 Start Code 用于标示这是一个NALU 单元的开始，必须是"00 00 00 01" 或"00 00 01"，  
NALU 头仅一个字节，其后都是 NALU 单元内容。打包时去除 "00 00 01" 或"00 00 00 01" 的开始码，把其他数据封包的 RTP 包即可，有如下例子：  
\[00 0000 01 67 42 A0 1E 23 56 0E 2F ... \]  
封装成 RTP 包将如下:  
\[ RTPHeader \] \[ 67 42 A0 1E 23 56 0E 2F \]  
（在这里要说明的是，如果客户端是通用的播放器，比如VLC或者JM的话需要将前导码去掉，但是如果使用的是ffmpeg在客户端解码的话，发送前不需要去掉前导码，去掉之后可能会导致ffmpeg解码错误）。  
  
2. 组合封包模式  
       即可能是由多个 NAL 单元组成一个 RTP 包。分别有4种组合方式：STAP-A，STAP-B， MTAP16， MTAP24。那么这里的类型值分别是 24，25，26 以及 27。  
  
3. 分片封包模式  
       用于把一个 NALU单元封装成多个 RTP 包。存在两种类型 FU-A 和 FU-B。类型值分别是 28 和 29。  
而当 NALU 的长度超过 MTU 时，就必须对 NALU 单元进行分片封包。 也称为Fragmentation Units(FUs)。将NALU拆分成小于MTU的数据包进行发送，如果使用的是VLC等网络播放器的话，需要设置FU header，如下图所示：  
![20140410094419968][]  
如果使用的是ffmpeg自行进行数据包接收与解码，则完全不必写FU header。

其实在后面的实际操作中会发现，SPS、PPS都是非常小，不到一百个字节，都是单个的NAl进行打包发送，而I帧一般都比较大，会采用分包发送，一般也是FU-A方式分片，其中MTU一般是1500个字节。FFmpeg中都有现成的源程序可以参考的。

对于H264的I帧、P帧等主要是FU（分片）发送，那么FU到底是怎样一个过程呢。

相同NAL单元的分片必须使用递增的RTP序号连续顺序发送(第一和最后分片之间没有其他的RTP包）。相似, NAL单元必须按照RTP顺序号的顺序装配。FUs不可以嵌套。即 一个FU 不可以包含另一个FU。运送FU的RTP时戳被设置成分片NALU的NALU的时刻。

FU-A的RTP荷载格式：

0                                              1                                             2                                            3  
        0   1   2  3   4  5  6   7  8   9   0  1  2  3  4   5   6   7   8  9   0  1   2  3  4   5  6   7   8  9  0   1  
      +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+  
      |       FU indicator          |      FU header             |                                                                            |  
      +--+--+--+--+--+--+--+--+--+--+--+-+--+--+--+--+                                                                             |  
      |                                                                                                                                                         |  
      |                                                             FU payload                                                                        |  
      |                                                                                                                                                         |  
      |                                                                             +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+  
      |                                                                                ：...OPTIONAL RTP padding                       |  
     +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+

**FU indicator :  1字节的分片单元指示**

+---------------+  
       |0|1|2|3|4|5|6|7|  
      +-+-+-+-+-+-+-+  
      |F|NRI|  Type   |  
      +---------------+

NRI: 2 bits, 00值指示NAL单元的内容不用于重建影响图像的帧间图像预测.这样的NAL单元可以被丢弃而不用冒影响图像完整性的风险。大于00的值指示NAL单元的解码要求维护引用图像的完整性。

注意：任何非零的NRI在H.264 解码器的处理是相同的。因此,接收者在传送NAL单元给解码器时不必操作NRI的值。NRI值必须根据分片NAL单元的NRI值设置。H.264编码器必须根据H.264规范设置NRI值。

当nal\_unit\_type 范围的是1到12。特别是，H.264规范要求对于nal\_unit\_type为6，9，10，11，12的NAL单元的NRI的值应该为0。

对于nal\_unit\_type等于7，8 (指示顺序参数集或图像参数集)的NAL单元,H.264编码器应该设置NRI为11 (二进制格式）。

对于nal\_unit\_type等于5的主编码图像的编码片NAL单元(指示编码片属于一个IDR图像), H.264编码器应设置NRI为11。

**FU header:  1字节的分片单元头**  
      +---------------+  
      |0|1|2|3|4|5|6|7|  
     +-+-+-+-+-+-+-+  
      |S|E|R|  Type   |  
      +---------------+

S: (1 bit)  
   当设置成1，开始位指示分片NAL单元的开始。当跟随的FU荷载不是分片NAL单元荷载的开始，开始位设为0。  
E: (1 bit)  
   当设置成1，结束位指示分片NAL单元的结束，即荷载的最后字节也是分片NAL单元的最后一个字节。  
   当跟随的FU荷载不是分片NAL单元的最后分片,结束位设置为0。  
R: (1 bit)  
    保留位必须设置为0，接收者必须忽略该位。  
Type: (5 bit)  
       NAL单元荷载类型定义。

FU payload : 分片单元荷载。

关于时间戳，需要注意的是h264的采样率为90000HZ，因此时间戳的单位为1(秒)/90000，因此如果当前视频帧率为25fps，那时间戳间隔或者说增量应该为3600，怎么算出来的呢，每帧是1/25秒，那么这1/25秒有多少个时间戳单元呢，除以1/90000即可。而如果帧率为30fps，则增量为3000，以此类推。

1）第一个FU-A包的FU indicator：  
F应该为当前NALU头的F，而NRI应该为当前NALU头的NRI，Type则等于28，表明它是FU-A包。  
FU header生成方法：S = 1，E = 0，R = 0，Type则等于NALU头中的Type。  
  
2）后续的N个FU-A包的FU indicator和第一个是完全一样的，如果不是最后一个包，则FU header应该为：S = 0，E = 0，R = 0，  
Type等于NALU头中的Type。  
  
3）最后一个FU-A包FU header应该为：S = 0，E = 1，R = 0，Type等于NALU头中的Type。  
  
因此总结就是：  
同一个NALU分包的FU indicator头是完全一致的，FU header只有S以及E位有区别，分别标记开始和结束，它们的RTP分包的序列号应该是依次递增的，并且它们的时间戳必须一致，而负载数据为NALU包去掉1个字节的NALU头后对剩余数据的拆分，这点很关键，你可以认为NALU头被拆分成了FU indicator和FU header，所以不再需要1字节的NALU头了。  
  
关于SPS以及PPS，配置帧的传输我采用了先发SPS，再发送PPS，并使用同样的时间戳，或者按照正常时间戳增量再或者组包发送的形式处理貌似都可以，看播放器怎么解码了，另外提一下，如果我们使用vlc进行播放的话，可以在sdp文件中设置SPS以及PPS，这样就可以不用发送它们了。  
  
使用VLC播放时，sdp文件中的分包模式选项：packetization-mode=1，否则有问题。另外sdp里面设置的编码type必须和rtp包中的一致。

ok关于H264的打包就说到这了，其实这些都有现成的了，不用自己去怎么琢磨，但是感兴趣的可以研究下，毕竟知道原理在看代码或者编代码的时候都会有一定的帮助，至少会提高点自信心吧。

顶

踩

[view plain]: http://blog.csdn.net/chenchong_219/article/details/37996161#
[20140410092432406]: /images/20220614/21ba8e6ab607485e94d1d2c7258d8842.png
[20140410094419968]: /images/20220614/54e7d21957b64882ad7e75bd40fc18e7.png