將H264碼流打包成RTP包
H264碼流打包成RTP包的程式碼如下：
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <string.h>
#include <winsock2.h>
#include <winsock2.h>
//#include "mem.h"
#define PACKET_BUFFER_END (unsigned int)0x00000000
#define MAX_RTP_PKT_LENGTH 1400
#define DEST_IP "180.101.59.185"
#define DEST_PORT 1234
#define H264 96
typedef struct
{
/**//* byte 0 */
unsigned char csrc_len:4; /**//* expect 0 */
unsigned char extension:1; /**//* expect 1, see RTP_OP below */
unsigned char padding:1; /**//* expect 0 */
unsigned char version:2; /**//* expect 2 */
/**//* byte 1 */
unsigned char payload:7; /**//* RTP_PAYLOAD_RTSP */
unsigned char marker:1; /**//* expect 1 */
/**//* bytes 2, 3 */
unsigned short seq_no;
/**//* bytes 4-7 */
unsigned long timestamp;
/**//* bytes 8-11 */
unsigned long ssrc; /**//* stream number is used here. */
} RTP_FIXED_HEADER;
typedef struct {
//byte 0
unsigned char TYPE:5;
unsigned char NRI:2;
unsigned char F:1;
} NALU_HEADER; /**//* 1 BYTES */
typedef struct {
//byte 0
unsigned char TYPE:5;
unsigned char NRI:2;
unsigned char F:1;
} FU_INDICATOR; /**//* 1 BYTES */
typedef struct {
//byte 0
unsigned char TYPE:5;
unsigned char R:1;
unsigned char E:1;
unsigned char S:1;
} FU_HEADER; /**//* 1 BYTES */
BOOL InitWinsock();#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <memory.h>
#include "h264.h"
#pragma comment(lib,"ws2_32.lib")
typedef struct
{
int startcodeprefix_len; //! 4 for parameter sets and first slice in picture, 3 for everything else (suggested)
unsigned len; //! Length of the NAL unit (Excluding the start code, which does not belong to the NALU)
unsigned max_size; //! Nal Unit Buffer size
int forbidden_bit; //! should be always FALSE
int nal_reference_idc; //! NALU_PRIORITY_xxxx
int nal_unit_type; //! NALU_TYPE_xxxx
char *buf; //! contains the first byte followed by the EBSP
unsigned short lost_packets; //! true, if packet loss is detected
} NALU_t;
FILE *bits = NULL; //!< the bit stream file
static int FindStartCode2 (unsigned char *Buf);//查詢開始字元0x000001
static int FindStartCode3 (unsigned char *Buf);//查詢開始字元0x00000001
//static bool flag = true;
static int info2=0, info3=0;
RTP_FIXED_HEADER *rtp_hdr;
NALU_HEADER *nalu_hdr;
FU_INDICATOR *fu_ind;
FU_HEADER *fu_hdr;
BOOL InitWinsock()
{
int Error;
WORD VersionRequested;
WSADATA WsaData;
VersionRequested=MAKEWORD(2,2);
Error=WSAStartup(VersionRequested,&WsaData); //啟動WinSock2
if(Error!=0)
{
return FALSE;
}
else
{
if(LOBYTE(WsaData.wVersion)!=2||HIBYTE(WsaData.wHighVersion)!=2)
{
WSACleanup();
return FALSE;
}
}
return TRUE;
}
//為NALU_t結構體分配記憶體空間
NALU_t *AllocNALU(int buffersize)
{
NALU_t *n;
if ((n = (NALU_t*)calloc (1, sizeof (NALU_t))) == NULL)
{
printf("AllocNALU: n");
exit(0);
}
n->max_size=buffersize;
if ((n->buf = (char*)calloc (buffersize, sizeof (char))) == NULL)
{
free (n);
printf ("AllocNALU: n->buf");
exit(0);
}
return n;
}
//釋放
void FreeNALU(NALU_t *n)
{
if (n)
{
if (n->buf)
{
free(n->buf);
n->buf=NULL;
}
free (n);
}
}
void OpenBitstreamFile (char *fn)
{
if (NULL == (bits=fopen(fn, "rb")))
{
printf("open file error\n");
exit(0);
}
}
//這個函式輸入為一個NAL結構體，主要功能為得到一個完整的NALU並儲存在NALU_t的buf中，獲取他的長度，填充F,IDC,TYPE位。
//並且返回兩個開始字元之間間隔的位元組數，即包含有字首的NALU的長度
int GetAnnexbNALU (NALU_t *nalu)
{
int pos = 0;
int StartCodeFound, rewind;
unsigned char *Buf;
if ((Buf = (unsigned char*)calloc (nalu->max_size , sizeof(char))) == NULL)
{
printf ("GetAnnexbNALU: Could not allocate Buf memory\n");
}
nalu->startcodeprefix_len=3;//初始化碼流序列的開始字元為3個位元組
if (3 != fread (Buf, 1, 3, bits))//從碼流中讀3個位元組
{
free(Buf);
return 0;
}
info2 = FindStartCode2 (Buf);//判斷是否為0x000001
if(info2 != 1)
{
//如果不是，再讀一個位元組
if(1 != fread(Buf+3, 1, 1, bits))//讀一個位元組
{
free(Buf);
return 0;
}
info3 = FindStartCode3 (Buf);//判斷是否為0x00000001
if (info3 != 1)//如果不是，返回-1
{
free(Buf);
return -1;
}
else
{
//如果是0x00000001,得到開始字首為4個位元組
pos = 4;
nalu->startcodeprefix_len = 4;
}
}
else
{
//如果是0x000001,得到開始字首為3個位元組
nalu->startcodeprefix_len = 3;
pos = 3;
}
//查詢下一個開始字元的標誌位
StartCodeFound = 0;
info2 = 0;
info3 = 0;
while (!StartCodeFound)
{
if (feof (bits))//判斷是否到了檔案尾，檔案結束，則返回非0值，否則返回0
{
nalu->len = (pos-1)-nalu->startcodeprefix_len; //NALU單元的長度。
memcpy (nalu->buf, &Buf[nalu->startcodeprefix_len], nalu->len);
nalu->forbidden_bit = nalu->buf[0] & 0x80; //1 bit
nalu->nal_reference_idc = nalu->buf[0] & 0x60; // 2 bit
nalu->nal_unit_type = (nalu->buf[0]) & 0x1f;// 5 bit
free(Buf);
return pos-1;
}
Buf[pos++] = fgetc (bits);//讀一個位元組到BUF中
info3 = FindStartCode3(&Buf[pos-4]);//判斷是否為0x00000001
if(info3 != 1)
{
info2 = FindStartCode2(&Buf[pos-3]);//判斷是否為0x000001
}
StartCodeFound = (info2 == 1 || info3 == 1);
}
// Here, we have found another start code (and read length of startcode bytes more than we should
// have. Hence, go back in the file
rewind = (info3 == 1)? -4 : -3;
if (0 != fseek (bits, rewind, SEEK_CUR))//把檔案指標指向前一個NALU的末尾，在當前檔案指標位置上偏移 rewind。
{
free(Buf);
printf("GetAnnexbNALU: Cannot fseek in the bit stream file");
}
// Here the Start code, the complete NALU, and the next start code is in the Buf.
// The size of Buf is pos, pos+rewind are the number of bytes excluding the next
// start code, and (pos+rewind)-startcodeprefix_len is the size of the NALU excluding the start code
nalu->len = (pos+rewind)-nalu->startcodeprefix_len; //NALU長度，不包括頭部。
memcpy (nalu->buf, &Buf[nalu->startcodeprefix_len], nalu->len);//拷貝一個完整NALU，不拷貝起始字首0x000001或0x00000001
nalu->forbidden_bit = nalu->buf[0] & 0x80; //1 bit
nalu->nal_reference_idc = nalu->buf[0] & 0x60; // 2 bit
nalu->nal_unit_type = (nalu->buf[0]) & 0x1f;// 5 bit
free(Buf);
return (pos+rewind);//返回兩個開始字元之間間隔的位元組數，即包含有字首的NALU的長度
}
//輸出NALU長度和TYPE
void dump(NALU_t *n)
{
if (!n)return;
//printf("a new nal:");
printf(" len: %d ", n->len);
printf("nal_unit_type: %x\n", n->nal_unit_type);
}
int main(int argc, char* argv[])
{
OpenBitstreamFile("./test2.264");//開啟264檔案，並將檔案指標賦給bits,在此修改檔名實現開啟別的264檔案。
NALU_t *n;
char* nalu_payload;
char sendbuf[1500];
unsigned short seq_num =0;
int bytes=0;
InitWinsock(); //初始化套接字型檔
SOCKET socket1;
struct sockaddr_in server;
int len =sizeof(server);
float framerate=15;
unsigned int timestamp_increse=0,ts_current=0;
timestamp_increse=(unsigned int)(90000.0 / framerate); //+0.5); //時間戳，H264的視訊設定成90000
server.sin_family=AF_INET;
server.sin_port=htons(DEST_PORT);
server.sin_addr.s_addr=inet_addr(DEST_IP);
socket1=socket(AF_INET,SOCK_DGRAM,0);
connect(socket1, (const sockaddr *)&server, len) ;//申請UDP套接字
n = AllocNALU(8000000);//為結構體nalu_t及其成員buf分配空間。返回值為指向nalu_t儲存空間的指標
while(!feof(bits))
{
GetAnnexbNALU(n);//每執行一次，檔案的指標指向本次找到的NALU的末尾，下一個位置即為下個NALU的起始碼0x000001
dump(n);//輸出NALU長度和TYPE
//（1）一個NALU就是一個RTP包的情況： RTP_FIXED_HEADER（12位元組） + NALU_HEADER（1位元組） + EBPS
//（2）一個NALU分成多個RTP包的情況： RTP_FIXED_HEADER （12位元組） + FU_INDICATOR （1位元組）+ FU_HEADER（1位元組） + EBPS(1400位元組)
memset(sendbuf,0,1500);//清空sendbuf；此時會將上次的時間戳清空，因此需要ts_current來儲存上次的時間戳值
//rtp固定包頭，為12位元組,該句將sendbuf[0]的地址賦給rtp_hdr，以後對rtp_hdr的寫入操作將直接寫入sendbuf。
rtp_hdr =(RTP_FIXED_HEADER*)&sendbuf[0];
//設定RTP HEADER，
rtp_hdr->payload = H264; //負載型別號，
rtp_hdr->version = 2; //版本號，此版本固定為2
rtp_hdr->marker = 0; //標誌位，由具體協議規定其值。
rtp_hdr->ssrc = htonl(10); //隨機指定為10，並且在本RTP會話中全域性唯一
// 當一個NALU小於1400位元組的時候，採用一個單RTP包傳送
if(n->len <= 1400)
{
//設定rtp M 位；
rtp_hdr->marker = 1;
rtp_hdr->seq_no = htons(seq_num ++); //序列號，每傳送一個RTP包增1，htons，將主機位元組序轉成網路位元組序。
//設定NALU HEADER,並將這個HEADER填入sendbuf[12]
nalu_hdr =(NALU_HEADER*)&sendbuf[12]; //將sendbuf[12]的地址賦給nalu_hdr，之後對nalu_hdr的寫入就將寫入sendbuf中；
nalu_hdr->F = n->forbidden_bit;
nalu_hdr->NRI=n->nal_reference_idc>>5;//有效資料在n->nal_reference_idc的第6，7位，需要右移5位才能將其值賦給nalu_hdr->NRI。
nalu_hdr->TYPE=n->nal_unit_type;
nalu_payload=&sendbuf[13];//同理將sendbuf[13]賦給nalu_payload
memcpy(nalu_payload,n->buf+1,n->len-1);//去掉nalu頭的nalu剩餘內容寫入sendbuf[13]開始的字串。
ts_current = ts_current + timestamp_increse;
rtp_hdr->timestamp=htonl(ts_current);
bytes=n->len + 12 ; //獲得sendbuf的長度,為nalu的長度（包含NALU頭但除去起始字首）加上rtp_header的固定長度12位元組
send(socket1, sendbuf, bytes, 0);//傳送rtp包
// Sleep(100);
}
else if(n->len > 1400) //這裡就要分成多個RTP包傳送了。
{
//得到該nalu需要用多少長度為1400位元組的RTP包來傳送
int k = 0, last = 0;
k = n->len / 1400;//需要k個1400位元組的RTP包，這裡為什麼不加1呢？因為是從0開始計數的。
last = n->len % 1400;//最後一個RTP包的需要裝載的位元組數
int t = 0;//用於指示當前傳送的是第幾個分片RTP包
ts_current = ts_current + timestamp_increse;
rtp_hdr->timestamp = htonl(ts_current);
while(t <= k)
{
rtp_hdr->seq_no = htons(seq_num++); //序列號，每傳送一個RTP包增1
if(!t)//傳送一個需要分片的NALU的第一個分片，置FU HEADER的S位,t = 0時進入此邏輯。
{
//設定rtp M 位；
rtp_hdr->marker = 0; //最後一個NALU時，該值設定成1，其他都設定成0。
//設定FU INDICATOR,並將這個HEADER填入sendbuf[12]
fu_ind =(FU_INDICATOR*)&sendbuf[12]; //將sendbuf[12]的地址賦給fu_ind，之後對fu_ind的寫入就將寫入sendbuf中；
fu_ind->F = n->forbidden_bit;
fu_ind->NRI = n->nal_reference_idc >> 5;
fu_ind->TYPE = 28; //FU-A型別。
//設定FU HEADER,並將這個HEADER填入sendbuf[13]
fu_hdr =(FU_HEADER*)&sendbuf[13];
fu_hdr->E = 0;
fu_hdr->R = 0;
fu_hdr->S = 1;
fu_hdr->TYPE = n->nal_unit_type;
nalu_payload = &sendbuf[14];//同理將sendbuf[14]賦給nalu_payload
memcpy(nalu_payload,n->buf+1,1400);//去掉NALU頭，每次拷貝1400個位元組。
bytes = 1400 + 14;//獲得sendbuf的長度,為nalu的長度（除去起始字首和NALU頭）加上rtp_header，fu_ind，fu_hdr的固定長度 14位元組
send( socket1, sendbuf, bytes, 0 );//傳送rtp包
t++;
}
//傳送一個需要分片的NALU的非第一個分片，清零FU HEADER的S位，如果該分片是該NALU的最後一個分片，置FU HEADER的E位
else if(k == t)//傳送的是最後一個分片，注意最後一個分片的長度可能超過1400位元組（當 l> 1386時）。
{
//設定rtp M 位；當前傳輸的是最後一個分片時該位置1
rtp_hdr->marker=1;
//設定FU INDICATOR,並將這個HEADER填入sendbuf[12]
fu_ind =(FU_INDICATOR*)&sendbuf[12]; //將sendbuf[12]的地址賦給fu_ind，之後對fu_ind的寫入就將寫入sendbuf中；
fu_ind->F=n->forbidden_bit;
fu_ind->NRI=n->nal_reference_idc>>5;
fu_ind->TYPE=28;
//設定FU HEADER,並將這個HEADER填入sendbuf[13]
fu_hdr = (FU_HEADER*)&sendbuf[13];
fu_hdr->R = 0;
fu_hdr->S = 0;
fu_hdr->TYPE = n->nal_unit_type;
fu_hdr->E = 1;
nalu_payload = &sendbuf[14];//同理將sendbuf[14]的地址賦給nalu_payload
memcpy(nalu_payload,n->buf + t*1400 + 1,last-1);//將nalu最後剩餘的l-1(去掉了一個位元組的NALU頭)位元組內容寫入sendbuf[14]開始的字串。
bytes = last - 1 + 14; //獲得sendbuf的長度,為剩餘nalu的長度l-1加上rtp_header，FU_INDICATOR,FU_HEADER三個包頭共14位元組
send(socket1, sendbuf, bytes, 0);//傳送rtp包
t++;
//Sleep(100);
}
//既不是第一個分片，也不是最後一個分片的處理。
else if(t < k && 0 != t)
{
//設定rtp M 位；
rtp_hdr->marker = 0;
//設定FU INDICATOR,並將這個HEADER填入sendbuf[12]
fu_ind = (FU_INDICATOR*)&sendbuf[12]; //將sendbuf[12]的地址賦給fu_ind，之後對fu_ind的寫入就將寫入sendbuf中；
fu_ind->F = n->forbidden_bit;
fu_ind->NRI = n->nal_reference_idc>>5;
fu_ind->TYPE = 28;
//設定FU HEADER,並將這個HEADER填入sendbuf[13]
fu_hdr =(FU_HEADER*)&sendbuf[13];
fu_hdr->R = 0;
fu_hdr->S = 0;
fu_hdr->E = 0;
fu_hdr->TYPE = n->nal_unit_type;
nalu_payload=&sendbuf[14];//同理將sendbuf[14]的地址賦給nalu_payload
memcpy(nalu_payload, n->buf + t * 1400 + 1,1400);//去掉起始字首的nalu剩餘內容寫入sendbuf[14]開始的字串。
bytes=1400 + 14; //獲得sendbuf的長度,為nalu的長度（除去原NALU頭）加上rtp_header，fu_ind，fu_hdr的固定長度14位元組
send(socket1, sendbuf, bytes, 0);//傳送rtp包
t++;
}
}
}
}
FreeNALU(n);
return 0;
}
static int FindStartCode2 (unsigned char *Buf)
{
if(Buf[0]!=0 || Buf[1]!=0 || Buf[2] !=1) return 0; //判斷是否為0x000001,如果是返回1
else return 1;
}
static int FindStartCode3 (unsigned char *Buf)
{
if(Buf[0]!=0 || Buf[1]!=0 || Buf[2] !=0 || Buf[3] !=1) return 0;//判斷是否為0x00000001,如果是返回1
else return 1;
}
RTP header格式，見下圖：
各個欄位代表含義如下：
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，如下圖所示：
如果使用的是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的打包就說到這了，其實這些都有現成的了，不用自己去怎麼琢磨，但是感興趣的可以研究下，畢竟知道原理在看程式碼或者編程式碼的時候都會有一定的幫助，至少會提高點自信心吧。
相關文章
- WEBRTC 接收H264 RTP資料流小結Web
- ant:如何用ant將web project打包成war包WebProject
- 流媒體傳輸協議之 RTP （上篇）協議
- 流媒體傳輸協議之 RTP（下篇）協議
- RTSP H264/HEVC 流 Wasm 播放ASM
- 視訊會議中或者錄播中使用RTP協議接收h264視訊協議
- 將Python指令碼打包成可執行檔案Python指令碼
- android camera採集、H264編碼與Rtmp推流Android
- 如何將web打包成jar檔案WebJAR
- iOS 儲存攝像頭H264視訊流iOS
- 使用HBuilder將web專案打包成appUIWebAPP
- JavaCV FFmpeg H264編碼Java
- 將自己的python程式碼打包成exe的可執行檔案Python
- js對flv提取h264、aac音視訊流JS
- 如何使用Maven將專案中的依賴打進jar包MavenJAR
- 1小時學會：最簡單的iOS直播推流（八）h264 aac 軟編碼iOS
- 1小時學會：最簡單的iOS直播推流（七）h264/aac 硬編碼iOS
- Intellij Idea 將Java專案打包成jarIntelliJIdeaJavaJAR
- 解決：如何將Python程式碼打包成exe可執行程式的問題Python行程
- Maven專案打jar包MavenJAR
- 將Python程式打包成可執行檔案薦Python
- 一篇文章讀懂流媒體傳輸協議RTP、RTCP、RTSP、SRTP&SRTCP協議TCP
- jenkins 打安卓包失敗Jenkins安卓
- ue4打包遊戲遊戲
- java打jar包的maven方式JavaJARMaven
- 【譯】使用 Google TWA 技術將 PWA 打包成 Android AppGoAndroidAPP
- 透過TopShelf將OwinSelfHost自宿主打包成服務
- springboot將jsp打包成jar執行的坑Spring BootJSJAR
- 手把手教你將H5遊戲打包成快遊戲H5遊戲
- RTP協議的報文結構協議
- 音視訊學習之 - H264編碼
- H264編碼分析及隱寫實踐
- IDEA+gradle將springBoot專案打可執行的Jar包IdeaGradleSpring BootJAR
- iOS .a庫打包成.framework（將極光推送的.a庫打包進framework）iOSFramework
- 【Android Build】高效批量打渠道包AndroidUI
- Android Studio module 打aar包Android
- ReactNative打離線包-ios篇ReactiOS
- 如何將 Python 專案打包成 exe，另帶解除安裝功能！Python