从零开始写一个RTSP服务器（八）一个多播的RTSP服务器_rtsp服务器 ip地址(1)

于 2024-05-16 02:18:55 发布
阅读量794 收藏 23
点赞数 9
文章标签： c语言 c++ 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_84976040/article/details/138932523
版权

img
img

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上C C++开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以戳这里获取

Content-length: 225\r\n
Content-type: application/sdp\r\n
\r\n
v=0
o=- 91565615172 1 IN IP4 127.0.0.1
t=0 0
a=control:*
a=type:broadcast
a=rtcp-unicast: reflection
m=video 39016 RTP/AVP 96
c=IN IP4 232.123.86.248/255
a=rtpmap:96 H264/90000
a=framerate:25
a=control:track0

 这个sdp描述文件里指明了多播地址和多播端口


	+ 这一行表明RTCP反馈采用单播
	
	 
	```
	a=rtcp-unicast: reflection
	
	```
	 在多播的情况下，这表明服务端RTP发送到多播组，RTCP发送到多播组，RTCP接收采用单播
	+ 这一行表明的多播目的端口为39016
	
	 
	```
	m=video 39016 RTP/AVP 96
	
	```
	+ 这一行表明了多播地址为`c=IN IP4 232.123.86.248/255`
	
	 
	```
	c=IN IP4 232.123.86.248/255
	
	```


多播和单播的sdp文件区别主要是多播需要指定好多播地址和多播端口


关于sdp这里就不再详细讲述了，如何有不清楚请看前面的文章


**SETUP**


* C–>S

SETUP rtsp://127.0.0.1:8554/live/track0 RTSP/1.0\r\n
CSeq: 4\r\n
Transport: RTP/AVP;multicast;client_port=39016-39017
\r\n

* S–>C

RTSP/1.0 200 OK\r\n
CSeq: 4\r\n
Transport: RTP/AVP;multicast;destination=232.123.86.248;source=192.168.31.115;port=39016-39017;ttl=255
Session: 66334873
\r\n



**PLAY**


* C–>S

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

* S–>C

RTSP/1.0 200 OK\r\n
CSeq: 5\r\n
Range: npt=0.000-\r\n
Session: 66334873; timeout=60
\r\n



### 二、多播的RTSP服务器实现过程


#### 2.1 创建套接字

/*
* 作者：_JT_
* 博客：https://blog.csdn.net/weixin_42462202
*/

main()
{
/* 创建套接字 */
serverSockfd = createTcpSocket();

/\* 绑定地址和端口 \*/
bindSocketAddr(serverSockfd, "0.0.0.0", SERVER_PORT);

/\* 开始监听 \*/
listen(serverSockfd, 10);

...

while(1)
{
    ...
}

}


#### 2.2 创建线程向多播地址推送RTP包


在进入while循环接收客户端前，我们创建一个线程不断地向多播地址发送RTP包

main()
{
…
pthread_create(&threadId, NULL, sendRtpPacket, NULL);

while(1)
{
    ...
}

}


下面看一看发送函数

/*
* 作者：_JT_
* 博客：https://blog.csdn.net/weixin_42462202
*/

sendRtpPacket()
{
…
while(1)
{
…

    /\* 获取一帧数据 \*/
   	getFrameFromH264File(fd, frame, 500000); 
    
    /\* 向多播地址发送RTP包 \*/
    rtpSendH264Frame(sockfd, MULTICAST_IP, MULTICAST_PORT,
                        rtpPacket, frame+startCode, frameSize);
    
    ...
}

}


#### 2.2 接收客户端连接


进入while循环后，开始接收客户端，然后处理客户端请求

main()
{
…

while(1)
{
    /\* 接收客户端 \*/
    acceptClient(serverSockfd, clientIp, &clientPort);
    
    /\* 处理客户端 \*/
    doClient(clientSockfd, clientIp, clientPort);
}

}


下面仔细看一看如何处理客户端请求


#### 2.3 解析命令


先解析请求方法，然后解析序列号，再根据不同地请求做不同的处理，然后再放回结果给客户端

/*
* 作者：_JT_
* 博客：https://blog.csdn.net/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);

    /\* 处理请求 \*/
    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, localIp);
    else if(!strcmp(method, "PLAY"))
        handleCmd\_PLAY(sBuf, cseq);

    /\* 返回结果给客户端 \*/
	send(clientSockfd, sBuf, strlen(sBuf), 0);
}

}


#### 2.4 处理请求


* OPTIONS

handleCmd_OPTIONS()
{
sprintf(result, “RTSP/1.0 200 OK\r\n”
“CSeq: %d\r\n”
“Public: OPTIONS, DESCRIBE, SETUP, PLAY\r\n”
“\r\n”,
cseq);
}

* DESCRIBE

 发送多播的sdp描述文件

