C C++最全从零开始写一个RTSP服务器（四）一个传输H(1)，最新大厂C C++校招面试经验汇总

于 2024-05-15 00:37:36 发布
阅读量497 收藏 6
点赞数 3
分类专栏： 程序员 文章标签： c语言 c++ 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/2401_84976585/article/details/138876883
版权

img
img

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

一开始进入main函数后，就监听服务器tcp套接字，绑定端口号，然后开始监听

然后再分别建立用于RTP和RTCP的udp套接字，绑定好端口

然后进入循环中开始服务

/\*
 \* 作者：\_JT\_
 \* 博客：https://blog.youkuaiyun.com/weixin\_42462202
 \*/

main()
{
	/\* 创建服务器tcp套接字，绑定端口，监听 \*/
    serverSockfd = createTcpSocket();
	bindSocketAddr(serverSockfd, "0.0.0.0", SERVER_PORT);
	listen(serverSockfd, 10);
	
    /\* 建立用于RTP和RTCP的udp套接字，绑定好端口 \*/
    serverRtpSockfd = createUdpSocket();
    serverRtcpSockfd = createUdpSocket();
    bindSocketAddr(serverRtpSockfd, "0.0.0.0", SERVER_RTP_PORT);
    bindSocketAddr(serverRtcpSockfd, "0.0.0.0", SERVER_RTCP_PORT);
    
	while(1)
	{
        ...
	}
}

二、接收客户端连接

在while循环中接收客户端，然后调用doClient服务

main()
{
    ...
    while(1)
	{
        clientSockfd = acceptClient(serverSockfd, clientIp, &clientPort);
        doClient(clientSockfd, clientIp, clientPort, serverRtpSockfd, serverRtcpSockfd);
	}
}

上面其实就是一个TCP服务器的基本步骤，没有什么特别的

下面来看一看doClient函数

三、解析命令

doClient就是一个while循环（这是一个同时只能服务一个客户的服务器），不断地接收命令解析命令，然后调用相应地操作

/\*
 \* 作者：\_JT\_
 \* 博客：https://blog.youkuaiyun.com/weixin\_42462202
 \*/
 
doClient()
{
	while(1)
	{
     	recv(clientSockfd, rBuf, BUF_MAX_SIZE, 0);   
        ...
        sscanf(line, "%s %s %s\r\n", method, url, version);
        ...
        sscanf(line, "CSeq: %d\r\n", &cseq)
        ...
	}
}

四、处理请求

在解析完客户端命令后，会调用相应的请求，处理完之后讲接收打印到sBuf中，然后发送给客户端

doClient()
{
	while(1)
	{
		...
         /\* 处理请求 \*/
         if(!strcmp(method, "OPTIONS"))
             handleCmd\_OPTIONS(sBuf, cseq);
        else if(!strcmp(method, "DESCRIBE"))
            handleCmd\_DESCRIBE(sBuf, cseq, url);
        else if(!strcmp(method, "SETUP"))
            handleCmd\_SETUP(sBuf, cseq, clientRtpPort);
        else if(!strcmp(method, "PLAY"))
            handleCmd\_PLAY(sBuf, cseq);
        
        /\* 放回结果 \*/
        send(clientSockfd, sBuf, strlen(sBuf), 0);
	}
}

下面来看看各个请求的行动

4.1 OPTIONS

返回可用方法

/\*
 \* 作者：\_JT\_
 \* 博客：https://blog.youkuaiyun.com/weixin\_42462202
 \*/
 
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;
}
4.2 DESCRIBE

返回sdp文件信息，这是一个H.264的媒体描述信息，详细内容已经在前面文章讲解过，这里不再累赘

/\*
 \* 作者：\_JT\_
 \* 博客：https://blog.youkuaiyun.com/weixin\_42462202
 \*/

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;
}
4.3 SETUP

SETUP过程发送服务端RTP端口和RTCP端口

/\*
 \* 作者：\_JT\_
 \* 博客：https://blog.youkuaiyun.com/weixin\_42462202
 \*/

static int handleCmd\_SETUP(char\* result, int cseq, int clientRtpPort,
                            int\* localRtpSockfd, int\* localRtcpSockfd)
{
    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;
}
4.4 PLAY

PLAY操作回复后，会开始发送RTP包

/\*
 \* 作者：\_JT\_
 \* 博客：https://blog.youkuaiyun.com/weixin\_42462202
 \*/

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;
}

