Linux下H.264碼流實時RTP打包與傳送

阿新 • • 發佈：2019-01-06

由於專案要求在DM6467T平臺上新增實時RTP打包傳送模組，這才找了找有沒有人分享這方面的經驗。這裡需要感謝網友：yanyuan9527，他寫的文章對我幫助很大，可以說讓一個完全小白的人瞭解了RTP打包，連結在此：http://www.chinavideo.org/forum.php?mod=viewthread&tid=7575

一、請大家閱讀上面提到的文章，我這裡就不詳細寫了，讀了之後應該對RTP打包有一定了解了。不過那篇文章是在windows下實現的，我要說的是linux。首先說linux與windows下socket的幾點區別：1.linux下的socket不用初始換。2.linux下定義socketfd直接是Int型，而windows下是SOCKET結構體。下圖是linux和windows下socket的區別

二、在linux系統下移植好那篇文章提供的原始碼，應該就可以跑通發包了，可以用抓包工具Wireshark抓下包試試。下面上程式碼：

1.rtp.h

// MPEG2RTP.h
#include <stdio.h>
#include <stdlib.h>

#include <string.h>

#include <sys/socket.h>

//#include "mem.h"

//


#define PACKET_BUFFER_END            (unsigned int)0x00000000


#define MAX_RTP_PKT_LENGTH     1400

#define DEST_IP                "192.168.0.30"
#define DEST_PORT            1234

#define H264                    96

typedef int SOCKET;

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();

2. rtp.c

// NALDecoder.cpp : Defines the entry point for the console application.
//


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <memory.h>
#include "rtp.h"

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>

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))//判斷是否到了檔案尾
    {
      nalu->len = (pos-1)-nalu->startcodeprefix_len;
      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的末尾
  {
    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;
  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[])
{
        //FILE *stream;
        //stream=fopen("Test.264", "wb");

	OpenBitstreamFile("./-a.264");//開啟264檔案，並將檔案指標賦給bits,在此修改檔名實現開啟別的264檔案。
	NALU_t *n;
	char* nalu_payload;  
	char sendbuf[1500];
	
	unsigned short seq_num =0;
        //printf("seq_num=%d\n",seq_num);//added by
	int	bytes=0;
	//InitWinsock(); //初始化套接字型檔
	SOCKET    socket1;
	struct sockaddr_in server;
        int len =sizeof(server);
	float framerate=25;
	unsigned int timestamp_increase=0,ts_current=0;
	timestamp_increase=(unsigned int)(90000.0 / framerate); //+0.5);

	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 struct sockaddr *)&server, len) ;//申請UDP套接字
	n = AllocNALU(8000000);//為結構體nalu_t及其成員buf分配空間。返回值為指向nalu_t儲存空間的指標
	


	while(!feof(bits)) 
	{
		GetAnnexbNALU(n);//每執行一次，檔案的指標指向本次找到的NALU的末尾，下一個位置即為下個NALU的起始碼0x000001
		dump(n);//輸出NALU長度和TYPE
		
		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
			//設定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_increase;
			rtp_hdr->timestamp=htonl(ts_current);
			bytes=n->len + 13 ;						//獲得sendbuf的長度,為nalu的長度（包含NALU頭但除去起始字首）加上rtp_header的固定長度12位元組
			send( socket1, sendbuf, bytes, 0 );//傳送rtp包
			//sleep(1);
//fwrite(sendbuf,bytes, 1, stream);	
		}
		
		else if(n->len>1400)
		{
			//得到該nalu需要用多少長度為1400位元組的RTP包來發送
			int k=0,l=0;
			k=n->len/1400;//需要k個1400位元組的RTP包
			l=n->len%1400;//最後一個RTP包的需要裝載的位元組數
			int t=0;//用於指示當前傳送的是第幾個分片RTP包
			ts_current=ts_current+timestamp_increase;
			rtp_hdr->timestamp=htonl(ts_current);
			while(t<=k)
			{
				rtp_hdr->seq_no = htons(seq_num ++); //序列號，每傳送一個RTP包增1
				if(!t)//傳送一個需要分片的NALU的第一個分片，置FU HEADER的S位
				{
					//設定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->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頭
					
					bytes=1400+14;						//獲得sendbuf的長度,為nalu的長度（除去起始字首和NALU頭）加上rtp_header，fu_ind，fu_hdr的固定長度14位元組
					send( socket1, sendbuf, bytes, 0 );//傳送rtp包
//fwrite(sendbuf,bytes, 1, stream);
                                        //sleep(1);
					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,l-1);//將nalu最後剩餘的l-1(去掉了一個位元組的NALU頭)位元組內容寫入sendbuf[14]開始的字串。
					bytes=l-1+14;		//獲得sendbuf的長度,為剩餘nalu的長度l-1加上rtp_header，FU_INDICATOR,FU_HEADER三個包頭共14位元組
					send( socket1, sendbuf, bytes, 0 );//傳送rtp包
//fwrite(sendbuf,bytes, 1, stream);
					t++;
				 	//sleep(1);
				}
				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->E=0;
					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包
//fwrite(sendbuf,bytes, 1, stream);
                                        //sleep(1);
					t++;
				}
			}
		}
        //usleep(40000);
	}
	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;
}

