mirror of
https://github.com/ossrs/srs.git
synced 2025-02-13 20:01:56 +00:00
Refactor RTC, rename variables.
This commit is contained in:
winlin
parent
9c8b7279f0
commit
a23f102874
4 changed files with 171 additions and 173 deletions
|
|
@ -789,9 +789,9 @@ srs_error_t SrsGoApiStreams::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessa
|
|||
#ifdef SRS_RTC
|
||||
uint32_t SrsGoApiRtcPlay::ssrc_num = 0;
|
||||
|
||||
SrsGoApiRtcPlay::SrsGoApiRtcPlay(SrsRtcServer* rtc_svr)
|
||||
SrsGoApiRtcPlay::SrsGoApiRtcPlay(SrsRtcServer* server)
|
||||
{
|
||||
rtc_server = rtc_svr;
|
||||
server_ = server;
|
||||
}
|
||||
|
||||
SrsGoApiRtcPlay::~SrsGoApiRtcPlay()
|
||||
|
|
@ -929,16 +929,15 @@ srs_error_t SrsGoApiRtcPlay::do_serve_http(ISrsHttpResponseWriter* w, ISrsHttpMe
|
|||
server_enabled, rtc_enabled, request.vhost.c_str());
|
||||
}
|
||||
|
||||
// TODO: FIXME: Maybe need a better name?
|
||||
// TODO: FIXME: When server enabled, but vhost disabled, should report error.
|
||||
SrsRtcSession* rtc_session = NULL;
|
||||
if ((err = rtc_server->create_rtc_session(&request, remote_sdp, local_sdp, eip, false, &rtc_session)) != srs_success) {
|
||||
SrsRtcSession* session = NULL;
|
||||
if ((err = server_->create_session(&request, remote_sdp, local_sdp, eip, false, &session)) != srs_success) {
|
||||
return srs_error_wrap(err, "create session");
|
||||
}
|
||||
if (encrypt.empty()) {
|
||||
rtc_session->set_encrypt(_srs_config->get_rtc_server_encrypt());
|
||||
session->set_encrypt(_srs_config->get_rtc_server_encrypt());
|
||||
} else {
|
||||
rtc_session->set_encrypt(encrypt != "false");
|
||||
session->set_encrypt(encrypt != "false");
|
||||
}
|
||||
|
||||
ostringstream os;
|
||||
|
|
@ -956,9 +955,9 @@ srs_error_t SrsGoApiRtcPlay::do_serve_http(ISrsHttpResponseWriter* w, ISrsHttpMe
|
|||
// TODO: add candidates in response json?
|
||||
|
||||
res->set("sdp", SrsJsonAny::str(local_sdp_str.c_str()));
|
||||
res->set("sessionid", SrsJsonAny::str(rtc_session->id().c_str()));
|
||||
res->set("sessionid", SrsJsonAny::str(session->id().c_str()));
|
||||
|
||||
srs_trace("RTC sid=%s, offer=%dB, answer=%dB", rtc_session->id().c_str(), remote_sdp_str.length(), local_sdp_str.length());
|
||||
srs_trace("RTC sid=%s, offer=%dB, answer=%dB", session->id().c_str(), remote_sdp_str.length(), local_sdp_str.length());
|
||||
|
||||
return err;
|
||||
}
|
||||
|
|
@ -1119,9 +1118,9 @@ srs_error_t SrsGoApiRtcPlay::exchange_sdp(const std::string& app, const std::str
|
|||
|
||||
uint32_t SrsGoApiRtcPublish::ssrc_num = 0;
|
||||
|
||||
SrsGoApiRtcPublish::SrsGoApiRtcPublish(SrsRtcServer* rtc_svr)
|
||||
SrsGoApiRtcPublish::SrsGoApiRtcPublish(SrsRtcServer* server)
|
||||
{
|
||||
rtc_server = rtc_svr;
|
||||
server_ = server;
|
||||
}
|
||||
|
||||
SrsGoApiRtcPublish::~SrsGoApiRtcPublish()
|
||||
|
|
@ -1254,10 +1253,9 @@ srs_error_t SrsGoApiRtcPublish::do_serve_http(ISrsHttpResponseWriter* w, ISrsHtt
|
|||
server_enabled, rtc_enabled, request.vhost.c_str());
|
||||
}
|
||||
|
||||
// TODO: FIXME: Maybe need a better name?
|
||||
// TODO: FIXME: When server enabled, but vhost disabled, should report error.
|
||||
SrsRtcSession* rtc_session = NULL;
|
||||
if ((err = rtc_server->create_rtc_session(&request, remote_sdp, local_sdp, eip, true, &rtc_session)) != srs_success) {
|
||||
SrsRtcSession* session = NULL;
|
||||
if ((err = server_->create_session(&request, remote_sdp, local_sdp, eip, true, &session)) != srs_success) {
|
||||
return srs_error_wrap(err, "create session");
|
||||
}
|
||||
|
||||
|
|
@ -1276,9 +1274,9 @@ srs_error_t SrsGoApiRtcPublish::do_serve_http(ISrsHttpResponseWriter* w, ISrsHtt
|
|||
// TODO: add candidates in response json?
|
||||
|
||||
res->set("sdp", SrsJsonAny::str(local_sdp_str.c_str()));
|
||||
res->set("sessionid", SrsJsonAny::str(rtc_session->id().c_str()));
|
||||
res->set("sessionid", SrsJsonAny::str(session->id().c_str()));
|
||||
|
||||
srs_trace("RTC sid=%s, offer=%dB, answer=%dB", rtc_session->id().c_str(), remote_sdp_str.length(), local_sdp_str.length());
|
||||
srs_trace("RTC sid=%s, offer=%dB, answer=%dB", session->id().c_str(), remote_sdp_str.length(), local_sdp_str.length());
|
||||
|
||||
return err;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -173,9 +173,9 @@ class SrsGoApiRtcPlay : public ISrsHttpHandler
|
|||
public:
|
||||
static uint32_t ssrc_num;
|
||||
private:
|
||||
SrsRtcServer* rtc_server;
|
||||
SrsRtcServer* server_;
|
||||
public:
|
||||
SrsGoApiRtcPlay(SrsRtcServer* rtc_svr);
|
||||
SrsGoApiRtcPlay(SrsRtcServer* server);
|
||||
virtual ~SrsGoApiRtcPlay();
|
||||
public:
|
||||
virtual srs_error_t serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r);
|
||||
|
|
@ -190,9 +190,9 @@ class SrsGoApiRtcPublish : public ISrsHttpHandler
|
|||
public:
|
||||
static uint32_t ssrc_num;
|
||||
private:
|
||||
SrsRtcServer* rtc_server;
|
||||
SrsRtcServer* server_;
|
||||
public:
|
||||
SrsGoApiRtcPublish(SrsRtcServer* rtc_svr);
|
||||
SrsGoApiRtcPublish(SrsRtcServer* server);
|
||||
virtual ~SrsGoApiRtcPublish();
|
||||
public:
|
||||
virtual srs_error_t serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r);
|
||||
|
|
|
|||
|
|
@ -161,9 +161,9 @@ SrsNtp SrsNtp::to_time_ms(uint64_t ntp)
|
|||
}
|
||||
|
||||
|
||||
SrsDtlsSession::SrsDtlsSession(SrsRtcSession* s)
|
||||
SrsRtcDtls::SrsRtcDtls(SrsRtcSession* s)
|
||||
{
|
||||
rtc_session = s;
|
||||
session_ = s;
|
||||
|
||||
dtls = NULL;
|
||||
bio_in = NULL;
|
||||
|
|
@ -178,7 +178,7 @@ SrsDtlsSession::SrsDtlsSession(SrsRtcSession* s)
|
|||
handshake_done = false;
|
||||
}
|
||||
|
||||
SrsDtlsSession::~SrsDtlsSession()
|
||||
SrsRtcDtls::~SrsRtcDtls()
|
||||
{
|
||||
if (dtls) {
|
||||
// this function will free bio_in and bio_out
|
||||
|
|
@ -195,7 +195,7 @@ SrsDtlsSession::~SrsDtlsSession()
|
|||
}
|
||||
}
|
||||
|
||||
srs_error_t SrsDtlsSession::initialize(SrsRequest* r)
|
||||
srs_error_t SrsRtcDtls::initialize(SrsRequest* r)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
|
|
@ -225,7 +225,7 @@ srs_error_t SrsDtlsSession::initialize(SrsRequest* r)
|
|||
return err;
|
||||
}
|
||||
|
||||
srs_error_t SrsDtlsSession::handshake()
|
||||
srs_error_t SrsRtcDtls::handshake()
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
|
|
@ -257,21 +257,21 @@ srs_error_t SrsDtlsSession::handshake()
|
|||
}
|
||||
|
||||
if (out_bio_len) {
|
||||
if ((err = rtc_session->sendonly_skt->sendto(out_bio_data, out_bio_len, 0)) != srs_success) {
|
||||
if ((err = session_->sendonly_skt->sendto(out_bio_data, out_bio_len, 0)) != srs_success) {
|
||||
return srs_error_wrap(err, "send dtls packet");
|
||||
}
|
||||
}
|
||||
|
||||
if (rtc_session->blackhole && rtc_session->blackhole_addr && rtc_session->blackhole_stfd) {
|
||||
if (session_->blackhole && session_->blackhole_addr && session_->blackhole_stfd) {
|
||||
// Ignore any error for black-hole.
|
||||
void* p = out_bio_data; int len = out_bio_len; SrsRtcSession* s = rtc_session;
|
||||
void* p = out_bio_data; int len = out_bio_len; SrsRtcSession* s = session_;
|
||||
srs_sendto(s->blackhole_stfd, p, len, (sockaddr*)s->blackhole_addr, sizeof(sockaddr_in), SRS_UTIME_NO_TIMEOUT);
|
||||
}
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
srs_error_t SrsDtlsSession::on_dtls(char* data, int nb_data)
|
||||
srs_error_t SrsRtcDtls::on_dtls(char* data, int nb_data)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
if (BIO_reset(bio_in) != 1) {
|
||||
|
|
@ -286,9 +286,9 @@ srs_error_t SrsDtlsSession::on_dtls(char* data, int nb_data)
|
|||
return srs_error_new(ERROR_OpenSslBIOWrite, "BIO_write");
|
||||
}
|
||||
|
||||
if (rtc_session->blackhole && rtc_session->blackhole_addr && rtc_session->blackhole_stfd) {
|
||||
if (session_->blackhole && session_->blackhole_addr && session_->blackhole_stfd) {
|
||||
// Ignore any error for black-hole.
|
||||
void* p = data; int len = nb_data; SrsRtcSession* s = rtc_session;
|
||||
void* p = data; int len = nb_data; SrsRtcSession* s = session_;
|
||||
srs_sendto(s->blackhole_stfd, p, len, (sockaddr*)s->blackhole_addr, sizeof(sockaddr_in), SRS_UTIME_NO_TIMEOUT);
|
||||
}
|
||||
|
||||
|
|
@ -310,20 +310,20 @@ srs_error_t SrsDtlsSession::on_dtls(char* data, int nb_data)
|
|||
return err;
|
||||
}
|
||||
|
||||
srs_error_t SrsDtlsSession::on_dtls_handshake_done()
|
||||
srs_error_t SrsRtcDtls::on_dtls_handshake_done()
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
srs_trace("rtc session=%s, DTLS handshake done.", rtc_session->id().c_str());
|
||||
srs_trace("rtc session=%s, DTLS handshake done.", session_->id().c_str());
|
||||
|
||||
handshake_done = true;
|
||||
if ((err = srtp_initialize()) != srs_success) {
|
||||
return srs_error_wrap(err, "srtp init failed");
|
||||
}
|
||||
|
||||
return rtc_session->on_connection_established();
|
||||
return session_->on_connection_established();
|
||||
}
|
||||
|
||||
srs_error_t SrsDtlsSession::on_dtls_application_data(const char* buf, const int nb_buf)
|
||||
srs_error_t SrsRtcDtls::on_dtls_application_data(const char* buf, const int nb_buf)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
|
|
@ -332,7 +332,7 @@ srs_error_t SrsDtlsSession::on_dtls_application_data(const char* buf, const int
|
|||
return err;
|
||||
}
|
||||
|
||||
srs_error_t SrsDtlsSession::srtp_initialize()
|
||||
srs_error_t SrsRtcDtls::srtp_initialize()
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
|
|
@ -366,7 +366,7 @@ srs_error_t SrsDtlsSession::srtp_initialize()
|
|||
return err;
|
||||
}
|
||||
|
||||
srs_error_t SrsDtlsSession::srtp_send_init()
|
||||
srs_error_t SrsRtcDtls::srtp_send_init()
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
|
|
@ -401,7 +401,7 @@ srs_error_t SrsDtlsSession::srtp_send_init()
|
|||
return err;
|
||||
}
|
||||
|
||||
srs_error_t SrsDtlsSession::srtp_recv_init()
|
||||
srs_error_t SrsRtcDtls::srtp_recv_init()
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
|
|
@ -433,7 +433,7 @@ srs_error_t SrsDtlsSession::srtp_recv_init()
|
|||
return err;
|
||||
}
|
||||
|
||||
srs_error_t SrsDtlsSession::protect_rtp(char* out_buf, const char* in_buf, int& nb_out_buf)
|
||||
srs_error_t SrsRtcDtls::protect_rtp(char* out_buf, const char* in_buf, int& nb_out_buf)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
|
|
@ -450,7 +450,7 @@ srs_error_t SrsDtlsSession::protect_rtp(char* out_buf, const char* in_buf, int&
|
|||
}
|
||||
|
||||
// TODO: FIXME: Merge with protect_rtp.
|
||||
srs_error_t SrsDtlsSession::protect_rtp2(void* rtp_hdr, int* len_ptr)
|
||||
srs_error_t SrsRtcDtls::protect_rtp2(void* rtp_hdr, int* len_ptr)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
|
|
@ -465,7 +465,7 @@ srs_error_t SrsDtlsSession::protect_rtp2(void* rtp_hdr, int* len_ptr)
|
|||
return err;
|
||||
}
|
||||
|
||||
srs_error_t SrsDtlsSession::unprotect_rtp(char* out_buf, const char* in_buf, int& nb_out_buf)
|
||||
srs_error_t SrsRtcDtls::unprotect_rtp(char* out_buf, const char* in_buf, int& nb_out_buf)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
|
|
@ -481,7 +481,7 @@ srs_error_t SrsDtlsSession::unprotect_rtp(char* out_buf, const char* in_buf, int
|
|||
return srs_error_new(ERROR_RTC_SRTP_UNPROTECT, "rtp unprotect failed");
|
||||
}
|
||||
|
||||
srs_error_t SrsDtlsSession::protect_rtcp(char* out_buf, const char* in_buf, int& nb_out_buf)
|
||||
srs_error_t SrsRtcDtls::protect_rtcp(char* out_buf, const char* in_buf, int& nb_out_buf)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
|
|
@ -497,7 +497,7 @@ srs_error_t SrsDtlsSession::protect_rtcp(char* out_buf, const char* in_buf, int&
|
|||
return srs_error_new(ERROR_RTC_SRTP_PROTECT, "rtcp protect failed");
|
||||
}
|
||||
|
||||
srs_error_t SrsDtlsSession::unprotect_rtcp(char* out_buf, const char* in_buf, int& nb_out_buf)
|
||||
srs_error_t SrsRtcDtls::unprotect_rtcp(char* out_buf, const char* in_buf, int& nb_out_buf)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
|
|
@ -513,7 +513,7 @@ srs_error_t SrsDtlsSession::unprotect_rtcp(char* out_buf, const char* in_buf, in
|
|||
return srs_error_new(ERROR_RTC_SRTP_UNPROTECT, "rtcp unprotect failed");
|
||||
}
|
||||
|
||||
SrsRtcPackets::SrsRtcPackets(int nn_cache_max)
|
||||
SrsRtcOutgoingPackets::SrsRtcOutgoingPackets(int nn_cache_max)
|
||||
{
|
||||
#if defined(SRS_DEBUG)
|
||||
debug_id = 0;
|
||||
|
|
@ -535,13 +535,13 @@ SrsRtcPackets::SrsRtcPackets(int nn_cache_max)
|
|||
cache = new SrsRtpPacket2[nn_cache];
|
||||
}
|
||||
|
||||
SrsRtcPackets::~SrsRtcPackets()
|
||||
SrsRtcOutgoingPackets::~SrsRtcOutgoingPackets()
|
||||
{
|
||||
srs_freepa(cache);
|
||||
nn_cache = 0;
|
||||
}
|
||||
|
||||
void SrsRtcPackets::reset(bool gso, bool merge_nalus)
|
||||
void SrsRtcOutgoingPackets::reset(bool gso, bool merge_nalus)
|
||||
{
|
||||
for (int i = 0; i < cursor; i++) {
|
||||
SrsRtpPacket2* packet = cache + i;
|
||||
|
|
@ -565,7 +565,7 @@ void SrsRtcPackets::reset(bool gso, bool merge_nalus)
|
|||
cursor = 0;
|
||||
}
|
||||
|
||||
SrsRtpPacket2* SrsRtcPackets::fetch()
|
||||
SrsRtpPacket2* SrsRtcOutgoingPackets::fetch()
|
||||
{
|
||||
if (cursor >= nn_cache) {
|
||||
return NULL;
|
||||
|
|
@ -573,23 +573,23 @@ SrsRtpPacket2* SrsRtcPackets::fetch()
|
|||
return cache + (cursor++);
|
||||
}
|
||||
|
||||
SrsRtpPacket2* SrsRtcPackets::back()
|
||||
SrsRtpPacket2* SrsRtcOutgoingPackets::back()
|
||||
{
|
||||
srs_assert(cursor > 0);
|
||||
return cache + cursor - 1;
|
||||
}
|
||||
|
||||
int SrsRtcPackets::size()
|
||||
int SrsRtcOutgoingPackets::size()
|
||||
{
|
||||
return cursor;
|
||||
}
|
||||
|
||||
int SrsRtcPackets::capacity()
|
||||
int SrsRtcOutgoingPackets::capacity()
|
||||
{
|
||||
return nn_cache;
|
||||
}
|
||||
|
||||
SrsRtpPacket2* SrsRtcPackets::at(int index)
|
||||
SrsRtpPacket2* SrsRtcOutgoingPackets::at(int index)
|
||||
{
|
||||
srs_assert(index < cursor);
|
||||
return cache + index;
|
||||
|
|
@ -600,7 +600,7 @@ SrsRtcPlayer::SrsRtcPlayer(SrsRtcSession* s, int parent_cid)
|
|||
_parent_cid = parent_cid;
|
||||
trd = new SrsDummyCoroutine();
|
||||
|
||||
rtc_session = s;
|
||||
session_ = s;
|
||||
|
||||
gso = false;
|
||||
merge_nalus = false;
|
||||
|
|
@ -657,7 +657,7 @@ srs_error_t SrsRtcPlayer::on_reload_rtc_server()
|
|||
|
||||
srs_error_t SrsRtcPlayer::on_reload_vhost_play(string vhost)
|
||||
{
|
||||
SrsRequest* req = rtc_session->req;
|
||||
SrsRequest* req = session_->req;
|
||||
|
||||
if (req->vhost != vhost) {
|
||||
return srs_success;
|
||||
|
|
@ -711,7 +711,7 @@ srs_error_t SrsRtcPlayer::cycle()
|
|||
srs_error_t err = srs_success;
|
||||
|
||||
SrsSource* source = NULL;
|
||||
SrsRequest* req = rtc_session->req;
|
||||
SrsRequest* req = session_->req;
|
||||
|
||||
// TODO: FIXME: Should refactor it, directly use http server as handler.
|
||||
ISrsSourceHandler* handler = _srs_hybrid->srs()->instance();
|
||||
|
|
@ -742,7 +742,7 @@ srs_error_t SrsRtcPlayer::cycle()
|
|||
mw_msgs = _srs_config->get_mw_msgs(req->vhost, realtime, true);
|
||||
|
||||
// We merged write more messages, so we need larger queue.
|
||||
ISrsUdpSender* sender = rtc_session->sendonly_skt->sender();
|
||||
ISrsUdpSender* sender = session_->sendonly_skt->sender();
|
||||
if (mw_msgs > 2) {
|
||||
sender->set_extra_ratio(150);
|
||||
} else if (mw_msgs > 0) {
|
||||
|
|
@ -750,15 +750,15 @@ srs_error_t SrsRtcPlayer::cycle()
|
|||
}
|
||||
|
||||
srs_trace("RTC source url=%s, source_id=[%d][%d], encrypt=%d, realtime=%d, mw_sleep=%dms, mw_msgs=%d", req->get_stream_url().c_str(),
|
||||
::getpid(), source->source_id(), rtc_session->encrypt, realtime, srsu2msi(mw_sleep), mw_msgs);
|
||||
::getpid(), source->source_id(), session_->encrypt, realtime, srsu2msi(mw_sleep), mw_msgs);
|
||||
|
||||
SrsMessageArray msgs(SRS_PERF_MW_MSGS);
|
||||
SrsRtcPackets pkts(SRS_PERF_RTC_RTP_PACKETS);
|
||||
SrsRtcOutgoingPackets pkts(SRS_PERF_RTC_RTP_PACKETS);
|
||||
|
||||
SrsPithyPrint* pprint = SrsPithyPrint::create_rtc_play();
|
||||
SrsAutoFree(SrsPithyPrint, pprint);
|
||||
|
||||
srs_trace("rtc session=%s, start play", rtc_session->id().c_str());
|
||||
srs_trace("rtc session=%s, start play", session_->id().c_str());
|
||||
bool stat_enabled = _srs_config->get_rtc_server_perf_stat();
|
||||
SrsStatistic* stat = SrsStatistic::instance();
|
||||
|
||||
|
|
@ -834,12 +834,12 @@ srs_error_t SrsRtcPlayer::cycle()
|
|||
}
|
||||
|
||||
srs_error_t SrsRtcPlayer::send_messages(
|
||||
SrsSource* source, SrsSharedPtrMessage** msgs, int nb_msgs, SrsRtcPackets& packets
|
||||
SrsSource* source, SrsSharedPtrMessage** msgs, int nb_msgs, SrsRtcOutgoingPackets& packets
|
||||
) {
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
// If DTLS is not OK, drop all messages.
|
||||
if (!rtc_session->dtls_session) {
|
||||
if (!session_->dtls_) {
|
||||
return err;
|
||||
}
|
||||
|
||||
|
|
@ -867,11 +867,11 @@ srs_error_t SrsRtcPlayer::send_messages(
|
|||
}
|
||||
|
||||
srs_error_t SrsRtcPlayer::messages_to_packets(
|
||||
SrsSource* source, SrsSharedPtrMessage** msgs, int nb_msgs, SrsRtcPackets& packets
|
||||
SrsSource* source, SrsSharedPtrMessage** msgs, int nb_msgs, SrsRtcOutgoingPackets& packets
|
||||
) {
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
ISrsUdpSender* sender = rtc_session->sendonly_skt->sender();
|
||||
ISrsUdpSender* sender = session_->sendonly_skt->sender();
|
||||
|
||||
for (int i = 0; i < nb_msgs; i++) {
|
||||
SrsSharedPtrMessage* msg = msgs[i];
|
||||
|
|
@ -951,13 +951,13 @@ srs_error_t SrsRtcPlayer::messages_to_packets(
|
|||
return err;
|
||||
}
|
||||
|
||||
srs_error_t SrsRtcPlayer::send_packets(SrsRtcPackets& packets)
|
||||
srs_error_t SrsRtcPlayer::send_packets(SrsRtcOutgoingPackets& packets)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
// Cache the encrypt flag and sender.
|
||||
bool encrypt = rtc_session->encrypt;
|
||||
ISrsUdpSender* sender = rtc_session->sendonly_skt->sender();
|
||||
bool encrypt = session_->encrypt;
|
||||
ISrsUdpSender* sender = session_->sendonly_skt->sender();
|
||||
|
||||
int nn_packets = packets.size();
|
||||
for (int i = 0; i < nn_packets; i++) {
|
||||
|
|
@ -991,7 +991,7 @@ srs_error_t SrsRtcPlayer::send_packets(SrsRtcPackets& packets)
|
|||
// Whether encrypt the RTP bytes.
|
||||
if (encrypt) {
|
||||
int nn_encrypt = (int)iov->iov_len;
|
||||
if ((err = rtc_session->dtls_session->protect_rtp2(iov->iov_base, &nn_encrypt)) != srs_success) {
|
||||
if ((err = session_->dtls_->protect_rtp2(iov->iov_base, &nn_encrypt)) != srs_success) {
|
||||
return srs_error_wrap(err, "srtp protect");
|
||||
}
|
||||
iov->iov_len = (size_t)nn_encrypt;
|
||||
|
|
@ -1000,8 +1000,8 @@ srs_error_t SrsRtcPlayer::send_packets(SrsRtcPackets& packets)
|
|||
packets.nn_rtp_bytes += (int)iov->iov_len;
|
||||
|
||||
// Set the address and control information.
|
||||
sockaddr_in* addr = (sockaddr_in*)rtc_session->sendonly_skt->peer_addr();
|
||||
socklen_t addrlen = (socklen_t)rtc_session->sendonly_skt->peer_addrlen();
|
||||
sockaddr_in* addr = (sockaddr_in*)session_->sendonly_skt->peer_addr();
|
||||
socklen_t addrlen = (socklen_t)session_->sendonly_skt->peer_addrlen();
|
||||
|
||||
mhdr->msg_hdr.msg_name = (sockaddr_in*)addr;
|
||||
mhdr->msg_hdr.msg_namelen = (socklen_t)addrlen;
|
||||
|
|
@ -1019,13 +1019,13 @@ srs_error_t SrsRtcPlayer::send_packets(SrsRtcPackets& packets)
|
|||
}
|
||||
|
||||
// TODO: FIXME: We can gather and pad audios, because they have similar size.
|
||||
srs_error_t SrsRtcPlayer::send_packets_gso(SrsRtcPackets& packets)
|
||||
srs_error_t SrsRtcPlayer::send_packets_gso(SrsRtcOutgoingPackets& packets)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
// Cache the encrypt flag and sender.
|
||||
bool encrypt = rtc_session->encrypt;
|
||||
ISrsUdpSender* sender = rtc_session->sendonly_skt->sender();
|
||||
bool encrypt = session_->encrypt;
|
||||
ISrsUdpSender* sender = session_->sendonly_skt->sender();
|
||||
|
||||
// Previous handler, if has the same size, we can use GSO.
|
||||
srs_mmsghdr* gso_mhdr = NULL; int gso_size = 0; int gso_encrypt = 0; int gso_cursor = 0;
|
||||
|
|
@ -1138,7 +1138,7 @@ srs_error_t SrsRtcPlayer::send_packets_gso(SrsRtcPackets& packets)
|
|||
// Whether encrypt the RTP bytes.
|
||||
if (encrypt) {
|
||||
int nn_encrypt = (int)iov->iov_len;
|
||||
if ((err = rtc_session->dtls_session->protect_rtp2(iov->iov_base, &nn_encrypt)) != srs_success) {
|
||||
if ((err = session_->dtls_->protect_rtp2(iov->iov_base, &nn_encrypt)) != srs_success) {
|
||||
return srs_error_wrap(err, "srtp protect");
|
||||
}
|
||||
iov->iov_len = (size_t)nn_encrypt;
|
||||
|
|
@ -1178,8 +1178,8 @@ srs_error_t SrsRtcPlayer::send_packets_gso(SrsRtcPackets& packets)
|
|||
|
||||
if (do_send) {
|
||||
// Set the address and control information.
|
||||
sockaddr_in* addr = (sockaddr_in*)rtc_session->sendonly_skt->peer_addr();
|
||||
socklen_t addrlen = (socklen_t)rtc_session->sendonly_skt->peer_addrlen();
|
||||
sockaddr_in* addr = (sockaddr_in*)session_->sendonly_skt->peer_addr();
|
||||
socklen_t addrlen = (socklen_t)session_->sendonly_skt->peer_addrlen();
|
||||
|
||||
mhdr->msg_hdr.msg_name = (sockaddr_in*)addr;
|
||||
mhdr->msg_hdr.msg_namelen = (socklen_t)addrlen;
|
||||
|
|
@ -1222,7 +1222,7 @@ srs_error_t SrsRtcPlayer::send_packets_gso(SrsRtcPackets& packets)
|
|||
return err;
|
||||
}
|
||||
|
||||
srs_error_t SrsRtcPlayer::package_nalus(SrsSharedPtrMessage* msg, SrsRtcPackets& packets)
|
||||
srs_error_t SrsRtcPlayer::package_nalus(SrsSharedPtrMessage* msg, SrsRtcOutgoingPackets& packets)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
|
|
@ -1312,7 +1312,7 @@ srs_error_t SrsRtcPlayer::package_nalus(SrsSharedPtrMessage* msg, SrsRtcPackets&
|
|||
return err;
|
||||
}
|
||||
|
||||
srs_error_t SrsRtcPlayer::package_opus(SrsSample* sample, SrsRtcPackets& packets, int nn_max_payload)
|
||||
srs_error_t SrsRtcPlayer::package_opus(SrsSample* sample, SrsRtcOutgoingPackets& packets, int nn_max_payload)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
|
|
@ -1348,7 +1348,7 @@ srs_error_t SrsRtcPlayer::package_opus(SrsSample* sample, SrsRtcPackets& packets
|
|||
return err;
|
||||
}
|
||||
|
||||
srs_error_t SrsRtcPlayer::package_fu_a(SrsSharedPtrMessage* msg, SrsSample* sample, int fu_payload_size, SrsRtcPackets& packets)
|
||||
srs_error_t SrsRtcPlayer::package_fu_a(SrsSharedPtrMessage* msg, SrsSample* sample, int fu_payload_size, SrsRtcOutgoingPackets& packets)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
|
|
@ -1389,7 +1389,7 @@ srs_error_t SrsRtcPlayer::package_fu_a(SrsSharedPtrMessage* msg, SrsSample* samp
|
|||
}
|
||||
|
||||
// Single NAL Unit Packet @see https://tools.ietf.org/html/rfc6184#section-5.6
|
||||
srs_error_t SrsRtcPlayer::package_single_nalu(SrsSharedPtrMessage* msg, SrsSample* sample, SrsRtcPackets& packets)
|
||||
srs_error_t SrsRtcPlayer::package_single_nalu(SrsSharedPtrMessage* msg, SrsSample* sample, SrsRtcOutgoingPackets& packets)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
|
|
@ -1409,7 +1409,7 @@ srs_error_t SrsRtcPlayer::package_single_nalu(SrsSharedPtrMessage* msg, SrsSampl
|
|||
return err;
|
||||
}
|
||||
|
||||
srs_error_t SrsRtcPlayer::package_stap_a(SrsSource* source, SrsSharedPtrMessage* msg, SrsRtcPackets& packets)
|
||||
srs_error_t SrsRtcPlayer::package_stap_a(SrsSource* source, SrsSharedPtrMessage* msg, SrsRtcOutgoingPackets& packets)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
|
|
@ -1468,7 +1468,7 @@ SrsRtcPublisher::SrsRtcPublisher(SrsRtcSession* session)
|
|||
{
|
||||
report_timer = new SrsHourGlass(this, 200 * SRS_UTIME_MILLISECONDS);
|
||||
|
||||
rtc_session = session;
|
||||
session_ = session;
|
||||
video_queue_ = new SrsRtpVideoQueue(1000);
|
||||
video_nack_ = new SrsRtpNackForReceiver(video_queue_, 1000 * 2 / 3);
|
||||
audio_queue_ = new SrsRtpAudioQueue(100);
|
||||
|
|
@ -1683,7 +1683,7 @@ srs_error_t SrsRtcPublisher::on_rtcp_xr(char* buf, int nb_buf)
|
|||
void SrsRtcPublisher::check_send_nacks(SrsRtpNackForReceiver* nack, uint32_t ssrc)
|
||||
{
|
||||
// If DTLS is not OK, drop all messages.
|
||||
if (!rtc_session->dtls_session) {
|
||||
if (!session_->dtls_) {
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -1713,9 +1713,9 @@ void SrsRtcPublisher::check_send_nacks(SrsRtpNackForReceiver* nack, uint32_t ssr
|
|||
int nb_protected_buf = stream.pos();
|
||||
|
||||
// FIXME: Merge nack rtcp into one packets.
|
||||
if (rtc_session->dtls_session->protect_rtcp(protected_buf, stream.data(), nb_protected_buf) == srs_success) {
|
||||
if (session_->dtls_->protect_rtcp(protected_buf, stream.data(), nb_protected_buf) == srs_success) {
|
||||
// TODO: FIXME: Check error.
|
||||
rtc_session->sendonly_skt->sendto(protected_buf, nb_protected_buf, 0);
|
||||
session_->sendonly_skt->sendto(protected_buf, nb_protected_buf, 0);
|
||||
}
|
||||
|
||||
++iter;
|
||||
|
|
@ -1727,7 +1727,7 @@ srs_error_t SrsRtcPublisher::send_rtcp_rr(uint32_t ssrc, SrsRtpQueue* rtp_queue)
|
|||
srs_error_t err = srs_success;
|
||||
|
||||
// If DTLS is not OK, drop all messages.
|
||||
if (!rtc_session->dtls_session) {
|
||||
if (!session_->dtls_) {
|
||||
return err;
|
||||
}
|
||||
|
||||
|
|
@ -1768,12 +1768,12 @@ srs_error_t SrsRtcPublisher::send_rtcp_rr(uint32_t ssrc, SrsRtpQueue* rtp_queue)
|
|||
|
||||
char protected_buf[kRtpPacketSize];
|
||||
int nb_protected_buf = stream.pos();
|
||||
if ((err = rtc_session->dtls_session->protect_rtcp(protected_buf, stream.data(), nb_protected_buf)) != srs_success) {
|
||||
if ((err = session_->dtls_->protect_rtcp(protected_buf, stream.data(), nb_protected_buf)) != srs_success) {
|
||||
return srs_error_wrap(err, "protect rtcp rr");
|
||||
}
|
||||
|
||||
// TDOO: FIXME: Check error.
|
||||
rtc_session->sendonly_skt->sendto(protected_buf, nb_protected_buf, 0);
|
||||
session_->sendonly_skt->sendto(protected_buf, nb_protected_buf, 0);
|
||||
return err;
|
||||
}
|
||||
|
||||
|
|
@ -1782,7 +1782,7 @@ srs_error_t SrsRtcPublisher::send_rtcp_xr_rrtr(uint32_t ssrc)
|
|||
srs_error_t err = srs_success;
|
||||
|
||||
// If DTLS is not OK, drop all messages.
|
||||
if (!rtc_session->dtls_session) {
|
||||
if (!session_->dtls_) {
|
||||
return err;
|
||||
}
|
||||
|
||||
|
|
@ -1828,12 +1828,12 @@ srs_error_t SrsRtcPublisher::send_rtcp_xr_rrtr(uint32_t ssrc)
|
|||
|
||||
char protected_buf[kRtpPacketSize];
|
||||
int nb_protected_buf = stream.pos();
|
||||
if ((err = rtc_session->dtls_session->protect_rtcp(protected_buf, stream.data(), nb_protected_buf)) != srs_success) {
|
||||
if ((err = session_->dtls_->protect_rtcp(protected_buf, stream.data(), nb_protected_buf)) != srs_success) {
|
||||
return srs_error_wrap(err, "protect rtcp xr");
|
||||
}
|
||||
|
||||
// TDOO: FIXME: Check error.
|
||||
rtc_session->sendonly_skt->sendto(protected_buf, nb_protected_buf, 0);
|
||||
session_->sendonly_skt->sendto(protected_buf, nb_protected_buf, 0);
|
||||
|
||||
return err;
|
||||
}
|
||||
|
|
@ -1843,7 +1843,7 @@ srs_error_t SrsRtcPublisher::send_rtcp_fb_pli(uint32_t ssrc)
|
|||
srs_error_t err = srs_success;
|
||||
|
||||
// If DTLS is not OK, drop all messages.
|
||||
if (!rtc_session->dtls_session) {
|
||||
if (!session_->dtls_) {
|
||||
return err;
|
||||
}
|
||||
|
||||
|
|
@ -1857,20 +1857,20 @@ srs_error_t SrsRtcPublisher::send_rtcp_fb_pli(uint32_t ssrc)
|
|||
|
||||
srs_trace("RTC PLI ssrc=%u", ssrc);
|
||||
|
||||
if (rtc_session->blackhole && rtc_session->blackhole_addr && rtc_session->blackhole_stfd) {
|
||||
if (session_->blackhole && session_->blackhole_addr && session_->blackhole_stfd) {
|
||||
// Ignore any error for black-hole.
|
||||
void* p = stream.data(); int len = stream.pos(); SrsRtcSession* s = rtc_session;
|
||||
void* p = stream.data(); int len = stream.pos(); SrsRtcSession* s = session_;
|
||||
srs_sendto(s->blackhole_stfd, p, len, (sockaddr*)s->blackhole_addr, sizeof(sockaddr_in), SRS_UTIME_NO_TIMEOUT);
|
||||
}
|
||||
|
||||
char protected_buf[kRtpPacketSize];
|
||||
int nb_protected_buf = stream.pos();
|
||||
if ((err = rtc_session->dtls_session->protect_rtcp(protected_buf, stream.data(), nb_protected_buf)) != srs_success) {
|
||||
if ((err = session_->dtls_->protect_rtcp(protected_buf, stream.data(), nb_protected_buf)) != srs_success) {
|
||||
return srs_error_wrap(err, "protect rtcp psfb pli");
|
||||
}
|
||||
|
||||
// TDOO: FIXME: Check error.
|
||||
rtc_session->sendonly_skt->sendto(protected_buf, nb_protected_buf, 0);
|
||||
session_->sendonly_skt->sendto(protected_buf, nb_protected_buf, 0);
|
||||
|
||||
return err;
|
||||
}
|
||||
|
|
@ -2224,7 +2224,7 @@ srs_error_t SrsRtcPublisher::do_collect_video_frame(std::vector<SrsRtpPacket2*>&
|
|||
void SrsRtcPublisher::request_keyframe()
|
||||
{
|
||||
int scid = _srs_context->get_id();
|
||||
int pcid = rtc_session->context_id();
|
||||
int pcid = session_->context_id();
|
||||
srs_trace("RTC play=[%d][%d] request keyframe from publish=[%d][%d]", ::getpid(), scid, ::getpid(), pcid);
|
||||
|
||||
video_queue_->request_keyframe();
|
||||
|
|
@ -2251,11 +2251,11 @@ SrsRtcSession::SrsRtcSession(SrsRtcServer* s)
|
|||
encrypt = true;
|
||||
|
||||
source_ = NULL;
|
||||
publisher = NULL;
|
||||
player = NULL;
|
||||
publisher_ = NULL;
|
||||
player_ = NULL;
|
||||
sendonly_skt = NULL;
|
||||
rtc_server = s;
|
||||
dtls_session = new SrsDtlsSession(this);
|
||||
server_ = s;
|
||||
dtls_ = new SrsRtcDtls(this);
|
||||
|
||||
session_state = INIT;
|
||||
last_stun_time = 0;
|
||||
|
|
@ -2268,9 +2268,9 @@ SrsRtcSession::SrsRtcSession(SrsRtcServer* s)
|
|||
|
||||
SrsRtcSession::~SrsRtcSession()
|
||||
{
|
||||
srs_freep(player);
|
||||
srs_freep(publisher);
|
||||
srs_freep(dtls_session);
|
||||
srs_freep(player_);
|
||||
srs_freep(publisher_);
|
||||
srs_freep(dtls_);
|
||||
srs_freep(req);
|
||||
srs_close_stfd(blackhole_stfd);
|
||||
srs_freep(blackhole_addr);
|
||||
|
|
@ -2348,7 +2348,7 @@ srs_error_t SrsRtcSession::initialize(SrsSource* source, SrsRequest* r, bool is_
|
|||
is_publisher_ = is_publisher;
|
||||
source_ = source;
|
||||
|
||||
if ((err = dtls_session->initialize(req)) != srs_success) {
|
||||
if ((err = dtls_->initialize(req)) != srs_success) {
|
||||
return srs_error_wrap(err, "init");
|
||||
}
|
||||
|
||||
|
|
@ -2415,20 +2415,20 @@ srs_error_t SrsRtcSession::on_stun(SrsUdpMuxSocket* skt, SrsStunPacket* r)
|
|||
|
||||
srs_error_t SrsRtcSession::on_dtls(char* data, int nb_data)
|
||||
{
|
||||
return dtls_session->on_dtls(data, nb_data);
|
||||
return dtls_->on_dtls(data, nb_data);
|
||||
}
|
||||
|
||||
srs_error_t SrsRtcSession::on_rtcp(char* data, int nb_data)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
if (dtls_session == NULL) {
|
||||
if (dtls_ == NULL) {
|
||||
return srs_error_new(ERROR_RTC_RTCP, "recv unexpect rtp packet before dtls done");
|
||||
}
|
||||
|
||||
char unprotected_buf[kRtpPacketSize];
|
||||
int nb_unprotected_buf = nb_data;
|
||||
if ((err = dtls_session->unprotect_rtcp(unprotected_buf, data, nb_unprotected_buf)) != srs_success) {
|
||||
if ((err = dtls_->unprotect_rtcp(unprotected_buf, data, nb_unprotected_buf)) != srs_success) {
|
||||
return srs_error_wrap(err, "rtcp unprotect failed");
|
||||
}
|
||||
|
||||
|
|
@ -2503,17 +2503,17 @@ srs_error_t SrsRtcSession::on_rtp(char* data, int nb_data)
|
|||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
if (publisher == NULL) {
|
||||
if (publisher_ == NULL) {
|
||||
return srs_error_new(ERROR_RTC_RTCP, "rtc publisher null");
|
||||
}
|
||||
|
||||
if (dtls_session == NULL) {
|
||||
if (dtls_ == NULL) {
|
||||
return srs_error_new(ERROR_RTC_RTCP, "recv unexpect rtp packet before dtls done");
|
||||
}
|
||||
|
||||
int nb_unprotected_buf = nb_data;
|
||||
char* unprotected_buf = new char[kRtpPacketSize];
|
||||
if ((err = dtls_session->unprotect_rtp(unprotected_buf, data, nb_unprotected_buf)) != srs_success) {
|
||||
if ((err = dtls_->unprotect_rtp(unprotected_buf, data, nb_unprotected_buf)) != srs_success) {
|
||||
srs_freepa(unprotected_buf);
|
||||
return srs_error_wrap(err, "rtp unprotect failed");
|
||||
}
|
||||
|
|
@ -2524,7 +2524,7 @@ srs_error_t SrsRtcSession::on_rtp(char* data, int nb_data)
|
|||
srs_sendto(blackhole_stfd, p, len, (sockaddr*)blackhole_addr, sizeof(sockaddr_in), SRS_UTIME_NO_TIMEOUT);
|
||||
}
|
||||
|
||||
return publisher->on_rtp(unprotected_buf, nb_unprotected_buf);
|
||||
return publisher_->on_rtp(unprotected_buf, nb_unprotected_buf);
|
||||
}
|
||||
|
||||
srs_error_t SrsRtcSession::on_connection_established()
|
||||
|
|
@ -2551,8 +2551,8 @@ srs_error_t SrsRtcSession::start_play()
|
|||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
srs_freep(player);
|
||||
player = new SrsRtcPlayer(this, _srs_context->get_id());
|
||||
srs_freep(player_);
|
||||
player_ = new SrsRtcPlayer(this, _srs_context->get_id());
|
||||
|
||||
uint32_t video_ssrc = 0;
|
||||
uint32_t audio_ssrc = 0;
|
||||
|
|
@ -2569,11 +2569,11 @@ srs_error_t SrsRtcSession::start_play()
|
|||
}
|
||||
}
|
||||
|
||||
if ((err = player->initialize(video_ssrc, audio_ssrc, video_payload_type, audio_payload_type)) != srs_success) {
|
||||
if ((err = player_->initialize(video_ssrc, audio_ssrc, video_payload_type, audio_payload_type)) != srs_success) {
|
||||
return srs_error_wrap(err, "SrsRtcPlayer init");
|
||||
}
|
||||
|
||||
if ((err = player->start()) != srs_success) {
|
||||
if ((err = player_->start()) != srs_success) {
|
||||
return srs_error_wrap(err, "start SrsRtcPlayer");
|
||||
}
|
||||
|
||||
|
|
@ -2584,10 +2584,10 @@ srs_error_t SrsRtcSession::start_publish()
|
|||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
srs_freep(publisher);
|
||||
publisher = new SrsRtcPublisher(this);
|
||||
srs_freep(publisher_);
|
||||
publisher_ = new SrsRtcPublisher(this);
|
||||
// Request PLI for exists players?
|
||||
//publisher->request_keyframe();
|
||||
//publisher_->request_keyframe();
|
||||
|
||||
uint32_t video_ssrc = 0;
|
||||
uint32_t audio_ssrc = 0;
|
||||
|
|
@ -2605,7 +2605,7 @@ srs_error_t SrsRtcSession::start_publish()
|
|||
}
|
||||
|
||||
// FIXME: err process.
|
||||
if ((err = publisher->initialize(video_ssrc, audio_ssrc, req)) != srs_success) {
|
||||
if ((err = publisher_->initialize(video_ssrc, audio_ssrc, req)) != srs_success) {
|
||||
return srs_error_wrap(err, "rtc publisher init");
|
||||
}
|
||||
|
||||
|
|
@ -2671,7 +2671,7 @@ srs_error_t SrsRtcSession::on_binding_request(SrsStunPacket* r)
|
|||
set_session_state(DOING_DTLS_HANDSHAKE);
|
||||
|
||||
peer_id = sendonly_skt->get_peer_id();
|
||||
rtc_server->insert_into_id_sessions(peer_id, this);
|
||||
server_->insert_into_id_sessions(peer_id, this);
|
||||
|
||||
set_session_state(DOING_DTLS_HANDSHAKE);
|
||||
srs_trace("rtc session=%s, STUN done, waitting DTLS handshake.", id().c_str());
|
||||
|
|
@ -2690,7 +2690,7 @@ srs_error_t SrsRtcSession::on_rtcp_feedback(char* buf, int nb_buf)
|
|||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
if (!dtls_session) {
|
||||
if (!dtls_) {
|
||||
return err;
|
||||
}
|
||||
|
||||
|
|
@ -2764,7 +2764,7 @@ srs_error_t SrsRtcSession::on_rtcp_feedback(char* buf, int nb_buf)
|
|||
|
||||
// TODO: FIXME: Check error.
|
||||
pkt->encode(&buf);
|
||||
dtls_session->protect_rtp(protected_buf, protected_buf, nb_protected_buf);
|
||||
dtls_->protect_rtp(protected_buf, protected_buf, nb_protected_buf);
|
||||
sendonly_skt->sendto(protected_buf, nb_protected_buf, 0);
|
||||
}
|
||||
|
||||
|
|
@ -2823,20 +2823,20 @@ srs_error_t SrsRtcSession::on_rtcp_ps_feedback(char* buf, int nb_buf)
|
|||
|
||||
srs_error_t SrsRtcSession::on_rtcp_xr(char* buf, int nb_buf)
|
||||
{
|
||||
if (publisher == NULL) {
|
||||
if (publisher_ == NULL) {
|
||||
return srs_error_new(ERROR_RTC_RTCP, "rtc publisher null");
|
||||
}
|
||||
|
||||
return publisher->on_rtcp_xr(buf, nb_buf);
|
||||
return publisher_->on_rtcp_xr(buf, nb_buf);
|
||||
}
|
||||
|
||||
srs_error_t SrsRtcSession::on_rtcp_sender_report(char* buf, int nb_buf)
|
||||
{
|
||||
if (publisher == NULL) {
|
||||
if (publisher_ == NULL) {
|
||||
return srs_error_new(ERROR_RTC_RTCP, "rtc publisher null");
|
||||
}
|
||||
|
||||
return publisher->on_rtcp_sender_report(buf, nb_buf);
|
||||
return publisher_->on_rtcp_sender_report(buf, nb_buf);
|
||||
}
|
||||
|
||||
srs_error_t SrsRtcSession::on_rtcp_receiver_report(char* buf, int nb_buf)
|
||||
|
|
@ -3275,12 +3275,12 @@ srs_error_t SrsRtcServer::on_udp_packet(SrsUdpMuxSocket* skt)
|
|||
srs_error_t err = srs_success;
|
||||
|
||||
char* data = skt->data(); int size = skt->size();
|
||||
SrsRtcSession* rtc_session = find_rtc_session_by_peer_id(skt->get_peer_id());
|
||||
SrsRtcSession* session = find_session_by_peer_id(skt->get_peer_id());
|
||||
|
||||
if (rtc_session) {
|
||||
if (session) {
|
||||
// Now, we got the RTC session to handle the packet, switch to its context
|
||||
// to make all logs write to the "correct" pid+cid.
|
||||
rtc_session->switch_to_context();
|
||||
session->switch_to_context();
|
||||
}
|
||||
|
||||
// For STUN, the peer address may change.
|
||||
|
|
@ -3292,32 +3292,32 @@ srs_error_t SrsRtcServer::on_udp_packet(SrsUdpMuxSocket* skt)
|
|||
srs_verbose("recv stun packet from %s, use-candidate=%d, ice-controlled=%d, ice-controlling=%d",
|
||||
skt->get_peer_id().c_str(), sr.get_use_candidate(), sr.get_ice_controlled(), sr.get_ice_controlling());
|
||||
|
||||
if (!rtc_session) {
|
||||
rtc_session = find_rtc_session_by_username(sr.get_username());
|
||||
if (rtc_session) {
|
||||
rtc_session->switch_to_context();
|
||||
if (!session) {
|
||||
session = find_session_by_username(sr.get_username());
|
||||
if (session) {
|
||||
session->switch_to_context();
|
||||
}
|
||||
}
|
||||
if (rtc_session == NULL) {
|
||||
return srs_error_new(ERROR_RTC_STUN, "can not find rtc_session, stun username=%s, peer_id=%s",
|
||||
if (session == NULL) {
|
||||
return srs_error_new(ERROR_RTC_STUN, "can not find session, stun username=%s, peer_id=%s",
|
||||
sr.get_username().c_str(), skt->get_peer_id().c_str());
|
||||
}
|
||||
|
||||
return rtc_session->on_stun(skt, &sr);
|
||||
return session->on_stun(skt, &sr);
|
||||
}
|
||||
|
||||
// For DTLS, RTCP or RTP, which does not support peer address changing.
|
||||
if (rtc_session == NULL) {
|
||||
return srs_error_new(ERROR_RTC_STUN, "can not find rtc_session, peer_id=%s", skt->get_peer_id().c_str());
|
||||
if (session == NULL) {
|
||||
return srs_error_new(ERROR_RTC_STUN, "can not find session, peer_id=%s", skt->get_peer_id().c_str());
|
||||
}
|
||||
|
||||
if (is_dtls((uint8_t*)data, size)) {
|
||||
return rtc_session->on_dtls(data, size);
|
||||
return session->on_dtls(data, size);
|
||||
} else if (is_rtp_or_rtcp((uint8_t*)data, size)) {
|
||||
if (is_rtcp((uint8_t*)data, size)) {
|
||||
return rtc_session->on_rtcp(data, size);
|
||||
return session->on_rtcp(data, size);
|
||||
}
|
||||
return rtc_session->on_rtp(data, size);
|
||||
return session->on_rtp(data, size);
|
||||
}
|
||||
|
||||
return srs_error_new(ERROR_RTC_UDP, "unknown udp packet type");
|
||||
|
|
@ -3340,7 +3340,7 @@ srs_error_t SrsRtcServer::listen_api()
|
|||
return err;
|
||||
}
|
||||
|
||||
srs_error_t SrsRtcServer::create_rtc_session(
|
||||
srs_error_t SrsRtcServer::create_session(
|
||||
SrsRequest* req, const SrsSdp& remote_sdp, SrsSdp& local_sdp, const std::string& mock_eip, bool publish,
|
||||
SrsRtcSession** psession
|
||||
) {
|
||||
|
|
@ -3404,9 +3404,9 @@ srs_error_t SrsRtcServer::create_rtc_session(
|
|||
return err;
|
||||
}
|
||||
|
||||
bool SrsRtcServer::insert_into_id_sessions(const string& peer_id, SrsRtcSession* rtc_session)
|
||||
bool SrsRtcServer::insert_into_id_sessions(const string& peer_id, SrsRtcSession* session)
|
||||
{
|
||||
return map_id_session.insert(make_pair(peer_id, rtc_session)).second;
|
||||
return map_id_session.insert(make_pair(peer_id, session)).second;
|
||||
}
|
||||
|
||||
void SrsRtcServer::check_and_clean_timeout_session()
|
||||
|
|
@ -3440,7 +3440,7 @@ int SrsRtcServer::nn_sessions()
|
|||
return (int)map_username_session.size();
|
||||
}
|
||||
|
||||
SrsRtcSession* SrsRtcServer::find_rtc_session_by_peer_id(const string& peer_id)
|
||||
SrsRtcSession* SrsRtcServer::find_session_by_peer_id(const string& peer_id)
|
||||
{
|
||||
map<string, SrsRtcSession*>::iterator iter = map_id_session.find(peer_id);
|
||||
if (iter == map_id_session.end()) {
|
||||
|
|
@ -3450,7 +3450,7 @@ SrsRtcSession* SrsRtcServer::find_rtc_session_by_peer_id(const string& peer_id)
|
|||
return iter->second;
|
||||
}
|
||||
|
||||
SrsRtcSession* SrsRtcServer::find_rtc_session_by_username(const std::string& username)
|
||||
SrsRtcSession* SrsRtcServer::find_session_by_username(const std::string& username)
|
||||
{
|
||||
map<string, SrsRtcSession*>::iterator iter = map_username_session.find(username);
|
||||
if (iter == map_username_session.end()) {
|
||||
|
|
|
|||
|
|
@ -103,10 +103,10 @@ enum SrsRtcSessionStateType
|
|||
CLOSED = 4,
|
||||
};
|
||||
|
||||
class SrsDtlsSession
|
||||
class SrsRtcDtls
|
||||
{
|
||||
private:
|
||||
SrsRtcSession* rtc_session;
|
||||
SrsRtcSession* session_;
|
||||
|
||||
SSL* dtls;
|
||||
BIO* bio_in;
|
||||
|
|
@ -121,8 +121,8 @@ private:
|
|||
bool handshake_done;
|
||||
|
||||
public:
|
||||
SrsDtlsSession(SrsRtcSession* s);
|
||||
virtual ~SrsDtlsSession();
|
||||
SrsRtcDtls(SrsRtcSession* s);
|
||||
virtual ~SrsRtcDtls();
|
||||
|
||||
srs_error_t initialize(SrsRequest* r);
|
||||
|
||||
|
|
@ -143,8 +143,8 @@ private:
|
|||
srs_error_t srtp_recv_init();
|
||||
};
|
||||
|
||||
// A group of RTP packets.
|
||||
class SrsRtcPackets
|
||||
// A group of RTP packets for outgoing(send to players).
|
||||
class SrsRtcOutgoingPackets
|
||||
{
|
||||
public:
|
||||
bool use_gso;
|
||||
|
|
@ -183,8 +183,8 @@ private:
|
|||
int nn_cache;
|
||||
SrsRtpPacket2* cache;
|
||||
public:
|
||||
SrsRtcPackets(int nn_cache_max);
|
||||
virtual ~SrsRtcPackets();
|
||||
SrsRtcOutgoingPackets(int nn_cache_max);
|
||||
virtual ~SrsRtcOutgoingPackets();
|
||||
public:
|
||||
void reset(bool gso, bool merge_nalus);
|
||||
SrsRtpPacket2* fetch();
|
||||
|
|
@ -200,7 +200,7 @@ protected:
|
|||
SrsCoroutine* trd;
|
||||
int _parent_cid;
|
||||
private:
|
||||
SrsRtcSession* rtc_session;
|
||||
SrsRtcSession* session_;
|
||||
uint32_t video_ssrc;
|
||||
uint32_t audio_ssrc;
|
||||
uint16_t video_payload_type;
|
||||
|
|
@ -238,17 +238,17 @@ public:
|
|||
public:
|
||||
virtual srs_error_t cycle();
|
||||
private:
|
||||
srs_error_t send_messages(SrsSource* source, SrsSharedPtrMessage** msgs, int nb_msgs, SrsRtcPackets& packets);
|
||||
srs_error_t messages_to_packets(SrsSource* source, SrsSharedPtrMessage** msgs, int nb_msgs, SrsRtcPackets& packets);
|
||||
srs_error_t send_packets(SrsRtcPackets& packets);
|
||||
srs_error_t send_packets_gso(SrsRtcPackets& packets);
|
||||
srs_error_t send_messages(SrsSource* source, SrsSharedPtrMessage** msgs, int nb_msgs, SrsRtcOutgoingPackets& packets);
|
||||
srs_error_t messages_to_packets(SrsSource* source, SrsSharedPtrMessage** msgs, int nb_msgs, SrsRtcOutgoingPackets& packets);
|
||||
srs_error_t send_packets(SrsRtcOutgoingPackets& packets);
|
||||
srs_error_t send_packets_gso(SrsRtcOutgoingPackets& packets);
|
||||
private:
|
||||
srs_error_t package_opus(SrsSample* sample, SrsRtcPackets& packets, int nn_max_payload);
|
||||
srs_error_t package_opus(SrsSample* sample, SrsRtcOutgoingPackets& packets, int nn_max_payload);
|
||||
private:
|
||||
srs_error_t package_fu_a(SrsSharedPtrMessage* msg, SrsSample* sample, int fu_payload_size, SrsRtcPackets& packets);
|
||||
srs_error_t package_nalus(SrsSharedPtrMessage* msg, SrsRtcPackets& packets);
|
||||
srs_error_t package_single_nalu(SrsSharedPtrMessage* msg, SrsSample* sample, SrsRtcPackets& packets);
|
||||
srs_error_t package_stap_a(SrsSource* source, SrsSharedPtrMessage* msg, SrsRtcPackets& packets);
|
||||
srs_error_t package_fu_a(SrsSharedPtrMessage* msg, SrsSample* sample, int fu_payload_size, SrsRtcOutgoingPackets& packets);
|
||||
srs_error_t package_nalus(SrsSharedPtrMessage* msg, SrsRtcOutgoingPackets& packets);
|
||||
srs_error_t package_single_nalu(SrsSharedPtrMessage* msg, SrsSample* sample, SrsRtcOutgoingPackets& packets);
|
||||
srs_error_t package_stap_a(SrsSource* source, SrsSharedPtrMessage* msg, SrsRtcOutgoingPackets& packets);
|
||||
};
|
||||
|
||||
class SrsRtcPublisher : virtual public ISrsHourGlass, virtual public ISrsRtpPacketDecodeHandler
|
||||
|
|
@ -256,7 +256,7 @@ class SrsRtcPublisher : virtual public ISrsHourGlass, virtual public ISrsRtpPack
|
|||
private:
|
||||
SrsHourGlass* report_timer;
|
||||
private:
|
||||
SrsRtcSession* rtc_session;
|
||||
SrsRtcSession* session_;
|
||||
uint32_t video_ssrc;
|
||||
uint32_t audio_ssrc;
|
||||
private:
|
||||
|
|
@ -301,15 +301,15 @@ public:
|
|||
|
||||
class SrsRtcSession
|
||||
{
|
||||
friend class SrsDtlsSession;
|
||||
friend class SrsRtcDtls;
|
||||
friend class SrsRtcPlayer;
|
||||
friend class SrsRtcPublisher;
|
||||
private:
|
||||
SrsRtcServer* rtc_server;
|
||||
SrsRtcServer* server_;
|
||||
SrsRtcSessionStateType session_state;
|
||||
SrsDtlsSession* dtls_session;
|
||||
SrsRtcPlayer* player;
|
||||
SrsRtcPublisher* publisher;
|
||||
SrsRtcDtls* dtls_;
|
||||
SrsRtcPlayer* player_;
|
||||
SrsRtcPublisher* publisher_;
|
||||
bool is_publisher_;
|
||||
private:
|
||||
SrsUdpMuxSocket* sendonly_skt;
|
||||
|
|
@ -438,16 +438,16 @@ public:
|
|||
virtual srs_error_t on_udp_packet(SrsUdpMuxSocket* skt);
|
||||
public:
|
||||
virtual srs_error_t listen_api();
|
||||
srs_error_t create_rtc_session(
|
||||
srs_error_t create_session(
|
||||
SrsRequest* req, const SrsSdp& remote_sdp, SrsSdp& local_sdp, const std::string& mock_eip, bool publish,
|
||||
SrsRtcSession** psession
|
||||
);
|
||||
bool insert_into_id_sessions(const std::string& peer_id, SrsRtcSession* rtc_session);
|
||||
bool insert_into_id_sessions(const std::string& peer_id, SrsRtcSession* session);
|
||||
void check_and_clean_timeout_session();
|
||||
int nn_sessions();
|
||||
private:
|
||||
SrsRtcSession* find_rtc_session_by_username(const std::string& ufrag);
|
||||
SrsRtcSession* find_rtc_session_by_peer_id(const std::string& peer_id);
|
||||
SrsRtcSession* find_session_by_username(const std::string& ufrag);
|
||||
SrsRtcSession* find_session_by_peer_id(const std::string& peer_id);
|
||||
// interface ISrsHourGlass
|
||||
public:
|
||||
virtual srs_error_t notify(int type, srs_utime_t interval, srs_utime_t tick);
|
||||
|
|
|
|||
Loading…
Reference in a new issue