diff --git a/webrtc/logging/rtc_event_log/mock/mock_rtc_event_log.h b/webrtc/logging/rtc_event_log/mock/mock_rtc_event_log.h index a47aa65cc8..7366c2947b 100644 --- a/webrtc/logging/rtc_event_log/mock/mock_rtc_event_log.h +++ b/webrtc/logging/rtc_event_log/mock/mock_rtc_event_log.h @@ -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)); diff --git a/webrtc/logging/rtc_event_log/rtc_event_log.cc b/webrtc/logging/rtc_event_log/rtc_event_log.cc index 96f1ea1d80..88f6b3a5d3 100644 --- a/webrtc/logging/rtc_event_log/rtc_event_log.cc +++ b/webrtc/logging/rtc_event_log/rtc_event_log.cc @@ -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 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 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); } diff --git a/webrtc/logging/rtc_event_log/rtc_event_log.h b/webrtc/logging/rtc_event_log/rtc_event_log.h index 766fd89bc2..f1bbcbba78 100644 --- a/webrtc/logging/rtc_event_log/rtc_event_log.h +++ b/webrtc/logging/rtc_event_log/rtc_event_log.h @@ -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 {} diff --git a/webrtc/logging/rtc_event_log/rtc_event_log.proto b/webrtc/logging/rtc_event_log/rtc_event_log.proto index 0da910a29f..8f654f982b 100644 --- a/webrtc/logging/rtc_event_log/rtc_event_log.proto +++ b/webrtc/logging/rtc_event_log/rtc_event_log.proto @@ -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; diff --git a/webrtc/logging/rtc_event_log/rtc_event_log_parser.cc b/webrtc/logging/rtc_event_log/rtc_event_log_parser.cc index 012b7e19da..713d4fc78a 100644 --- a/webrtc/logging/rtc_event_log/rtc_event_log_parser.cc +++ b/webrtc/logging/rtc_event_log/rtc_event_log_parser.cc @@ -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) { diff --git a/webrtc/logging/rtc_event_log/rtc_event_log_parser.h b/webrtc/logging/rtc_event_log/rtc_event_log_parser.h index c81b8fb10e..739ccee220 100644 --- a/webrtc/logging/rtc_event_log/rtc_event_log_parser.h +++ b/webrtc/logging/rtc_event_log/rtc_event_log_parser.h @@ -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) diff --git a/webrtc/logging/rtc_event_log/rtc_event_log_unittest.cc b/webrtc/logging/rtc_event_log/rtc_event_log_unittest.cc index 1173bf57df..ae264aaf4b 100644 --- a/webrtc/logging/rtc_event_log/rtc_event_log_unittest.cc +++ b/webrtc/logging/rtc_event_log/rtc_event_log_unittest.cc @@ -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()); } - // 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(), prng.Rand())); @@ -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 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 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(); diff --git a/webrtc/logging/rtc_event_log/rtc_event_log_unittest_helper.cc b/webrtc/logging/rtc_event_log/rtc_event_log_unittest_helper.cc index 6d92b46ce4..e7db5930f7 100644 --- a/webrtc/logging/rtc_event_log/rtc_event_log_unittest_helper.cc +++ b/webrtc/logging/rtc_event_log/rtc_event_log_unittest_helper.cc @@ -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); diff --git a/webrtc/modules/bitrate_controller/send_side_bandwidth_estimation.cc b/webrtc/modules/bitrate_controller/send_side_bandwidth_estimation.cc index ad8a6f9e77..2c683fd34b 100644 --- a/webrtc/modules/bitrate_controller/send_side_bandwidth_estimation.cc +++ b/webrtc/modules/bitrate_controller/send_side_bandwidth_estimation.cc @@ -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; diff --git a/webrtc/modules/bitrate_controller/send_side_bandwidth_estimation_unittest.cc b/webrtc/modules/bitrate_controller/send_side_bandwidth_estimation_unittest.cc index 7841f5fb40..825828b452 100644 --- a/webrtc/modules/bitrate_controller/send_side_bandwidth_estimation_unittest.cc +++ b/webrtc/modules/bitrate_controller/send_side_bandwidth_estimation_unittest.cc @@ -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; diff --git a/webrtc/modules/congestion_controller/delay_based_bwe.cc b/webrtc/modules/congestion_controller/delay_based_bwe.cc index d18847fb08..71fefac26f 100644 --- a/webrtc/modules/congestion_controller/delay_based_bwe.cc +++ b/webrtc/modules/congestion_controller/delay_based_bwe.cc @@ -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(); diff --git a/webrtc/tools/event_log_visualizer/analyzer.cc b/webrtc/tools/event_log_visualizer/analyzer.cc index 2f8b7ed02f..5c0433a358 100644 --- a/webrtc/tools/event_log_visualizer/analyzer.cc +++ b/webrtc/tools/event_log_visualizer/analyzer.cc @@ -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; } diff --git a/webrtc/tools/event_log_visualizer/analyzer.h b/webrtc/tools/event_log_visualizer/analyzer.h index bb7667fbb8..f0557a20c1 100644 --- a/webrtc/tools/event_log_visualizer/analyzer.h +++ b/webrtc/tools/event_log_visualizer/analyzer.h @@ -45,7 +45,7 @@ struct LoggedRtcpPacket { std::unique_ptr packet; }; -struct BwePacketLossEvent { +struct LossBasedBweUpdate { uint64_t timestamp; int32_t new_bitrate; uint8_t fraction_loss; @@ -150,7 +150,7 @@ class EventLogAnalyzer { std::map> rtcp_packets_; // A list of all updates from the send-side loss-based bandwidth estimator. - std::vector bwe_loss_updates_; + std::vector bwe_loss_updates_; // Window and step size used for calculating moving averages, e.g. bitrate. // The generated data points will be |step_| microseconds apart. diff --git a/webrtc/voice_engine/channel.cc b/webrtc/voice_engine/channel.cc index b0aa654f27..acd8052691 100644 --- a/webrtc/voice_engine/channel.cc +++ b/webrtc/voice_engine/channel.cc @@ -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); } }