Mirror/ZLMediaKit
1
0
Fork 0
mirror of https://github.com/ZLMediaKit/ZLMediaKit.git synced 2026-06-30 06:42:22 +08:00
Code Issues Packages Projects Releases Wiki Activity

AI automatically translates all comments in the code into English (#3917)

Browse Source
This commit is contained in:
alex
2024-09-19 14:53:50 +08:00
committed by GitHub
parent 046de691cb
commit 4152dcd409
279 changed files with 10602 additions and 3038 deletions
Download Patch File Download Diff File Expand all files Collapse all files

60
src/Rtp/RtpServer.cpp
View File

@@ -63,7 +63,8 @@ public:
void onRecvRtp(const Socket::Ptr &sock, const Buffer::Ptr &buf, struct sockaddr *addr) {
_process->inputRtp(true, sock, buf->data(), buf->size(), addr);
// 统计rtp接受情况，用于发送rr包
// 统计rtp接受情况，用于发送rr包 [AUTO-TRANSLATED:bd2fbe7e]
// Count RTP reception status, used to send RR packets
auto header = (RtpHeader *)buf->data();
sendRtcp(ntohl(header->ssrc), addr);
}
@@ -71,13 +72,15 @@ public:
void startRtcp() {
weak_ptr<RtcpHelper> weak_self = shared_from_this();
_rtcp_sock->setOnRead([weak_self](const Buffer::Ptr &buf, struct sockaddr *addr, int addr_len) {
// 用于接受rtcp打洞包
// 用于接受rtcp打洞包 [AUTO-TRANSLATED:d75d9d87]
// Used to receive RTCP hole punching packets
auto strong_self = weak_self.lock();
if (!strong_self || !strong_self->_process) {
return;
}
if (!strong_self->_rtcp_addr) {
// 只设置一次rtcp对端端口
// 只设置一次rtcp对端端口 [AUTO-TRANSLATED:fdc4eb4e]
// Set the RTCP peer port only once
strong_self->_rtcp_addr = std::make_shared<struct sockaddr_storage>();
memcpy(strong_self->_rtcp_addr.get(), addr, addr_len);
}
@@ -85,14 +88,16 @@ public:
for (auto &rtcp : rtcps) {
strong_self->_process->onRtcp(rtcp);
}
// 收到sr rtcp后驱动返回rr rtcp
// 收到sr rtcp后驱动返回rr rtcp [AUTO-TRANSLATED:d7373077]
// After receiving SR RTCP, the driver returns RR RTCP
strong_self->sendRtcp(strong_self->_ssrc, (struct sockaddr *)(strong_self->_rtcp_addr.get()));
});
}
private:
void sendRtcp(uint32_t rtp_ssrc, struct sockaddr *addr) {
// 每5秒发送一次rtcp
// 每5秒发送一次rtcp [AUTO-TRANSLATED:3c9bcb7b]
// Send RTCP every 5 seconds
if (_ticker.elapsedTime() < 5000) {
return;
}
@@ -100,12 +105,14 @@ private:
auto rtcp_addr = (struct sockaddr *)_rtcp_addr.get();
if (!rtcp_addr) {
// 默认的，rtcp端口为rtp端口+1
// 默认的，rtcp端口为rtp端口+1 [AUTO-TRANSLATED:273d164d]
// By default, the RTCP port is the RTP port + 1
switch (addr->sa_family) {
case AF_INET: ((sockaddr_in *)addr)->sin_port = htons(ntohs(((sockaddr_in *)addr)->sin_port) + 1); break;
case AF_INET6: ((sockaddr_in6 *)addr)->sin6_port = htons(ntohs(((sockaddr_in6 *)addr)->sin6_port) + 1); break;
}
// 未收到rtcp打洞包时，采用默认的rtcp端口
// 未收到rtcp打洞包时，采用默认的rtcp端口 [AUTO-TRANSLATED:d99b12b8]
// When no RTCP hole punching packet is received, the default RTCP port is used
rtcp_addr = addr;
}
_rtcp_sock->send(_process->createRtcpRR(rtp_ssrc + 1, rtp_ssrc), rtcp_addr);
@@ -123,33 +130,41 @@ private:
};
void RtpServer::start(uint16_t local_port, const char *local_ip, const MediaTuple &tuple, TcpMode tcp_mode, bool re_use_port, uint32_t ssrc, int only_track, bool multiplex) {
//创建udp服务器
// 创建udp服务器 [AUTO-TRANSLATED:99619428]
// Create UDP server
auto poller = EventPollerPool::Instance().getPoller();
Socket::Ptr rtp_socket = Socket::createSocket(poller, true);
Socket::Ptr rtcp_socket = Socket::createSocket(poller, true);
if (local_port == 0) {
//随机端口，rtp端口采用偶数
// 随机端口，rtp端口采用偶数 [AUTO-TRANSLATED:3664eaf5]
// Random port, RTP port uses even numbers
auto pair = std::make_pair(rtp_socket, rtcp_socket);
makeSockPair(pair, local_ip, re_use_port);
local_port = rtp_socket->get_local_port();
} else if (!rtp_socket->bindUdpSock(local_port, local_ip, re_use_port)) {
//用户指定端口
// 用户指定端口 [AUTO-TRANSLATED:1328393b]
// User-specified port
throw std::runtime_error(StrPrinter << "创建rtp端口 " << local_ip << ":" << local_port << " 失败:" << get_uv_errmsg(true));
} else if (!rtcp_socket->bindUdpSock(local_port + 1, local_ip, re_use_port)) {
// rtcp端口
// rtcp端口 [AUTO-TRANSLATED:00cf932e]
// RTCP port
throw std::runtime_error(StrPrinter << "创建rtcp端口 " << local_ip << ":" << local_port + 1 << " 失败:" << get_uv_errmsg(true));
}
//设置udp socket读缓存
// 设置udp socket读缓存 [AUTO-TRANSLATED:3bf101d7]
// Set UDP socket read cache
GET_CONFIG(int, udpRecvSocketBuffer, RtpProxy::kUdpRecvSocketBuffer);
SockUtil::setRecvBuf(rtp_socket->rawFD(), udpRecvSocketBuffer);
//创建udp服务器
// 创建udp服务器 [AUTO-TRANSLATED:99619428]
// Create UDP server
UdpServer::Ptr udp_server;
RtcpHelper::Ptr helper;
//增加了多路复用判断，如果多路复用为true，就走else逻辑，同时保留了原来stream_id为空走else逻辑
// 增加了多路复用判断，如果多路复用为true，就走else逻辑，同时保留了原来stream_id为空走else逻辑 [AUTO-TRANSLATED:114690b1]
// Added multiplexing judgment. If multiplexing is true, then go to the else logic, while retaining the original stream_id is empty to go to the else logic
if (!tuple.stream.empty() && !multiplex) {
//指定了流id，那么一个端口一个流(不管是否包含多个ssrc的多个流，绑定rtp源后，会筛选掉ip端口不匹配的流)
// 指定了流id，那么一个端口一个流(不管是否包含多个ssrc的多个流，绑定rtp源后，会筛选掉ip端口不匹配的流) [AUTO-TRANSLATED:3aeb611e]
// If a stream ID is specified, then one port is one stream (regardless of whether it contains multiple streams with multiple SSRCs, after binding the RTP source, streams that do not match the IP port will be filtered out)
helper = std::make_shared<RtcpHelper>(std::move(rtcp_socket), tuple);
helper->startRtcp();
helper->setRtpServerInfo(local_port, tcp_mode, re_use_port, ssrc, only_track);
@@ -164,7 +179,8 @@ void RtpServer::start(uint16_t local_port, const char *local_ip, const MediaTupl
WarnL << "ssrc mismatched, rtp dropped: " << rtp_ssrc << " != " << ssrc;
} else {
if (!bind_peer_addr) {
//绑定对方ip+端口，防止多个设备或一个设备多次推流从而日志报ssrc不匹配问题
// 绑定对方ip+端口，防止多个设备或一个设备多次推流从而日志报ssrc不匹配问题 [AUTO-TRANSLATED:f27dd373]
// Bind the peer IP + port to prevent multiple devices or one device from pushing multiple streams, resulting in log reports of mismatched SSRCs
bind_peer_addr = true;
rtp_socket->bindPeerAddr(addr, addr_len);
}
@@ -172,7 +188,8 @@ void RtpServer::start(uint16_t local_port, const char *local_ip, const MediaTupl
}
});
} else {
//单端口多线程接收多个流，根据ssrc区分流
// 单端口多线程接收多个流，根据ssrc区分流 [AUTO-TRANSLATED:e11c3ca8]
// Single-port multi-threaded reception of multiple streams, distinguishing streams based on SSRC
udp_server = std::make_shared<UdpServer>();
(*udp_server)[RtpSession::kOnlyTrack] = only_track;
(*udp_server)[RtpSession::kUdpRecvBuffer] = udpRecvSocketBuffer;
@@ -185,7 +202,8 @@ void RtpServer::start(uint16_t local_port, const char *local_ip, const MediaTupl
TcpServer::Ptr tcp_server;
if (tcp_mode == PASSIVE || tcp_mode == ACTIVE) {
auto processor = helper ? helper->getProcess() : nullptr;
// 如果共享同一个processor对象，那么tcp server深圳为单线程模式确保线程安全
// 如果共享同一个processor对象，那么tcp server深圳为单线程模式确保线程安全 [AUTO-TRANSLATED:68bdd877]
// If the same processor object is shared, then the TCP server Shenzhen is in single-threaded mode to ensure thread safety
tcp_server = std::make_shared<TcpServer>(processor ? poller : nullptr);
(*tcp_server)[RtpSession::kVhost] = tuple.vhost;
(*tcp_server)[RtpSession::kApp] = tuple.app;
@@ -198,14 +216,16 @@ void RtpServer::start(uint16_t local_port, const char *local_ip, const MediaTupl
session->setRtpProcess(processor);
});
} else if (tuple.stream.empty()) {
// tcp主动模式时只能一个端口一个流，必须指定流id; 创建TcpServer对象也仅用于传参
// tcp主动模式时只能一个端口一个流，必须指定流id; 创建TcpServer对象也仅用于传参 [AUTO-TRANSLATED:61d2a642]
// In TCP active mode, only one port can have one stream, and the stream ID must be specified; the TcpServer object is created only for parameter passing
throw std::runtime_error(StrPrinter << "tcp主动模式时必需指定流id");
}
}
_on_cleanup = [rtp_socket]() {
if (rtp_socket) {
//去除循环引用
// 去除循环引用 [AUTO-TRANSLATED:9afaed31]
// Remove circular references
rtp_socket->setOnRead(nullptr);
}
};