RTSP协议的实现

程序员文章站 2022-07-01 09:54:50

...

写在前面

目前正在学习RTSP协议，偶然间发现在这篇文章非常好，故转载学习使用：RTSP协议的实现
本文所有代码均来自此篇文章，在此基础上做了一些自己的笔记，然后有些许改变，文章也会讲解下socket，感觉啃下来，不懂rtsp，不知道socket也是可以读懂的，这期间也是我自己的学习过程。

创建套接字

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

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

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

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

TCP函数定义:

/*
* 创建tcp socket套接字
*/
static int createTcpSocket()
{
    int sockfd;
    int on = 1;

    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if(sockfd < 0)
        return -1;

    setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, (const char*)&on, sizeof(on));

    return sockfd;
}

UDP协议函数

/*
* 创建udp socket套接字
*/
static int createUdpSocket()
{
    int sockfd;
    int on = 1;

    sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if(sockfd < 0)
        return -1;

    setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, (const char*)&on, sizeof(on));

    return sockfd;
}

socket()函数

在 Linux 下使用 <sys/socket.h> 头文件中 socket() 函数来创建套接字，原型为：

#include<sys/types.h>
#include<sys/socket.h>
int socket(int domain, int type, int protocol);

domain参数

函数socket()的参数domain用于设置网络通信的域，函数socket()根据这个参数选择通信协议的族。通信协议族在文件sys/socket.h中定义。

常用的几个定义为：

名称	含义	名称	含义
PF_UNIX,PF_LOCAL	本地通信	PF_X25	ITU-T X25 / ISO-8208协议
AF_INET,PF_INET	IPv4 Internet协议	PF_AX25	Amateur radio AX.25
PF_INET6	IPv6 Internet协议	PF_ATMPVC	原始ATM PVC访问
PF_IPX	IPX-Novell协议	PF_APPLETALK	Appletalk
PF_NETLINK	内核用户界面设备	PF_PACKET	底层包访问

显而易见本次采用的是IPv4 Internet协议，所以入参AF_INET。
在Linux系统中AF_和PF_是等价的。

type参数

函数socket()的参数type用于设置套接字通信的类型，主要有SOCKET_STREAM（流式套接字）、SOCK_DGRAM（数据包套接字）等。
其具体定义：

名称	含义
SOCK_STREAM	Tcp连接，提供序列化的、可靠的、双向连接的字节流。支持带外数据传输
SOCK_DGRAM	支持UDP连接(无连接状态的消息，不可靠，最大长度固定)
SOCK_SEQPACKET	序列化包，提供一个序列化的、可靠的、双向的基本连接的数据传输通道，数据长度定常。每次调用读系统调用时数据需要将全部数据读出
SOCK_RAW	RAW类型，提供原始网络协议访问
SOCK_RDM	提供可靠的数据报文，不过可能数据会有乱序
SOCK_PACKET	这是一个专用类型，不能呢过在通用程序中使用

本文采用SOCK_STREAM入参TCP，采用SOCK_DGRAM入参UDP。

protocol参数

函数socket()的第3个参数protocol用于制定某个协议的特定类型，即type类型中的某个类型。通常某协议中只有一种特定类型，这样protocol参数仅能设置为0；但是有些协议有多种特定的类型，就需要设置这个参数来选择特定的类型。

当protocol为0时，会自动选择type类型对应的默认协议。

本文采用0入参

setsockopt()函数设置socket的状态

头文件：

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

定义函数：

int getsockopt(int fd, int level, int optname, void* optval, socklen_t* optlen);

参数fd

指定的socket对象，即上文提到的sockfd，是socket套接字的上下文

参数level

代表欲读取的网络层, 一般设成SOL_SOCKET 以存取socket 层，其原定义为：

#define SOL_SOCKET	1

level定义了哪个选项将被使用。通常情况下是SOL_SOCKET，意思是正在使用的socket选项。它还可以通过设置一个特殊协议号码来设置协议选项

参数optname

代表欲取得何种选项状态，常见的参数值如下所示。