五、H.264 RTP打包发送

从H.264文件中读取一个NALU，向客户端发送RTP包（目的IP，目的RTP端口）

/\*
 \* 作者：\_JT\_
 \* 博客：https://blog.youkuaiyun.com/weixin\_42462202
 \*/

doClient()
{
	while(1)
	{
		...
		...
		...
		if(!strcmp(method, "PLAY"))
		{
            while(1)
            {
                /\* 获取一帧 \*/
            	frameSize = getFrameFromH264File(fd, frame, 500000);
                
                /\* RTP打包发送 \*/
            	rtpSendH264Frame(localRtpSockfd, clientIP, clientRtpPort,
            					rtpPacket, frame+startCode, frameSize);
		
            }
	
        }

    }
}

下面看一看RTP打包过程，RTP打包实现了单NALU打包和分片打包

/\*
 \* 作者：\_JT\_
 \* 博客：https://blog.youkuaiyun.com/weixin\_42462202
 \*/

static int rtpSendH264Frame(int socket, const char\* ip, int16_t port,
                            struct RtpPacket\* rtpPacket, uint8_t\* frame, uint32_t frameSize)
{
    /\* 如果包比较小，则采用单NALU打包 \*/
    if (frameSize <= RTP_MAX_PKT_SIZE)
    {
        rtpSendPacket(socket, ip, port, rtpPacket, frameSize);
    }
    else //否则采用分片打包
    {   
        for (i = 0; i < pktNum; i++)
        {
            /\* 填充载荷的前两个字节 \*/
            rtpPacket->payload[0] = (naluType & 0x60) | 28;
            rtpPacket->payload[1] = naluType & 0x1F;
            
            /\* 发送RTP包 \*/
            rtpSendPacket(socket, ip, port, rtpPacket, RTP_MAX_PKT_SIZE+2);
        }
    }
}

六、源码

我也懒得建个Git仓了，源码就直接贴到这里吧，虽然有点长，嘻嘻

总共有3个文件，h264_rtsp_server.c、rtp.c、rtp.h

h264_rtsp_server.c
/\*
 \* 作者：\_JT\_
 \* 博客：https://blog.youkuaiyun.com/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>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <assert.h>

#include "rtp.h"

#define H264\_FILE\_NAME "test.h264"
#define SERVER\_PORT 8554
#define SERVER\_RTP\_PORT 55532
#define SERVER\_RTCP\_PORT 55533
#define BUF\_MAX\_SIZE (1024\*1024)

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;
}

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;
}

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;
}

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;
}

static inline int startCode3(char\* buf)
{
    if(buf[0] == 0 && buf[1] == 0 && buf[2] == 1)
        return 1;
    else
        return 0;
}

static inline int startCode4(char\* buf)
{
    if(buf[0] == 0 && buf[1] == 0 && buf[2] == 0 && buf[3] == 1)
        return 1;
    else
        return 0;
}

static char\* findNextStartCode(char\* buf, int len)
{
    int i;

    if(len < 3)
        return NULL;

    for(i = 0; i < len-3; ++i)
    {
        if(startCode3(buf) || startCode4(buf))
            return buf;
        
        ++buf;
    }

    if(startCode3(buf))
        return buf;

    return NULL;
}

static int getFrameFromH264File(int fd, char\* frame, int size)
{
    int rSize, frameSize;
    char\* nextStartCode;

    if(fd < 0)
        return fd;

    rSize = read(fd, frame, size);
    if(!startCode3(frame) && !startCode4(frame))
        return -1;
    
    nextStartCode = findNextStartCode(frame+3, rSize-3);
    if(!nextStartCode)
    {
        //lseek(fd, 0, SEEK\_SET);
        //frameSize = rSize;
        return -1;
    }
    else
    {
        frameSize = (nextStartCode-frame);
        lseek(fd, frameSize-rSize, SEEK\_CUR);
    }

    return frameSize;
}

static int rtpSendH264Frame(int socket, const char\* ip, int16_t port,
                            struct RtpPacket\* rtpPacket, uint8_t\* frame, uint32_t frameSize)
{
    uint8_t naluType; // nalu第一个字节
    int sendBytes = 0;
    int ret;

    naluType = frame[0];

