H264网络摄像头（三）
三、RTSP
1. udp client
找了网上一些例子，（就像前面那篇里查阅的博客一样）有用ortsp的（但只说了个部分代码，没有说怎么捣鼓），有用live555的。一开始，也想跟着他们利用live555，移植过来做。但是live555多是C++封装的。关于live555的，http://www.pudn.com/downloads459/sourcecode/multimedia/streaming/detail1932452.html，这里做了一点整理。虽然我崇尚C++类的思想，但我做嵌入式底层及UC(UNIX C，其实是linux c)时间较多，还是习惯C语言的过程编程。因此，再次搜索，有人提及live555实现得过于复杂，可以自己写个简单的，推荐《 按照RFC3984协议实现H264视频RTP打包（附源代码）》。
这篇文章，后面提到了，他的做法是要利用.sdp文件。也就是VLC播放器先打开.sdp文件，然后h264文件那边再发送数据。经观察，VLC播放器打开.sdp文件后，其实就是在本地创建了UDP server，h264文件那边是最为UDP client来连接的。
大致清楚了，先来实现看看。上一篇，我们得到了cap.h264文件，同时也能用vlc播放了。现在发送cap.h264到vlc播放。
w.sdp：
m=video 8080 RTP/AVP 96
a=rtpmap:96 H264
a=framerate:15
c=IN IP4 192.168.1.202
第一行，视频，本地端口8080；第三行，帧率15；第四行，client ipv4地址。
main.c：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <unistd.h>
#include <fcntl.h>
#include <pthread.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/wait.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <signal.h>
#include <errno.h>
#define PACKET_BUFFER_END (unsigned int)0x00000000 // 包结束标志
#define MAX_RTP_PKT_LENGTH 1400 // 最大RTP包长度
#define H264 96 //
// 定义RTP固定头结构
typedef struct
{
/* byte 0 */
unsigned char csrc_len:4; /* CSRC 计数4位 */
unsigned char extension:1; /* 扩展1位 */
unsigned char padding:1; /* 填充1位 */
unsigned char version:2; /* 版本2位 */
/* byte 1 */
unsigned char payload:7; /* 负载类型 */
unsigned char marker:1; /* 标志1位 */
/* bytes 2, 3 */
unsigned short seq_no;
/* bytes 4-7 */
unsigned long timestamp;
/* bytes 8-11 */
unsigned long ssrc; /* 实际上它是一个随即生成的ID，表示了一个RTP连接。在应用的时候，确保这个ID唯一就可以了。*/
} 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
{
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;
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 */
static int is_run;
static int sockfd;
char sendbuf[1500];
//为NALU_t结构体分配内存空间
NALU_t *AllocNALU(int buffersize)
{
NALU_t *pNalu;
if ((pNalu = (NALU_t*)calloc (1, sizeof (NALU_t))) == NULL) {
printf("AllocNALU: Nalu");
exit(0);
}
pNalu->max_size=buffersize;
if ((pNalu->buf = (char*)calloc (buffersize, sizeof (char))) == NULL) {
free (pNalu);
printf ("AllocNALU: Nalu->buf");
exit(0);
}
return pNalu;
}
//释放
void FreeNALU(NALU_t *pNalu)
{
if (pNalu) {
if (pNalu->buf) {
free(pNalu->buf);
pNalu->buf=NULL;
}
free (pNalu);
}
}
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;
}
// 这个函数输入为一个NAL结构体，主要功能为得到一个完整的NALU并保存在NALU_t的buf中，获取他的长度，填充F,IDC,TYPE位。
// 并且返回两个开始字符之间间隔的字节数，即包含有前缀的NALU的长度
int GetAnnexbNALU (NALU_t *pNalu, FILE *bits)
{
int info2=0, info3=0;
int pos = 0;
int StartCodeFound, rewind;
unsigned char *Buf;
if ((Buf = (unsigned char*)calloc (pNalu->max_size , sizeof(char))) == NULL)
printf ("GetAnnexbNALU: Could not allocate Buf memory\n");
if (3 != fread (Buf, 1, 3, bits)) { //从码流中读3个字节
free(Buf);
return -1;
}
if (Buf[0]!=0 || Buf[1]!=0) {
free(Buf);
return -1;
}
if (Buf[2]==1) {
pNalu->startcodeprefix_len=3; //初始化码流序列的开始字符为3个字节
pos =3;
}else {
if (1 != fread (Buf+3, 1, 1, bits)) { //从码流中读1个字节
free(Buf);
return -1;
}
if (Buf[2]!=0 || Buf[3]!=1) {
free(Buf);
return -1;
}
pos = 4;
pNalu->startcodeprefix_len = 4;
}
//查找下一个开始字符的标志位
StartCodeFound = 0;
info2 = 0;
info3 = 0;
while (!StartCodeFound) {
if (feof (bits)) { //判断是否到了文件尾
break;
}
Buf[pos++] = fgetc (bits);//读一个字节到BUF中
info3 = FindStartCode3(&Buf[pos-4]);//判断是否为0x00000001
if(info3 != 1)
info2 = FindStartCode2(&Buf[pos-3]);//判断是否为0x000001
StartCodeFound =(info2|info3);
}
if (StartCodeFound) {
// 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");
}
} else {
rewind = -1;
}
// 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
pNalu->len = (pos+rewind)-pNalu->startcodeprefix_len;
memcpy (pNalu->buf, &Buf[pNalu->startcodeprefix_len], pNalu->len);//拷贝一个完整NALU，不拷贝起始前缀0x000001或0x00000001
pNalu->forbidden_bit = pNalu->buf[0] & 0x80; //1bit
pNalu->nal_reference_idc = pNalu->buf[0] & 0x60; // 2 bit
pNalu->nal_unit_type = (pNalu->buf[0]) & 0x1f;// 5 bit
free(Buf);
return (pos+rewind); //返回两个开始字符之间间隔的字节数，即包含有前缀的NALU的长度
}
//输出NALU长度和TYPE
void dump(NALU_t *pNalu)
{
if (!pNalu) return;
printf(" len: %d ", pNalu->len);
printf("nal_unit_type: %x\n", pNalu->nal_unit_type);
}
void client_handler()
{
FILE *bits; //!< the bit stream file
NALU_t *pNalu;
char* nalu_payload;
RTP_FIXED_HEADER *rtp_hdr;
NALU_HEADER *nalu_hdr;
FU_INDICATOR *fu_ind;
FU_HEADER *fu_hdr;
unsigned short seq_num =0;
int bytes=0;
printf("open cap.h264 ...\n");
if ((bits = fopen("cap.h264", "rb"))==NULL) {
printf("open file error\n");
return;
}
printf("open successfully\n");
float framerate=15;
unsigned int timestamp_increse=0, ts_current=0;
timestamp_increse=(unsigned int)(90000.0 / framerate); //+0.5); 90000 = ??
pNalu = AllocNALU(8000000);//为结构体nalu_t及其成员buf分配空间。返回值为指向nalu_t存储空间的指针 ??
printf("run ...\n");
while(is_run) {
if(GetAnnexbNALU(pNalu, bits) < 0) {//每执行一次，文件的指针指向本次找到的NALU的末尾，下一个位置即为下个NALU的起始码0x000001
printf("end\n");
is_run = 0;
break;
}
dump(pNalu); //输出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(pNalu->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=pNalu->forbidden_bit;
nalu_hdr->NRI=pNalu->nal_reference_idc>>5;//有效数据在n->nal_reference_idc的第6，7位，需要右移5位才能将其值赋给nalu_hdr->NRI。
nalu_hdr->TYPE=pNalu->nal_unit_type;
nalu_payload=&sendbuf[13];//同理将sendbuf[13]赋给nalu_payload
memcpy(nalu_payload,pNalu->buf+1,pNalu->len-1);//去掉nalu头的nalu剩余内容写入sendbuf[13]开始的字符串。
ts_current=ts_current+timestamp_increse;
rtp_hdr->timestamp=htonl(ts_current);
bytes=pNalu->len + 12 ; //获得sendbuf的长度,为nalu的长度（包含NALU头但除去起始前缀）加上rtp_header的固定长度12字节
send(sockfd, sendbuf, bytes, 0 ); //发送rtp包
// Sleep(100);
} else {
//得到该nalu需要用多少长度为1400字节的RTP包来发送
int k=0, l=0;
k=pNalu->len/1400; //需要k个1400字节的RTP包
l=pNalu->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位
{
//设置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=pNalu->forbidden_bit;
fu_ind->NRI=pNalu->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=pNalu->nal_unit_type;
nalu_payload=&sendbuf[14];//同理将sendbuf[14]赋给nalu_payload
memcpy(nalu_payload,pNalu->buf+1,1400);//去掉NALU头
bytes=1400+14; //获得sendbuf的长度,为nalu的长度（除去起始前缀和NALU头）加上rtp_header，fu_ind，fu_hdr的固定长度14字节
send(sockfd, sendbuf, bytes, 0 );//发送rtp包
t++;
} else {
if(k==t) { // 发送最后一个零头，清零FU HEADER的S位，置FU HEADER的E位.注意最后一个分片的长度
// 可能超过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=pNalu->forbidden_bit;
fu_ind->NRI=pNalu->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=pNalu->nal_unit_type;
fu_hdr->E=1;
nalu_payload=&sendbuf[14];//同理将sendbuf[14]的地址赋给nalu_payload
memcpy(nalu_payload,pNalu->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(sockfd, sendbuf, bytes, 0 );//发送rtp包
t++;
// Sleep(100);
}else {
if(t<k) { // 发送其他整块（1400）
//设置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=pNalu->forbidden_bit;
fu_ind->NRI=pNalu->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=pNalu->nal_unit_type;
nalu_payload=&sendbuf[14];//同理将sendbuf[14]的地址赋给nalu_payload
memcpy(nalu_payload,pNalu->buf+t*1400+1,1400);//去掉起始前缀的nalu剩余内容写入sendbuf[14]开始的字符串。
bytes=1400+14; //获得sendbuf的长度,为nalu的长度（除去原NALU头）加上rtp_header，fu_ind，fu_hdr的固定长度14字节
send(sockfd, sendbuf, bytes, 0 );//发送rtp包
t++;
}
}
}
}
}
}
FreeNALU(pNalu);
fclose(bits);
}
void sig_handler(int sig)
{
fprintf(stderr, "\npid %d handle the exit event ... \n", getpid());
is_run = 0;
close(sockfd);
fprintf(stderr, "exit.\n");
/* child exit really */
_exit(0);
}
int main()
{
int res = 0;
struct sockaddr_in addr;
socklen_t len = sizeof(addr);
signal(SIGINT, sig_handler);
is_run = 1;
sockfd = socket(AF_INET, SOCK_DGRAM, 0);
if(-1 == sockfd) {
perror("socket");
return -1;
}
fprintf(stderr, "create sockfd successfully !\n");
addr.sin_family = AF_INET;
addr.sin_port = htons(8080);
addr.sin_addr.s_addr = inet_addr("192.168.1.57");
res = connect(sockfd, (struct sockaddr*)&addr, len);
if(-1 == res) {
perror("connect");
goto listen_err;
}
fprintf(stderr, "connect 192.168.1.57:8080 successfully !\n");
client_handler();
listen_err:
close(sockfd);
return res;
}
代码写的比较简单，这几篇文章的主要目地是了解流程。具体的完整实现与优化，我的想法是可以一直别人开源的代码，修改、优化，并开源测试。
编译得到rtsp程序，与cap.h264在同一目录下。先VLC打开w.sdp，然后运行rtsp程序。
最后的效果，比直接播放cap.h264的效果差，udp，在同一个局域网，网络差的时候，也会有不少丢包。