SO_DEBUG	打开或关闭排错模式
SO_REUSEADDR	允许在bind ()过程中本地地址可重复使用
SO_TYPE	返回socket 形态
SO_ERROR	返回socket 已发生的错误原因
SO_DONTROUTE	送出的数据包不要利用路由设备来传输
SO_BROADCAST	使用广播方式传送
SO_SNDBUF	设置送出的`暂存区大小
SO_RCVBUF	设置接收的暂存区大小
SO_KEEPALIVE	定期确定连线是否已终止
SO_OOBINLINE	当接收到OOB 数据时会马上送至标准输入设备
SO_LINGER	确保数据安全且可靠的传送出去.

本文采用SO_REUSEADDR

参数optval &参数optlen

参数 optval 代表欲设置的值, 参数optlen 则为optval 的长度.
指的是函数socket()的type值，即optval 设置为 1时，实际设置为SOCK_STREAM。

绑定地址和端口号

在创建完socket套接字后需要将地址和端口号绑定，TCP时，服务端必须要绑定固定的地址和端口号，这样才能进行监听，在客户端访问这个地址和端口号时才能做出应答。
函数定义：

static int bindSocketAddr(int sockfd, const char* ip, int port)
{
    struct sockaddr_in addr;

    addr.sin_family = AF_INET;
    addr.sin_port = htons(port);
    addr.sin_addr.s_addr = inet_addr(ip);

    if(bind(sockfd, (struct sockaddr *)&addr, sizeof(struct sockaddr)) < 0)
        return -1;

    return 0;
}

sockaddr_in 结构体

结构体定义：

#include <netinet/in.h>
/* Structure describing an Internet socket address.  */
struct sockaddr_in
  {
    __SOCKADDR_COMMON (sin_);
    in_port_t sin_port;	/* Port number.  */
    struct in_addr sin_addr; /* Internet address.  */

    /* Pad to size of `struct sockaddr'. */
    unsigned char sin_zero[sizeof (struct sockaddr) -
			   __SOCKADDR_COMMON_SIZE -
			   sizeof (in_port_t) -
			   sizeof (struct in_addr)];
  };

里面相互引用关系可以自行查看下，这里主要是使用三个参数。
sin_family指代协议族，在socket编程中只能是AF_INET
sin_port存储端口号（使用网络字节顺序，htons转换）
sin_addr存储IP地址，使用in_addr这个数据结构，使用inet_addr转换

bind函数

函数定义：

#include <sys/types.h>
#include <sys/socket.h>
int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

sockfd是上面说到的套接字上下文
addr指向套接字地址结构的指针
addrlen结构的大小

这个示例绑定的地址是INADDR_ANY，端口号为8554

开始监听

函数定义：

#include <sys/types.h>
#include <sys/socket.h>
int listen(int sockfd, int backlog)

backlog

TCP的连接是一个过程，不是瞬间链接完成的，所以同时可能存在多个连接，进程内是有一个类似于队列的存在去进行容纳这些请求，这个参数就是设置容纳的请求个数，一般30以内。

创建RTP和RTCP的套接字

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

1、serverRtpSockfd = createUdpSocket();
2、serverRtcpSockfd = createUdpSocket();

这里的创建函数参考上面的。

绑定端口号：

bindSocketAddr(serverRtpSockfd, "0.0.0.0", SERVER_RTP_PORT);
bindSocketAddr(serverRtcpSockfd, "0.0.0.0", SERVER_RTCP_PORT);

同理这里也参考上面提到的函数。
注：0.0.0.0指的是本机上的所有IPV4地址

开始accept等待客户端连接

函数定义：

/*
* 开始accept等待客户端连接
* sockfd socket套接字上下文
* ip 地址 连接成功后通过ip指针返回客户端ip
* port 端口号 连接成功后通过port指针返回客户端port
*/
static int acceptClient(int sockfd, char* ip, int* port)
{
    int clientfd;
    socklen_t len = 0;
    struct sockaddr_in addr;

    memset(&addr, 0, sizeof(addr));
    len = sizeof(addr);

    clientfd = accept(sockfd, (struct sockaddr *)&addr, &len);
    if(clientfd < 0)
        return -1;
    
    strcpy(ip, inet_ntoa(addr.sin_addr));
    *port = ntohs(addr.sin_port);

    return clientfd;
}

