Style cleanup in RTCPReceiver
Rename variables and private functions to follow style, replace remaining asserts with DCHECKs. add 'ms' suffix to time variables derived from clock_ add 'ntp' suffix to time variables derived from ntp time. No functional changes expected. BUG=None Review-Url: https://codereview.webrtc.org/2588753002 Cr-Commit-Position: refs/heads/master@{#15706}
This commit is contained in:
danilchap
Commit bot
parent
cb29be5cfa
commit
8bab796db7
@ -10,7 +10,6 @@
|
||||
|
||||
#include "webrtc/modules/rtp_rtcp/source/rtcp_receiver.h"
|
||||
|
||||
#include <assert.h>
|
||||
#include <string.h>
|
||||
|
||||
#include <limits>
|
||||
@ -108,25 +107,25 @@ RTCPReceiver::RTCPReceiver(
|
||||
TransportFeedbackObserver* transport_feedback_observer,
|
||||
VideoBitrateAllocationObserver* bitrate_allocation_observer,
|
||||
ModuleRtpRtcp* owner)
|
||||
: _clock(clock),
|
||||
: clock_(clock),
|
||||
receiver_only_(receiver_only),
|
||||
_rtpRtcp(*owner),
|
||||
rtp_rtcp_(owner),
|
||||
rtcp_bandwidth_observer_(rtcp_bandwidth_observer),
|
||||
rtcp_intra_frame_observer_(rtcp_intra_frame_observer),
|
||||
transport_feedback_observer_(transport_feedback_observer),
|
||||
bitrate_allocation_observer_(bitrate_allocation_observer),
|
||||
main_ssrc_(0),
|
||||
_remoteSSRC(0),
|
||||
_remoteSenderInfo(),
|
||||
remote_ssrc_(0),
|
||||
xr_rrtr_status_(false),
|
||||
xr_rr_rtt_ms_(0),
|
||||
_lastReceivedRrMs(0),
|
||||
_lastIncreasedSequenceNumberMs(0),
|
||||
last_received_rr_ms_(0),
|
||||
last_increased_sequence_number_ms_(0),
|
||||
stats_callback_(nullptr),
|
||||
packet_type_counter_observer_(packet_type_counter_observer),
|
||||
num_skipped_packets_(0),
|
||||
last_skipped_packets_warning_(clock->TimeInMilliseconds()) {
|
||||
memset(&_remoteSenderInfo, 0, sizeof(_remoteSenderInfo));
|
||||
last_skipped_packets_warning_ms_(clock->TimeInMilliseconds()) {
|
||||
RTC_DCHECK(owner);
|
||||
memset(&remote_sender_info_, 0, sizeof(remote_sender_info_));
|
||||
}
|
||||
|
||||
RTCPReceiver::~RTCPReceiver() {}
|
||||
@ -140,12 +139,12 @@ bool RTCPReceiver::IncomingPacket(const uint8_t* packet, size_t packet_size) {
|
||||
PacketInformation packet_information;
|
||||
if (!ParseCompoundPacket(packet, packet + packet_size, &packet_information))
|
||||
return false;
|
||||
TriggerCallbacksFromRTCPPacket(packet_information);
|
||||
TriggerCallbacksFromRtcpPacket(packet_information);
|
||||
return true;
|
||||
}
|
||||
|
||||
int64_t RTCPReceiver::LastReceivedReceiverReport() const {
|
||||
rtc::CritScope lock(&_criticalSectionRTCPReceiver);
|
||||
rtc::CritScope lock(&rtcp_receiver_lock_);
|
||||
int64_t last_received_rr = -1;
|
||||
for (const auto& kv : received_infos_)
|
||||
if (kv.second.last_time_received_ms > last_received_rr)
|
||||
@ -154,23 +153,21 @@ int64_t RTCPReceiver::LastReceivedReceiverReport() const {
|
||||
}
|
||||
|
||||
void RTCPReceiver::SetRemoteSSRC(uint32_t ssrc) {
|
||||
rtc::CritScope lock(&_criticalSectionRTCPReceiver);
|
||||
|
||||
// new SSRC reset old reports
|
||||
memset(&_remoteSenderInfo, 0, sizeof(_remoteSenderInfo));
|
||||
rtc::CritScope lock(&rtcp_receiver_lock_);
|
||||
// New SSRC reset old reports.
|
||||
memset(&remote_sender_info_, 0, sizeof(remote_sender_info_));
|
||||
last_received_sr_ntp_.Reset();
|
||||
|
||||
_remoteSSRC = ssrc;
|
||||
remote_ssrc_ = ssrc;
|
||||
}
|
||||
|
||||
uint32_t RTCPReceiver::RemoteSSRC() const {
|
||||
rtc::CritScope lock(&_criticalSectionRTCPReceiver);
|
||||
return _remoteSSRC;
|
||||
rtc::CritScope lock(&rtcp_receiver_lock_);
|
||||
return remote_ssrc_;
|
||||
}
|
||||
|
||||
void RTCPReceiver::SetSsrcs(uint32_t main_ssrc,
|
||||
const std::set<uint32_t>& registered_ssrcs) {
|
||||
rtc::CritScope lock(&_criticalSectionRTCPReceiver);
|
||||
rtc::CritScope lock(&rtcp_receiver_lock_);
|
||||
main_ssrc_ = main_ssrc;
|
||||
registered_ssrcs_ = registered_ssrcs;
|
||||
}
|
||||
@ -180,7 +177,7 @@ int32_t RTCPReceiver::RTT(uint32_t remote_ssrc,
|
||||
int64_t* avg_rtt_ms,
|
||||
int64_t* min_rtt_ms,
|
||||
int64_t* max_rtt_ms) const {
|
||||
rtc::CritScope lock(&_criticalSectionRTCPReceiver);
|
||||
rtc::CritScope lock(&rtcp_receiver_lock_);
|
||||
|
||||
auto it = received_report_blocks_.find(main_ssrc_);
|
||||
if (it == received_report_blocks_.end())
|
||||
@ -211,13 +208,13 @@ int32_t RTCPReceiver::RTT(uint32_t remote_ssrc,
|
||||
}
|
||||
|
||||
void RTCPReceiver::SetRtcpXrRrtrStatus(bool enable) {
|
||||
rtc::CritScope lock(&_criticalSectionRTCPReceiver);
|
||||
rtc::CritScope lock(&rtcp_receiver_lock_);
|
||||
xr_rrtr_status_ = enable;
|
||||
}
|
||||
|
||||
bool RTCPReceiver::GetAndResetXrRrRtt(int64_t* rtt_ms) {
|
||||
assert(rtt_ms);
|
||||
rtc::CritScope lock(&_criticalSectionRTCPReceiver);
|
||||
RTC_DCHECK(rtt_ms);
|
||||
rtc::CritScope lock(&rtcp_receiver_lock_);
|
||||
if (xr_rr_rtt_ms_ == 0) {
|
||||
return false;
|
||||
}
|
||||
@ -226,30 +223,30 @@ bool RTCPReceiver::GetAndResetXrRrRtt(int64_t* rtt_ms) {
|
||||
return true;
|
||||
}
|
||||
|
||||
bool RTCPReceiver::NTP(uint32_t* ReceivedNTPsecs,
|
||||
uint32_t* ReceivedNTPfrac,
|
||||
uint32_t* RTCPArrivalTimeSecs,
|
||||
uint32_t* RTCPArrivalTimeFrac,
|
||||
bool RTCPReceiver::NTP(uint32_t* received_ntp_secs,
|
||||
uint32_t* received_ntp_frac,
|
||||
uint32_t* rtcp_arrival_time_secs,
|
||||
uint32_t* rtcp_arrival_time_frac,
|
||||
uint32_t* rtcp_timestamp) const {
|
||||
rtc::CritScope lock(&_criticalSectionRTCPReceiver);
|
||||
rtc::CritScope lock(&rtcp_receiver_lock_);
|
||||
if (!last_received_sr_ntp_.Valid())
|
||||
return false;
|
||||
|
||||
// NTP from incoming SenderReport.
|
||||
if (ReceivedNTPsecs)
|
||||
*ReceivedNTPsecs = _remoteSenderInfo.NTPseconds;
|
||||
if (ReceivedNTPfrac)
|
||||
*ReceivedNTPfrac = _remoteSenderInfo.NTPfraction;
|
||||
if (received_ntp_secs)
|
||||
*received_ntp_secs = remote_sender_info_.NTPseconds;
|
||||
if (received_ntp_frac)
|
||||
*received_ntp_frac = remote_sender_info_.NTPfraction;
|
||||
|
||||
// Rtp time from incoming SenderReport.
|
||||
if (rtcp_timestamp)
|
||||
*rtcp_timestamp = _remoteSenderInfo.RTPtimeStamp;
|
||||
*rtcp_timestamp = remote_sender_info_.RTPtimeStamp;
|
||||
|
||||
// Local NTP time when we received a RTCP packet with a send block.
|
||||
if (RTCPArrivalTimeSecs)
|
||||
*RTCPArrivalTimeSecs = last_received_sr_ntp_.seconds();
|
||||
if (RTCPArrivalTimeFrac)
|
||||
*RTCPArrivalTimeFrac = last_received_sr_ntp_.fractions();
|
||||
if (rtcp_arrival_time_secs)
|
||||
*rtcp_arrival_time_secs = last_received_sr_ntp_.seconds();
|
||||
if (rtcp_arrival_time_frac)
|
||||
*rtcp_arrival_time_frac = last_received_sr_ntp_.fractions();
|
||||
|
||||
return true;
|
||||
}
|
||||
@ -257,7 +254,7 @@ bool RTCPReceiver::NTP(uint32_t* ReceivedNTPsecs,
|
||||
bool RTCPReceiver::LastReceivedXrReferenceTimeInfo(
|
||||
rtcp::ReceiveTimeInfo* info) const {
|
||||
RTC_DCHECK(info);
|
||||
rtc::CritScope lock(&_criticalSectionRTCPReceiver);
|
||||
rtc::CritScope lock(&rtcp_receiver_lock_);
|
||||
if (!last_received_xr_ntp_.Valid())
|
||||
return false;
|
||||
|
||||
@ -265,20 +262,20 @@ bool RTCPReceiver::LastReceivedXrReferenceTimeInfo(
|
||||
info->last_rr = remote_time_info_.last_rr;
|
||||
|
||||
// Get the delay since last received report (RFC 3611).
|
||||
uint32_t receive_time = CompactNtp(last_received_xr_ntp_);
|
||||
uint32_t now = CompactNtp(NtpTime(*_clock));
|
||||
uint32_t receive_time_ntp = CompactNtp(last_received_xr_ntp_);
|
||||
uint32_t now_ntp = CompactNtp(NtpTime(*clock_));
|
||||
|
||||
info->delay_since_last_rr = now - receive_time;
|
||||
info->delay_since_last_rr = now_ntp - receive_time_ntp;
|
||||
return true;
|
||||
}
|
||||
|
||||
int32_t RTCPReceiver::SenderInfoReceived(RTCPSenderInfo* senderInfo) const {
|
||||
assert(senderInfo);
|
||||
rtc::CritScope lock(&_criticalSectionRTCPReceiver);
|
||||
int32_t RTCPReceiver::SenderInfoReceived(RTCPSenderInfo* sender_info) const {
|
||||
RTC_DCHECK(sender_info);
|
||||
rtc::CritScope lock(&rtcp_receiver_lock_);
|
||||
if (!last_received_sr_ntp_.Valid())
|
||||
return -1;
|
||||
|
||||
memcpy(senderInfo, &(_remoteSenderInfo), sizeof(RTCPSenderInfo));
|
||||
memcpy(sender_info, &remote_sender_info_, sizeof(RTCPSenderInfo));
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -286,7 +283,7 @@ int32_t RTCPReceiver::SenderInfoReceived(RTCPSenderInfo* senderInfo) const {
|
||||
int32_t RTCPReceiver::StatisticsReceived(
|
||||
std::vector<RTCPReportBlock>* receive_blocks) const {
|
||||
RTC_DCHECK(receive_blocks);
|
||||
rtc::CritScope lock(&_criticalSectionRTCPReceiver);
|
||||
rtc::CritScope lock(&rtcp_receiver_lock_);
|
||||
for (const auto& reports_per_receiver : received_report_blocks_)
|
||||
for (const auto& report : reports_per_receiver.second)
|
||||
receive_blocks->push_back(report.second.report_block);
|
||||
@ -296,7 +293,7 @@ int32_t RTCPReceiver::StatisticsReceived(
|
||||
bool RTCPReceiver::ParseCompoundPacket(const uint8_t* packet_begin,
|
||||
const uint8_t* packet_end,
|
||||
PacketInformation* packet_information) {
|
||||
rtc::CritScope lock(&_criticalSectionRTCPReceiver);
|
||||
rtc::CritScope lock(&rtcp_receiver_lock_);
|
||||
|
||||
CommonHeader rtcp_block;
|
||||
for (const uint8_t* next_block = packet_begin; next_block != packet_end;
|
||||
@ -314,7 +311,7 @@ bool RTCPReceiver::ParseCompoundPacket(const uint8_t* packet_begin,
|
||||
}
|
||||
|
||||
if (packet_type_counter_.first_packet_time_ms == -1)
|
||||
packet_type_counter_.first_packet_time_ms = _clock->TimeInMilliseconds();
|
||||
packet_type_counter_.first_packet_time_ms = clock_->TimeInMilliseconds();
|
||||
|
||||
switch (rtcp_block.type()) {
|
||||
case rtcp::SenderReport::kPacketType:
|
||||
@ -324,27 +321,27 @@ bool RTCPReceiver::ParseCompoundPacket(const uint8_t* packet_begin,
|
||||
HandleReceiverReport(rtcp_block, packet_information);
|
||||
break;
|
||||
case rtcp::Sdes::kPacketType:
|
||||
HandleSDES(rtcp_block, packet_information);
|
||||
HandleSdes(rtcp_block, packet_information);
|
||||
break;
|
||||
case rtcp::ExtendedReports::kPacketType:
|
||||
HandleXr(rtcp_block, packet_information);
|
||||
break;
|
||||
case rtcp::Bye::kPacketType:
|
||||
HandleBYE(rtcp_block);
|
||||
HandleBye(rtcp_block);
|
||||
break;
|
||||
case rtcp::Rtpfb::kPacketType:
|
||||
switch (rtcp_block.fmt()) {
|
||||
case rtcp::Nack::kFeedbackMessageType:
|
||||
HandleNACK(rtcp_block, packet_information);
|
||||
HandleNack(rtcp_block, packet_information);
|
||||
break;
|
||||
case rtcp::Tmmbr::kFeedbackMessageType:
|
||||
HandleTMMBR(rtcp_block, packet_information);
|
||||
HandleTmmbr(rtcp_block, packet_information);
|
||||
break;
|
||||
case rtcp::Tmmbn::kFeedbackMessageType:
|
||||
HandleTMMBN(rtcp_block, packet_information);
|
||||
HandleTmmbn(rtcp_block, packet_information);
|
||||
break;
|
||||
case rtcp::RapidResyncRequest::kFeedbackMessageType:
|
||||
HandleSR_REQ(rtcp_block, packet_information);
|
||||
HandleSrReq(rtcp_block, packet_information);
|
||||
break;
|
||||
case rtcp::TransportFeedback::kFeedbackMessageType:
|
||||
HandleTransportFeedback(rtcp_block, packet_information);
|
||||
@ -357,16 +354,16 @@ bool RTCPReceiver::ParseCompoundPacket(const uint8_t* packet_begin,
|
||||
case rtcp::Psfb::kPacketType:
|
||||
switch (rtcp_block.fmt()) {
|
||||
case rtcp::Pli::kFeedbackMessageType:
|
||||
HandlePLI(rtcp_block, packet_information);
|
||||
HandlePli(rtcp_block, packet_information);
|
||||
break;
|
||||
case rtcp::Sli::kFeedbackMessageType:
|
||||
HandleSLI(rtcp_block, packet_information);
|
||||
HandleSli(rtcp_block, packet_information);
|
||||
break;
|
||||
case rtcp::Rpsi::kFeedbackMessageType:
|
||||
HandleRPSI(rtcp_block, packet_information);
|
||||
HandleRpsi(rtcp_block, packet_information);
|
||||
break;
|
||||
case rtcp::Fir::kFeedbackMessageType:
|
||||
HandleFIR(rtcp_block, packet_information);
|
||||
HandleFir(rtcp_block, packet_information);
|
||||
break;
|
||||
case rtcp::Remb::kFeedbackMessageType:
|
||||
HandlePsfbApp(rtcp_block, packet_information);
|
||||
@ -382,15 +379,15 @@ bool RTCPReceiver::ParseCompoundPacket(const uint8_t* packet_begin,
|
||||
}
|
||||
}
|
||||
|
||||
if (packet_type_counter_observer_ != NULL) {
|
||||
if (packet_type_counter_observer_) {
|
||||
packet_type_counter_observer_->RtcpPacketTypesCounterUpdated(
|
||||
main_ssrc_, packet_type_counter_);
|
||||
}
|
||||
|
||||
int64_t now = _clock->TimeInMilliseconds();
|
||||
if (now - last_skipped_packets_warning_ >= kMaxWarningLogIntervalMs &&
|
||||
int64_t now_ms = clock_->TimeInMilliseconds();
|
||||
if (now_ms - last_skipped_packets_warning_ms_ >= kMaxWarningLogIntervalMs &&
|
||||
num_skipped_packets_ > 0) {
|
||||
last_skipped_packets_warning_ = now;
|
||||
last_skipped_packets_warning_ms_ = now_ms;
|
||||
LOG(LS_WARNING) << num_skipped_packets_
|
||||
<< " RTCP blocks were skipped due to being malformed or of "
|
||||
"unrecognized/unsupported type, during the past "
|
||||
@ -408,28 +405,28 @@ void RTCPReceiver::HandleSenderReport(const CommonHeader& rtcp_block,
|
||||
return;
|
||||
}
|
||||
|
||||
const uint32_t remoteSSRC = sender_report.sender_ssrc();
|
||||
const uint32_t remote_ssrc = sender_report.sender_ssrc();
|
||||
|
||||
packet_information->remote_ssrc = remoteSSRC;
|
||||
packet_information->remote_ssrc = remote_ssrc;
|
||||
|
||||
CreateReceiveInformation(remoteSSRC);
|
||||
CreateReceiveInformation(remote_ssrc);
|
||||
|
||||
TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "SR",
|
||||
"remote_ssrc", remoteSSRC, "ssrc", main_ssrc_);
|
||||
"remote_ssrc", remote_ssrc, "ssrc", main_ssrc_);
|
||||
|
||||
// Have I received RTP packets from this party?
|
||||
if (_remoteSSRC == remoteSSRC) {
|
||||
if (remote_ssrc_ == remote_ssrc) {
|
||||
// Only signal that we have received a SR when we accept one.
|
||||
packet_information->packet_type_flags |= kRtcpSr;
|
||||
|
||||
// Save the NTP time of this report.
|
||||
_remoteSenderInfo.NTPseconds = sender_report.ntp().seconds();
|
||||
_remoteSenderInfo.NTPfraction = sender_report.ntp().fractions();
|
||||
_remoteSenderInfo.RTPtimeStamp = sender_report.rtp_timestamp();
|
||||
_remoteSenderInfo.sendPacketCount = sender_report.sender_packet_count();
|
||||
_remoteSenderInfo.sendOctetCount = sender_report.sender_octet_count();
|
||||
remote_sender_info_.NTPseconds = sender_report.ntp().seconds();
|
||||
remote_sender_info_.NTPfraction = sender_report.ntp().fractions();
|
||||
remote_sender_info_.RTPtimeStamp = sender_report.rtp_timestamp();
|
||||
remote_sender_info_.sendPacketCount = sender_report.sender_packet_count();
|
||||
remote_sender_info_.sendOctetCount = sender_report.sender_octet_count();
|
||||
|
||||
last_received_sr_ntp_.SetCurrent(*_clock);
|
||||
last_received_sr_ntp_.SetCurrent(*clock_);
|
||||
} else {
|
||||
// We will only store the send report from one source, but
|
||||
// we will store all the receive blocks.
|
||||
@ -437,7 +434,7 @@ void RTCPReceiver::HandleSenderReport(const CommonHeader& rtcp_block,
|
||||
}
|
||||
|
||||
for (const rtcp::ReportBlock report_block : sender_report.report_blocks())
|
||||
HandleReportBlock(report_block, packet_information, remoteSSRC);
|
||||
HandleReportBlock(report_block, packet_information, remote_ssrc);
|
||||
}
|
||||
|
||||
void RTCPReceiver::HandleReceiverReport(const CommonHeader& rtcp_block,
|
||||
@ -448,19 +445,19 @@ void RTCPReceiver::HandleReceiverReport(const CommonHeader& rtcp_block,
|
||||
return;
|
||||
}
|
||||
|
||||
const uint32_t remoteSSRC = receiver_report.sender_ssrc();
|
||||
const uint32_t remote_ssrc = receiver_report.sender_ssrc();
|
||||
|
||||
packet_information->remote_ssrc = remoteSSRC;
|
||||
packet_information->remote_ssrc = remote_ssrc;
|
||||
|
||||
CreateReceiveInformation(remoteSSRC);
|
||||
CreateReceiveInformation(remote_ssrc);
|
||||
|
||||
TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "RR",
|
||||
"remote_ssrc", remoteSSRC, "ssrc", main_ssrc_);
|
||||
"remote_ssrc", remote_ssrc, "ssrc", main_ssrc_);
|
||||
|
||||
packet_information->packet_type_flags |= kRtcpRr;
|
||||
|
||||
for (const ReportBlock& report_block : receiver_report.report_blocks())
|
||||
HandleReportBlock(report_block, packet_information, remoteSSRC);
|
||||
HandleReportBlock(report_block, packet_information, remote_ssrc);
|
||||
}
|
||||
|
||||
void RTCPReceiver::HandleReportBlock(const ReportBlock& report_block,
|
||||
@ -482,7 +479,7 @@ void RTCPReceiver::HandleReportBlock(const ReportBlock& report_block,
|
||||
ReportBlockWithRtt* report_block_info =
|
||||
&received_report_blocks_[report_block.source_ssrc()][remote_ssrc];
|
||||
|
||||
_lastReceivedRrMs = _clock->TimeInMilliseconds();
|
||||
last_received_rr_ms_ = clock_->TimeInMilliseconds();
|
||||
report_block_info->report_block.remoteSSRC = remote_ssrc;
|
||||
report_block_info->report_block.sourceSSRC = report_block.source_ssrc();
|
||||
report_block_info->report_block.fractionLost = report_block.fraction_lost();
|
||||
@ -492,7 +489,7 @@ void RTCPReceiver::HandleReportBlock(const ReportBlock& report_block,
|
||||
report_block_info->report_block.extendedHighSeqNum) {
|
||||
// We have successfully delivered new RTP packets to the remote side after
|
||||
// the last RR was sent from the remote side.
|
||||
_lastIncreasedSequenceNumberMs = _lastReceivedRrMs;
|
||||
last_increased_sequence_number_ms_ = last_received_rr_ms_;
|
||||
}
|
||||
report_block_info->report_block.extendedHighSeqNum =
|
||||
report_block.extended_high_seq_num();
|
||||
@ -502,18 +499,18 @@ void RTCPReceiver::HandleReportBlock(const ReportBlock& report_block,
|
||||
report_block_info->report_block.lastSR = report_block.last_sr();
|
||||
|
||||
int64_t rtt_ms = 0;
|
||||
uint32_t send_time = report_block.last_sr();
|
||||
uint32_t send_time_ntp = report_block.last_sr();
|
||||
// RFC3550, section 6.4.1, LSR field discription states:
|
||||
// If no SR has been received yet, the field is set to zero.
|
||||
// Receiver rtp_rtcp module is not expected to calculate rtt using
|
||||
// Sender Reports even if it accidentally can.
|
||||
if (!receiver_only_ && send_time != 0) {
|
||||
uint32_t delay = report_block.delay_since_last_sr();
|
||||
if (!receiver_only_ && send_time_ntp != 0) {
|
||||
uint32_t delay_ntp = report_block.delay_since_last_sr();
|
||||
// Local NTP time.
|
||||
uint32_t receive_time = CompactNtp(NtpTime(*_clock));
|
||||
uint32_t receive_time_ntp = CompactNtp(NtpTime(*clock_));
|
||||
|
||||
// RTT in 1/(2^16) seconds.
|
||||
uint32_t rtt_ntp = receive_time - delay - send_time;
|
||||
uint32_t rtt_ntp = receive_time_ntp - delay_ntp - send_time_ntp;
|
||||
// Convert to 1/1000 seconds (milliseconds).
|
||||
rtt_ms = CompactNtpRttToMs(rtt_ntp);
|
||||
if (rtt_ms > report_block_info->max_rtt_ms)
|
||||
@ -539,7 +536,7 @@ void RTCPReceiver::CreateReceiveInformation(uint32_t remote_ssrc) {
|
||||
// Create or find receive information.
|
||||
ReceiveInformation* receive_info = &received_infos_[remote_ssrc];
|
||||
// Update that this remote is alive.
|
||||
receive_info->last_time_received_ms = _clock->TimeInMilliseconds();
|
||||
receive_info->last_time_received_ms = clock_->TimeInMilliseconds();
|
||||
}
|
||||
|
||||
RTCPReceiver::ReceiveInformation* RTCPReceiver::GetReceiveInformation(
|
||||
@ -551,39 +548,39 @@ RTCPReceiver::ReceiveInformation* RTCPReceiver::GetReceiveInformation(
|
||||
}
|
||||
|
||||
bool RTCPReceiver::RtcpRrTimeout(int64_t rtcp_interval_ms) {
|
||||
rtc::CritScope lock(&_criticalSectionRTCPReceiver);
|
||||
if (_lastReceivedRrMs == 0)
|
||||
rtc::CritScope lock(&rtcp_receiver_lock_);
|
||||
if (last_received_rr_ms_ == 0)
|
||||
return false;
|
||||
|
||||
int64_t time_out_ms = kRrTimeoutIntervals * rtcp_interval_ms;
|
||||
if (_clock->TimeInMilliseconds() > _lastReceivedRrMs + time_out_ms) {
|
||||
if (clock_->TimeInMilliseconds() > last_received_rr_ms_ + time_out_ms) {
|
||||
// Reset the timer to only trigger one log.
|
||||
_lastReceivedRrMs = 0;
|
||||
last_received_rr_ms_ = 0;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool RTCPReceiver::RtcpRrSequenceNumberTimeout(int64_t rtcp_interval_ms) {
|
||||
rtc::CritScope lock(&_criticalSectionRTCPReceiver);
|
||||
if (_lastIncreasedSequenceNumberMs == 0)
|
||||
rtc::CritScope lock(&rtcp_receiver_lock_);
|
||||
if (last_increased_sequence_number_ms_ == 0)
|
||||
return false;
|
||||
|
||||
int64_t time_out_ms = kRrTimeoutIntervals * rtcp_interval_ms;
|
||||
if (_clock->TimeInMilliseconds() >
|
||||
_lastIncreasedSequenceNumberMs + time_out_ms) {
|
||||
if (clock_->TimeInMilliseconds() >
|
||||
last_increased_sequence_number_ms_ + time_out_ms) {
|
||||
// Reset the timer to only trigger one log.
|
||||
_lastIncreasedSequenceNumberMs = 0;
|
||||
last_increased_sequence_number_ms_ = 0;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool RTCPReceiver::UpdateRTCPReceiveInformationTimers() {
|
||||
rtc::CritScope lock(&_criticalSectionRTCPReceiver);
|
||||
rtc::CritScope lock(&rtcp_receiver_lock_);
|
||||
|
||||
bool update_bounding_set = false;
|
||||
int64_t now_ms = _clock->TimeInMilliseconds();
|
||||
int64_t now_ms = clock_->TimeInMilliseconds();
|
||||
// Use audio define since we don't know what interval the remote peer use.
|
||||
int64_t timeouted_ms = now_ms - 5 * RTCP_INTERVAL_AUDIO_MS;
|
||||
|
||||
@ -612,8 +609,8 @@ bool RTCPReceiver::UpdateRTCPReceiveInformationTimers() {
|
||||
}
|
||||
|
||||
std::vector<rtcp::TmmbItem> RTCPReceiver::BoundingSet(bool* tmmbr_owner) {
|
||||
rtc::CritScope lock(&_criticalSectionRTCPReceiver);
|
||||
ReceiveInformation* receive_info = GetReceiveInformation(_remoteSSRC);
|
||||
rtc::CritScope lock(&rtcp_receiver_lock_);
|
||||
ReceiveInformation* receive_info = GetReceiveInformation(remote_ssrc_);
|
||||
if (!receive_info)
|
||||
return std::vector<rtcp::TmmbItem>();
|
||||
|
||||
@ -621,7 +618,7 @@ std::vector<rtcp::TmmbItem> RTCPReceiver::BoundingSet(bool* tmmbr_owner) {
|
||||
return receive_info->tmmbn;
|
||||
}
|
||||
|
||||
void RTCPReceiver::HandleSDES(const CommonHeader& rtcp_block,
|
||||
void RTCPReceiver::HandleSdes(const CommonHeader& rtcp_block,
|
||||
PacketInformation* packet_information) {
|
||||
rtcp::Sdes sdes;
|
||||
if (!sdes.Parse(rtcp_block)) {
|
||||
@ -640,7 +637,7 @@ void RTCPReceiver::HandleSDES(const CommonHeader& rtcp_block,
|
||||
packet_information->packet_type_flags |= kRtcpSdes;
|
||||
}
|
||||
|
||||
void RTCPReceiver::HandleNACK(const CommonHeader& rtcp_block,
|
||||
void RTCPReceiver::HandleNack(const CommonHeader& rtcp_block,
|
||||
PacketInformation* packet_information) {
|
||||
rtcp::Nack nack;
|
||||
if (!nack.Parse(rtcp_block)) {
|
||||
@ -665,14 +662,14 @@ void RTCPReceiver::HandleNACK(const CommonHeader& rtcp_block,
|
||||
}
|
||||
}
|
||||
|
||||
void RTCPReceiver::HandleBYE(const CommonHeader& rtcp_block) {
|
||||
void RTCPReceiver::HandleBye(const CommonHeader& rtcp_block) {
|
||||
rtcp::Bye bye;
|
||||
if (!bye.Parse(rtcp_block)) {
|
||||
++num_skipped_packets_;
|
||||
return;
|
||||
}
|
||||
|
||||
// clear our lists
|
||||
// Clear our lists.
|
||||
for (auto& reports_per_receiver : received_report_blocks_)
|
||||
reports_per_receiver.second.erase(bye.sender_ssrc());
|
||||
|
||||
@ -703,12 +700,11 @@ void RTCPReceiver::HandleXr(const CommonHeader& rtcp_block,
|
||||
HandleXrTargetBitrate(*xr.target_bitrate(), packet_information);
|
||||
}
|
||||
|
||||
void RTCPReceiver::HandleXrReceiveReferenceTime(
|
||||
uint32_t sender_ssrc,
|
||||
const rtcp::Rrtr& rrtr) {
|
||||
void RTCPReceiver::HandleXrReceiveReferenceTime(uint32_t sender_ssrc,
|
||||
const rtcp::Rrtr& rrtr) {
|
||||
remote_time_info_.ssrc = sender_ssrc;
|
||||
remote_time_info_.last_rr = CompactNtp(rrtr.ntp());
|
||||
last_received_xr_ntp_.SetCurrent(*_clock);
|
||||
last_received_xr_ntp_.SetCurrent(*clock_);
|
||||
}
|
||||
|
||||
void RTCPReceiver::HandleXrDlrrReportBlock(const rtcp::ReceiveTimeInfo& rti) {
|
||||
@ -720,16 +716,16 @@ void RTCPReceiver::HandleXrDlrrReportBlock(const rtcp::ReceiveTimeInfo& rti) {
|
||||
return;
|
||||
|
||||
// The send_time and delay_rr fields are in units of 1/2^16 sec.
|
||||
uint32_t send_time = rti.last_rr;
|
||||
uint32_t send_time_ntp = rti.last_rr;
|
||||
// RFC3611, section 4.5, LRR field discription states:
|
||||
// If no such block has been received, the field is set to zero.
|
||||
if (send_time == 0)
|
||||
if (send_time_ntp == 0)
|
||||
return;
|
||||
|
||||
uint32_t delay_rr = rti.delay_since_last_rr;
|
||||
uint32_t now = CompactNtp(NtpTime(*_clock));
|
||||
uint32_t delay_ntp = rti.delay_since_last_rr;
|
||||
uint32_t now_ntp = CompactNtp(NtpTime(*clock_));
|
||||
|
||||
uint32_t rtt_ntp = now - delay_rr - send_time;
|
||||
uint32_t rtt_ntp = now_ntp - delay_ntp - send_time_ntp;
|
||||
xr_rr_rtt_ms_ = CompactNtpRttToMs(rtt_ntp);
|
||||
}
|
||||
|
||||
@ -752,7 +748,7 @@ void RTCPReceiver::HandleXrTargetBitrate(
|
||||
packet_information->target_bitrate_allocation.emplace(bitrate_allocation);
|
||||
}
|
||||
|
||||
void RTCPReceiver::HandlePLI(const CommonHeader& rtcp_block,
|
||||
void RTCPReceiver::HandlePli(const CommonHeader& rtcp_block,
|
||||
PacketInformation* packet_information) {
|
||||
rtcp::Pli pli;
|
||||
if (!pli.Parse(rtcp_block)) {
|
||||
@ -769,7 +765,7 @@ void RTCPReceiver::HandlePLI(const CommonHeader& rtcp_block,
|
||||
}
|
||||
}
|
||||
|
||||
void RTCPReceiver::HandleTMMBR(const CommonHeader& rtcp_block,
|
||||
void RTCPReceiver::HandleTmmbr(const CommonHeader& rtcp_block,
|
||||
PacketInformation* packet_information) {
|
||||
rtcp::Tmmbr tmmbr;
|
||||
if (!tmmbr.Parse(rtcp_block)) {
|
||||
@ -794,14 +790,14 @@ void RTCPReceiver::HandleTMMBR(const CommonHeader& rtcp_block,
|
||||
entry->tmmbr_item = rtcp::TmmbItem(sender_ssrc,
|
||||
request.bitrate_bps(),
|
||||
request.packet_overhead());
|
||||
entry->last_updated_ms = _clock->TimeInMilliseconds();
|
||||
entry->last_updated_ms = clock_->TimeInMilliseconds();
|
||||
|
||||
packet_information->packet_type_flags |= kRtcpTmmbr;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void RTCPReceiver::HandleTMMBN(const CommonHeader& rtcp_block,
|
||||
void RTCPReceiver::HandleTmmbn(const CommonHeader& rtcp_block,
|
||||
PacketInformation* packet_information) {
|
||||
rtcp::Tmmbn tmmbn;
|
||||
if (!tmmbn.Parse(rtcp_block)) {
|
||||
@ -819,8 +815,8 @@ void RTCPReceiver::HandleTMMBN(const CommonHeader& rtcp_block,
|
||||
receive_info->tmmbn.push_back(item);
|
||||
}
|
||||
|
||||
void RTCPReceiver::HandleSR_REQ(const CommonHeader& rtcp_block,
|
||||
PacketInformation* packet_information) {
|
||||
void RTCPReceiver::HandleSrReq(const CommonHeader& rtcp_block,
|
||||
PacketInformation* packet_information) {
|
||||
rtcp::RapidResyncRequest sr_req;
|
||||
if (!sr_req.Parse(rtcp_block)) {
|
||||
++num_skipped_packets_;
|
||||
@ -830,7 +826,7 @@ void RTCPReceiver::HandleSR_REQ(const CommonHeader& rtcp_block,
|
||||
packet_information->packet_type_flags |= kRtcpSrReq;
|
||||
}
|
||||
|
||||
void RTCPReceiver::HandleSLI(const CommonHeader& rtcp_block,
|
||||
void RTCPReceiver::HandleSli(const CommonHeader& rtcp_block,
|
||||
PacketInformation* packet_information) {
|
||||
rtcp::Sli sli;
|
||||
if (!sli.Parse(rtcp_block)) {
|
||||
@ -846,7 +842,7 @@ void RTCPReceiver::HandleSLI(const CommonHeader& rtcp_block,
|
||||
}
|
||||
}
|
||||
|
||||
void RTCPReceiver::HandleRPSI(const CommonHeader& rtcp_block,
|
||||
void RTCPReceiver::HandleRpsi(const CommonHeader& rtcp_block,
|
||||
PacketInformation* packet_information) {
|
||||
rtcp::Rpsi rpsi;
|
||||
if (!rpsi.Parse(rtcp_block)) {
|
||||
@ -871,7 +867,7 @@ void RTCPReceiver::HandlePsfbApp(const CommonHeader& rtcp_block,
|
||||
++num_skipped_packets_;
|
||||
}
|
||||
|
||||
void RTCPReceiver::HandleFIR(const CommonHeader& rtcp_block,
|
||||
void RTCPReceiver::HandleFir(const CommonHeader& rtcp_block,
|
||||
PacketInformation* packet_information) {
|
||||
rtcp::Fir fir;
|
||||
if (!fir.Parse(rtcp_block)) {
|
||||
@ -882,7 +878,7 @@ void RTCPReceiver::HandleFIR(const CommonHeader& rtcp_block,
|
||||
ReceiveInformation* receive_info = GetReceiveInformation(fir.sender_ssrc());
|
||||
|
||||
for (const rtcp::Fir::Request& fir_request : fir.requests()) {
|
||||
// Is it our sender that is requested to generate a new keyframe
|
||||
// Is it our sender that is requested to generate a new keyframe.
|
||||
if (main_ssrc_ != fir_request.ssrc)
|
||||
continue;
|
||||
|
||||
@ -893,7 +889,7 @@ void RTCPReceiver::HandleFIR(const CommonHeader& rtcp_block,
|
||||
if (fir_request.seq_nr == receive_info->last_fir_sequence_number)
|
||||
continue;
|
||||
|
||||
int64_t now_ms = _clock->TimeInMilliseconds();
|
||||
int64_t now_ms = clock_->TimeInMilliseconds();
|
||||
// Sanity: don't go crazy with the callbacks.
|
||||
if (now_ms - receive_info->last_fir_request_ms < RTCP_MIN_FRAME_LENGTH_MS)
|
||||
continue;
|
||||
@ -933,7 +929,7 @@ void RTCPReceiver::UpdateTmmbr() {
|
||||
}
|
||||
|
||||
// Set bounding set: inform remote clients about the new bandwidth.
|
||||
_rtpRtcp.SetTmmbn(std::move(bounding));
|
||||
rtp_rtcp_->SetTmmbn(std::move(bounding));
|
||||
}
|
||||
|
||||
void RTCPReceiver::RegisterRtcpStatisticsCallback(
|
||||
@ -947,8 +943,8 @@ RtcpStatisticsCallback* RTCPReceiver::GetRtcpStatisticsCallback() {
|
||||
return stats_callback_;
|
||||
}
|
||||
|
||||
// Holding no Critical section
|
||||
void RTCPReceiver::TriggerCallbacksFromRTCPPacket(
|
||||
// Holding no Critical section.
|
||||
void RTCPReceiver::TriggerCallbacksFromRtcpPacket(
|
||||
const PacketInformation& packet_information) {
|
||||
// Process TMMBR and REMB first to avoid multiple callbacks
|
||||
// to OnNetworkChanged.
|
||||
@ -960,18 +956,18 @@ void RTCPReceiver::TriggerCallbacksFromRTCPPacket(
|
||||
std::set<uint32_t> registered_ssrcs;
|
||||
{
|
||||
// We don't want to hold this critsect when triggering the callbacks below.
|
||||
rtc::CritScope lock(&_criticalSectionRTCPReceiver);
|
||||
rtc::CritScope lock(&rtcp_receiver_lock_);
|
||||
local_ssrc = main_ssrc_;
|
||||
registered_ssrcs = registered_ssrcs_;
|
||||
}
|
||||
if (!receiver_only_ && (packet_information.packet_type_flags & kRtcpSrReq)) {
|
||||
_rtpRtcp.OnRequestSendReport();
|
||||
rtp_rtcp_->OnRequestSendReport();
|
||||
}
|
||||
if (!receiver_only_ && (packet_information.packet_type_flags & kRtcpNack)) {
|
||||
if (!packet_information.nack_sequence_numbers.empty()) {
|
||||
LOG(LS_VERBOSE) << "Incoming NACK length: "
|
||||
<< packet_information.nack_sequence_numbers.size();
|
||||
_rtpRtcp.OnReceivedNack(packet_information.nack_sequence_numbers);
|
||||
rtp_rtcp_->OnReceivedNack(packet_information.nack_sequence_numbers);
|
||||
}
|
||||
}
|
||||
|
||||
@ -1011,14 +1007,14 @@ void RTCPReceiver::TriggerCallbacksFromRTCPPacket(
|
||||
}
|
||||
if ((packet_information.packet_type_flags & kRtcpSr) ||
|
||||
(packet_information.packet_type_flags & kRtcpRr)) {
|
||||
int64_t now = _clock->TimeInMilliseconds();
|
||||
int64_t now_ms = clock_->TimeInMilliseconds();
|
||||
rtcp_bandwidth_observer_->OnReceivedRtcpReceiverReport(
|
||||
packet_information.report_blocks, packet_information.rtt_ms, now);
|
||||
packet_information.report_blocks, packet_information.rtt_ms, now_ms);
|
||||
}
|
||||
}
|
||||
if ((packet_information.packet_type_flags & kRtcpSr) ||
|
||||
(packet_information.packet_type_flags & kRtcpRr)) {
|
||||
_rtpRtcp.OnReceivedRtcpReportBlocks(packet_information.report_blocks);
|
||||
rtp_rtcp_->OnReceivedRtcpReportBlocks(packet_information.report_blocks);
|
||||
}
|
||||
|
||||
if (transport_feedback_observer_ &&
|
||||
@ -1058,7 +1054,7 @@ int32_t RTCPReceiver::CNAME(uint32_t remoteSSRC,
|
||||
char cName[RTCP_CNAME_SIZE]) const {
|
||||
RTC_DCHECK(cName);
|
||||
|
||||
rtc::CritScope lock(&_criticalSectionRTCPReceiver);
|
||||
rtc::CritScope lock(&rtcp_receiver_lock_);
|
||||
auto received_cname_it = received_cnames_.find(remoteSSRC);
|
||||
if (received_cname_it == received_cnames_.end())
|
||||
return -1;
|
||||
@ -1069,10 +1065,10 @@ int32_t RTCPReceiver::CNAME(uint32_t remoteSSRC,
|
||||
}
|
||||
|
||||
std::vector<rtcp::TmmbItem> RTCPReceiver::TmmbrReceived() {
|
||||
rtc::CritScope lock(&_criticalSectionRTCPReceiver);
|
||||
rtc::CritScope lock(&rtcp_receiver_lock_);
|
||||
std::vector<rtcp::TmmbItem> candidates;
|
||||
|
||||
int64_t now_ms = _clock->TimeInMilliseconds();
|
||||
int64_t now_ms = clock_->TimeInMilliseconds();
|
||||
// Use audio define since we don't know what interval the remote peer use.
|
||||
int64_t timeouted_ms = now_ms - 5 * RTCP_INTERVAL_AUDIO_MS;
|
||||
|
||||
|
||||
@ -67,14 +67,14 @@ class RTCPReceiver {
|
||||
void SetRemoteSSRC(uint32_t ssrc);
|
||||
uint32_t RemoteSSRC() const;
|
||||
|
||||
// get received cname
|
||||
int32_t CNAME(uint32_t remoteSSRC, char cName[RTCP_CNAME_SIZE]) const;
|
||||
// Get received cname.
|
||||
int32_t CNAME(uint32_t remote_ssrc, char cname[RTCP_CNAME_SIZE]) const;
|
||||
|
||||
// get received NTP
|
||||
bool NTP(uint32_t* ReceivedNTPsecs,
|
||||
uint32_t* ReceivedNTPfrac,
|
||||
uint32_t* RTCPArrivalTimeSecs,
|
||||
uint32_t* RTCPArrivalTimeFrac,
|
||||
// Get received NTP.
|
||||
bool NTP(uint32_t* received_ntp_secs,
|
||||
uint32_t* received_ntp_frac,
|
||||
uint32_t* rtcp_arrival_time_secs,
|
||||
uint32_t* rtcp_arrival_time_frac,
|
||||
uint32_t* rtcp_timestamp) const;
|
||||
|
||||
bool LastReceivedXrReferenceTimeInfo(rtcp::ReceiveTimeInfo* info) const;
|
||||
@ -86,12 +86,12 @@ class RTCPReceiver {
|
||||
int64_t* min_rtt_ms,
|
||||
int64_t* max_rtt_ms) const;
|
||||
|
||||
int32_t SenderInfoReceived(RTCPSenderInfo* senderInfo) const;
|
||||
int32_t SenderInfoReceived(RTCPSenderInfo* sender_info) const;
|
||||
|
||||
void SetRtcpXrRrtrStatus(bool enable);
|
||||
bool GetAndResetXrRrRtt(int64_t* rtt_ms);
|
||||
|
||||
// get statistics
|
||||
// Get statistics.
|
||||
int32_t StatisticsReceived(std::vector<RTCPReportBlock>* receiveBlocks) const;
|
||||
|
||||
// Returns true if we haven't received an RTCP RR for several RTCP
|
||||
@ -130,92 +130,92 @@ class RTCPReceiver {
|
||||
const uint8_t* packet_end,
|
||||
PacketInformation* packet_information);
|
||||
|
||||
void TriggerCallbacksFromRTCPPacket(
|
||||
void TriggerCallbacksFromRtcpPacket(
|
||||
const PacketInformation& packet_information);
|
||||
|
||||
void CreateReceiveInformation(uint32_t remote_ssrc)
|
||||
EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver);
|
||||
EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
|
||||
ReceiveInformation* GetReceiveInformation(uint32_t remote_ssrc)
|
||||
EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver);
|
||||
EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
|
||||
|
||||
void HandleSenderReport(const rtcp::CommonHeader& rtcp_block,
|
||||
PacketInformation* packet_information)
|
||||
EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver);
|
||||
EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
|
||||
|
||||
void HandleReceiverReport(const rtcp::CommonHeader& rtcp_block,
|
||||
PacketInformation* packet_information)
|
||||
EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver);
|
||||
EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
|
||||
|
||||
void HandleReportBlock(const rtcp::ReportBlock& report_block,
|
||||
PacketInformation* packet_information,
|
||||
uint32_t remoteSSRC)
|
||||
EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver);
|
||||
uint32_t remote_ssrc)
|
||||
EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
|
||||
|
||||
void HandleSDES(const rtcp::CommonHeader& rtcp_block,
|
||||
void HandleSdes(const rtcp::CommonHeader& rtcp_block,
|
||||
PacketInformation* packet_information)
|
||||
EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver);
|
||||
EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
|
||||
|
||||
void HandleXr(const rtcp::CommonHeader& rtcp_block,
|
||||
PacketInformation* packet_information)
|
||||
EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver);
|
||||
EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
|
||||
|
||||
void HandleXrReceiveReferenceTime(uint32_t sender_ssrc,
|
||||
const rtcp::Rrtr& rrtr)
|
||||
EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver);
|
||||
EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
|
||||
|
||||
void HandleXrDlrrReportBlock(const rtcp::ReceiveTimeInfo& rti)
|
||||
EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver);
|
||||
EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
|
||||
|
||||
void HandleXrTargetBitrate(const rtcp::TargetBitrate& target_bitrate,
|
||||
PacketInformation* packet_information)
|
||||
EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver);
|
||||
EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
|
||||
|
||||
void HandleNACK(const rtcp::CommonHeader& rtcp_block,
|
||||
void HandleNack(const rtcp::CommonHeader& rtcp_block,
|
||||
PacketInformation* packet_information)
|
||||
EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver);
|
||||
EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
|
||||
|
||||
void HandleBYE(const rtcp::CommonHeader& rtcp_block)
|
||||
EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver);
|
||||
void HandleBye(const rtcp::CommonHeader& rtcp_block)
|
||||
EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
|
||||
|
||||
void HandlePLI(const rtcp::CommonHeader& rtcp_block,
|
||||
void HandlePli(const rtcp::CommonHeader& rtcp_block,
|
||||
PacketInformation* packet_information)
|
||||
EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver);
|
||||
EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
|
||||
|
||||
void HandleSLI(const rtcp::CommonHeader& rtcp_block,
|
||||
void HandleSli(const rtcp::CommonHeader& rtcp_block,
|
||||
PacketInformation* packet_information)
|
||||
EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver);
|
||||
EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
|
||||
|
||||
void HandleRPSI(const rtcp::CommonHeader& rtcp_block,
|
||||
void HandleRpsi(const rtcp::CommonHeader& rtcp_block,
|
||||
PacketInformation* packet_information)
|
||||
EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver);
|
||||
EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
|
||||
|
||||
void HandlePsfbApp(const rtcp::CommonHeader& rtcp_block,
|
||||
PacketInformation* packet_information)
|
||||
EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver);
|
||||
EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
|
||||
|
||||
void HandleTMMBR(const rtcp::CommonHeader& rtcp_block,
|
||||
void HandleTmmbr(const rtcp::CommonHeader& rtcp_block,
|
||||
PacketInformation* packet_information)
|
||||
EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver);
|
||||
EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
|
||||
|
||||
void HandleTMMBN(const rtcp::CommonHeader& rtcp_block,
|
||||
void HandleTmmbn(const rtcp::CommonHeader& rtcp_block,
|
||||
PacketInformation* packet_information)
|
||||
EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver);
|
||||
EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
|
||||
|
||||
void HandleSR_REQ(const rtcp::CommonHeader& rtcp_block,
|
||||
PacketInformation* packet_information)
|
||||
EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver);
|
||||
void HandleSrReq(const rtcp::CommonHeader& rtcp_block,
|
||||
PacketInformation* packet_information)
|
||||
EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
|
||||
|
||||
void HandleFIR(const rtcp::CommonHeader& rtcp_block,
|
||||
void HandleFir(const rtcp::CommonHeader& rtcp_block,
|
||||
PacketInformation* packet_information)
|
||||
EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver);
|
||||
EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
|
||||
|
||||
void HandleTransportFeedback(const rtcp::CommonHeader& rtcp_block,
|
||||
PacketInformation* packet_information)
|
||||
EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver);
|
||||
EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
|
||||
|
||||
Clock* const _clock;
|
||||
Clock* const clock_;
|
||||
const bool receiver_only_;
|
||||
ModuleRtpRtcp& _rtpRtcp;
|
||||
ModuleRtpRtcp* const rtp_rtcp_;
|
||||
|
||||
rtc::CriticalSection feedbacks_lock_;
|
||||
RtcpBandwidthObserver* const rtcp_bandwidth_observer_;
|
||||
@ -223,13 +223,13 @@ class RTCPReceiver {
|
||||
TransportFeedbackObserver* const transport_feedback_observer_;
|
||||
VideoBitrateAllocationObserver* const bitrate_allocation_observer_;
|
||||
|
||||
rtc::CriticalSection _criticalSectionRTCPReceiver;
|
||||
uint32_t main_ssrc_ GUARDED_BY(_criticalSectionRTCPReceiver);
|
||||
uint32_t _remoteSSRC GUARDED_BY(_criticalSectionRTCPReceiver);
|
||||
std::set<uint32_t> registered_ssrcs_ GUARDED_BY(_criticalSectionRTCPReceiver);
|
||||
rtc::CriticalSection rtcp_receiver_lock_;
|
||||
uint32_t main_ssrc_ GUARDED_BY(rtcp_receiver_lock_);
|
||||
uint32_t remote_ssrc_ GUARDED_BY(rtcp_receiver_lock_);
|
||||
std::set<uint32_t> registered_ssrcs_ GUARDED_BY(rtcp_receiver_lock_);
|
||||
|
||||
// Received send report
|
||||
RTCPSenderInfo _remoteSenderInfo;
|
||||
// Received sender report.
|
||||
RTCPSenderInfo remote_sender_info_;
|
||||
// When did we receive the last send report.
|
||||
NtpTime last_received_sr_ntp_;
|
||||
|
||||
@ -238,22 +238,21 @@ class RTCPReceiver {
|
||||
// Time when the report was received.
|
||||
NtpTime last_received_xr_ntp_;
|
||||
// Estimated rtt, zero when there is no valid estimate.
|
||||
bool xr_rrtr_status_ GUARDED_BY(_criticalSectionRTCPReceiver);
|
||||
bool xr_rrtr_status_ GUARDED_BY(rtcp_receiver_lock_);
|
||||
int64_t xr_rr_rtt_ms_;
|
||||
|
||||
// Received report blocks.
|
||||
ReportBlockMap received_report_blocks_
|
||||
GUARDED_BY(_criticalSectionRTCPReceiver);
|
||||
ReceivedInfoMap received_infos_ GUARDED_BY(_criticalSectionRTCPReceiver);
|
||||
ReportBlockMap received_report_blocks_ GUARDED_BY(rtcp_receiver_lock_);
|
||||
ReceivedInfoMap received_infos_ GUARDED_BY(rtcp_receiver_lock_);
|
||||
std::map<uint32_t, std::string> received_cnames_
|
||||
GUARDED_BY(_criticalSectionRTCPReceiver);
|
||||
GUARDED_BY(rtcp_receiver_lock_);
|
||||
|
||||
// The last time we received an RTCP RR.
|
||||
int64_t _lastReceivedRrMs;
|
||||
int64_t last_received_rr_ms_;
|
||||
|
||||
// The time we last received an RTCP RR telling we have successfully
|
||||
// delivered RTP packet to the remote side.
|
||||
int64_t _lastIncreasedSequenceNumberMs;
|
||||
int64_t last_increased_sequence_number_ms_;
|
||||
|
||||
RtcpStatisticsCallback* stats_callback_ GUARDED_BY(feedbacks_lock_);
|
||||
|
||||
@ -263,7 +262,7 @@ class RTCPReceiver {
|
||||
RTCPUtility::NackStats nack_stats_;
|
||||
|
||||
size_t num_skipped_packets_;
|
||||
int64_t last_skipped_packets_warning_;
|
||||
int64_t last_skipped_packets_warning_ms_;
|
||||
};
|
||||
} // namespace webrtc
|
||||
#endif // WEBRTC_MODULES_RTP_RTCP_SOURCE_RTCP_RECEIVER_H_
|
||||
|
||||
@ -38,7 +38,6 @@
|
||||
namespace webrtc {
|
||||
|
||||
class ModuleRtpRtcpImpl;
|
||||
class RTCPReceiver;
|
||||
class RtcEventLog;
|
||||
|
||||
class NACKStringBuilder {
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user