devbox
数据科学灵魂
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

2、RTSP协议的实现_stm32网络摄像头rtsp

作者：数据科学灵魂 | 2024-01-30 11:48:35

赞

踩

stm32网络摄像头rtsp

写在前面


此系列只追求精简，旨在学习RTSP协议的实现过程，不追求复杂完美，所以这里要实现的RTSP服务器为了简单，实现上同一时间只能有一个客户端，下面开始介绍实现过程

在写一个RTSP服务器之前，我们必须知道一个RTSP服务器最简单的包含两部分，一部分是RTSP的交互，一部分是RTP发送，本文先实现RTSP交互过程

一、创建套接字


想一下我们在vlc输入rtsp://127.0.0.1:8554后发生了什么事？

在这种情况下，vlc其实是一个rtsp客户端，当输入这个url后，vlc知道目的IP为127.0.0.1，目的端口号为8854，这时vlc会发起一个tcp连接取连接服务器，连接成功后就开始发送请求，服务端响应

所以我们要写一个rtsp服务器，第一步肯定是创建tcp服务器

首先创建tcp套接字，绑定端口，监听

  1. //1.创建套接字
  2. serverSockfd = socket(AF_INET, SOCK_STREAM, 0);
  3. setsockopt(serverSockfd, SOL_SOCKET, SO_REUSEADDR, (const char*)&on, sizeof(on));
  4.  
  5. //2.绑定地址和端口号  这个示例绑定的地址是INADDR_ANY，端口号为8554
  6. bind(serverSockfd, (struct sockaddr *)&addr, sizeof(struct sockaddr)
  7.  
  8. //3.开始监听
  9. listen(serverSockfd, 10);

RTSP服务器传输音视频数据和信息使用的是RTP和RTCP，所以我们还要为RTP和RTCP创建UDP套接字，并绑定号端口

  1. //1.创建套接字
  2. serverRtpSockfd = createUdpSocket();
  3. serverRtcpSockfd = createUdpSocket();
  4.  
  5. //2.绑定端口号 当创建好套接字还有绑定号端口后，就可以接收客户端请求了
  6. bindSocketAddr(serverRtpSockfd, "0.0.0.0", SERVER_RTP_PORT);
  7. bindSocketAddr(serverRtcpSockfd, "0.0.0.0", SERVER_RTCP_PORT);
  8.  
  9. //3.开始accept等待客户端连接
  10. clientfd = accept(serverSockfd, (struct sockaddr *)&addr, &len);

 

二、解析请求

当rtsp客户端连接成功后就会开始发送请求，服务器这是需要接收客户端请求并开始解析，再采取相应得操作

这里我们做得最简单，首先解析第一行得到方法，对于OPTIONS、DESCRIBE、PLAY、TEARDOWN我们只解析CSeq。对于SETUP，我们讲client_port解析出来

所以我们要做的第一步就是解析请求中的信息

 

解析完请求命令后，接下来就是更具不同得方法做不同的响应了，如下

  1. /*
  2.  * 作者：_JT_
  3.  * 博客：https://blog.csdn.net/weixin_42462202
  4.  */
  5. if(!strcmp(method, "OPTIONS"))
  6. {
  7. 	handleCmd_OPTIONS();
  8. }
  9. else if(!strcmp(method, "DESCRIBE"))
  10. {
  11. 	handleCmd_DESCRIBE();
  12. }
  13. else if(!strcmp(method, "SETUP"))
  14. {
  15. 	handleCmd_SETUP();
  16. }
  17. else if(!strcmp(method, "PLAY"))
  18. {
  19. 	handleCmd_PLAY();
  20. }
  21. else if(!strcmp(method, "TEARDOWN"))
  22. {
  23. 	handleCmd_TEARDOWN();
  24. }

 

三、OPTIONS响应

OPTIONS是客户端向服务端请求可用的方法，我们这里就向客户端回复我们当前可用的方法

  1. sprintf(sBuf, "RTSP/1.0 200 OK\r\n"
  2. 				"CSeq: %d\r\n"
  3. 				"Public: OPTIONS, DESCRIBE, SETUP, PLAY\r\n"
  4. 				"\r\n",
  5. 				cseq);
  6. send(clientSockfd, sBuf, strlen(sBuf));

四、DESCRIBE响应

DESCRIBE是客户端向服务器请求媒体信息，这是服务器需要回复sdp描述文件，这个例子中的媒体是H.264

  • sdp文件生成

  1. sprintf(sdp, "v=0\r\n"
  2. 			"o=- 9%ld 1 IN IP4 %s\r\n"
  3. 			"t=0 0\r\n"
  4. 			"a=control:*\r\n"
  5. 			"m=video 0 RTP/AVP 96\r\n"
  6. 			"a=rtpmap:96 H264/90000\r\n"
  7. 			"a=control:track0\r\n",
  8. 			time(NULL), localIp);

回复

  1. sprintf(sBuf, "RTSP/1.0 200 OK\r\n"
  2. 		"CSeq: %d\r\n"
  3. 		"Content-Base: %s\r\n"
  4. 		"Content-type: application/sdp\r\n"
  5. 		"Content-length: %d\r\n\r\n"
  6. 		"%s",
  7. 		cseq,
  8. 		url,
  9. 		strlen(sdp),
  10. 		sdp);
  11. 		
  12. send(clientSockfd, sBuf, strlen(sBuf));

五、SETUP响应

SETUP是客户端请求建立会话连接，并发送了客户端的RTP端口和RTCP端口，那么此时服务端需要回复服务端的RTP端口和RTCP端口

六、PLAY响应

PLAY时客户端向服务器请求播放，这时服务端回复完请求后就开始通过setup过程中创建的udp套接字发送RTP包

七、源码

  1.  
  2.  
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <stdint.h>
  6. #include <string.h>
  7. #include <sys/types.h>
  8. #include <sys/socket.h>
  9. #include <sys/socket.h>
  10. #include <netinet/in.h>
  11. #include <arpa/inet.h>
  12. #include <time.h>
  13.  
  14. #define SERVER_PORT     8554
  15. #define SERVER_RTP_PORT  55532
  16. #define SERVER_RTCP_PORT 55533
  17. #define BUF_MAX_SIZE    (1024*1024)
  18.  
  19. static int createTcpSocket()
  20. {
  21.     int sockfd;
  22.     int on = 1;
  23.  
  24.     sockfd = socket(AF_INET, SOCK_STREAM, 0);
  25.     if(sockfd < 0)
  26.         return -1;
  27.  
  28.     setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, (const char*)&on, sizeof(on));
  29.  
  30.     return sockfd;
  31. }
  32.  
  33. static int createUdpSocket()
  34. {
  35.     int sockfd;
  36.     int on = 1;
  37.  
  38.     sockfd = socket(AF_INET, SOCK_DGRAM, 0);
  39.     if(sockfd < 0)
  40.         return -1;
  41.  
  42.     setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, (const char*)&on, sizeof(on));
  43.  
  44.     return sockfd;
  45. }
  46.  
  47. static int bindSocketAddr(int sockfd, const char* ip, int port)
  48. {
  49.     struct sockaddr_in addr;
  50.  
  51.     addr.sin_family = AF_INET;
  52.     addr.sin_port = htons(port);
  53.     addr.sin_addr.s_addr = inet_addr(ip);
  54.  
  55.     if(bind(sockfd, (struct sockaddr *)&addr, sizeof(struct sockaddr)) < 0)
  56.         return -1;
  57.  
  58.     return 0;
  59. }
  60.  
  61. static int acceptClient(int sockfd, char* ip, int* port)
  62. {
  63.     int clientfd;
  64.     socklen_t len = 0;
  65.     struct sockaddr_in addr;
  66.  
  67.     memset(&addr, 0, sizeof(addr));
  68.     len = sizeof(addr);
  69.  
  70.     clientfd = accept(sockfd, (struct sockaddr *)&addr, &len);
  71.     if(clientfd < 0)
  72.         return -1;
  73.     
  74.     strcpy(ip, inet_ntoa(addr.sin_addr));
  75.     *port = ntohs(addr.sin_port);
  77.     return clientfd;
  78. }
  79.  
  80. static char* getLineFromBuf(char* buf, char* line)
  81. {
  82.     while(*buf != '\n')
  83.     {
  84.         *line = *buf;
  85.         line++;
  86.         buf++;
  87.     }
  88.  
  89.     *line = '\n';
  90.     ++line;
  91.     *line = '\0';
  93.     ++buf;
  94.     return buf; 
  95. }
  96.  
  97. static int handleCmd_OPTIONS(char* result, int cseq)
  98. {
  99.     sprintf(result, "RTSP/1.0 200 OK\r\n"
  100.                     "CSeq: %d\r\n"
  101.                     "Public: OPTIONS, DESCRIBE, SETUP, PLAY\r\n"
  102.                     "\r\n",
  103.                     cseq);
  104.                 
  105.     return 0;
  106. }
  107.  
  108. static int handleCmd_DESCRIBE(char* result, int cseq, char* url)
  109. {
  110.     char sdp[500];
  111.     char localIp[100];
  112.  
  113.     sscanf(url, "rtsp://%[^:]:", localIp);
  114.  
  115.     sprintf(sdp, "v=0\r\n"
  116.                  "o=- 9%ld 1 IN IP4 %s\r\n"
  117.                  "t=0 0\r\n"
  118.                  "a=control:*\r\n"
  119.                  "m=video 0 RTP/AVP 96\r\n"
  120.                  "a=rtpmap:96 H264/90000\r\n"
  121.                  "a=control:track0\r\n",
  122.                  time(NULL), localIp);
  123.     
  124.     sprintf(result, "RTSP/1.0 200 OK\r\nCSeq: %d\r\n"
  125.                     "Content-Base: %s\r\n"
  126.                     "Content-type: application/sdp\r\n"
  127.                     "Content-length: %d\r\n\r\n"
  128.                     "%s",
  129.                     cseq,
  130.                     url,
  131.                     strlen(sdp),
  132.                     sdp);
  133.     
  134.     return 0;
  135. }
  136.  
  137. static int handleCmd_SETUP(char* result, int cseq, int clientRtpPort)
  138. {
  139.     sprintf(result, "RTSP/1.0 200 OK\r\n"
  140.                     "CSeq: %d\r\n"
  141.                     "Transport: RTP/AVP;unicast;client_port=%d-%d;server_port=%d-%d\r\n"
  142.                     "Session: 66334873\r\n"
  143.                     "\r\n",
  144.                     cseq,
  145.                     clientRtpPort,
  146.                     clientRtpPort+1,
  147.                     SERVER_RTP_PORT,
  148.                     SERVER_RTCP_PORT);
  149.     
  150.     return 0;
  151. }
  152.  
  153. static int handleCmd_PLAY(char* result, int cseq)
  154. {
  155.     sprintf(result, "RTSP/1.0 200 OK\r\n"
  156.                     "CSeq: %d\r\n"
  157.                     "Range: npt=0.000-\r\n"
  158.                     "Session: 66334873; timeout=60\r\n\r\n",
  159.                     cseq);
  160.     
  161.     return 0;
  162. }
  163.  
  164. static void doClient(int clientSockfd, const char* clientIP, int clientPort,
  165.                         int serverRtpSockfd, int serverRtcpSockfd)
  166. {
  167.     char method[40];
  168.     char url[100];
  169.     char version[40];
  170.     int cseq;
  171.     int clientRtpPort, clientRtcpPort;
  172.     char *bufPtr;
  173.     char* rBuf = malloc(BUF_MAX_SIZE);
  174.     char* sBuf = malloc(BUF_MAX_SIZE);
  175.     char line[400];
  176.  
  177.     while(1)
  178.     {
  179.         int recvLen;
  180.  
  181.         recvLen = recv(clientSockfd, rBuf, BUF_MAX_SIZE, 0);
  182.         if(recvLen <= 0)
  183.             goto out;
  184.  
  185.         rBuf[recvLen] = '\0';
  186.         printf("---------------C->S--------------\n");
  187.         printf("%s", rBuf);
  188.  
  189.         /* 解析方法 */
  190.         bufPtr = getLineFromBuf(rBuf, line);
  191.         if(sscanf(line, "%s %s %s\r\n", method, url, version) != 3)
  192.         {
  193.             printf("parse err\n");
  194.             goto out;
  195.         }
  196.  
  197.         /* 解析序列号 */
  198.         bufPtr = getLineFromBuf(bufPtr, line);
  199.         if(sscanf(line, "CSeq: %d\r\n", &cseq) != 1)
  200.         {
  201.             printf("parse err\n");
  202.             goto out;
  203.         }
  204.  
  205.         /* 如果是SETUP，那么就再解析client_port */
  206.         if(!strcmp(method, "SETUP"))
  207.         {
  208.             while(1)
  209.             {
  210.                 bufPtr = getLineFromBuf(bufPtr, line);
  211.                 if(!strncmp(line, "Transport:", strlen("Transport:")))
  212.                 {
  213.                     sscanf(line, "Transport: RTP/AVP;unicast;client_port=%d-%d\r\n",
  214.                                     &clientRtpPort, &clientRtcpPort);
  215.                     break;
  216.                 }
  217.             }
  218.         }
  219.  
  220.         if(!strcmp(method, "OPTIONS"))
  221.         {
  222.             if(handleCmd_OPTIONS(sBuf, cseq))
  223.             {
  224.                 printf("failed to handle options\n");
  225.                 goto out;
  226.             }
  227.         }
  228.         else if(!strcmp(method, "DESCRIBE"))
  229.         {
  230.             if(handleCmd_DESCRIBE(sBuf, cseq, url))
  231.             {
  232.                 printf("failed to handle describe\n");
  233.                 goto out;
  234.             }
  235.         }
  236.         else if(!strcmp(method, "SETUP"))
  237.         {
  238.             if(handleCmd_SETUP(sBuf, cseq, clientRtpPort))
  239.             {
  240.                 printf("failed to handle setup\n");
  241.                 goto out;
  242.             }
  243.         }
  244.         else if(!strcmp(method, "PLAY"))
  245.         {
  246.             if(handleCmd_PLAY(sBuf, cseq))
  247.             {
  248.                 printf("failed to handle play\n");
  249.                 goto out;
  250.             }
  251.         }
  252.         else
  253.         {
  254.             goto out;
  255.         }
  256.  
  257.         printf("---------------S->C--------------\n");
  258.         printf("%s", sBuf);
  259.         send(clientSockfd, sBuf, strlen(sBuf), 0);
  260.     }
  261. out:
  262.     close(clientSockfd);
  263.     free(rBuf);
  264.     free(sBuf);
  265. }
  266.  
  267. int main(int argc, char* argv[])
  268. {
  269.     int serverSockfd;
  270.     int serverRtpSockfd, serverRtcpSockfd;
  271.     int ret;
  272.  
  273.     serverSockfd = createTcpSocket();
  274.     if(serverSockfd < 0)
  275.     {
  276.         printf("failed to create tcp socket\n");
  277.         return -1;
  278.     }
  279.  
  280.     ret = bindSocketAddr(serverSockfd, "0.0.0.0", SERVER_PORT);
  281.     if(ret < 0)
  282.     {
  283.         printf("failed to bind addr\n");
  284.         return -1;
  285.     }
  286.  
  287.     ret = listen(serverSockfd, 10);
  288.     if(ret < 0)
  289.     {
  290.         printf("failed to listen\n");
  291.         return -1;
  292.     }
  293.  
  294.     serverRtpSockfd = createUdpSocket();
  295.     serverRtcpSockfd = createUdpSocket();
  296.     if(serverRtpSockfd < 0 || serverRtcpSockfd < 0)
  297.     {
  298.         printf("failed to create udp socket\n");
  299.         return -1;
  300.     }
  301.  
  302.     if(bindSocketAddr(serverRtpSockfd, "0.0.0.0", SERVER_RTP_PORT) < 0 ||
  303.         bindSocketAddr(serverRtcpSockfd, "0.0.0.0", SERVER_RTCP_PORT) < 0)
  304.     {
  305.         printf("failed to bind addr\n");
  306.         return -1;
  307.     }
  308.  
  309.     printf("rtsp://127.0.0.1:%d\n", SERVER_PORT);
  310.  
  311.     while(1)
  312.     {
  313.         int clientSockfd;
  314.         char clientIp[40];
  315.         int clientPort;
  316.  
  317.         clientSockfd = acceptClient(serverSockfd, clientIp, &clientPort);
  318.         if(clientSockfd < 0)
  319.         {
  320.             printf("failed to accept client\n");
  321.             return -1;
  322.         }
  323.  
  324.         printf("accept client;client ip:%s,client port:%d\n", clientIp, clientPort);
  325.  
  326.         doClient(clientSockfd, clientIp, clientPort, serverRtpSockfd, serverRtcpSockfd);
  327.     }
  328.  
  329.     return 0;
  330. }

八、测试

编译运行源码，打开vlc，输入rtsp://127.0.0.1:8554，点击开始播放，可以看到控制台会打印出交互过程，或是用wireshak抓包

本篇文章到这里结束，至此完成了RTSP协议的交互部分，在PLAY之后并没有开始发送RTP包，所以暂时还看不到视频，究竟如何发送RTP包，请看下一篇文章
 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/article/detail/46217
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号