accept函数

#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

sockfd是由socket函数返回的套接字描述符，
参数addr和addrlen用来返回已连接的对端进程（客户端）的协议地址。
如果我们对客户端的协议地址不感兴趣，可以把arrd和addrlen均置为空指针

从addr内取出ip和port的时涉及到网络顺序，即涉及到大小端，所以用inet_ntoa(addr.sin_addr)与ntohs(addr.sin_port)分别将取出的ip与端口转换顺序。

解析请求

当rtsp客户端连接成功后就会开始发送请求，服务器这时需要接收客户端请求并开始解析，再采取相应得操作
请求的格式参考另一篇文章：RTSP协议讲解

OPTIONS rtsp://127.0.0.1:8554/live RTSP/1.0\r\n
CSeq: 2\r\n
\r\n

DESCRIBE rtsp://127.0.0.1:8554/live RTSP/1.0\r\n
CSeq: 3\r\n
Accept: application/sdp\r\n
\r\n

SETUP rtsp://127.0.0.1:8554/live/track0 RTSP/1.0\r\n
CSeq: 4\r\n
Transport: RTP/AVP;unicast;client_port=54492-54493\r\n
\r\n

PLAY rtsp://127.0.0.1:8554/live RTSP/1.0\r\n
CSeq: 5\r\n
Session: 66334873\r\n
Range: npt=0.000-\r\n
\r\n

这里我们做得最简单，首先解析第一行得到方法，对于OPTIONS、DESCRIBE、PLAY、TEARDOWN我们只解析CSeq。对于SETUP，我们将client_port解析出来
所以我们要做的第一步就是解析请求中的信息

接收客户端数据

recvLen = recv(clientSockfd, rBuf, BUF_MAX_SIZE, 0);

这里实现了一个简单得函数getLineFromBuf，从buf中读取一行(\r\n)

解析第一行请求得到方法

sscanf(line, "%s %s %s\r\n", method, url, version);

sscanf函数定义：

#include <stdio.h>
 int sscanf (char *str, char * format [, argument, ...]);

sscanf()函数用于从字符串中读取指定格式的数据

str为要读取数据的字符串；
format为用户指定的格式；
argument为变量，用来保存读取到的数据
用起来和sprintf或者printf的格式很像，只不过作用和场景不同。

如果方法是SETUP则再解析client_port

if(!strcmp(method, "SETUP"))
{
	sscanf(line, "Transport: RTP/AVP;unicast;client_port=%d-%d\r\n",
		&clientRtpPort, &clientRtcpPort);
}

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

if(!strcmp(method, "OPTIONS"))
{
	handleCmd_OPTIONS();
}
else if(!strcmp(method, "DESCRIBE"))
{
	handleCmd_DESCRIBE();
}
else if(!strcmp(method, "SETUP"))
{
	handleCmd_SETUP();
}
else if(!strcmp(method, "PLAY"))
{
	handleCmd_PLAY();
}
else if(!strcmp(method, "TEARDOWN"))
{
	handleCmd_TEARDOWN();
}

strcmp()函数

strcmp函数定义：

#include <string.h>
int strcmp(const char *s1, const char *s2);

strcmp() 用来比较字符串（区分大小写）
【参数】s1, s2 为需要比较的两个字符串。
这里常用的是比较两个字符串是否相同，完全相同时返回0

DESCRIBE响应

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

sdp文件生成

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

这里只是简单的做个例子

sprintf(sBuf, "RTSP/1.0 200 OK\r\n"
		"CSeq: %d\r\n"
		"Content-Base: %s\r\n"
		"Content-type: application/sdp\r\n"
		"Content-length: %d\r\n\r\n"
		"%s",
		cseq,
		url,
		strlen(sdp),
		sdp);
		
send(clientSockfd, sBuf, strlen(sBuf));

SETUP响应

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

