zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

ReportBlockData and observer added, for stats collection in future CLs.

Browse Source 
The ReportBlockData contains information about a ReportBlock and
additional data such as RTT. This will be used for the calculation of
RTCRemoteInboundRtpStreamStats, see full picture here:
https://webrtc-review.googlesource.com/c/src/+/134107

ReportBlockData is a class version of the previously internal struct
RTCPReceiver::ReportBlockWithRtt.
- The new name makes sense even if we add more info to it, which will
  be needed for future metrics.
- The new location is modules/rtp_rtcp/include/report_block_data.h.

The RTCPReceiver allows obtaining the ReportBlockData in two ways:
1. Using a ReportBlockDataObserver that is notified on receiving a
   report block.
2. Using the GetLatestReportBlockData().

Both codepaths will be needed; video stats uses observers and audio
stats uses polling.

Further plumbing will be done in follow-up CLs.

Bug: webrtc:10455, webrtc:10456
Change-Id: Ic9e5b4f451b5f4b203efcd6fa3bbf9736487e1f4
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/136584
Commit-Queue: Henrik Boström <hbos@webrtc.org>
Reviewed-by: Danil Chapovalov <danilchap@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#27961}
This commit is contained in:
Henrik Boström
2019-05-16 13:32:20 +02:00
committed by Commit Bot
parent 8d3d6cf908
commit f204787478
6 changed files with 377 additions and 45 deletions
Download Patch File Download Diff File Expand all files Collapse all files

93
modules/rtp_rtcp/source/rtcp_receiver.cc
View File