handleCmd_DESCRIBE()
{
/* 多播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”
“a=type:broadcast\r\n”
“a=rtcp-unicast: reflection\r\n”
“m=video %d RTP/AVP 96\r\n”
“c=IN IP4 %s/255\r\n”
“a=rtpmap:96 H264/90000\r\n”
“a=control:track0\r\n”,
time(NULL),
localIp,
MULTICAST_PORT,
MULTICAST_IP);

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

}

* SETUP

handleCmd_SETUP()
{
sprintf(result, “RTSP/1.0 200 OK\r\n”
“CSeq: %d\r\n”
“Transport: RTP/AVP;multicast;destination=%s;”
“source=%s;port=%d- %d;ttl=255\r\n”
“Session: 66334873\r\n”
“\r\n”,
cseq,
MULTICAST_IP,
localIp,
MULTICAST_PORT,
MULTICAST_PORT+1);
}

* PLAY

handleCmd_PLAY()
{
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);
}

 在play回复完成之后，客户端就会去多播地址拉取媒体流，然后播放


#### 源码


源码有三个文件：`multicast_rtsp_server`、`rtp.h`、`rtp.c`


##### multicast\_rtsp\_server.c

/*
* 作者：_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>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <assert.h>
#include <pthread.h>

#include “rtp.h”

#define H264_FILE_NAME “test.h264”
#define MULTICAST_IP “239.255.255.11”
#define SERVER_PORT 8554
#define MULTICAST_PORT 9832
#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;
}
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"
             "a=type:broadcast\r\n"
             "a=rtcp-unicast: reflection\r\n"
             "m=video %d RTP/AVP 96\r\n"
             "c=IN IP4 %s/255\r\n"
             "a=rtpmap:96 H264/90000\r\n"
             "a=control:track0\r\n",
             time(NULL),
             localIp,
             MULTICAST_PORT,
             MULTICAST_IP);

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, char* localIp)
{
sprintf(result, “RTSP/1.0 200 OK\r\n”
“CSeq: %d\r\n”
“Transport: RTP/AVP;multicast;destination=%s;source=%s;port=%d-%d;ttl=255\r\n”
“Session: 66334873\r\n”
“\r\n”,
cseq,
MULTICAST_IP,
localIp,
MULTICAST_PORT,
MULTICAST_PORT+1);

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;

}

img
img

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上C C++开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以戳这里获取

              localIp,
                MULTICAST_PORT,
                MULTICAST_PORT+1);

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;

}

[外链图片转存中…(img-nUaS4ZCJ-1715797113524)]
[外链图片转存中…(img-O2t700Au-1715797113524)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上C C++开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以戳这里获取

2401_84976040
关注
  • 9
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
rtsp服务器: C语言实现rtsp服务器
xiaoning132的专栏
05-08 1739
class RtspServer { public: RtspServer(void); ~RtspServer(void); public: int start_server(unsigned short port); /*RTSP OVER HTTP*/ int http_cmd_server(int socket, char *cmd, int flag); int http_session_stop(unsigned int *rtspsession); /*分配端口池*/ .
从零开始写一个RTSP服务器（四）一个传输H.264的RTSP服务器
热门推荐
JT同学的博客
08-10 1万+
从零开始写一个RTSP服务器系列 从零开始写一个RTSP服务器（一）不一样的RTSP协议讲解 从零开始写一个RTSP服务器（二）RTSP协议的实现 从零开始写一个RTSP服务器（三）RTP传输H.264 从零开始写一个RTSP服务器（四）一个传输H.264的RTSP服务器 从零开始写一个RTSP服务器（五）RTP传输AAC(待写) 从零开始写一个RTSP服务器（六）一个传输AAC的RTSP服务器(...
web端 多路 视频实时播放rtsp流
05-22
springboot+websocket+ ffmpeg 实现web无插件多路视频实时播放rtsp流
从零开始写一个RTSP服务器（八）一个多播的RTSP服务器
JT同学的博客
08-13 6407
从零开始写一个RTSP服务器系列 ★我的开源项目-RtspServer 从零开始写一个RTSP服务器（一）不一样的RTSP协议讲解 从零开始写一个RTSP服务器（二）RTSP协议的实现 从零开始写一个RTSP服务器（三）RTP传输H.264 从零开始写一个RTSP服务器（四）一个传输H.264的RTSP服务器 从零开始写一个RTSP服务器（五）RTP传输AAC 从零开始写一个RTSP服务器（六）一...
Rtsp之服务搭建
08-25 1万+
最近想要测试rtsp客户端获取H264或者H265的视频流，由于本人比较穷，没有相应的设备测试，只能决定使用vlc搭建一个rtsp的服务，然后自己来编写客户端完成调试。 vlc搭建rtsp服务步骤如下：  点击串流：    点击添加    若不是这种格式需要进行转码：   然后一直下一步即可完成。 我这里说的重点不是上述内容，如果按照上面的步骤，可以完成rtsp服...
Rtsp服务器搭建(RTSP协议实现)
weixin_66034721的博客
05-22 1479
Rtsp服务器搭建(RTSP协议实现)
HTML RTSP 多个视频流播放
m0_62285976的博客
04-01 704
HTML RTSP 多个视频流播放当你知道 RTSP 流的地址时，你就可以直接使用它来替换 your-rtsp-stream-url-1 和 your-rtsp-stream-url-2。
hisi_rtsp_demo-master.zip_3516_RTSP服务器_rtsp 3516_海思 rtsp_海思RTSP
07-15
RTSP 服务器， 高效率，运行在海思3516平台
RTSP.rar_Rtsp 服务器端源程序_rfc_rtsp
09-14
这个文档会帮助你理解如何建立和管理一个RTSP会话，以及如何通过它来控制媒体服务器上的流。 而"www.pudn.com.txt"可能是一个来源或版权信息的文本文件，通常这类文件会包含文件的获取途径、作者信息或者使用许可。...
RTSP.rar_Linux C下载器_RTSP播放器_RTSP服务器_live555_rtsp
07-15
这是一个linux下用C语言写的基于RTSP的实现多媒体文件下载的客户端程序，从指定的RTSP服务器(可使用live555)下载多媒体文件(文件格式为TS)，将RTSP服务器返回的RTP数据包解析出来存成文件，存成的文件可以使用VLC的...
msdl-1.0.rar_Rtsp 服务器端源程序_msdl_rtsp_rtsp linux_流媒体
09-20
总的来说，“msdl-1.0.rar”提供的Rtsp服务器端源程序为开发者提供了一个实践和学习流媒体技术的实战平台，结合Linux环境下的编程经验，可以深入掌握Rtsp协议及其在服务器端的应用，为构建高性能的流媒体服务打下...
一个可立即运行的模拟RTSP流的RTSP流服务器
01-22
【标题】：“一个可立即运行的模拟RTSP流的RTSP流服务器” RTSP（Real-Time Streaming Protocol）是一种网络协议，用于控制实时流媒体的播放。这个标题表明我们正在讨论的是一款能够立即运行的模拟RTSP流的服务器...
RTSP协议--图文解释
西江物联的博客
09-18 1万+
一、什么是RTSP RTSP（Real Time Streaming Protocol）实时流传输协议。是 TCP/IP 协议体系中的一个应用层协议，RTSP在体系结构上位于RTP和RTCP之上，它使用TCP或UDP完成数据传输如下图1所示。 ...
【RTSP/RTP/RTCP/SDP】协议详解
王木木
09-29 5608
一、RTSP协议 RTSP（Real Time Streaming Protocol）是一个有效地在IP网络上传输流媒体数据的应用层协议。RTSP对流媒体提供了诸如暂停，快进、停止等控制，而它本身并不传输数据，RTSP的作用相当于流媒体服务器的远程控制。它的语法和运作跟HTTP 1.1类似，但并不特别强调时间同步，所以比较能容忍网络延迟。并因RTSP具有重新导向功能，可视实际负载情况来转换提...
C语言libcurl：RTSP（Real Time Streaming Protocol），RFC2326，实时流传输协议
RToax
04-23 1765
RTSP是TCP/IP协议体系中的一个应用层协议，由哥伦比亚大学、网景和RealNetworks公司提交的IETF RFC标准。 /* * Copyright (c) 2011 - 2019, Jim Hollinger * All rights reserved. * * Redistribution and use in source and binary forms, with ...
RTSP 详细介绍
FrankieWang008的专栏
08-28 1752
一：总体了解 RTSP(Real-Time Stream Protocol )是一种基于文本的应用层协议,直白的讲客户端与服务器建立连接并从服务器上接收流，服务器上的流可以是采集的，文件，等等。 二：服务器模式    1：以文件为例，输入到服务器的源可以做一个MediaSession, 的list来管理各各文件流，最理想的方式是这个list管理各个客户端要请求的流，这中间就要做复制流的操作。
RTSP协议抓包及讲解
最新发布
明天你好的博客
09-29 3651
本节主要讲解 RTSP 协议，通过 wireshark 抓包的方式对协议进行分析。RTSP（Real Time Streaming Protocol），RFC2326，实时流传输协议，是 TCP/IP 协议体系中的一个应用层协议，由哥伦比亚大学、网景和 RealNetworks 公司提交的 IETF RFC 标准。该协议定义了一对多应用程序如何有效地通过 IP 网络传送多媒体数据。RTSP 是用来控制声音或影像的多媒体串流协议， 并允许同时多个串流需求控制。
python用socket写一个rtsp服务器
05-27
下面是一个简单的Python程序，使用socket编写了一个RTSP服务器： ```python import socket def main(): # 创建socket对象 server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # 绑定IP地址...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值