sprintf(result, "RTSP/1.0 200 OK\r\n"
			"CSeq: %d\r\n"
			"Transport: RTP/AVP;unicast;client_port=%d-%d;server_port=%d-%d\r\n"
			"Session: 66334873\r\n"
			"\r\n",
			cseq,
			clientRtpPort,
			clientRtpPort+1,
			SERVER_RTP_PORT,
			SERVER_RTCP_PORT);

send(clientSockfd, sBuf, strlen(sBuf));

其中session id是随便写的，只要保证在多个会话连接时唯一的就行
play响应之后就可以向客户端的RTP端口发送RTP包了

PLAY响应

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

sprintf(result, "RTSP/1.0 200 OK\r\n"
				"CSeq: %d\r\n"
				"Range: npt=0.000-\r\n"
				"Session: 66334873; timeout=60\r\n\r\n",
				cseq);

send(clientSockfd, sBuf, strlen(sBuf));

开始发送数据
回复之后，就开始向客户端指定的RTP端口发送RTP包，如何发送RTP包，下篇文章再介绍

源码

/*
 * 作者：_JT_
 * 博客：https://blog.csdn.net/weixin_42462202
 */
 
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <time.h>

#define SERVER_PORT     8554 // 服务端 端口
#define SERVER_RTP_PORT  55532 // 服务端RTP 端口
#define SERVER_RTCP_PORT 55533 // 服务端RTCP 端口
#define BUF_MAX_SIZE    (1024*1024) //最大存储buf size

/*
* 创建tcp socket套接字
*/
static int createTcpSocket()
{
    int sockfd;
    int on = 1;

    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if(sockfd < 0)
        return -1;

    setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, (const char*)&on, sizeof(on));

    return sockfd;
}

/*
* 创建udp socket套接字
*/
static int createUdpSocket()
{
    int sockfd;
    int on = 1;

    sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if(sockfd < 0)
        return -1;

    setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, (const char*)&on, sizeof(on));

    return sockfd;
}

/*
* 绑定地址和端口号
* sockfd socket套接字上下文
* ip 地址
* port 端口号 
*/
static int bindSocketAddr(int sockfd, const char* ip, int port)
{
    struct sockaddr_in addr;

    addr.sin_family = AF_INET;
    addr.sin_port = htons(port);
    addr.sin_addr.s_addr = inet_addr(ip);

    if(bind(sockfd, (struct sockaddr *)&addr, sizeof(struct sockaddr)) < 0)
        return -1;

    return 0;
}

/*
* 开始accept等待客户端连接
* sockfd socket套接字上下文
* ip 地址 连接成功后通过ip指针返回客户端ip
* port 端口号 连接成功后通过port指针返回客户端port
*/
static int acceptClient(int sockfd, char* ip, int* port)
{
    int clientfd;
    socklen_t len = 0;
    struct sockaddr_in addr;

    memset(&addr, 0, sizeof(addr));
    len = sizeof(addr);

    clientfd = accept(sockfd, (struct sockaddr *)&addr, &len);
    if(clientfd < 0)
        return -1;
    
    strcpy(ip, inet_ntoa(addr.sin_addr));
    *port = ntohs(addr.sin_port);

    return clientfd;
}

/*
* 从buf中复制出一行数据出来，即监测行尾的换行符
* buf 接收到的元数据
* line 复制出来的一行数据
* return 返回取完数据后第一个新的地址，即换行符后的首地址
*/
static char* getLineFromBuf(char* buf, char* line)
{
    while(*buf != '\n')
    {
        *line = *buf;
        line++;
        buf++;
    }

    *line = '\n';
    ++line;
    *line = '\0';

    ++buf;
    return buf; 
}

/*
* 处理命令是OPTIONS需要的返回数据
* result 输入待解析的数据
* cseq 输出解析玩的cseq的数据的地址
*/
static int handleCmd_OPTIONS(char* result, int cseq)
{
    sprintf(result, "RTSP/1.0 200 OK\r\n"
                    "CSeq: %d\r\n"
                    "Public: OPTIONS, DESCRIBE, SETUP, PLAY\r\n"
                    "\r\n",
                    cseq);
                
    return 0;
}

