rtp打包H264

[cpp] view
plaincopyprint?

#include <stdio.h>

#include <stdlib.h>

#include <conio.h>

#include <string.h>

#include <winsock2.h>

#pragma comment( lib, "ws2_32.lib" )

#define PACKET_BUFFER_END (unsigned int)0x00000000

#define MAX_RTP_PKT_LENGTH 1400

#define DEST_IP "192.168.0.25"

#define DEST_PORT 1234

#define H264 96

/******************************************************************

RTP_FIXED_HEADER

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

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

|V=2|P|X| CC |M| PT | sequence number |

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

| timestamp |

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

| synchronization source (SSRC) identifier |

+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+

| contributing source (CSRC) identifiers |

| .... |

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

******************************************************************/

typedef struct

{

/* byte 0 */

unsigned char csrc_len:4; /* CC expect 0 */

unsigned char extension:1;/* X expect 1, see RTP_OP below */

unsigned char padding:1; /* P expect 0 */

unsigned char version:2; /* V expect 2 */

/* byte 1 */

unsigned char payload:7; /* PT RTP_PAYLOAD_RTSP */

unsigned char marker:1; /* M expect 1 */

/* byte 2,3 */

unsigned short seq_no; /*sequence number*/

/* byte 4-7 */

unsigned long timestamp;

/* byte 8-11 */

unsigned long ssrc; /* stream number is used here. */

} RTP_FIXED_HEADER;/*12 bytes*/

/******************************************************************

NALU_HEADER

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

|0|1|2|3|4|5|6|7|

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

|F|NRI| Type |

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

******************************************************************/

typedef struct {

//byte 0

unsigned char TYPE:5;

unsigned char NRI:2;

unsigned char F:1;

} NALU_HEADER; /* 1 byte */

/******************************************************************

FU_INDICATOR

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

|0|1|2|3|4|5|6|7|

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

|F|NRI| Type |

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

******************************************************************/

typedef struct {

//byte 0

unsigned char TYPE:5;

unsigned char NRI:2;

unsigned char F:1;

} FU_INDICATOR; /*1 byte */

/******************************************************************

FU_HEADER

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

|0|1|2|3|4|5|6|7|

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

|S|E|R| Type |

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

******************************************************************/

typedef struct {

//byte 0

unsigned char TYPE:5;

unsigned char R:1;

unsigned char E:1;

unsigned char S:1;

} FU_HEADER; /* 1 byte */

H264.h头文件内容：

RTPSend.cpp文件内容：

[cpp] view
plaincopyprint?

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <memory.h>

#include "h264.h"

#define UDP_MAX_SIZE 1400

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 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的长度

}

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;

}

int rtpnum = 0;

//输出NALU长度和TYPE

void dump(NALU_t *n)

{

if (!n)return;

printf("%3d, len: %6d ",rtpnum++, n->len);

printf("nal_unit_type: %x\n", n->nal_unit_type);

}

int main(int argc, char* argv[])

{

OpenBitstreamFile("E:\\测试数据\\tv480x320.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);

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

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->version = 2; //版本号，此版本固定为2

rtp_hdr->marker = 0; //标志位，由具体协议规定其值。

rtp_hdr->payload = H264;//负载类型号，

rtp_hdr->ssrc = htonl(10);//随机指定为10，并且在本RTP会话中全局唯一

//当一个NALU小于1400字节的时候，采用一个单RTP包发送

if(n->len<=UDP_MAX_SIZE){

//设置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_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{

int packetNum = n->len/UDP_MAX_SIZE;

if (n->len%UDP_MAX_SIZE != 0)

packetNum ++;

int lastPackSize = n->len - (packetNum-1)*UDP_MAX_SIZE;

int packetIndex = 1 ;

ts_current=ts_current+timestamp_increse;

rtp_hdr->timestamp=htonl(ts_current);

//发送第一个的FU，S=1，E=0，R=0

rtp_hdr->seq_no = htons(seq_num ++); //序列号，每发送一个RTP包增1

//设置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->S=1;

fu_hdr->E=0;

fu_hdr->R=0;

fu_hdr->TYPE=n->nal_unit_type;

nalu_payload=&sendbuf[14];//同理将sendbuf[14]赋给nalu_payload

memcpy(nalu_payload,n->buf+1,UDP_MAX_SIZE);//去掉NALU头

bytes=UDP_MAX_SIZE+14;//获得sendbuf的长度,为nalu的长度（除去起始前缀和NALU头）加上rtp_header，fu_ind，fu_hdr的固定长度14字节

send( socket1, sendbuf, bytes, 0 );//发送RTP包

//发送中间的FU，S=0，E=0，R=0

for(packetIndex=2;packetIndex<packetNum;packetIndex++)

{

rtp_hdr->seq_no = htons(seq_num ++); //序列号，每发送一个RTP包增1

//设置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->S=0;

fu_hdr->E=0;

fu_hdr->R=0;

fu_hdr->TYPE=n->nal_unit_type;

nalu_payload=&sendbuf[14];//同理将sendbuf[14]的地址赋给nalu_payload

memcpy(nalu_payload,n->buf+(packetIndex-1)*UDP_MAX_SIZE+1,UDP_MAX_SIZE);//去掉起始前缀的nalu剩余内容写入sendbuf[14]开始的字符串。

bytes=UDP_MAX_SIZE+14;//获得sendbuf的长度,为nalu的长度（除去原NALU头）加上rtp_header，fu_ind，fu_hdr的固定长度14字节

send( socket1, sendbuf, bytes, 0 );//发送rtp包

}

//发送最后一个的FU，S=0，E=1，R=0

rtp_hdr->seq_no = htons(seq_num ++);

//设置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->S=0;

fu_hdr->E=1;

fu_hdr->R=0;

fu_hdr->TYPE=n->nal_unit_type;

nalu_payload=&sendbuf[14];//同理将sendbuf[14]的地址赋给nalu_payload

memcpy(nalu_payload,n->buf+(packetIndex-1)*UDP_MAX_SIZE+1,lastPackSize-1);//将nalu最后剩余的-1(去掉了一个字节的NALU头)字节内容写入sendbuf[14]开始的字符串。

bytes=lastPackSize-1+14;//获得sendbuf的长度,为剩余nalu的长度l-1加上rtp_header，FU_INDICATOR,FU_HEADER三个包头共14字节

send( socket1, sendbuf, bytes, 0 );//发送rtp包

}

//Sleep(33);

}

FreeNALU(n);

return 0;

}

将以下文本保存为rtpPara.sdp文件

m=video 1234 RTP/AVP 96

a=rtpmap:96 H264

a=framerate:30

c=IN IP4 192.168.0.25

用VLC打开该文件，然后运行编译好的发送程序。

注意头文件和sdp文件的IP都要与实验机器的IP吻合。

该代码在NALDecoder程序基础上修改了一个内存bug而已。感谢前人的开源。