目录
源码框架分析
主函数中只有两部分，初始化rtsp服务和视频编码程序
RtspServer_init
我们在编写代码前的设想是让开发板作为服务器，windows作为客户端。于是服务器一定是先运行，然后像socket那样初始化完成后阻塞监听，等待客户端连接。
S(server)C(client)模式，基本都是这样的结构。
初始化部分代码如下
void RtspServer_init(void)
{
int i;
pthread_t threadId = 0;
memset(&g_rtp_playload,0,sizeof(g_rtp_playload));
strcpy(&g_rtp_playload,"G726-32");
g_audio_rate = 8000;
pthread_mutex_init(&g_sendmutex,NULL);
pthread_mutex_init(&g_mutex,NULL);
pthread_cond_init(&g_cond,NULL);
memset(&g_rtspClients,0,sizeof(RTSP_CLIENT)*MAX_RTSP_CLIENT);
//pthread_create(&g_SendDataThreadId, NULL, SendDataThread, NULL);
struct sched_param thdsched;
thdsched.sched_priority = 2;
//to listen visiting
pthread_create(&threadId, NULL, RtspServerListen, NULL);
//pthread_setschedparam(threadId,SCHED_RR,&thdsched);
printf("RTSP:-----Init Rtsp server\n");
pthread_create(&gs_RtpPid, 0, vdRTPSendThread, NULL);
//exitok++;
}
一上来先申请一个线程，盲猜就是用来监听
接着为payload的存放申请空间，以RTP开头，是应为rtsp与rtp之间有联系，rtsp实际上是以rtp包来发送的，所以以rtp开头
g_rtp_playload是一个20个字节的数组，后面将G726-32放入数组，这表示是一种音频标准的payload
下面的g_audio_rate = 8000;就是音频的采样率，后续没有用到，如果做音频相关的东西就可以进行使用
接着初始化全局的mutex和cond
再为g_rtspClients申请空间，用于存放连接的客户端的信息，数据结构如下
typedef struct
{
int index;
int socket;
int reqchn;
int seqnum;
int seqnum2;
unsigned int tsvid;
unsigned int tsaud;
int status;
int sessionid;
int rtpport[2];
int rtcpport;
char IP[20];
char urlPre[PARAM_STRING_MAX];
}RTSP_CLIENT;
接着配置sched_param结构体，看起来是和线程调度的优先级有关。如果线程比较多，对CPU资源进行争抢的时候，就需要设置，可以调用系统API进行线程的调度。
这里作为预留，实际代码中没有必要使用
pthread_setschedparam(threadId,SCHED_RR,&thdsched);注释掉了
RtspServer_init中真正被调用的函数是RtspServerListen，开启了一个线程进行监听。socket的转网络字节序、servaddr的配置、bind、listen都放在了这个线程里面。
vdRTPSendThread用于发送，也开启了一个线程进行
SAMPLE_VENC_720P_CLASSIC
这个函数就是标准的海思sample，但是加入了rtsp的内容
我们将sample修改为只用一路，码率控制模式改为固定fixQP
其他内容没有什么变动，具体参考专栏海思3518E开发笔记中2开头的内容
修改的部分是第六步，从venc编码通道（vb）中获取视频流并保存，这里改为获取视频流后不保存，直接放到rtsp通道中传输
于是在原来保存264码流的地方，换成通过rtsp发送出去
HI_S32 SAMPLE_COMM_VENC_Sentjin(VENC_STREAM_S *pstStream)
{
HI_S32 i,flag=0;
for(i=0;i<MAX_RTSP_CLIENT;i++)//have atleast a connect
{
if(g_rtspClients[i].status == RTSP_SENDING)
{
flag = 1;
break;
}
}
if(flag)
{
for (i = 0; i < pstStream->u32PackCount; i++)
{
HI_S32 lens=0,j,lastadd=0,newadd=0,showflap=0;
char sendbuf[320*1024];
//char tmp[640*1024];
lens = pstStream->pstPack[i].u32Len-pstStream->pstPack[i].u32Offset;
memcpy(&sendbuf[0],pstStream->pstPack[i].pu8Addr+pstStream->pstPack[i].u32Offset,lens);
//printf("lens = %d, count= %d\n",lens,count++);
VENC_Sent(sendbuf,lens);
lens = 0;
}
}
return HI_SUCCESS;
}
实际应用场景中，可能有很多路的rtsp流，这里我们宏定义只用一路
下面对rtsp的状态进行判断，如果处于发送状态就进行发送
然后调用VENC_Sent将准备好的包发出去
详细分析
RtspServer_init
RtspServerListen
这里主要就是网络编程中配置端口号，修改网络字节序的内容
端口号使用的是554，这是RTSP的默认端口号
setsockopt来设置socket属性，设置了SO_REUSEADDR可以用来复用
然后就是bind和listen
接下来到accept
如果没人连接，就阻塞到while的判断中，有人连接就进入while
并且将连接过来的ip地址打印出来
接着再进行socket的设置，选项是SO_SNDBUF，即设置发送缓冲区的大小
然后对新连接的rtspClient的status进行判断，如果等于RTSP_IDLE就进行处理。由于g_rtspClients是全局变量，定义之后自动初始化为0，就是status枚举里的第一个。
这样处理，只要是新的ip地址，就一定是空闲状态，进if后，就把他的状态换成connected，避免反复操作
进入if之后，将接入的客户端的属性进行一一填充。
memset(&g_rtspClients[i],0,sizeof(RTSP_CLIENT));
g_rtspClients[i].index = i;
g_rtspClients[i].socket = s32CSocket;
g_rtspClients[i].status = RTSP_CONNECTED ;//RTSP_SENDING;
g_rtspClients[i].sessionid = nSessionId++;
strcpy(g_rtspClients[i].IP,inet_ntoa(addrAccept.sin_addr));
填充完属性后建立一个线程，进行当前接入客户端的处理。
如果超过最大限制，那么就将超过的覆盖到原来的0，这样循环覆盖下去（设计方面的思路，也可以超过直接不再连接）
处理的函数是RtspClientMsg，只服务当前接入的客户端
在看这一段代码的时候，就需要对RTSP传输协议有一定的了解，函数中ParseRequestString对RTSP消息头进行解析
RtspClientMsg函数一进去，做了一个RTSP_CLIENT * pClient来接受传进来的结构体，不直接用是避免修改原来结构体里的内容
当连接进来的客户端的状态不是架空的时候，就进行数据的receive，一次只读RTSP_RECV_SIZE这么多，没有读完的部分留到下一次继续读，如果读出来的字节数小于0，那么是错误的，把状态重新改为置空
接下来定义了一系列的局部变量，作为ParseRequestString的输出参数。
该函数原型如下
int ParseRequestString(char const* reqStr,
unsigned reqStrSize,
char* resultCmdName,
unsigned resultCmdNameMaxSize,
char* resultURLPreSuffix,
unsigned resultURLPreSuffixMaxSize,
char* resultURLSuffix,
unsigned resultURLSuffixMaxSize,
char* resultCSeq,
unsigned resultCSeqMaxSize)
第一个参数为前面socket接收到的字符串，就是进行分析的目标
第二个参数是接受到字符串的大小
第三个参数用来存放解析出来的RTSP method
第四个参数是函数执行前申请存放第三个参数的数组的大小
第五个参数是解析出来的URL前缀
第六个参数是用来存放第五个参数的数组大小
第七个参数是解析出来的URL后缀
第八个参数是存放第七个参数的数组大小
第九个参数是解析出来的会话序列号
第十个参数是存放第九个参数的数组大小
以上解析出来的参数都和RTSP会话内容对应，详细参考我之前写的RTSP协议详解
后面的内容就是对解析出来的RTSP methods进行对应操作
接下来仔细分析ParseRequestString函数
ParseRequestString
这个函数的作用就是解析RTSP协议中CS交互信息，多为一些字符串操作
第一段
// Read everything up to the first space as the command name:
int parseSucceeded = FALSE;
unsigned i;
for (i = 0; i < resultCmdNameMaxSize-1 && i < reqStrSize; ++i)
{
char c = reqStr[i];
if (c == ' ' || c == '\t')
{
parseSucceeded = TRUE;
break;
}
resultCmdName[i] = c;
}
resultCmdName[i] = '\0';
if (!parseSucceeded) return FALSE;
首先做了一个flag，来表示是否成功分析
接着对获取的数据进行分段，标志是空格或制表符
这个循环就获取了RTSP 的method
由于解析出来的是字符串，就需要将最后一个字符替换为字符串的结束标志
第二段
// Skip over the prefix of any "rtsp://" or "rtsp:/" URL that follows:
unsigned j = i+1;
while (j < reqStrSize && (reqStr[j] == ' ' || reqStr[j] == '\t')) ++j; // skip over any additional white space
for (j = i+1; j < reqStrSize-8; ++j) {
if ((reqStr[j] == 'r' || reqStr[j] == 'R')
&& (reqStr[j+1] == 't' || reqStr[j+1] == 'T')
&& (reqStr[j+2] == 's' || reqStr[j+2] == 'S')
&& (reqStr[j+3] == 'p' || reqStr[j+3] == 'P')
&& reqStr[j+4] == ':' && reqStr[j+5] == '/') {
j += 6;
if (reqStr[j] == '/') {
// This is a "rtsp://" URL; skip over the host:port part that follows:
++j;
while (j < reqStrSize && reqStr[j] != '/' && reqStr[j] != ' ') ++j;
} else {
// This is a "rtsp:/" URL; back up to the "/":
--j;
}
i = j;
break;
}
}
// Look for the URL suffix (before the following "RTSP/"):
parseSucceeded = FALSE;
unsigned k;
for (k = i+1; k < reqStrSize-5; ++k) {
if (reqStr[k] == 'R' && reqStr[k+1] == 'T' &&
reqStr[k+2] == 'S' && reqStr[k+3] == 'P' && reqStr[k+4] == '/') {
while (--k >= i && reqStr[k] == ' ') {} // go back over all spaces before "RTSP/"
unsigned k1 = k;
while (k1 > i && reqStr[k1] != '/' && reqStr[k1] != ' ') --k1;
// the URL suffix comes from [k1+1,k]
// Copy "resultURLSuffix":
if (k - k1 + 1 > resultURLSuffixMaxSize) return FALSE; // there's no room
unsigned n = 0, k2 = k1+1;
while (k2 <= k) resultURLSuffix[n++] = reqStr[k2++];
resultURLSuffix[n] = '\0';
// Also look for the URL 'pre-suffix' before this:
unsigned k3 = --k1;
while (k3 > i && reqStr[k3] != '/' && reqStr[k3] != ' ') --k3;
// the URL pre-suffix comes from [k3+1,k1]
// Copy "resultURLPreSuffix":
if (k1 - k3 + 1 > resultURLPreSuffixMaxSize) return FALSE; // there's no room
n = 0; k2 = k3+1;
while (k2 <= k1) resultURLPreSuffix[n++] = reqStr[k2++];
resultURLPreSuffix[n] = '\0';
i = k + 7; // to go past " RTSP/"
parseSucceeded = TRUE;
break;
}
}
if (!parseSucceeded) return FALSE;
首先用j获取第二段关键信息，就是用上次的最后地址i再往后偏移一个地址
然后兼容大小写，作用是跳过rtsp://或rtsp:/
然后找到/后面的不是/或者空格的那一个地址，就是解析出来的URL的首地址
第三段
// Look for "CSeq:", skip whitespace,
// then read everything up to the next \r or \n as 'CSeq':
parseSucceeded = FALSE;
for (j = i; j < reqStrSize-5; ++j) {
if (reqStr[j] == 'C' && reqStr[j+1] == 'S' && reqStr[j+2] == 'e' &&
reqStr[j+3] == 'q' && reqStr[j+4] == ':') {
j += 5;
unsigned n;
while (j < reqStrSize && (reqStr[j] == ' ' || reqStr[j] == '\t')) ++j;
for (n = 0; n < resultCSeqMaxSize-1 && j < reqStrSize; ++n,++j) {
char c = reqStr[j];
if (c == '\r' || c == '\n') {
parseSucceeded = TRUE;
break;
}
resultCSeq[n] = c;
}
resultCSeq[n] = '\0';
break;
}
}
if (!parseSucceeded) return FALSE;
用于解析出CSeq字段
以上就是作为服务器的开发板对客户端发来的请求信息的解析，解析完毕后做相应的处理
OPTIONS
以OptionAnswer为例
int OptionAnswer(char *cseq, int sock)
{
if (sock != 0)
{
char buf[1024];
memset(buf,0,1024);
char *pTemp = buf;
pTemp += sprintf(pTemp,"RTSP/1.0 200 OK\r\nCSeq: %s\r\n%sPublic: %s\r\n\r\n",
cseq,dateHeader(),"OPTIONS,DESCRIBE,SETUP,PLAY,PAUSE,TEARDOWN");
int reg = send(sock, buf,strlen(buf),0);
if(reg <= 0)
{
return FALSE;
}
else
{
printf(">>>>>%s\n",buf);
}
return TRUE;
}
return FALSE;
}
服务端收到客户端的请求后，向客户端返回信息
返回的信息放在buf中，通过socket通道发送
返回的信息按照RTSP规则
DESCRIBE
int DescribeAnswer(char *cseq,int sock,char * urlSuffix,char* recvbuf)
{
if (sock != 0)
{
char sdpMsg[1024];
char buf[2048];
memset(buf,0,2048);
memset(sdpMsg,0,1024);
char*localip;
localip = GetLocalIP(sock);
char *pTemp = buf;
pTemp += sprintf(pTemp,"RTSP/1.0 200 OK\r\nCSeq: %s\r\n",cseq);
pTemp += sprintf(pTemp,"%s",dateHeader());
pTemp += sprintf(pTemp,"Content-Type: application/sdp\r\n");
char *pTemp2 = sdpMsg;
pTemp2 += sprintf(pTemp2,"v=0\r\n");
pTemp2 += sprintf(pTemp2,"o=StreamingServer 3331435948 1116907222000 IN IP4 %s\r\n",localip);
pTemp2 += sprintf(pTemp2,"s=H.264\r\n");
pTemp2 += sprintf(pTemp2,"c=IN IP4 0.0.0.0\r\n");
pTemp2 += sprintf(pTemp2,"t=0 0\r\n");
pTemp2 += sprintf(pTemp2,"a=control:*\r\n");
/*H264 TrackID=0 RTP_PT 96*/
pTemp2 += sprintf(pTemp2,"m=video 0 RTP/AVP 96\r\n");
pTemp2 += sprintf(pTemp2,"a=control:trackID=0\r\n");
pTemp2 += sprintf(pTemp2,"a=rtpmap:96 H264/90000\r\n");
pTemp2 += sprintf(pTemp2,"a=fmtp:96 packetization-mode=1; sprop-parameter-sets=%s\r\n", "AAABBCCC");
#if 1
/*G726*/
pTemp2 += sprintf(pTemp2,"m=audio 0 RTP/AVP 97\r\n");
pTemp2 += sprintf(pTemp2,"a=control:trackID=1\r\n");
if(strcmp(g_rtp_playload,"AAC")==0)
{
pTemp2 += sprintf(pTemp2,"a=rtpmap:97 MPEG4-GENERIC/%d/2\r\n",16000);
pTemp2 += sprintf(pTemp2,"a=fmtp:97 streamtype=5;profile-level-id=1;mode=AAC-hbr;sizelength=13;indexlength=3;indexdeltalength=3;config=1410\r\n");
}
else
{
pTemp2 += sprintf(pTemp2,"a=rtpmap:97 G726-32/%d/1\r\n",8000);
pTemp2 += sprintf(pTemp2,"a=fmtp:97 packetization-mode=1\r\n");
}
#endif
pTemp += sprintf(pTemp,"Content-length: %d\r\n", strlen(sdpMsg));
pTemp += sprintf(pTemp,"Content-Base: rtsp://%s/%s/\r\n\r\n",localip,urlSuffix);
//printf("mem ready\n");
strcat(pTemp, sdpMsg);
free(localip);
//printf("Describe ready sent\n");
int re = send(sock, buf, strlen(buf),0);
if(re <= 0)
{
return FALSE;
}
else
{
printf(">>>>>%s\n",buf);
}
}
return TRUE;
}
传进来的参数
- cseq——会话的序列号
- sock——socket建立的网络通道
- urlSuffix——解析出来的URL字符串
- recvbuf——服务器接收到的整个信息
函数中，先获取了服务器本地的IP地址
接下来，就按照RTSP的DESCRIBE标准进行回复
RTP协议中，使用VLC进行播放，需要有一个SDP文件进行解析才能播放，RTP传的是裸流，没有控制信息，需要本地配置
而RTSP协议中，SDP包含在交互信息中，不需要用VLC打开SDP文件，通过解析交互信息，客户端就能够知道怎么去解析视频流，代码中的体现如下
char *pTemp2 = sdpMsg;
pTemp2 += sprintf(pTemp2,"v=0\r\n");
pTemp2 += sprintf(pTemp2,"o=StreamingServer 3331435948 1116907222000 IN IP4 %s\r\n",localip);
pTemp2 += sprintf(pTemp2,"s=H.264\r\n");
pTemp2 += sprintf(pTemp2,"c=IN IP4 0.0.0.0\r\n");
pTemp2 += sprintf(pTemp2,"t=0 0\r\n");
pTemp2 += sprintf(pTemp2,"a=control:*\r\n");
PLAY
int PlayAnswer(char *cseq, int sock,int SessionId,char* urlPre,char* recvbuf)
{
if (sock != 0)
{
char buf[1024];
memset(buf,0,1024);
char *pTemp = buf;
char*localip;
localip = GetLocalIP(sock);
pTemp += sprintf(pTemp,"RTSP/1.0 200 OK\r\nCSeq: %s\r\n%sRange: npt=0.000-\r\nSession: %d\r\nRTP-Info: url=rtsp://%s/%s;seq=0\r\n\r\n",
cseq,dateHeader(),SessionId,localip,urlPre);
free(localip);
int reg = send(sock, buf,strlen(buf),0);
if(reg <= 0)
{
return FALSE;
}
else
{
printf(">>>>>%s",buf);
udpfd = socket(AF_INET,SOCK_DGRAM,0);//UDP
struct sockaddr_in server;
server.sin_family=AF_INET;
server.sin_port=htons(g_rtspClients[0].rtpport[0]);
server.sin_addr.s_addr=inet_addr(g_rtspClients[0].IP);
connect(udpfd,(struct sockaddr *)&server,sizeof(server));
printf("udp up\n");
}
return TRUE;
}
return FALSE;
}
客户端play请求后，服务端开启一个UDP的SOCKET通道进行裸流的传输，命令走的是TCP通道。这就是RTSP的设计
因为考虑实时，所以用的是UDP
vdRTPSendThread
HI_VOID* vdRTPSendThread(HI_VOID *p)
{
while(1)
{
if(!list_empty(&RTPbuf_head))
{
RTPbuf_s *p = get_first_item(&RTPbuf_head,RTPbuf_s,list);
VENC_Sent(p->buf,p->len);
list_del(&(p->list));
free(p->buf);
free(p);
p = NULL;
count--;
//printf("count = %d\n",count);
}
usleep(5000);
}
}
在client连接后，server收到play指令，创建裸流的UDP通道
发送是在vdRTPSendThread线程中进行。每隔5微妙在RTPbuf_head链表里查找数据，有数据就进行发送
get_first_item用来取出链表里的第一个非空节点
然后将节点中的内容通过VENC_Sent发送出去，函数的内容主要是为了H264封RTP包添加包头
发送完就将它释放掉
这里的send是消费者，不断发送链表中的数据
有消费者就有生产者，生产在编码的地方
发送有两种方法，一种直接发送，一种是环形buffer发送
直接发送的方法是编码一帧，就发一帧。直接发送的方法不是在vdRTPSendThread线程中，而是在编码的地方发送，编完一帧就发一帧
HI_S32 SAMPLE_COMM_VENC_Sentjin(VENC_STREAM_S *pstStream)
{
HI_S32 i,flag=0;
for(i=0;i<MAX_RTSP_CLIENT;i++)//have atleast a connect
{
if(g_rtspClients[i].status == RTSP_SENDING)
{
flag = 1;
break;
}
}
if(flag)
{
for (i = 0; i < pstStream->u32PackCount; i++)
{
HI_S32 lens=0,j,lastadd=0,newadd=0,showflap=0;
char sendbuf[320*1024];
//char tmp[640*1024];
lens = pstStream->pstPack[i].u32Len-pstStream->pstPack[i].u32Offset;
memcpy(&sendbuf[0],pstStream->pstPack[i].pu8Addr+pstStream->pstPack[i].u32Offset,lens);
//printf("lens = %d, count= %d\n",lens,count++);
VENC_Sent(sendbuf,lens);
lens = 0;
}
}
return HI_SUCCESS;
}
直接发送的方式优势是简单，但实际应用中不会这么去做。实际情况中会比较复杂，编码和传输的速度不一定适配。
如果发送的速度比编码的速度块，那么发送就要等编码。时间上会有冗余
环形buffer就可以有一定的缓冲。如果发送比编码快，那么就阻塞，就像视频缓冲；如果编码比发送快，甚至套了发送一圈了，那么可以增大环形buffer，但是早晚会有崩溃的一天，编码快得多就要考虑系统的设计。
实际谁快谁慢是不确定的，比如网络波动会影响发送的速度。有时候发送慢了，那编码的帧排列准备；有时候发送快了，那么在排队的编码完的帧等待的数量少一点。
环形buffer发送的代码如下
HI_S32 saveStream(VENC_STREAM_S *pstStream)
{
HI_S32 i,j,lens=0;
for(j=0;j<MAX_RTSP_CLIENT;j++)//have atleast a connect
{
if(g_rtspClients[j].status == RTSP_SENDING)
{
for (i = 0; i < pstStream->u32PackCount; i++)
{
RTPbuf_s *p = (RTPbuf_s *)malloc(sizeof(RTPbuf_s));
INIT_LIST_HEAD(&(p->list));
lens = pstStream->pstPack[i].u32Len-pstStream->pstPack[i].u32Offset;
p->buf = (char *)malloc(lens);
p->len = lens;
memcpy(p->buf,pstStream->pstPack[i].pu8Addr+pstStream->pstPack[i].u32Offset,lens);
list_add_tail(&(p->list),&RTPbuf_head);
count++;
//printf("count = %d\n",count);
}
}
}
return HI_SUCCESS;
}
环形buffer是通过链表实现
count是用来记录剩余编码完的帧的数量，发送的话就去减减，到0说明编码完的帧用完了。
这里就是上面说的生产者，把编码完的帧送到全局的链表中，由vdRTPSendThread发送
发送完一个节点，就把这个节点拿掉，并且把内存释放
5431
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