/*
* 处理命令是DESCRIBE需要的返回数据
* result 输入待解析的数据
* cseq 输出解析玩的cseq的数据的地址
* url 输出解析玩的url的数据的地址
*/
static int handleCmd_DESCRIBE(char* result, int cseq, char* url)
{
    char sdp[500];
    char localIp[100];

    sscanf(url, "rtsp://%[^:]:", localIp);

    sprintf(sdp, "v=0\r\n"
                 "o=- 9%ld 1 IN IP4 %s\r\n"
                 "t=0 0\r\n"
                 "a=control:*\r\n"
                 "m=video 0 RTP/AVP 96\r\n"
                 "a=rtpmap:96 H264/90000\r\n"
                 "a=control:track0\r\n",
                 time(NULL), localIp);
    
    sprintf(result, "RTSP/1.0 200 OK\r\nCSeq: %d\r\n"
                    "Content-Base: %s\r\n"
                    "Content-type: application/sdp\r\n"
                    "Content-length: %d\r\n\r\n"
                    "%s",
                    cseq,
                    url,
                    strlen(sdp),
                    sdp);
    
    return 0;
}

/*
* 处理命令是SETUP需要的返回数据
* result 输入待解析的数据
* cseq 输出解析玩的cseq的数据的地址
* clientRtpPort 输出解析玩的clientRtpPort的数据的地址
*/
static int handleCmd_SETUP(char* result, int cseq, int clientRtpPort)
{
    sprintf(result, "RTSP/1.0 200 OK\r\n"
                    "CSeq: %d\r\n"
                    "Transport: RTP/AVP;unicast;client_port=%d-%d;server_port=%d-%d\r\n"
                    "Session: 66334873\r\n"
                    "\r\n",
                    cseq,
                    clientRtpPort,
                    clientRtpPort+1,
                    SERVER_RTP_PORT,
                    SERVER_RTCP_PORT);
    
    return 0;
}

/*
* 处理命令是PLAY需要的返回数据
* result 输入待解析的数据
* cseq 输出解析玩的cseq的数据的地址
*/
static int handleCmd_PLAY(char* result, int cseq)
{
    sprintf(result, "RTSP/1.0 200 OK\r\n"
                    "CSeq: %d\r\n"
                    "Range: npt=0.000-\r\n"
                    "Session: 66334873; timeout=60\r\n\r\n",
                    cseq);
    
    return 0;
}

/*
* RTSP处理函数
*/
static void doClient(int clientSockfd, const char* clientIP, int clientPort,
                        int serverRtpSockfd, int serverRtcpSockfd)
{
    char method[40]; //装命令的数组
    char url[100]; 
    char version[40];
    int cseq;
    int clientRtpPort, clientRtcpPort;
    char *bufPtr;
    char* rBuf = malloc(BUF_MAX_SIZE);
    char* sBuf = malloc(BUF_MAX_SIZE);
    char line[400];

    while(1)
    {
        int recvLen;

        recvLen = recv(clientSockfd, rBuf, BUF_MAX_SIZE, 0); 
        if(recvLen <= 0)
            goto out;

        rBuf[recvLen] = '\0';
        printf("---------------C->S--------------\n");
        printf("%s", rBuf);

        /* 解析方法 */
        bufPtr = getLineFromBuf(rBuf, line);
        if(sscanf(line, "%s %s %s\r\n", method, url, version) != 3)
        {
            printf("parse err\n");
            goto out;
        }

        /* 解析*** */
        bufPtr = getLineFromBuf(bufPtr, line);
        if(sscanf(line, "CSeq: %d\r\n", &cseq) != 1)
        {
            printf("parse err\n");
            goto out;
        }

        /* 如果是SETUP，那么就再解析client_port */
        if(!strcmp(method, "SETUP"))
        {
            while(1)
            {
                bufPtr = getLineFromBuf(bufPtr, line);
                if(!strncmp(line, "Transport:", strlen("Transport:")))
                {
                    sscanf(line, "Transport: RTP/AVP;unicast;client_port=%d-%d\r\n",
                                    &clientRtpPort, &clientRtcpPort);
                    break;
                }
            }
        }

        if(!strcmp(method, "OPTIONS"))
        {
            if(handleCmd_OPTIONS(sBuf, cseq))
            {
                printf("failed to handle options\n");
                goto out;
            }
        }
        else if(!strcmp(method, "DESCRIBE"))
        {
            if(handleCmd_DESCRIBE(sBuf, cseq, url))
            {
                printf("failed to handle describe\n");
                goto out;
            }
        }
        else if(!strcmp(method, "SETUP"))
        {
            if(handleCmd_SETUP(sBuf, cseq, clientRtpPort))
            {
                printf("failed to handle setup\n");
                goto out;
            }
        }
        else if(!strcmp(method, "PLAY"))
        {
            if(handleCmd_PLAY(sBuf, cseq))
            {
                printf("failed to handle play\n");
                goto out;
            }
        }
        else
        {
            goto out;
        }

        printf("---------------S->C--------------\n");
        printf("%s", sBuf);
        send(clientSockfd, sBuf, strlen(sBuf), 0);
    }
out:
    close(clientSockfd);
    free(rBuf);
    free(sBuf);
}

