admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Rename some variables and methods in RTC event log.

Browse Source 
Rename loss based and delay based bwe updates in proto (and correspondingly in the C++ code).

BUG=webrtc:6423

Review-Url: https://codereview.webrtc.org/2705613002
Cr-Commit-Position: refs/heads/master@{#16719}
This commit is contained in:
terelius 2017-02-20 05:14:41 -08:00 committed by Commit bot
parent 21e4e0b0ab
commit 424e6cfd58
14 changed files with 114 additions and 113 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
webrtc/logging/rtc_event_log/mock/mock_rtc_event_log.h
View File

@ -54,13 +54,13 @@ class MockRtcEventLog : public RtcEventLog {
MOCK_METHOD1(LogAudioPlayout, void(uint32_t ssrc));
MOCK_METHOD3(LogBwePacketLossEvent,
void(int32_t bitrate,
MOCK_METHOD3(LogLossBasedBweUpdate,
void(int32_t bitrate_bps,
uint8_t fraction_loss,
int32_t total_packets));
MOCK_METHOD2(LogBwePacketDelayEvent,
void(int32_t bitrate, BandwidthUsage detector_state));
MOCK_METHOD2(LogDelayBasedBweUpdate,
void(int32_t bitrate_bps, BandwidthUsage detector_state));
MOCK_METHOD1(LogAudioNetworkAdaptation,
void(const AudioNetworkAdaptor::EncoderRuntimeConfig& config));

30
webrtc/logging/rtc_event_log/rtc_event_log.cc
View File

@ -74,10 +74,10 @@ class RtcEventLogImpl final : public RtcEventLog {
const uint8_t* packet,
size_t length) override;
void LogAudioPlayout(uint32_t ssrc) override;
void LogBwePacketLossEvent(int32_t bitrate,
void LogLossBasedBweUpdate(int32_t bitrate_bps,
uint8_t fraction_loss,
int32_t total_packets) override;
void LogBwePacketDelayEvent(int32_t bitrate,
void LogDelayBasedBweUpdate(int32_t bitrate_bps,
BandwidthUsage detector_state) override;
void LogAudioNetworkAdaptation(
const AudioNetworkAdaptor::EncoderRuntimeConfig& config) override;
@ -131,18 +131,18 @@ rtclog::MediaType ConvertMediaType(MediaType media_type) {
return rtclog::ANY;
}
rtclog::BwePacketDelayEvent::DetectorState ConvertDetectorState(
rtclog::DelayBasedBweUpdate::DetectorState ConvertDetectorState(
BandwidthUsage state) {
switch (state) {
case BandwidthUsage::kBwNormal:
return rtclog::BwePacketDelayEvent::BWE_NORMAL;
return rtclog::DelayBasedBweUpdate::BWE_NORMAL;
case BandwidthUsage::kBwUnderusing:
return rtclog::BwePacketDelayEvent::BWE_UNDERUSING;
return rtclog::DelayBasedBweUpdate::BWE_UNDERUSING;
case BandwidthUsage::kBwOverusing:
return rtclog::BwePacketDelayEvent::BWE_OVERUSING;
return rtclog::DelayBasedBweUpdate::BWE_OVERUSING;
}
RTC_NOTREACHED();
return rtclog::BwePacketDelayEvent::BWE_NORMAL;
return rtclog::DelayBasedBweUpdate::BWE_NORMAL;
}
// The RTP and RTCP buffers reserve space for twice the expected number of
@ -439,26 +439,26 @@ void RtcEventLogImpl::LogAudioPlayout(uint32_t ssrc) {
StoreEvent(&event);
}
void RtcEventLogImpl::LogBwePacketLossEvent(int32_t bitrate,
void RtcEventLogImpl::LogLossBasedBweUpdate(int32_t bitrate_bps,
uint8_t fraction_loss,
int32_t total_packets) {
std::unique_ptr<rtclog::Event> event(new rtclog::Event());
event->set_timestamp_us(rtc::TimeMicros());
event->set_type(rtclog::Event::BWE_PACKET_LOSS_EVENT);
auto bwe_event = event->mutable_bwe_packet_loss_event();
bwe_event->set_bitrate(bitrate);
event->set_type(rtclog::Event::LOSS_BASED_BWE_UPDATE);
auto bwe_event = event->mutable_loss_based_bwe_update();
bwe_event->set_bitrate_bps(bitrate_bps);
bwe_event->set_fraction_loss(fraction_loss);
bwe_event->set_total_packets(total_packets);
StoreEvent(&event);
}
void RtcEventLogImpl::LogBwePacketDelayEvent(int32_t bitrate,
void RtcEventLogImpl::LogDelayBasedBweUpdate(int32_t bitrate_bps,
BandwidthUsage detector_state) {
std::unique_ptr<rtclog::Event> event(new rtclog::Event());
event->set_timestamp_us(rtc::TimeMicros());
event->set_type(rtclog::Event::BWE_PACKET_DELAY_EVENT);
auto bwe_event = event->mutable_bwe_packet_delay_event();
bwe_event->set_bitrate(bitrate);
event->set_type(rtclog::Event::DELAY_BASED_BWE_UPDATE);
auto bwe_event = event->mutable_delay_based_bwe_update();
bwe_event->set_bitrate_bps(bitrate_bps);
bwe_event->set_detector_state(ConvertDetectorState(detector_state));
StoreEvent(&event);
}

8
webrtc/logging/rtc_event_log/rtc_event_log.h
View File

@ -112,12 +112,12 @@ class RtcEventLog {
virtual void LogAudioPlayout(uint32_t ssrc) = 0;
// Logs a bitrate update from the bandwidth estimator based on packet loss.
virtual void LogBwePacketLossEvent(int32_t bitrate,
virtual void LogLossBasedBweUpdate(int32_t bitrate_bps,
uint8_t fraction_loss,
int32_t total_packets) = 0;
// Logs a bitrate update from the bandwidth estimator based on delay changes.
virtual void LogBwePacketDelayEvent(int32_t bitrate,
virtual void LogDelayBasedBweUpdate(int32_t bitrate_bps,
BandwidthUsage detector_state) = 0;
// Logs audio encoder re-configuration driven by audio network adaptor.
@ -162,10 +162,10 @@ class RtcEventLogNullImpl final : public RtcEventLog {
const uint8_t* packet,
size_t length) override {}
void LogAudioPlayout(uint32_t ssrc) override {}
void LogBwePacketLossEvent(int32_t bitrate,
void LogLossBasedBweUpdate(int32_t bitrate_bps,
uint8_t fraction_loss,
int32_t total_packets) override {}
void LogBwePacketDelayEvent(int32_t bitrate,
void LogDelayBasedBweUpdate(int32_t bitrate_bps,
BandwidthUsage detector_state) override {}
void LogAudioNetworkAdaptation(
const AudioNetworkAdaptor::EncoderRuntimeConfig& config) override {}

20
webrtc/logging/rtc_event_log/rtc_event_log.proto
View File

@ -31,8 +31,8 @@ message Event {
RTP_EVENT = 3;
RTCP_EVENT = 4;
AUDIO_PLAYOUT_EVENT = 5;
BWE_PACKET_LOSS_EVENT = 6;
BWE_PACKET_DELAY_EVENT = 7;
LOSS_BASED_BWE_UPDATE = 6;
DELAY_BASED_BWE_UPDATE = 7;
VIDEO_RECEIVER_CONFIG_EVENT = 8;
VIDEO_SENDER_CONFIG_EVENT = 9;
AUDIO_RECEIVER_CONFIG_EVENT = 10;
@ -52,11 +52,11 @@ message Event {
// optional - but required if type == AUDIO_PLAYOUT_EVENT
optional AudioPlayoutEvent audio_playout_event = 5;
// optional - but required if type == BWE_PACKET_LOSS_EVENT
optional BwePacketLossEvent bwe_packet_loss_event = 6;
// optional - but required if type == LOSS_BASED_BWE_UPDATE
optional LossBasedBweUpdate loss_based_bwe_update = 6;
// optional - but required if type == BWE_PACKET_DELAY_EVENT
optional BwePacketDelayEvent bwe_packet_delay_event = 7;
// optional - but required if type == DELAY_BASED_BWE_UPDATE
optional DelayBasedBweUpdate delay_based_bwe_update = 7;
// optional - but required if type == VIDEO_RECEIVER_CONFIG_EVENT
optional VideoReceiveConfig video_receiver_config = 8;
@ -106,9 +106,9 @@ message AudioPlayoutEvent {
optional uint32 local_ssrc = 2;
}
message BwePacketLossEvent {
message LossBasedBweUpdate {
// required - Bandwidth estimate (in bps) after the update.
optional int32 bitrate = 1;
optional int32 bitrate_bps = 1;
// required - Fraction of lost packets since last receiver report
// computed as floor( 256 * (#lost_packets / #total_packets) ).
@ -120,7 +120,7 @@ message BwePacketLossEvent {
optional int32 total_packets = 3;
}
message BwePacketDelayEvent {
message DelayBasedBweUpdate {
enum DetectorState {
BWE_NORMAL = 0;
BWE_UNDERUSING = 1;
@ -128,7 +128,7 @@ message BwePacketDelayEvent {
}
// required - Bandwidth estimate (in bps) after the update.
optional int32 bitrate = 1;
optional int32 bitrate_bps = 1;
// required - The state of the overuse detector.
optional DetectorState detector_state = 2;

50
webrtc/logging/rtc_event_log/rtc_event_log_parser.cc
View File

@ -69,10 +69,10 @@ ParsedRtcEventLog::EventType GetRuntimeEventType(
return ParsedRtcEventLog::EventType::RTCP_EVENT;
case rtclog::Event::AUDIO_PLAYOUT_EVENT:
return ParsedRtcEventLog::EventType::AUDIO_PLAYOUT_EVENT;
case rtclog::Event::BWE_PACKET_LOSS_EVENT:
return ParsedRtcEventLog::EventType::BWE_PACKET_LOSS_EVENT;
case rtclog::Event::BWE_PACKET_DELAY_EVENT:
return ParsedRtcEventLog::EventType::BWE_PACKET_DELAY_EVENT;
case rtclog::Event::LOSS_BASED_BWE_UPDATE:
return ParsedRtcEventLog::EventType::LOSS_BASED_BWE_UPDATE;
case rtclog::Event::DELAY_BASED_BWE_UPDATE:
return ParsedRtcEventLog::EventType::DELAY_BASED_BWE_UPDATE;
case rtclog::Event::VIDEO_RECEIVER_CONFIG_EVENT:
return ParsedRtcEventLog::EventType::VIDEO_RECEIVER_CONFIG_EVENT;
case rtclog::Event::VIDEO_SENDER_CONFIG_EVENT:
@ -89,13 +89,13 @@ ParsedRtcEventLog::EventType GetRuntimeEventType(
}
BandwidthUsage GetRuntimeDetectorState(
rtclog::BwePacketDelayEvent::DetectorState detector_state) {
rtclog::DelayBasedBweUpdate::DetectorState detector_state) {
switch (detector_state) {
case rtclog::BwePacketDelayEvent::BWE_NORMAL:
case rtclog::DelayBasedBweUpdate::BWE_NORMAL:
return kBwNormal;
case rtclog::BwePacketDelayEvent::BWE_UNDERUSING:
case rtclog::DelayBasedBweUpdate::BWE_UNDERUSING:
return kBwUnderusing;
case rtclog::BwePacketDelayEvent::BWE_OVERUSING:
case rtclog::DelayBasedBweUpdate::BWE_OVERUSING:
return kBwOverusing;
}
RTC_NOTREACHED();
@ -461,19 +461,19 @@ void ParsedRtcEventLog::GetAudioPlayout(size_t index, uint32_t* ssrc) const {
}
}
void ParsedRtcEventLog::GetBwePacketLossEvent(size_t index,
int32_t* bitrate,
void ParsedRtcEventLog::GetLossBasedBweUpdate(size_t index,
int32_t* bitrate_bps,
uint8_t* fraction_loss,
int32_t* total_packets) const {
RTC_CHECK_LT(index, GetNumberOfEvents());
const rtclog::Event& event = events_[index];
RTC_CHECK(event.has_type());
RTC_CHECK_EQ(event.type(), rtclog::Event::BWE_PACKET_LOSS_EVENT);
RTC_CHECK(event.has_bwe_packet_loss_event());
const rtclog::BwePacketLossEvent& loss_event = event.bwe_packet_loss_event();
RTC_CHECK(loss_event.has_bitrate());
if (bitrate != nullptr) {
*bitrate = loss_event.bitrate();
RTC_CHECK_EQ(event.type(), rtclog::Event::LOSS_BASED_BWE_UPDATE);
RTC_CHECK(event.has_loss_based_bwe_update());
const rtclog::LossBasedBweUpdate& loss_event = event.loss_based_bwe_update();
RTC_CHECK(loss_event.has_bitrate_bps());
if (bitrate_bps != nullptr) {
*bitrate_bps = loss_event.bitrate_bps();
}
RTC_CHECK(loss_event.has_fraction_loss());
if (fraction_loss != nullptr) {
@ -485,20 +485,20 @@ void ParsedRtcEventLog::GetBwePacketLossEvent(size_t index,
}
}
void ParsedRtcEventLog::GetBwePacketDelayEvent(
void ParsedRtcEventLog::GetDelayBasedBweUpdate(
size_t index,
int32_t* bitrate,
int32_t* bitrate_bps,
BandwidthUsage* detector_state) const {
RTC_CHECK_LT(index, GetNumberOfEvents());
const rtclog::Event& event = events_[index];
RTC_CHECK(event.has_type());
RTC_CHECK_EQ(event.type(), rtclog::Event::BWE_PACKET_DELAY_EVENT);
RTC_CHECK(event.has_bwe_packet_delay_event());
const rtclog::BwePacketDelayEvent& delay_event =
event.bwe_packet_delay_event();
RTC_CHECK(delay_event.has_bitrate());
if (bitrate != nullptr) {
*bitrate = delay_event.bitrate();
RTC_CHECK_EQ(event.type(), rtclog::Event::DELAY_BASED_BWE_UPDATE);
RTC_CHECK(event.has_delay_based_bwe_update());
const rtclog::DelayBasedBweUpdate& delay_event =
event.delay_based_bwe_update();
RTC_CHECK(delay_event.has_bitrate_bps());
if (bitrate_bps != nullptr) {
*bitrate_bps = delay_event.bitrate_bps();
}
RTC_CHECK(delay_event.has_detector_state());
if (detector_state != nullptr) {

12
webrtc/logging/rtc_event_log/rtc_event_log_parser.h
View File

@ -42,8 +42,8 @@ class ParsedRtcEventLog {
RTP_EVENT = 3,
RTCP_EVENT = 4,
AUDIO_PLAYOUT_EVENT = 5,
BWE_PACKET_LOSS_EVENT = 6,
BWE_PACKET_DELAY_EVENT = 7,
LOSS_BASED_BWE_UPDATE = 6,
DELAY_BASED_BWE_UPDATE = 7,
VIDEO_RECEIVER_CONFIG_EVENT = 8,
VIDEO_SENDER_CONFIG_EVENT = 9,
AUDIO_RECEIVER_CONFIG_EVENT = 10,
@ -120,8 +120,8 @@ class ParsedRtcEventLog {
// the corresponding output parameters. Each output parameter can be set to
// nullptr if that
// value isn't needed.
void GetBwePacketLossEvent(size_t index,
int32_t* bitrate,
void GetLossBasedBweUpdate(size_t index,
int32_t* bitrate_bps,
uint8_t* fraction_loss,
int32_t* total_packets) const;
@ -129,8 +129,8 @@ class ParsedRtcEventLog {
// and stores the values in the corresponding output parameters. Each output
// parameter can be set to nullptr if that
// value isn't needed.
void GetBwePacketDelayEvent(size_t index,
int32_t* bitrate,
void GetDelayBasedBweUpdate(size_t index,
int32_t* bitrate_bps,
BandwidthUsage* detector_state) const;
// Reads a audio network adaptation event to a (non-NULL)

16
webrtc/logging/rtc_event_log/rtc_event_log_unittest.cc
View File

@ -283,7 +283,7 @@ void LogSessionAndReadBack(size_t rtp_count,
for (size_t i = 0; i < playout_count; i++) {
playout_ssrcs.push_back(prng.Rand<uint32_t>());
}
// Create bwe_loss_count random bitrate updates for BwePacketLoss.
// Create bwe_loss_count random bitrate updates for LossBasedBwe.
for (size_t i = 0; i < bwe_loss_count; i++) {
bwe_loss_updates.push_back(
std::make_pair(prng.Rand<int32_t>(), prng.Rand<uint8_t>()));
@ -333,7 +333,7 @@ void LogSessionAndReadBack(size_t rtp_count,
fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
}
if (i * bwe_loss_count >= bwe_loss_index * rtp_count) {
log_dumper->LogBwePacketLossEvent(
log_dumper->LogLossBasedBweUpdate(
bwe_loss_updates[bwe_loss_index - 1].first,
bwe_loss_updates[bwe_loss_index - 1].second, i);
bwe_loss_index++;
@ -500,7 +500,7 @@ TEST(RtcEventLogTest, LogEventAndReadBack) {
remove(temp_filename.c_str());
}
TEST(RtcEventLogTest, LogPacketLossEventAndReadBack) {
TEST(RtcEventLogTest, LogLossBasedBweUpdateAndReadBack) {
Random prng(1234);
// Generate a random packet loss event.
@ -520,7 +520,7 @@ TEST(RtcEventLogTest, LogPacketLossEventAndReadBack) {
std::unique_ptr<RtcEventLog> log_dumper(RtcEventLog::Create());
log_dumper->StartLogging(temp_filename, 10000000);
fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
log_dumper->LogBwePacketLossEvent(bitrate, fraction_lost, total_packets);
log_dumper->LogLossBasedBweUpdate(bitrate, fraction_lost, total_packets);
fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
log_dumper->StopLogging();
@ -540,7 +540,7 @@ TEST(RtcEventLogTest, LogPacketLossEventAndReadBack) {
remove(temp_filename.c_str());
}
TEST(RtcEventLogTest, LogPacketDelayEventAndReadBack) {
TEST(RtcEventLogTest, LogDelayBasedBweUpdateAndReadBack) {
Random prng(1234);
// Generate 3 random packet delay event.
@ -560,11 +560,11 @@ TEST(RtcEventLogTest, LogPacketDelayEventAndReadBack) {
std::unique_ptr<RtcEventLog> log_dumper(RtcEventLog::Create());
log_dumper->StartLogging(temp_filename, 10000000);
fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
log_dumper->LogBwePacketDelayEvent(bitrate1, kBwNormal);
log_dumper->LogDelayBasedBweUpdate(bitrate1, kBwNormal);
fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
log_dumper->LogBwePacketDelayEvent(bitrate2, kBwOverusing);
log_dumper->LogDelayBasedBweUpdate(bitrate2, kBwOverusing);
fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
log_dumper->LogBwePacketDelayEvent(bitrate3, kBwUnderusing);
log_dumper->LogDelayBasedBweUpdate(bitrate3, kBwUnderusing);
fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
log_dumper->StopLogging();

42
webrtc/logging/rtc_event_log/rtc_event_log_unittest_helper.cc
View File

@ -44,13 +44,13 @@ MediaType GetRuntimeMediaType(rtclog::MediaType media_type) {
}
BandwidthUsage GetRuntimeDetectorState(
rtclog::BwePacketDelayEvent::DetectorState detector_state) {
rtclog::DelayBasedBweUpdate::DetectorState detector_state) {
switch (detector_state) {
case rtclog::BwePacketDelayEvent::BWE_NORMAL:
case rtclog::DelayBasedBweUpdate::BWE_NORMAL:
return kBwNormal;
case rtclog::BwePacketDelayEvent::BWE_UNDERUSING:
case rtclog::DelayBasedBweUpdate::BWE_UNDERUSING:
return kBwUnderusing;
case rtclog::BwePacketDelayEvent::BWE_OVERUSING:
case rtclog::DelayBasedBweUpdate::BWE_OVERUSING:
return kBwOverusing;
}
RTC_NOTREACHED();
@ -78,18 +78,18 @@ BandwidthUsage GetRuntimeDetectorState(
<< "Event of type " << type << " has "
<< (event.has_rtcp_packet() ? "" : "no ") << "RTCP packet";
}
if ((type == rtclog::Event::BWE_PACKET_LOSS_EVENT) !=
event.has_bwe_packet_loss_event()) {
if ((type == rtclog::Event::LOSS_BASED_BWE_UPDATE) !=
event.has_loss_based_bwe_update()) {
return ::testing::AssertionFailure()
<< "Event of type " << type << " has "
<< (event.has_bwe_packet_loss_event() ? "" : "no ") << "packet loss";
<< (event.has_loss_based_bwe_update() ? "" : "no ") << "loss update";
}
if ((type == rtclog::Event::BWE_PACKET_DELAY_EVENT) !=
event.has_bwe_packet_delay_event()) {
if ((type == rtclog::Event::DELAY_BASED_BWE_UPDATE) !=
event.has_delay_based_bwe_update()) {
return ::testing::AssertionFailure()
<< "Event of type " << type << " has "
<< (event.has_bwe_packet_delay_event() ? "" : "no ")
<< "packet delay";
<< (event.has_delay_based_bwe_update() ? "" : "no ")
<< "delay update";
}
if ((type == rtclog::Event::AUDIO_PLAYOUT_EVENT) !=
event.has_audio_playout_event()) {
@ -475,10 +475,10 @@ void RtcEventLogTestHelper::VerifyBweLossEvent(
int32_t total_packets) {
const rtclog::Event& event = parsed_log.events_[index];
ASSERT_TRUE(IsValidBasicEvent(event));
ASSERT_EQ(rtclog::Event::BWE_PACKET_LOSS_EVENT, event.type());
const rtclog::BwePacketLossEvent& bwe_event = event.bwe_packet_loss_event();
ASSERT_TRUE(bwe_event.has_bitrate());
EXPECT_EQ(bitrate, bwe_event.bitrate());
ASSERT_EQ(rtclog::Event::LOSS_BASED_BWE_UPDATE, event.type());
const rtclog::LossBasedBweUpdate& bwe_event = event.loss_based_bwe_update();
ASSERT_TRUE(bwe_event.has_bitrate_bps());
EXPECT_EQ(bitrate, bwe_event.bitrate_bps());
ASSERT_TRUE(bwe_event.has_fraction_loss());
EXPECT_EQ(fraction_loss, bwe_event.fraction_loss());
ASSERT_TRUE(bwe_event.has_total_packets());
@ -488,7 +488,7 @@ void RtcEventLogTestHelper::VerifyBweLossEvent(
int32_t parsed_bitrate;
uint8_t parsed_fraction_loss;
int32_t parsed_total_packets;
parsed_log.GetBwePacketLossEvent(
parsed_log.GetLossBasedBweUpdate(
index, &parsed_bitrate, &parsed_fraction_loss, &parsed_total_packets);
EXPECT_EQ(bitrate, parsed_bitrate);
EXPECT_EQ(fraction_loss, parsed_fraction_loss);
@ -502,10 +502,10 @@ void RtcEventLogTestHelper::VerifyBweDelayEvent(
BandwidthUsage detector_state) {
const rtclog::Event& event = parsed_log.events_[index];
ASSERT_TRUE(IsValidBasicEvent(event));
ASSERT_EQ(rtclog::Event::BWE_PACKET_DELAY_EVENT, event.type());
const rtclog::BwePacketDelayEvent& bwe_event = event.bwe_packet_delay_event();
ASSERT_TRUE(bwe_event.has_bitrate());
EXPECT_EQ(bitrate, bwe_event.bitrate());
ASSERT_EQ(rtclog::Event::DELAY_BASED_BWE_UPDATE, event.type());
const rtclog::DelayBasedBweUpdate& bwe_event = event.delay_based_bwe_update();
ASSERT_TRUE(bwe_event.has_bitrate_bps());
EXPECT_EQ(bitrate, bwe_event.bitrate_bps());
ASSERT_TRUE(bwe_event.has_detector_state());
EXPECT_EQ(detector_state,
GetRuntimeDetectorState(bwe_event.detector_state()));
@ -513,7 +513,7 @@ void RtcEventLogTestHelper::VerifyBweDelayEvent(
// Check consistency of the parser.
int32_t parsed_bitrate;
BandwidthUsage parsed_detector_state;
parsed_log.GetBwePacketDelayEvent(index, &parsed_bitrate,
parsed_log.GetDelayBasedBweUpdate(index, &parsed_bitrate,
&parsed_detector_state);
EXPECT_EQ(bitrate, parsed_bitrate);
EXPECT_EQ(detector_state, parsed_detector_state);

2
webrtc/modules/bitrate_controller/send_side_bandwidth_estimation.cc
View File

@ -286,7 +286,7 @@ void SendSideBandwidthEstimation::UpdateEstimate(int64_t now_ms) {
last_fraction_loss_ != last_logged_fraction_loss_ ||
last_rtc_event_log_ms_ == -1 ||
now_ms - last_rtc_event_log_ms_ > kRtcEventLogPeriodMs) {
event_log_->LogBwePacketLossEvent(capped_bitrate, last_fraction_loss_,
event_log_->LogLossBasedBweUpdate(capped_bitrate, last_fraction_loss_,
expected_packets_since_last_loss_update_);
last_logged_fraction_loss_ = last_fraction_loss_;
last_rtc_event_log_ms_ = now_ms;

2
webrtc/modules/bitrate_controller/send_side_bandwidth_estimation_unittest.cc
View File

@ -66,7 +66,7 @@ TEST(SendSideBweTest, InitialDelayBasedBweWithProbing) {
TEST(SendSideBweTest, DoesntReapplyBitrateDecreaseWithoutFollowingRemb) {
MockRtcEventLog event_log;
EXPECT_CALL(event_log,
LogBwePacketLossEvent(testing::Gt(0), testing::Gt(0), 0))
LogLossBasedBweUpdate(testing::Gt(0), testing::Gt(0), 0))
.Times(1);
SendSideBandwidthEstimation bwe(&event_log);
static const int kMinBitrateBps = 100000;

2
webrtc/modules/congestion_controller/delay_based_bwe.cc
View File

@ -395,7 +395,7 @@ DelayBasedBwe::Result DelayBasedBwe::IncomingPacketInfo(
result.target_bitrate_bps);
if (event_log_ && (result.target_bitrate_bps != last_logged_bitrate_ ||
detector_.State() != last_logged_state_)) {
event_log_->LogBwePacketDelayEvent(result.target_bitrate_bps,
event_log_->LogDelayBasedBweUpdate(result.target_bitrate_bps,
detector_.State());
last_logged_bitrate_ = result.target_bitrate_bps;
last_logged_state_ = detector_.State();

22
webrtc/tools/event_log_visualizer/analyzer.cc
View File

@ -435,24 +435,24 @@ EventLogAnalyzer::EventLogAnalyzer(const ParsedRtcEventLog& log)
case ParsedRtcEventLog::LOG_END: {
break;
}
case ParsedRtcEventLog::BWE_PACKET_LOSS_EVENT: {
BwePacketLossEvent bwe_update;
case ParsedRtcEventLog::AUDIO_PLAYOUT_EVENT: {
break;
}
case ParsedRtcEventLog::LOSS_BASED_BWE_UPDATE: {
LossBasedBweUpdate bwe_update;
bwe_update.timestamp = parsed_log_.GetTimestamp(i);
parsed_log_.GetBwePacketLossEvent(i, &bwe_update.new_bitrate,
&bwe_update.fraction_loss,
&bwe_update.expected_packets);
parsed_log_.GetLossBasedBweUpdate(i, &bwe_update.new_bitrate,
&bwe_update.fraction_loss,
&bwe_update.expected_packets);
bwe_loss_updates_.push_back(bwe_update);
break;
}
case ParsedRtcEventLog::DELAY_BASED_BWE_UPDATE: {
break;
}
case ParsedRtcEventLog::AUDIO_NETWORK_ADAPTATION_EVENT: {
break;
}
case ParsedRtcEventLog::BWE_PACKET_DELAY_EVENT: {
break;
}
case ParsedRtcEventLog::AUDIO_PLAYOUT_EVENT: {
break;
}
case ParsedRtcEventLog::UNKNOWN_EVENT: {
break;
}

4
webrtc/tools/event_log_visualizer/analyzer.h
View File

@ -45,7 +45,7 @@ struct LoggedRtcpPacket {
std::unique_ptr<rtcp::RtcpPacket> packet;
};
struct BwePacketLossEvent {
struct LossBasedBweUpdate {
uint64_t timestamp;
int32_t new_bitrate;
uint8_t fraction_loss;
@ -150,7 +150,7 @@ class EventLogAnalyzer {
std::map<StreamId, std::vector<LoggedRtcpPacket>> rtcp_packets_;
// A list of all updates from the send-side loss-based bandwidth estimator.
std::vector<BwePacketLossEvent> bwe_loss_updates_;
std::vector<LossBasedBweUpdate> bwe_loss_updates_;
// Window and step size used for calculating moving averages, e.g. bitrate.
// The generated data points will be |step_| microseconds apart.

9
webrtc/voice_engine/channel.cc
View File

@ -130,20 +130,21 @@ class RtcEventLogProxy final : public webrtc::RtcEventLog {
}
}
void LogBwePacketLossEvent(int32_t bitrate,
void LogLossBasedBweUpdate(int32_t bitrate_bps,
uint8_t fraction_loss,
int32_t total_packets) override {
rtc::CritScope lock(&crit_);
if (event_log_) {
event_log_->LogBwePacketLossEvent(bitrate, fraction_loss, total_packets);
event_log_->LogLossBasedBweUpdate(bitrate_bps, fraction_loss,
total_packets);
}
}
void LogBwePacketDelayEvent(int32_t bitrate,
void LogDelayBasedBweUpdate(int32_t bitrate_bps,
BandwidthUsage detector_state) override {
rtc::CritScope lock(&crit_);
if (event_log_) {
event_log_->LogBwePacketDelayEvent(bitrate, detector_state);
event_log_->LogDelayBasedBweUpdate(bitrate_bps, detector_state);
}
}