    if (frameSize <= RTP_MAX_PKT_SIZE) // nalu长度小于最大包场：单一NALU单元模式
    {
        /\*
 \* 0 1 2 3 4 5 6 7 8 9
 \* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 \* |F|NRI| Type | a single NAL unit ... |
 \* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 \*/
        memcpy(rtpPacket->payload, frame, frameSize);
        ret = rtpSendPacket(socket, ip, port, rtpPacket, frameSize);
        if(ret < 0)
            return -1;

        rtpPacket->rtpHeader.seq++;
        sendBytes += ret;
        if ((naluType & 0x1F) == 7 || (naluType & 0x1F) == 8) // 如果是SPS、PPS就不需要加时间戳
            goto out;
    }
    else // nalu长度小于最大包场：分片模式
    {
        /\*
 \* 0 1 2
 \* 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3
 \* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 \* | FU indicator | FU header | FU payload ... |
 \* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 \*/

        /\*
 \* FU Indicator
 \* 0 1 2 3 4 5 6 7
 \* +-+-+-+-+-+-+-+-+
 \* |F|NRI| Type |
 \* +---------------+
 \*/

        /\*
 \* FU Header
 \* 0 1 2 3 4 5 6 7
 \* +-+-+-+-+-+-+-+-+
 \* |S|E|R| Type |
 \* +---------------+
 \*/

        int pktNum = frameSize / RTP_MAX_PKT_SIZE;       // 有几个完整的包
        int remainPktSize = frameSize % RTP_MAX_PKT_SIZE; // 剩余不完整包的大小
        int i, pos = 1;

        /\* 发送完整的包 \*/
        for (i = 0; i < pktNum; i++)
        {
            rtpPacket->payload[0] = (naluType & 0x60) | 28;
            rtpPacket->payload[1] = naluType & 0x1F;
            
            if (i == 0) //第一包数据
                rtpPacket->payload[1] |= 0x80; // start
            else if (remainPktSize == 0 && i == pktNum - 1) //最后一包数据
                rtpPacket->payload[1] |= 0x40; // end

            memcpy(rtpPacket->payload+2, frame+pos, RTP_MAX_PKT_SIZE);
            ret = rtpSendPacket(socket, ip, port, rtpPacket, RTP_MAX_PKT_SIZE+2);
            if(ret < 0)
                return -1;

            rtpPacket->rtpHeader.seq++;
            sendBytes += ret;
            pos += RTP_MAX_PKT_SIZE;
        }

        /\* 发送剩余的数据 \*/
        if (remainPktSize > 0)
        {
            rtpPacket->payload[0] = (naluType & 0x60) | 28;
            rtpPacket->payload[1] = naluType & 0x1F;
            rtpPacket->payload[1] |= 0x40; //end

            memcpy(rtpPacket->payload+2, frame+pos, remainPktSize+2);
            ret = rtpSendPacket(socket, ip, port, rtpPacket, remainPktSize+2);
            if(ret < 0)
                return -1;

            rtpPacket->rtpHeader.seq++;
            sendBytes += ret;
        }
    }

out:

    return sendBytes;
}

static char\* getLineFromBuf(char\* buf, char\* line)
{
    while(\*buf != '\n')
    {
        \*line = \*buf;
        line++;
        buf++;
    }

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

    ++buf;
    return buf; 
}

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;
}

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;
}

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;
}

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;
}

static void doClient(int clientSockfd, const char\* clientIP, int clientPort,
                                        int serverRtpSockfd, int serverRtcpSockfd)
{
    char method[40];
    char url[100];
    char version[40];


![img](https://img-blog.csdnimg.cn/img_convert/be32c6ce7f1d0d77f864969197b563c4.png)
![img](https://img-blog.csdnimg.cn/img_convert/c0936f2ff729d016146cffcde0b24f33.png)

**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**[需要这份系统化的资料的朋友，可以添加戳这里获取](https://bbs.youkuaiyun.com/topics/618668825)**


**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**

    "Range: npt=0.000-\r\n"
                    "Session: 66334873; timeout=60\r\n\r\n",
                    cseq);
    
    return 0;
}

static void doClient(int clientSockfd, const char\* clientIP, int clientPort,
                                        int serverRtpSockfd, int serverRtcpSockfd)
{
    char method[40];
    char url[100];
    char version[40];


[外链图片转存中...(img-OPPmQ7H2-1715704633838)]
[外链图片转存中...(img-65m0qKma-1715704633838)]

**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**[需要这份系统化的资料的朋友，可以添加戳这里获取](https://bbs.youkuaiyun.com/topics/618668825)**


**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值