2021-04-09 20:42:36 +08:00
|
|
|
|
/*
|
|
|
|
|
* Copyright (c) 2016 The ZLMediaKit project authors. All Rights Reserved.
|
|
|
|
|
*
|
|
|
|
|
* This file is part of ZLMediaKit(https://github.com/xia-chu/ZLMediaKit).
|
|
|
|
|
*
|
|
|
|
|
* Use of this source code is governed by MIT license that can be found in the
|
|
|
|
|
* LICENSE file in the root of the source tree. All contributing project authors
|
|
|
|
|
* may be found in the AUTHORS file in the root of the source tree.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#include "WebRtcTransport.h"
|
2021-03-24 16:52:41 +08:00
|
|
|
|
#include <iostream>
|
|
|
|
|
#include "Rtcp/Rtcp.h"
|
2021-04-02 23:01:58 +08:00
|
|
|
|
#include "Rtsp/RtpReceiver.h"
|
|
|
|
|
#define RTX_SSRC_OFFSET 2
|
|
|
|
|
#define RTP_CNAME "zlmediakit-rtp"
|
|
|
|
|
#define RTX_CNAME "zlmediakit-rtx"
|
|
|
|
|
|
2021-04-07 17:51:06 +08:00
|
|
|
|
//RTC配置项目
|
|
|
|
|
namespace RTC {
|
|
|
|
|
#define RTC_FIELD "rtc."
|
|
|
|
|
//rtp和rtcp接受超时时间
|
|
|
|
|
const string kTimeOutSec = RTC_FIELD"timeoutSec";
|
|
|
|
|
//服务器外网ip
|
|
|
|
|
const string kExternIP = RTC_FIELD"externIP";
|
|
|
|
|
|
|
|
|
|
static onceToken token([]() {
|
|
|
|
|
mINI::Instance()[kTimeOutSec] = 15;
|
|
|
|
|
mINI::Instance()[kExternIP] = "";
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
}//namespace RTC
|
|
|
|
|
|
2021-03-27 10:16:49 +08:00
|
|
|
|
WebRtcTransport::WebRtcTransport(const EventPoller::Ptr &poller) {
|
2021-04-04 23:20:10 +08:00
|
|
|
|
_poller = poller;
|
2021-04-02 17:08:11 +08:00
|
|
|
|
_dtls_transport = std::make_shared<RTC::DtlsTransport>(poller, this);
|
2021-04-04 23:20:10 +08:00
|
|
|
|
_ice_server = std::make_shared<RTC::IceServer>(this, makeRandStr(4), makeRandStr(28).substr(4));
|
2021-03-24 16:52:41 +08:00
|
|
|
|
}
|
|
|
|
|
|
2021-04-07 17:21:59 +08:00
|
|
|
|
void WebRtcTransport::onCreate(){
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
2021-03-27 10:16:49 +08:00
|
|
|
|
void WebRtcTransport::onDestory(){
|
2021-04-02 17:08:11 +08:00
|
|
|
|
_dtls_transport = nullptr;
|
|
|
|
|
_ice_server = nullptr;
|
2021-03-27 09:38:13 +08:00
|
|
|
|
}
|
2021-03-24 16:52:41 +08:00
|
|
|
|
|
2021-04-04 23:20:10 +08:00
|
|
|
|
const EventPoller::Ptr& WebRtcTransport::getPoller() const{
|
|
|
|
|
return _poller;
|
|
|
|
|
}
|
|
|
|
|
|
2021-03-26 11:07:03 +08:00
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
|
|
void WebRtcTransport::OnIceServerSendStunPacket(const RTC::IceServer *iceServer, const RTC::StunPacket *packet, RTC::TransportTuple *tuple) {
|
2021-04-02 17:08:11 +08:00
|
|
|
|
onSendSockData((char *) packet->GetData(), packet->GetSize(), (struct sockaddr_in *) tuple);
|
2021-03-26 11:07:03 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void WebRtcTransport::OnIceServerSelectedTuple(const RTC::IceServer *iceServer, RTC::TransportTuple *tuple) {
|
|
|
|
|
InfoL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void WebRtcTransport::OnIceServerConnected(const RTC::IceServer *iceServer) {
|
|
|
|
|
InfoL;
|
2021-04-01 14:16:42 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void WebRtcTransport::OnIceServerCompleted(const RTC::IceServer *iceServer) {
|
|
|
|
|
InfoL;
|
2021-04-01 10:09:50 +08:00
|
|
|
|
if (_answer_sdp->media[0].role == DtlsRole::passive) {
|
2021-04-02 17:08:11 +08:00
|
|
|
|
_dtls_transport->Run(RTC::DtlsTransport::Role::SERVER);
|
2021-04-01 10:09:50 +08:00
|
|
|
|
} else {
|
2021-04-02 17:08:11 +08:00
|
|
|
|
_dtls_transport->Run(RTC::DtlsTransport::Role::CLIENT);
|
2021-04-01 10:09:50 +08:00
|
|
|
|
}
|
2021-03-26 11:07:03 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void WebRtcTransport::OnIceServerDisconnected(const RTC::IceServer *iceServer) {
|
|
|
|
|
InfoL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
|
|
void WebRtcTransport::OnDtlsTransportConnected(
|
|
|
|
|
const RTC::DtlsTransport *dtlsTransport,
|
|
|
|
|
RTC::SrtpSession::CryptoSuite srtpCryptoSuite,
|
|
|
|
|
uint8_t *srtpLocalKey,
|
|
|
|
|
size_t srtpLocalKeyLen,
|
|
|
|
|
uint8_t *srtpRemoteKey,
|
|
|
|
|
size_t srtpRemoteKeyLen,
|
|
|
|
|
std::string &remoteCert) {
|
|
|
|
|
InfoL;
|
2021-04-02 17:08:11 +08:00
|
|
|
|
_srtp_session_send = std::make_shared<RTC::SrtpSession>(RTC::SrtpSession::Type::OUTBOUND, srtpCryptoSuite, srtpLocalKey, srtpLocalKeyLen);
|
2021-04-02 23:01:58 +08:00
|
|
|
|
_srtp_session_recv = std::make_shared<RTC::SrtpSession>(RTC::SrtpSession::Type::INBOUND, srtpCryptoSuite, srtpRemoteKey, srtpRemoteKeyLen);
|
2021-04-02 17:08:11 +08:00
|
|
|
|
onStartWebRTC();
|
2021-03-26 11:07:03 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void WebRtcTransport::OnDtlsTransportSendData(const RTC::DtlsTransport *dtlsTransport, const uint8_t *data, size_t len) {
|
2021-04-02 17:08:11 +08:00
|
|
|
|
onSendSockData((char *)data, len);
|
2021-03-26 11:07:03 +08:00
|
|
|
|
}
|
|
|
|
|
|
2021-04-07 17:51:06 +08:00
|
|
|
|
void WebRtcTransport::OnDtlsTransportConnecting(const RTC::DtlsTransport *dtlsTransport) {
|
|
|
|
|
InfoL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void WebRtcTransport::OnDtlsTransportFailed(const RTC::DtlsTransport *dtlsTransport) {
|
|
|
|
|
InfoL;
|
|
|
|
|
onShutdown(SockException(Err_shutdown, "dtls transport failed"));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void WebRtcTransport::OnDtlsTransportClosed(const RTC::DtlsTransport *dtlsTransport) {
|
|
|
|
|
InfoL;
|
|
|
|
|
onShutdown(SockException(Err_shutdown, "dtls close notify received"));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void WebRtcTransport::OnDtlsTransportApplicationDataReceived(const RTC::DtlsTransport *dtlsTransport, const uint8_t *data, size_t len) {
|
|
|
|
|
InfoL << hexdump(data, len);
|
|
|
|
|
}
|
2021-03-26 11:07:03 +08:00
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
2021-04-02 17:56:24 +08:00
|
|
|
|
void WebRtcTransport::onSendSockData(const char *buf, size_t len, bool flush){
|
2021-04-02 17:08:11 +08:00
|
|
|
|
auto tuple = _ice_server->GetSelectedTuple();
|
2021-03-26 11:07:03 +08:00
|
|
|
|
assert(tuple);
|
2021-04-02 17:56:24 +08:00
|
|
|
|
onSendSockData(buf, len, (struct sockaddr_in *) tuple, flush);
|
2021-03-26 11:07:03 +08:00
|
|
|
|
}
|
|
|
|
|
|
2021-04-02 20:35:43 +08:00
|
|
|
|
const RtcSession& WebRtcTransport::getSdp(SdpType type) const{
|
|
|
|
|
switch (type) {
|
|
|
|
|
case SdpType::offer: return *_offer_sdp;
|
|
|
|
|
case SdpType::answer: return *_answer_sdp;
|
|
|
|
|
default: throw std::invalid_argument("不识别的sdp类型");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2021-04-07 20:33:53 +08:00
|
|
|
|
RTC::TransportTuple* WebRtcTransport::getSelectedTuple() const{
|
|
|
|
|
return _ice_server->GetSelectedTuple();
|
|
|
|
|
}
|
|
|
|
|
|
2021-04-01 10:09:50 +08:00
|
|
|
|
string getFingerprint(const string &algorithm_str, const std::shared_ptr<RTC::DtlsTransport> &transport){
|
|
|
|
|
auto algorithm = RTC::DtlsTransport::GetFingerprintAlgorithm(algorithm_str);
|
|
|
|
|
for (auto &finger_prints : transport->GetLocalFingerprints()) {
|
|
|
|
|
if (finger_prints.algorithm == algorithm) {
|
|
|
|
|
return finger_prints.value;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
throw std::invalid_argument(StrPrinter << "不支持的加密算法:" << algorithm_str);
|
|
|
|
|
}
|
|
|
|
|
|
2021-04-02 17:08:11 +08:00
|
|
|
|
void WebRtcTransport::setRemoteDtlsFingerprint(const RtcSession &remote){
|
|
|
|
|
//设置远端dtls签名
|
|
|
|
|
RTC::DtlsTransport::Fingerprint remote_fingerprint;
|
|
|
|
|
remote_fingerprint.algorithm = RTC::DtlsTransport::GetFingerprintAlgorithm(_offer_sdp->media[0].fingerprint.algorithm);
|
|
|
|
|
remote_fingerprint.value = _offer_sdp->media[0].fingerprint.hash;
|
|
|
|
|
_dtls_transport->SetRemoteFingerprint(remote_fingerprint);
|
|
|
|
|
}
|
|
|
|
|
|
2021-04-05 00:12:46 +08:00
|
|
|
|
void WebRtcTransport::onCheckSdp(SdpType type, RtcSession &sdp){
|
2021-04-02 17:08:11 +08:00
|
|
|
|
for (auto &m : sdp.media) {
|
|
|
|
|
if (m.type != TrackApplication && !m.rtcp_mux) {
|
|
|
|
|
throw std::invalid_argument("只支持rtcp-mux模式");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if (sdp.group.mids.empty()) {
|
|
|
|
|
throw std::invalid_argument("只支持group BUNDLE模式");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2021-03-31 17:15:26 +08:00
|
|
|
|
std::string WebRtcTransport::getAnswerSdp(const string &offer){
|
2021-04-07 20:41:17 +08:00
|
|
|
|
try {
|
|
|
|
|
//// 解析offer sdp ////
|
|
|
|
|
_offer_sdp = std::make_shared<RtcSession>();
|
|
|
|
|
_offer_sdp->loadFrom(offer);
|
|
|
|
|
onCheckSdp(SdpType::offer, *_offer_sdp);
|
|
|
|
|
setRemoteDtlsFingerprint(*_offer_sdp);
|
|
|
|
|
|
|
|
|
|
//// sdp 配置 ////
|
|
|
|
|
SdpAttrFingerprint fingerprint;
|
|
|
|
|
fingerprint.algorithm = _offer_sdp->media[0].fingerprint.algorithm;
|
|
|
|
|
fingerprint.hash = getFingerprint(fingerprint.algorithm, _dtls_transport);
|
|
|
|
|
RtcConfigure configure;
|
|
|
|
|
configure.setDefaultSetting(_ice_server->GetUsernameFragment(), _ice_server->GetPassword(),
|
|
|
|
|
RtpDirection::sendrecv, fingerprint);
|
|
|
|
|
onRtcConfigure(configure);
|
|
|
|
|
|
|
|
|
|
//// 生成answer sdp ////
|
|
|
|
|
_answer_sdp = configure.createAnswer(*_offer_sdp);
|
|
|
|
|
onCheckSdp(SdpType::answer, *_answer_sdp);
|
|
|
|
|
return _answer_sdp->toString();
|
|
|
|
|
} catch (exception &ex) {
|
|
|
|
|
onShutdown(SockException(Err_shutdown, ex.what()));
|
|
|
|
|
throw;
|
|
|
|
|
}
|
2021-03-31 17:15:26 +08:00
|
|
|
|
}
|
|
|
|
|
|
2021-03-24 16:52:41 +08:00
|
|
|
|
bool is_dtls(char *buf) {
|
|
|
|
|
return ((*buf > 19) && (*buf < 64));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool is_rtp(char *buf) {
|
|
|
|
|
RtpHeader *header = (RtpHeader *) buf;
|
|
|
|
|
return ((header->pt < 64) || (header->pt >= 96));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool is_rtcp(char *buf) {
|
|
|
|
|
RtpHeader *header = (RtpHeader *) buf;
|
|
|
|
|
return ((header->pt >= 64) && (header->pt < 96));
|
|
|
|
|
}
|
|
|
|
|
|
2021-04-02 17:08:11 +08:00
|
|
|
|
void WebRtcTransport::inputSockData(char *buf, size_t len, RTC::TransportTuple *tuple) {
|
2021-03-24 16:52:41 +08:00
|
|
|
|
if (RTC::StunPacket::IsStun((const uint8_t *) buf, len)) {
|
|
|
|
|
RTC::StunPacket *packet = RTC::StunPacket::Parse((const uint8_t *) buf, len);
|
|
|
|
|
if (packet == nullptr) {
|
|
|
|
|
WarnL << "parse stun error" << std::endl;
|
|
|
|
|
return;
|
|
|
|
|
}
|
2021-04-02 17:08:11 +08:00
|
|
|
|
_ice_server->ProcessStunPacket(packet, tuple);
|
2021-03-24 16:52:41 +08:00
|
|
|
|
return;
|
|
|
|
|
}
|
2021-03-26 11:07:03 +08:00
|
|
|
|
if (is_dtls(buf)) {
|
2021-04-02 17:08:11 +08:00
|
|
|
|
_dtls_transport->ProcessDtlsData((uint8_t *) buf, len);
|
2021-03-24 16:52:41 +08:00
|
|
|
|
return;
|
|
|
|
|
}
|
2021-04-01 14:16:42 +08:00
|
|
|
|
if (is_rtp(buf)) {
|
2021-04-02 17:56:24 +08:00
|
|
|
|
if (_srtp_session_recv->DecryptSrtp((uint8_t *) buf, &len)) {
|
|
|
|
|
onRtp(buf, len);
|
2021-04-03 08:45:18 +08:00
|
|
|
|
} else {
|
|
|
|
|
WarnL;
|
2021-04-02 17:56:24 +08:00
|
|
|
|
}
|
2021-04-01 14:16:42 +08:00
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
if (is_rtcp(buf)) {
|
2021-04-02 17:56:24 +08:00
|
|
|
|
if (_srtp_session_recv->DecryptSrtcp((uint8_t *) buf, &len)) {
|
|
|
|
|
onRtcp(buf, len);
|
2021-04-03 08:45:18 +08:00
|
|
|
|
} else {
|
|
|
|
|
WarnL;
|
2021-04-02 17:56:24 +08:00
|
|
|
|
}
|
2021-04-01 14:16:42 +08:00
|
|
|
|
return;
|
|
|
|
|
}
|
2021-03-24 16:52:41 +08:00
|
|
|
|
}
|
|
|
|
|
|
2021-04-04 21:42:11 +08:00
|
|
|
|
void WebRtcTransport::sendRtpPacket(char *buf, size_t len, bool flush, uint8_t pt) {
|
2021-03-24 16:52:41 +08:00
|
|
|
|
const uint8_t *p = (uint8_t *) buf;
|
|
|
|
|
bool ret = false;
|
2021-04-02 17:08:11 +08:00
|
|
|
|
if (_srtp_session_send) {
|
2021-04-04 21:42:11 +08:00
|
|
|
|
ret = _srtp_session_send->EncryptRtp(&p, &len, pt);
|
2021-03-24 16:52:41 +08:00
|
|
|
|
}
|
|
|
|
|
if (ret) {
|
2021-04-02 17:56:24 +08:00
|
|
|
|
onSendSockData((char *) p, len, flush);
|
2021-03-24 16:52:41 +08:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2021-04-02 23:12:37 +08:00
|
|
|
|
void WebRtcTransport::sendRtcpPacket(char *buf, size_t len, bool flush){
|
|
|
|
|
const uint8_t *p = (uint8_t *) buf;
|
|
|
|
|
bool ret = false;
|
|
|
|
|
if (_srtp_session_send) {
|
|
|
|
|
ret = _srtp_session_send->EncryptRtcp(&p, &len);
|
|
|
|
|
}
|
|
|
|
|
if (ret) {
|
|
|
|
|
onSendSockData((char *) p, len, flush);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2021-03-24 16:52:41 +08:00
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////
|
2021-03-27 10:16:49 +08:00
|
|
|
|
WebRtcTransportImp::Ptr WebRtcTransportImp::create(const EventPoller::Ptr &poller){
|
|
|
|
|
WebRtcTransportImp::Ptr ret(new WebRtcTransportImp(poller), [](WebRtcTransportImp *ptr){
|
|
|
|
|
ptr->onDestory();
|
|
|
|
|
delete ptr;
|
|
|
|
|
});
|
2021-04-07 17:21:59 +08:00
|
|
|
|
ret->onCreate();
|
2021-03-27 10:16:49 +08:00
|
|
|
|
return ret;
|
|
|
|
|
}
|
2021-03-24 16:52:41 +08:00
|
|
|
|
|
2021-04-07 17:21:59 +08:00
|
|
|
|
void WebRtcTransportImp::onCreate(){
|
|
|
|
|
WebRtcTransport::onCreate();
|
|
|
|
|
_socket = Socket::createSocket(getPoller(), false);
|
2021-03-24 16:52:41 +08:00
|
|
|
|
//随机端口,绑定全部网卡
|
|
|
|
|
_socket->bindUdpSock(0);
|
2021-04-07 17:21:59 +08:00
|
|
|
|
weak_ptr<WebRtcTransportImp> weak_self = shared_from_this();
|
|
|
|
|
_socket->setOnRead([weak_self](const Buffer::Ptr &buf, struct sockaddr *addr, int addr_len) mutable {
|
|
|
|
|
auto strong_self = weak_self.lock();
|
|
|
|
|
if (strong_self) {
|
|
|
|
|
strong_self->inputSockData(buf->data(), buf->size(), addr);
|
|
|
|
|
}
|
2021-03-24 16:52:41 +08:00
|
|
|
|
});
|
2021-04-07 17:51:06 +08:00
|
|
|
|
_self = shared_from_this();
|
|
|
|
|
|
|
|
|
|
GET_CONFIG(float, timeoutSec, RTC::kTimeOutSec);
|
|
|
|
|
_timer = std::make_shared<Timer>(timeoutSec / 2, [weak_self]() {
|
|
|
|
|
auto strong_self = weak_self.lock();
|
|
|
|
|
if (!strong_self) {
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
if (strong_self->_alive_ticker.elapsedTime() > timeoutSec * 1000) {
|
|
|
|
|
strong_self->onShutdown(SockException(Err_timeout, "接受rtp和rtcp超时"));
|
|
|
|
|
}
|
|
|
|
|
return true;
|
|
|
|
|
}, getPoller());
|
2021-03-24 16:52:41 +08:00
|
|
|
|
}
|
|
|
|
|
|
2021-04-07 17:21:59 +08:00
|
|
|
|
WebRtcTransportImp::WebRtcTransportImp(const EventPoller::Ptr &poller) : WebRtcTransport(poller) {
|
2021-04-07 17:51:06 +08:00
|
|
|
|
InfoL << this;
|
|
|
|
|
}
|
2021-04-07 17:21:59 +08:00
|
|
|
|
|
2021-04-07 17:51:06 +08:00
|
|
|
|
WebRtcTransportImp::~WebRtcTransportImp() {
|
|
|
|
|
InfoL << this;
|
2021-04-07 17:21:59 +08:00
|
|
|
|
}
|
|
|
|
|
|
2021-03-27 10:16:49 +08:00
|
|
|
|
void WebRtcTransportImp::onDestory() {
|
|
|
|
|
WebRtcTransport::onDestory();
|
2021-04-07 18:35:38 +08:00
|
|
|
|
uint64_t duration = _alive_ticker.createdTime() / 1000;
|
|
|
|
|
|
|
|
|
|
//流量统计事件广播
|
|
|
|
|
GET_CONFIG(uint32_t, iFlowThreshold, General::kFlowThreshold);
|
|
|
|
|
|
|
|
|
|
if (_play_src) {
|
2021-04-07 20:40:42 +08:00
|
|
|
|
WarnL << "RTC播放器("
|
|
|
|
|
<< _media_info._vhost << "/"
|
|
|
|
|
<< _media_info._app << "/"
|
|
|
|
|
<< _media_info._streamid
|
|
|
|
|
<< ")结束播放,耗时(s):" << duration;
|
2021-04-07 18:35:38 +08:00
|
|
|
|
if (_bytes_usage >= iFlowThreshold * 1024) {
|
|
|
|
|
NoticeCenter::Instance().emitEvent(Broadcast::kBroadcastFlowReport, _media_info, _bytes_usage, duration, true, static_cast<SockInfo &>(*_socket));
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (_push_src) {
|
2021-04-07 20:40:42 +08:00
|
|
|
|
WarnL << "RTC推流器("
|
|
|
|
|
<< _media_info._vhost << "/"
|
|
|
|
|
<< _media_info._app << "/"
|
|
|
|
|
<< _media_info._streamid
|
|
|
|
|
<< ")结束推流,耗时(s):" << duration;
|
2021-04-07 18:35:38 +08:00
|
|
|
|
if (_bytes_usage >= iFlowThreshold * 1024) {
|
|
|
|
|
NoticeCenter::Instance().emitEvent(Broadcast::kBroadcastFlowReport, _media_info, _bytes_usage, duration, false, static_cast<SockInfo &>(*_socket));
|
|
|
|
|
}
|
|
|
|
|
}
|
2021-03-27 10:16:49 +08:00
|
|
|
|
}
|
|
|
|
|
|
2021-04-07 18:35:38 +08:00
|
|
|
|
void WebRtcTransportImp::attach(const RtspMediaSource::Ptr &src, const MediaInfo &info, bool is_play) {
|
2021-03-24 16:52:41 +08:00
|
|
|
|
assert(src);
|
2021-04-07 18:35:38 +08:00
|
|
|
|
_media_info = info;
|
2021-04-05 11:32:38 +08:00
|
|
|
|
if (is_play) {
|
|
|
|
|
_play_src = src;
|
|
|
|
|
} else {
|
|
|
|
|
_push_src = src;
|
|
|
|
|
}
|
2021-03-24 16:52:41 +08:00
|
|
|
|
}
|
|
|
|
|
|
2021-04-03 08:32:20 +08:00
|
|
|
|
void WebRtcTransportImp::onSendSockData(const char *buf, size_t len, struct sockaddr_in *dst, bool flush) {
|
|
|
|
|
auto ptr = BufferRaw::create();
|
|
|
|
|
ptr->assign(buf, len);
|
|
|
|
|
_socket->send(ptr, (struct sockaddr *)(dst), sizeof(struct sockaddr), flush);
|
|
|
|
|
}
|
|
|
|
|
|
2021-04-03 08:45:18 +08:00
|
|
|
|
///////////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
|
|
bool WebRtcTransportImp::canSendRtp() const{
|
|
|
|
|
auto &sdp = getSdp(SdpType::answer);
|
2021-04-05 11:32:38 +08:00
|
|
|
|
return _play_src && (sdp.media[0].direction == RtpDirection::sendrecv || sdp.media[0].direction == RtpDirection::sendonly);
|
2021-04-03 08:45:18 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool WebRtcTransportImp::canRecvRtp() const{
|
|
|
|
|
auto &sdp = getSdp(SdpType::answer);
|
2021-04-05 11:32:38 +08:00
|
|
|
|
return _push_src && (sdp.media[0].direction == RtpDirection::sendrecv || sdp.media[0].direction == RtpDirection::recvonly);
|
2021-04-03 08:45:18 +08:00
|
|
|
|
}
|
|
|
|
|
|
2021-04-02 17:08:11 +08:00
|
|
|
|
void WebRtcTransportImp::onStartWebRTC() {
|
2021-04-04 23:20:10 +08:00
|
|
|
|
for (auto &m : getSdp(SdpType::offer).media) {
|
|
|
|
|
if (m.type == TrackVideo) {
|
|
|
|
|
_recv_video_ssrc = m.rtp_ssrc.ssrc;
|
|
|
|
|
}
|
|
|
|
|
for (auto &plan : m.plan) {
|
|
|
|
|
auto hit_pan = getSdp(SdpType::answer).getMedia(m.type)->getPlan(plan.pt);
|
|
|
|
|
if (!hit_pan) {
|
|
|
|
|
continue;
|
2021-04-02 23:01:58 +08:00
|
|
|
|
}
|
2021-04-04 23:20:10 +08:00
|
|
|
|
//获取offer端rtp的ssrc和pt相关信息
|
|
|
|
|
auto &ref = _rtp_info_pt[plan.pt];
|
|
|
|
|
_rtp_info_ssrc[m.rtp_ssrc.ssrc] = &ref;
|
|
|
|
|
ref.plan = &plan;
|
|
|
|
|
ref.media = &m;
|
|
|
|
|
ref.is_common_rtp = getCodecId(plan.codec) != CodecInvalid;
|
|
|
|
|
ref.rtcp_context_recv = std::make_shared<RtcpContext>(ref.plan->sample_rate, true);
|
|
|
|
|
ref.rtcp_context_send = std::make_shared<RtcpContext>(ref.plan->sample_rate, false);
|
|
|
|
|
ref.receiver = std::make_shared<RtpReceiverImp>([&ref, this](RtpPacket::Ptr rtp) {
|
|
|
|
|
onSortedRtp(ref, std::move(rtp));
|
|
|
|
|
}, [ref, this](const RtpPacket::Ptr &rtp) {
|
|
|
|
|
onBeforeSortedRtp(ref, rtp);
|
|
|
|
|
});
|
2021-04-02 23:01:58 +08:00
|
|
|
|
}
|
|
|
|
|
}
|
2021-04-04 23:20:10 +08:00
|
|
|
|
|
|
|
|
|
if (canRecvRtp()) {
|
2021-04-05 11:32:38 +08:00
|
|
|
|
_push_src->setSdp(getSdp(SdpType::answer).toRtspSdp());
|
2021-04-04 23:20:10 +08:00
|
|
|
|
}
|
2021-04-03 08:32:20 +08:00
|
|
|
|
if (canSendRtp()) {
|
2021-04-07 17:21:59 +08:00
|
|
|
|
_reader = _play_src->getRing()->attach(getPoller(), true);
|
2021-04-03 08:32:20 +08:00
|
|
|
|
weak_ptr<WebRtcTransportImp> weak_self = shared_from_this();
|
|
|
|
|
_reader->setReadCB([weak_self](const RtspMediaSource::RingDataType &pkt) {
|
|
|
|
|
auto strongSelf = weak_self.lock();
|
|
|
|
|
if (!strongSelf) {
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
size_t i = 0;
|
|
|
|
|
pkt->for_each([&](const RtpPacket::Ptr &rtp) {
|
|
|
|
|
strongSelf->onSendRtp(rtp, ++i == pkt->size());
|
|
|
|
|
});
|
2021-03-24 16:52:41 +08:00
|
|
|
|
});
|
2021-04-02 20:35:43 +08:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2021-04-05 00:12:46 +08:00
|
|
|
|
void WebRtcTransportImp::onCheckSdp(SdpType type, RtcSession &sdp){
|
2021-04-02 17:56:24 +08:00
|
|
|
|
WebRtcTransport::onCheckSdp(type, sdp);
|
2021-04-02 20:35:43 +08:00
|
|
|
|
if (type != SdpType::answer || !canSendRtp()) {
|
2021-04-02 17:56:24 +08:00
|
|
|
|
return;
|
|
|
|
|
}
|
2021-04-02 20:35:43 +08:00
|
|
|
|
|
2021-04-05 00:06:21 +08:00
|
|
|
|
RtcSession rtsp_send_sdp;
|
2021-04-05 11:32:38 +08:00
|
|
|
|
rtsp_send_sdp.loadFrom(_play_src->getSdp(), false);
|
2021-04-05 00:06:21 +08:00
|
|
|
|
|
2021-04-02 17:56:24 +08:00
|
|
|
|
for (auto &m : sdp.media) {
|
|
|
|
|
if (m.type == TrackApplication) {
|
|
|
|
|
continue;
|
|
|
|
|
}
|
2021-04-05 00:06:21 +08:00
|
|
|
|
//添加answer sdp的ssrc信息
|
2021-04-05 11:32:38 +08:00
|
|
|
|
m.rtp_ssrc.ssrc = _play_src->getSsrc(m.type);
|
2021-04-02 23:01:58 +08:00
|
|
|
|
m.rtp_ssrc.cname = RTP_CNAME;
|
|
|
|
|
//todo 先屏蔽rtx,因为chrome报错
|
|
|
|
|
if (false && m.getRelatedRtxPlan(m.plan[0].pt)) {
|
|
|
|
|
m.rtx_ssrc.ssrc = RTX_SSRC_OFFSET + m.rtp_ssrc.ssrc;
|
|
|
|
|
m.rtx_ssrc.cname = RTX_CNAME;
|
|
|
|
|
}
|
2021-04-05 00:06:21 +08:00
|
|
|
|
auto rtsp_media = rtsp_send_sdp.getMedia(m.type);
|
2021-04-02 21:08:40 +08:00
|
|
|
|
if (rtsp_media && getCodecId(rtsp_media->plan[0].codec) == getCodecId(m.plan[0].codec)) {
|
2021-04-05 00:06:21 +08:00
|
|
|
|
//记录发送rtp的pt
|
2021-04-02 21:08:40 +08:00
|
|
|
|
_send_rtp_pt[m.type] = m.plan[0].pt;
|
|
|
|
|
}
|
2021-04-02 17:56:24 +08:00
|
|
|
|
}
|
2021-03-24 16:52:41 +08:00
|
|
|
|
}
|
|
|
|
|
|
2021-04-02 18:28:01 +08:00
|
|
|
|
void WebRtcTransportImp::onRtcConfigure(RtcConfigure &configure) const {
|
|
|
|
|
WebRtcTransport::onRtcConfigure(configure);
|
|
|
|
|
|
2021-04-05 11:32:38 +08:00
|
|
|
|
if (_play_src) {
|
|
|
|
|
//这是播放,同时也可能有推流
|
|
|
|
|
configure.video.direction = _push_src ? RtpDirection::sendrecv : RtpDirection::sendonly;
|
|
|
|
|
configure.audio.direction = configure.video.direction;
|
|
|
|
|
configure.setPlayRtspInfo(_play_src->getSdp());
|
|
|
|
|
} else if (_push_src) {
|
|
|
|
|
//这只是推流
|
2021-04-04 23:20:10 +08:00
|
|
|
|
configure.video.direction = RtpDirection::recvonly;
|
|
|
|
|
configure.audio.direction = RtpDirection::recvonly;
|
2021-04-05 11:32:38 +08:00
|
|
|
|
} else {
|
|
|
|
|
throw std::invalid_argument("未设置播放或推流的媒体源");
|
2021-04-02 18:28:01 +08:00
|
|
|
|
}
|
|
|
|
|
|
2021-04-03 08:45:18 +08:00
|
|
|
|
//添加接收端口candidate信息
|
2021-04-02 18:28:01 +08:00
|
|
|
|
configure.addCandidate(*getIceCandidate());
|
|
|
|
|
}
|
|
|
|
|
|
2021-04-02 17:08:11 +08:00
|
|
|
|
SdpAttrCandidate::Ptr WebRtcTransportImp::getIceCandidate() const{
|
|
|
|
|
auto candidate = std::make_shared<SdpAttrCandidate>();
|
|
|
|
|
candidate->foundation = "udpcandidate";
|
2021-04-03 08:45:18 +08:00
|
|
|
|
//rtp端口
|
2021-04-02 17:08:11 +08:00
|
|
|
|
candidate->component = 1;
|
|
|
|
|
candidate->transport = "udp";
|
2021-04-03 08:45:18 +08:00
|
|
|
|
//优先级,单candidate时随便
|
2021-04-02 17:08:11 +08:00
|
|
|
|
candidate->priority = 100;
|
2021-04-07 17:51:06 +08:00
|
|
|
|
GET_CONFIG(string, extern_ip, RTC::kExternIP);
|
|
|
|
|
candidate->address = extern_ip.empty() ? SockUtil::get_local_ip() : extern_ip;
|
2021-04-02 17:56:24 +08:00
|
|
|
|
candidate->port = _socket->get_local_port();
|
2021-04-02 17:08:11 +08:00
|
|
|
|
candidate->type = "host";
|
|
|
|
|
return candidate;
|
|
|
|
|
}
|
|
|
|
|
|
2021-04-03 08:45:18 +08:00
|
|
|
|
///////////////////////////////////////////////////////////////////
|
|
|
|
|
|
2021-04-02 23:01:58 +08:00
|
|
|
|
class RtpReceiverImp : public RtpReceiver {
|
|
|
|
|
public:
|
|
|
|
|
RtpReceiverImp( function<void(RtpPacket::Ptr rtp)> cb, function<void(const RtpPacket::Ptr &rtp)> cb_before = nullptr){
|
|
|
|
|
_on_sort = std::move(cb);
|
|
|
|
|
_on_before_sort = std::move(cb_before);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
~RtpReceiverImp() override = default;
|
|
|
|
|
|
|
|
|
|
bool inputRtp(TrackType type, int samplerate, uint8_t *ptr, size_t len){
|
|
|
|
|
return handleOneRtp((int) type, type, samplerate, ptr, len);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
protected:
|
|
|
|
|
void onRtpSorted(RtpPacket::Ptr rtp, int track_index) override {
|
|
|
|
|
_on_sort(std::move(rtp));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void onBeforeRtpSorted(const RtpPacket::Ptr &rtp, int track_index) override {
|
|
|
|
|
if (_on_before_sort) {
|
|
|
|
|
_on_before_sort(rtp);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private:
|
|
|
|
|
function<void(RtpPacket::Ptr rtp)> _on_sort;
|
|
|
|
|
function<void(const RtpPacket::Ptr &rtp)> _on_before_sort;
|
|
|
|
|
};
|
|
|
|
|
|
2021-04-02 17:56:24 +08:00
|
|
|
|
void WebRtcTransportImp::onRtcp(const char *buf, size_t len) {
|
2021-04-07 18:35:38 +08:00
|
|
|
|
_bytes_usage += len;
|
2021-04-03 00:04:52 +08:00
|
|
|
|
auto rtcps = RtcpHeader::loadFromBytes((char *) buf, len);
|
|
|
|
|
for (auto rtcp : rtcps) {
|
|
|
|
|
switch ((RtcpType) rtcp->pt) {
|
|
|
|
|
case RtcpType::RTCP_SR : {
|
|
|
|
|
//对方汇报rtp发送情况
|
|
|
|
|
RtcpSR *sr = (RtcpSR *) rtcp;
|
2021-04-04 23:20:10 +08:00
|
|
|
|
auto it = _rtp_info_ssrc.find(sr->ssrc);
|
|
|
|
|
if (it != _rtp_info_ssrc.end()) {
|
2021-04-03 00:04:52 +08:00
|
|
|
|
it->second->rtcp_context_recv->onRtcp(sr);
|
2021-04-03 08:32:20 +08:00
|
|
|
|
auto rr = it->second->rtcp_context_recv->createRtcpRR(sr->items.ssrc, sr->ssrc);
|
2021-04-03 00:04:52 +08:00
|
|
|
|
sendRtcpPacket(rr->data(), rr->size(), true);
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case RtcpType::RTCP_RR : {
|
2021-04-07 17:51:06 +08:00
|
|
|
|
_alive_ticker.resetTime();
|
2021-04-03 00:04:52 +08:00
|
|
|
|
//对方汇报rtp接收情况
|
|
|
|
|
RtcpRR *rr = (RtcpRR *) rtcp;
|
2021-04-04 23:20:10 +08:00
|
|
|
|
auto it = _rtp_info_ssrc.find(rr->ssrc);
|
|
|
|
|
if (it != _rtp_info_ssrc.end()) {
|
2021-04-03 08:32:20 +08:00
|
|
|
|
auto sr = it->second->rtcp_context_send->createRtcpSR(rr->items.ssrc);
|
2021-04-03 00:04:52 +08:00
|
|
|
|
sendRtcpPacket(sr->data(), sr->size(), true);
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
}
|
2021-04-03 08:45:18 +08:00
|
|
|
|
case RtcpType::RTCP_BYE : {
|
2021-04-07 17:21:59 +08:00
|
|
|
|
//对方汇报停止发送rtp
|
|
|
|
|
RtcpBye *bye = (RtcpBye *) rtcp;
|
|
|
|
|
for (auto ssrc : bye->getSSRC()) {
|
|
|
|
|
auto it = _rtp_info_ssrc.find(*ssrc);
|
|
|
|
|
if (it == _rtp_info_ssrc.end()) {
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
_rtp_info_pt.erase(it->second->plan->pt);
|
|
|
|
|
_rtp_info_ssrc.erase(it);
|
|
|
|
|
}
|
|
|
|
|
onShutdown(SockException(Err_eof, "rtcp bye message received"));
|
2021-04-03 08:45:18 +08:00
|
|
|
|
break;
|
|
|
|
|
}
|
2021-04-23 18:27:47 +08:00
|
|
|
|
case RtcpType::RTCP_PSFB:
|
2021-04-22 17:34:26 +08:00
|
|
|
|
case RtcpType::RTCP_RTPFB: {
|
2021-04-26 21:03:04 +08:00
|
|
|
|
InfoL << "\n" << rtcp->dumpString();
|
2021-04-22 17:34:26 +08:00
|
|
|
|
break;
|
|
|
|
|
}
|
2021-04-03 00:04:52 +08:00
|
|
|
|
default: break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2021-04-03 08:45:18 +08:00
|
|
|
|
void WebRtcTransportImp::onRtp(const char *buf, size_t len) {
|
2021-04-07 18:35:38 +08:00
|
|
|
|
_bytes_usage += len;
|
2021-04-07 17:51:06 +08:00
|
|
|
|
_alive_ticker.resetTime();
|
2021-04-03 08:45:18 +08:00
|
|
|
|
RtpHeader *rtp = (RtpHeader *) buf;
|
|
|
|
|
//根据接收到的rtp的pt信息,找到该流的信息
|
2021-04-04 23:20:10 +08:00
|
|
|
|
auto it = _rtp_info_pt.find(rtp->pt);
|
|
|
|
|
if (it == _rtp_info_pt.end()) {
|
2021-04-03 08:45:18 +08:00
|
|
|
|
WarnL;
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
auto &info = it->second;
|
|
|
|
|
//解析并排序rtp
|
|
|
|
|
info.receiver->inputRtp(info.media->type, info.plan->sample_rate, (uint8_t *) buf, len);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////
|
2021-04-03 08:32:20 +08:00
|
|
|
|
|
2021-04-02 23:01:58 +08:00
|
|
|
|
void WebRtcTransportImp::onSortedRtp(const RtpPayloadInfo &info, RtpPacket::Ptr rtp) {
|
|
|
|
|
if(!info.is_common_rtp){
|
2021-04-03 08:45:18 +08:00
|
|
|
|
//todo rtx/red/ulpfec类型的rtp先未处理
|
2021-04-03 00:04:52 +08:00
|
|
|
|
return;
|
2021-04-02 23:01:58 +08:00
|
|
|
|
}
|
2021-04-02 23:12:37 +08:00
|
|
|
|
if (_pli_ticker.elapsedTime() > 2000) {
|
2021-04-07 21:02:28 +08:00
|
|
|
|
//定期发送pli请求关键帧,方便非rtc等协议
|
2021-04-02 23:12:37 +08:00
|
|
|
|
_pli_ticker.resetTime();
|
2021-04-23 18:27:47 +08:00
|
|
|
|
auto pli = RtcpFB::create(PSFBType::RTCP_PSFB_PLI);
|
2021-04-03 09:34:49 +08:00
|
|
|
|
pli->ssrc = htonl(0);
|
|
|
|
|
pli->ssrc_media = htonl(_recv_video_ssrc);
|
2021-04-23 18:27:47 +08:00
|
|
|
|
sendRtcpPacket((char *) pli.get(), pli->getSize(), true);
|
2021-04-02 23:12:37 +08:00
|
|
|
|
}
|
2021-04-05 11:32:38 +08:00
|
|
|
|
if (_push_src) {
|
|
|
|
|
_push_src->onWrite(std::move(rtp), false);
|
|
|
|
|
}
|
2021-04-02 23:01:58 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void WebRtcTransportImp::onBeforeSortedRtp(const RtpPayloadInfo &info, const RtpPacket::Ptr &rtp) {
|
2021-04-03 08:45:18 +08:00
|
|
|
|
//统计rtp收到的情况,好做rr汇报
|
2021-04-03 00:04:52 +08:00
|
|
|
|
info.rtcp_context_recv->onRtp(rtp->getSeq(), rtp->getStampMS(), rtp->size() - RtpPacket::kRtpTcpHeaderSize);
|
2021-04-02 23:01:58 +08:00
|
|
|
|
}
|
2021-04-03 08:32:20 +08:00
|
|
|
|
|
|
|
|
|
void WebRtcTransportImp::onSendRtp(const RtpPacket::Ptr &rtp, bool flush){
|
2021-04-04 21:42:11 +08:00
|
|
|
|
auto &pt = _send_rtp_pt[rtp->type];
|
2021-04-10 21:58:27 +08:00
|
|
|
|
if (pt == 0xFF) {
|
2021-04-03 08:32:20 +08:00
|
|
|
|
//忽略,对方不支持该编码类型
|
|
|
|
|
return;
|
|
|
|
|
}
|
2021-04-07 18:35:38 +08:00
|
|
|
|
_bytes_usage += rtp->size() - RtpPacket::kRtpTcpHeaderSize;
|
2021-04-04 21:42:11 +08:00
|
|
|
|
sendRtpPacket(rtp->data() + RtpPacket::kRtpTcpHeaderSize, rtp->size() - RtpPacket::kRtpTcpHeaderSize, flush, pt);
|
2021-04-03 08:45:18 +08:00
|
|
|
|
//统计rtp发送情况,好做sr汇报
|
2021-04-04 23:20:10 +08:00
|
|
|
|
_rtp_info_pt[pt].rtcp_context_send->onRtp(rtp->getSeq(), rtp->getStampMS(), rtp->size() - RtpPacket::kRtpTcpHeaderSize);
|
2021-04-03 08:32:20 +08:00
|
|
|
|
}
|
2021-04-07 17:21:59 +08:00
|
|
|
|
|
|
|
|
|
void WebRtcTransportImp::onShutdown(const SockException &ex){
|
|
|
|
|
InfoL << ex.what();
|
2021-04-07 17:51:06 +08:00
|
|
|
|
_self = nullptr;
|
2021-04-07 17:21:59 +08:00
|
|
|
|
}
|
|
|
|
|
|
2021-04-07 18:18:27 +08:00
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
|
|
bool WebRtcTransportImp::close(MediaSource &sender, bool force) {
|
|
|
|
|
//此回调在其他线程触发
|
|
|
|
|
if(!_push_src || (!force && _push_src->totalReaderCount())){
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
string err = StrPrinter << "close media:" << sender.getSchema() << "/" << sender.getVhost() << "/" << sender.getApp() << "/" << sender.getId() << " " << force;
|
|
|
|
|
onShutdown(SockException(Err_shutdown,err));
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int WebRtcTransportImp::totalReaderCount(MediaSource &sender) {
|
|
|
|
|
return _push_src ? _push_src->totalReaderCount() : sender.readerCount();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
MediaOriginType WebRtcTransportImp::getOriginType(MediaSource &sender) const {
|
|
|
|
|
return MediaOriginType::rtc_push;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
string WebRtcTransportImp::getOriginUrl(MediaSource &sender) const {
|
|
|
|
|
return "";
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
std::shared_ptr<SockInfo> WebRtcTransportImp::getOriginSock(MediaSource &sender) const {
|
2021-04-07 20:33:53 +08:00
|
|
|
|
return const_cast<WebRtcTransportImp *>(this)->shared_from_this();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
|
|
string WebRtcTransportImp::get_local_ip() {
|
|
|
|
|
return getSdp(SdpType::answer).media[0].candidate[0].address;
|
2021-04-07 18:18:27 +08:00
|
|
|
|
}
|
|
|
|
|
|
2021-04-07 20:33:53 +08:00
|
|
|
|
uint16_t WebRtcTransportImp::get_local_port() {
|
|
|
|
|
return _socket->get_local_port();
|
2021-04-07 18:18:27 +08:00
|
|
|
|
}
|
2021-04-07 20:33:53 +08:00
|
|
|
|
|
|
|
|
|
string WebRtcTransportImp::get_peer_ip() {
|
|
|
|
|
return SockUtil::inet_ntoa(((struct sockaddr_in *) getSelectedTuple())->sin_addr);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
uint16_t WebRtcTransportImp::get_peer_port() {
|
|
|
|
|
return ntohs(((struct sockaddr_in *) getSelectedTuple())->sin_port);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
string WebRtcTransportImp::getIdentifier() const {
|
|
|
|
|
return StrPrinter << this;
|
|
|
|
|
}
|