@ -42,6 +42,7 @@
#include "modules/rtp_rtcp/source/tmmbr_help.h"
#include "rtc_base/checks.h"
#include "rtc_base/logging.h"
#include "rtc_base/time_utils.h"
#include "rtc_base/trace_event.h"
#include "system_wrappers/include/ntp_time.h"
@ -69,7 +70,9 @@ struct RTCPReceiver::PacketInformation {
uint32_t remote_ssrc = 0;
std::vector<uint16_t> nack_sequence_numbers;
// TODO(hbos): Remove |report_blocks| in favor of |report_block_datas|.
ReportBlockList report_blocks;
std::vector<ReportBlockData> report_block_datas;
int64_t rtt_ms = 0;
uint32_t receiver_estimated_max_bitrate_bps = 0;
std::unique_ptr<rtcp::TransportFeedback> transport_feedback;
@ -108,16 +111,6 @@ struct RTCPReceiver::RrtrInformation {
uint32_t local_receive_mid_ntp_time;
};
struct RTCPReceiver::ReportBlockWithRtt {
RTCPReportBlock report_block;
int64_t last_rtt_ms = 0;
int64_t min_rtt_ms = 0;
int64_t max_rtt_ms = 0;
int64_t sum_rtt_ms = 0;
size_t num_rtts = 0;
};
struct RTCPReceiver::LastFirStatus {
LastFirStatus(int64_t now_ms, uint8_t sequence_number)
: request_ms(now_ms), sequence_number(sequence_number) {}
@ -154,6 +147,7 @@ RTCPReceiver::RTCPReceiver(
last_received_rb_ms_(0),
last_increased_sequence_number_ms_(0),
stats_callback_(nullptr),
report_block_data_observer_(nullptr),
packet_type_counter_observer_(packet_type_counter_observer),
num_skipped_packets_(0),
last_skipped_packets_warning_ms_(clock->TimeInMilliseconds()) {
@ -213,22 +207,24 @@ int32_t RTCPReceiver::RTT(uint32_t remote_ssrc,
if (it_info == it->second.end())
return -1;
const ReportBlockWithRtt* report_block = &it_info->second;
const ReportBlockData* report_block_data = &it_info->second;
if (report_block->num_rtts == 0)
if (report_block_data->num_rtts() == 0)
return -1;
if (last_rtt_ms)
*last_rtt_ms = report_block->last_rtt_ms;
*last_rtt_ms = report_block_data->last_rtt_ms();
if (avg_rtt_ms)
*avg_rtt_ms = report_block->sum_rtt_ms / report_block->num_rtts;
if (avg_rtt_ms) {
*avg_rtt_ms =
report_block_data->sum_rtt_ms() / report_block_data->num_rtts();
}
if (min_rtt_ms)
*min_rtt_ms = report_block->min_rtt_ms;
*min_rtt_ms = report_block_data->min_rtt_ms();
if (max_rtt_ms)
*max_rtt_ms = report_block->max_rtt_ms;
*max_rtt_ms = report_block_data->max_rtt_ms();
return 0;
}
@ -307,10 +303,19 @@ int32_t RTCPReceiver::StatisticsReceived(
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);
receive_blocks->push_back(report.second.report_block());
return 0;
}
std::vector<ReportBlockData> RTCPReceiver::GetLatestReportBlockData() const {
std::vector<ReportBlockData> result;
rtc::CritScope lock(&rtcp_receiver_lock_);
for (const auto& reports_per_receiver : received_report_blocks_)
for (const auto& report : reports_per_receiver.second)
result.push_back(report.second);
return result;
}
bool RTCPReceiver::ParseCompoundPacket(const uint8_t* packet_begin,
const uint8_t* packet_end,
PacketInformation* packet_information) {
@ -483,26 +488,26 @@ void RTCPReceiver::HandleReportBlock(const ReportBlock& report_block,
last_received_rb_ms_ = clock_->TimeInMilliseconds();
ReportBlockWithRtt* report_block_info =
ReportBlockData* report_block_data =
&received_report_blocks_[report_block.source_ssrc()][remote_ssrc];
report_block_info->report_block.sender_ssrc = remote_ssrc;
report_block_info->report_block.source_ssrc = report_block.source_ssrc();
report_block_info->report_block.fraction_lost = report_block.fraction_lost();
report_block_info->report_block.packets_lost =
report_block.cumulative_lost_signed();
RTCPReportBlock rtcp_report_block;
rtcp_report_block.sender_ssrc = remote_ssrc;
rtcp_report_block.source_ssrc = report_block.source_ssrc();
rtcp_report_block.fraction_lost = report_block.fraction_lost();
rtcp_report_block.packets_lost = report_block.cumulative_lost_signed();
if (report_block.extended_high_seq_num() >
report_block_info->report_block.extended_highest_sequence_number) {
report_block_data->report_block().extended_highest_sequence_number) {
// We have successfully delivered new RTP packets to the remote side after
// the last RR was sent from the remote side.
last_increased_sequence_number_ms_ = clock_->TimeInMilliseconds();
}
report_block_info->report_block.extended_highest_sequence_number =
rtcp_report_block.extended_highest_sequence_number =
report_block.extended_high_seq_num();
report_block_info->report_block.jitter = report_block.jitter();
report_block_info->report_block.delay_since_last_sender_report =
rtcp_report_block.jitter = report_block.jitter();
rtcp_report_block.delay_since_last_sender_report =
report_block.delay_since_last_sr();
report_block_info->report_block.last_sender_report_timestamp =
report_block.last_sr();
rtcp_report_block.last_sender_report_timestamp = report_block.last_sr();
report_block_data->SetReportBlock(rtcp_report_block, rtc::TimeUTCMicros());
int64_t rtt_ms = 0;
uint32_t send_time_ntp = report_block.last_sr();
@ -527,21 +532,14 @@ void RTCPReceiver::HandleReportBlock(const ReportBlock& report_block,
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)
report_block_info->max_rtt_ms = rtt_ms;
if (report_block_info->num_rtts == 0 ||
rtt_ms < report_block_info->min_rtt_ms)
report_block_info->min_rtt_ms = rtt_ms;
report_block_info->last_rtt_ms = rtt_ms;
report_block_info->sum_rtt_ms += rtt_ms;
++report_block_info->num_rtts;
report_block_data->AddRoundTripTimeSample(rtt_ms);
packet_information->rtt_ms = rtt_ms;
}
packet_information->report_blocks.push_back(report_block_info->report_block);
packet_information->report_blocks.push_back(
report_block_data->report_block());
packet_information->report_block_datas.push_back(*report_block_data);
}
RTCPReceiver::TmmbrInformation* RTCPReceiver::FindOrCreateTmmbrInfo(
@ -975,6 +973,12 @@ RtcpStatisticsCallback* RTCPReceiver::GetRtcpStatisticsCallback() {
return stats_callback_;
}
void RTCPReceiver::SetReportBlockDataObserver(
ReportBlockDataObserver* observer) {
rtc::CritScope cs(&feedbacks_lock_);
report_block_data_observer_ = observer;
}
// Holding no Critical section.
void RTCPReceiver::TriggerCallbacksFromRtcpPacket(
const PacketInformation& packet_information) {
@ -1085,6 +1089,13 @@ void RTCPReceiver::TriggerCallbacksFromRtcpPacket(
stats_callback_->StatisticsUpdated(stats, report_block.source_ssrc);
}
}
if (report_block_data_observer_) {
for (const auto& report_block_data :
packet_information.report_block_datas) {
report_block_data_observer_->OnReportBlockDataUpdated(
report_block_data);
}
}
}
}