int main(int argc, char* argv[])
{
    int serverSockfd;
    int serverRtpSockfd, serverRtcpSockfd;
    int ret;

    serverSockfd = createTcpSocket();
    if(serverSockfd < 0)
    {
        printf("failed to create tcp socket\n");
        return -1;
    }

    ret = bindSocketAddr(serverSockfd, "0.0.0.0", SERVER_PORT);
    if(ret < 0)
    {
        printf("failed to bind addr\n");
        return -1;
    }

    ret = listen(serverSockfd, 10);
    if(ret < 0)
    {
        printf("failed to listen\n");
        return -1;
    }

    serverRtpSockfd = createUdpSocket();
    serverRtcpSockfd = createUdpSocket();
    if(serverRtpSockfd < 0 || serverRtcpSockfd < 0)
    {
        printf("failed to create udp socket\n");
        return -1;
    }

    if(bindSocketAddr(serverRtpSockfd, "0.0.0.0", SERVER_RTP_PORT) < 0 ||
        bindSocketAddr(serverRtcpSockfd, "0.0.0.0", SERVER_RTCP_PORT) < 0)
    {
        printf("failed to bind addr\n");
        return -1;
    }

    printf("rtsp://127.0.0.1:%d\n", SERVER_PORT);

    while(1)
    {
        int clientSockfd;
        char clientIp[40];
        int clientPort;

        clientSockfd = acceptClient(serverSockfd, clientIp, &clientPort);
        if(clientSockfd < 0)
        {
            printf("failed to accept client\n");
            return -1;
        }

        printf("accept client;client ip:%s,client port:%d\n", clientIp, clientPort);

        doClient(clientSockfd, clientIp, clientPort, serverRtpSockfd, serverRtcpSockfd);
    }

    return 0;
}

RTSP协议的实现

写在前面

创建套接字

TCP函数定义:

UDP协议函数

socket()函数

domain参数

type参数

protocol参数

setsockopt()函数设置socket的状态

参数fd

参数level

参数optname

参数optval &参数optlen

绑定地址和端口号

sockaddr_in 结构体

bind函数

开始监听

backlog

创建RTP和RTCP的套接字

开始accept等待客户端连接

accept函数

解析请求

DESCRIBE响应

SETUP响应

PLAY响应

源码

Android获取本地相册图片和拍照获取图片的实现方法

天猫魔投如何实现电视投屏的?天猫魔进行电视投屏的方法

python 实现在tkinter中动态显示label图片的方法

python 实现视频流下载保存MP4的方法

用CSS3实现无限循环的无缝滚动的示例代码

详解基于React.js和Node.js的SSR实现方案

基于node简单实现RSA加解密的方法步骤

小程序显示弹窗时禁止下层的内容滚动实现方法

对Python中实现两个数的值交换的集中方法详解

sql实现修改表字段名的方法详解