三、程式跑通之後下一步，就是要移植到DM6467T下encode工程中進行實時打包，也就是編碼一幀完成後直接RTP打包，而不是讀取檔案流。在encode工程中有個writer執行緒，裡面的fwrite函式就是writer執行緒的核心，這裡我將fwrite替換成rtp()打包函式。

列出幾點注意事項：

1. 移植過程中將所有對檔案的操作改成對BUFFER指標的操作

2. 注意對RTP頭中seq_no的修改

3. 注意對時間戳的修改

4. 由於實時傳送需要不停地呼叫rtp打包程式，就需要將建立socket的部分程式移到迴圈之外。這是因為linux的檔案操作符是有限的，不停地建立會用光檔案操作符，而對socket的close不能立即釋放資源，會有延時，即使close也解決不了問題（至少我沒能解決，如果有解決的朋友希望不吝賜教）。

第三部分只是簡單列出移植過程中所遇到的問題以及解決思路，未上詳盡解釋以及程式碼，不過網上應該都有具體方法，有問題也可以留言討論，我用的是UDP包。（關於討論的事非常抱歉，由於樓主不做那個專案很久了，基本忘光了，不過近期會貼上當時的程式碼）

將程式移植完成以後通過VLC實時解碼，可能還會出現1秒鐘的延遲，那是由於VLC預設的網路快取時間是1000ms，網路條件好的可以改成300ms，延時將大大減小。

附件內容是將文中所提到的網友的windows程式做簡單修改移植linux下的RTP打包傳送程式：點選開啟連結

Linux下H.264碼流實時RTP打包與傳送

Linux下H.264碼流實時RTP打包與傳送

H.264碼流的RTP打包格式[FU-A]

H.264碼流打包為RTP碼流

Linux安裝SRS伺服器轉發H.264碼流

【視頻編解碼·學習筆記】6. H.264碼流分析工程創建

libx264編碼---YUV影象資料編碼為h.264碼流

海思3518EV200 SDK中獲取和儲存H.264碼流詳解

H.264---碼流格式分析

使用FFMPEG類庫分離出多媒體檔案中的H 264碼流

H.264碼流解析一個SPS的nalu及獲取視訊的解析度

【H.264/AVC視訊編解碼技術詳解】十二、解析H.264碼流的巨集塊結構（上）

H.264碼流分析

H.264 碼流結構解析 (整理)

MP4中提取H.264碼流

利用mp4v2實現H.264裸碼流實時封裝

android平臺下基於ffmpeg採集Camera資料編碼成H.264推流到RTMP伺服器

live555在Linux下最簡單地實現實時流媒體點播

FFMPEG 實時解碼網路H264碼流，RTP封裝

Linux下git源碼安裝【轉】

linux下源代碼搭建php環境之mysql（一）

Linux下H.264碼流實時RTP打包與傳送

相關推薦