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

Resolve cyclic dependency between audio network adaptor and event log api

Browse Source 
BUG=webrtc:7257

Review-Url: https://codereview.webrtc.org/2745473003
Cr-Commit-Position: refs/heads/master@{#17565}
This commit is contained in:
michaelt
2017-04-06 05:59:10 -07:00
committed by Commit bot
parent 28dc285f22
commit cde46b7278
46 changed files with 101 additions and 108 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
webrtc/logging/BUILD.gn
View File

@ -87,6 +87,7 @@ if (rtc_enable_protobuf) {
":rtc_event_log_proto",
"..:webrtc_common",
"../call:call_interfaces",
"../modules/audio_coding:audio_network_adaptor",
"../modules/rtp_rtcp:rtp_rtcp",
"../system_wrappers",
]
@ -114,6 +115,7 @@ if (rtc_enable_protobuf) {
"../base:rtc_base_approved",
"../base:rtc_base_tests_utils",
"../call",
"../modules/audio_coding:audio_network_adaptor",
"../modules/rtp_rtcp",
"../system_wrappers:metrics_default",
"../test:test_support",

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

@ -14,6 +14,7 @@
#include <string>
#include "webrtc/logging/rtc_event_log/rtc_event_log.h"
#include "webrtc/modules/audio_coding/audio_network_adaptor/include/audio_network_adaptor.h"
#include "webrtc/test/gmock.h"
namespace webrtc {
@ -70,7 +71,7 @@ class MockRtcEventLog : public RtcEventLog {
void(int32_t bitrate_bps, BandwidthUsage detector_state));
MOCK_METHOD1(LogAudioNetworkAdaptation,
void(const AudioNetworkAdaptor::EncoderRuntimeConfig& config));
void(const AudioEncoderRuntimeConfig& config));
MOCK_METHOD4(LogProbeClusterCreated,
void(int id, int bitrate_bps, int min_probes, int min_bytes));

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

@ -22,6 +22,7 @@
#include "webrtc/base/timeutils.h"
#include "webrtc/call/call.h"
#include "webrtc/logging/rtc_event_log/rtc_event_log_helper_thread.h"
#include "webrtc/modules/audio_coding/audio_network_adaptor/include/audio_network_adaptor.h"
#include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h"
#include "webrtc/modules/rtp_rtcp/source/byte_io.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/app.h"
@ -29,8 +30,8 @@
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/common_header.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_jitter_report.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_reports.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/receiver_report.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/psfb.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/receiver_report.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/rtpfb.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/sdes.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/sender_report.h"
@ -85,7 +86,7 @@ class RtcEventLogImpl final : public RtcEventLog {
void LogDelayBasedBweUpdate(int32_t bitrate_bps,
BandwidthUsage detector_state) override;
void LogAudioNetworkAdaptation(
const AudioNetworkAdaptor::EncoderRuntimeConfig& config) override;
const AudioEncoderRuntimeConfig& config) override;
void LogProbeClusterCreated(int id,
int bitrate_bps,
int min_probes,
@ -504,7 +505,7 @@ void RtcEventLogImpl::LogDelayBasedBweUpdate(int32_t bitrate_bps,
}
void RtcEventLogImpl::LogAudioNetworkAdaptation(
const AudioNetworkAdaptor::EncoderRuntimeConfig& config) {
const AudioEncoderRuntimeConfig& config) {
std::unique_ptr<rtclog::Event> event(new rtclog::Event());
event->set_timestamp_us(rtc::TimeMicros());
event->set_type(rtclog::Event::AUDIO_NETWORK_ADAPTATION_EVENT);

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

@ -17,7 +17,6 @@
#include "webrtc/base/platform_file.h"
#include "webrtc/call/audio_receive_stream.h"
#include "webrtc/call/audio_send_stream.h"
#include "webrtc/modules/audio_coding/audio_network_adaptor/include/audio_network_adaptor.h"
#include "webrtc/modules/remote_bitrate_estimator/include/bwe_defines.h"
#include "webrtc/video_receive_stream.h"
#include "webrtc/video_send_stream.h"
@ -32,6 +31,7 @@ class EventStream;
class Clock;
class RtcEventLogImpl;
struct AudioEncoderRuntimeConfig;
enum class MediaType;
@ -135,7 +135,7 @@ class RtcEventLog {
// Logs audio encoder re-configuration driven by audio network adaptor.
virtual void LogAudioNetworkAdaptation(
const AudioNetworkAdaptor::EncoderRuntimeConfig& config) = 0;
const AudioEncoderRuntimeConfig& config) = 0;
// Logs when a probe cluster is created.
virtual void LogProbeClusterCreated(int id,
@ -199,7 +199,7 @@ class RtcEventLogNullImpl final : public RtcEventLog {
void LogDelayBasedBweUpdate(int32_t bitrate_bps,
BandwidthUsage detector_state) override {}
void LogAudioNetworkAdaptation(
const AudioNetworkAdaptor::EncoderRuntimeConfig& config) override {}
const AudioEncoderRuntimeConfig& config) override {}
void LogProbeClusterCreated(int id,
int bitrate_bps,
int min_probes,

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

@ -22,6 +22,7 @@
#include "webrtc/base/logging.h"
#include "webrtc/call/call.h"
#include "webrtc/logging/rtc_event_log/rtc_event_log.h"
#include "webrtc/modules/audio_coding/audio_network_adaptor/include/audio_network_adaptor.h"
#include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h"
namespace webrtc {
@ -511,7 +512,7 @@ void ParsedRtcEventLog::GetDelayBasedBweUpdate(
void ParsedRtcEventLog::GetAudioNetworkAdaptation(
size_t index,
AudioNetworkAdaptor::EncoderRuntimeConfig* config) const {
AudioEncoderRuntimeConfig* config) const {
RTC_CHECK_LT(index, GetNumberOfEvents());
const rtclog::Event& event = events_[index];
RTC_CHECK(event.has_type());

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

@ -151,11 +151,10 @@ class ParsedRtcEventLog {
BandwidthUsage* detector_state) const;
// Reads a audio network adaptation event to a (non-NULL)
// AudioNetworkAdaptor::EncoderRuntimeConfig struct. Only the fields that are
// AudioEncoderRuntimeConfig struct. Only the fields that are
// stored in the protobuf will be written.
void GetAudioNetworkAdaptation(
size_t index,
AudioNetworkAdaptor::EncoderRuntimeConfig* config) const;
void GetAudioNetworkAdaptation(size_t index,
AudioEncoderRuntimeConfig* config) const;
ParsedRtcEventLog::BweProbeClusterCreatedEvent GetBweProbeClusterCreated(
size_t index) const;

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

@ -22,6 +22,7 @@
#include "webrtc/logging/rtc_event_log/rtc_event_log.h"
#include "webrtc/logging/rtc_event_log/rtc_event_log_parser.h"
#include "webrtc/logging/rtc_event_log/rtc_event_log_unittest_helper.h"
#include "webrtc/modules/audio_coding/audio_network_adaptor/include/audio_network_adaptor.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/sender_report.h"
#include "webrtc/modules/rtp_rtcp/source/rtp_header_extension.h"
@ -227,9 +228,8 @@ void GenerateAudioSendConfig(uint32_t extensions_bitvector,
}
}
void GenerateAudioNetworkAdaptation(
uint32_t extensions_bitvector,
AudioNetworkAdaptor::EncoderRuntimeConfig* config,
void GenerateAudioNetworkAdaptation(uint32_t extensions_bitvector,
AudioEncoderRuntimeConfig* config,
Random* prng) {
config->bitrate_bps = rtc::Optional<int>(prng->Rand(0, 3000000));
config->enable_fec = rtc::Optional<bool>(prng->Rand<bool>());
@ -859,7 +859,7 @@ class AudioNetworkAdaptationReadWriteTest : public ConfigReadWriteTest {
RtcEventLogTestHelper::VerifyAudioNetworkAdaptation(parsed_log, index,
config);
}
AudioNetworkAdaptor::EncoderRuntimeConfig config;
AudioEncoderRuntimeConfig config;
};
TEST(RtcEventLogTest, LogAudioReceiveConfig) {

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

@ -15,6 +15,7 @@
#include <string>
#include "webrtc/base/checks.h"
#include "webrtc/modules/audio_coding/audio_network_adaptor/include/audio_network_adaptor.h"
#include "webrtc/test/gtest.h"
#include "webrtc/test/testsupport/fileutils.h"
@ -548,8 +549,8 @@ void RtcEventLogTestHelper::VerifyBweDelayEvent(
void RtcEventLogTestHelper::VerifyAudioNetworkAdaptation(
const ParsedRtcEventLog& parsed_log,
size_t index,
const AudioNetworkAdaptor::EncoderRuntimeConfig& config) {
AudioNetworkAdaptor::EncoderRuntimeConfig parsed_config;
const AudioEncoderRuntimeConfig& config) {
AudioEncoderRuntimeConfig parsed_config;
parsed_log.GetAudioNetworkAdaptation(index, &parsed_config);
EXPECT_EQ(config.bitrate_bps, parsed_config.bitrate_bps);
EXPECT_EQ(config.enable_dtx, parsed_config.enable_dtx);

2
webrtc/logging/rtc_event_log/rtc_event_log_unittest_helper.h
View File

@ -63,7 +63,7 @@ class RtcEventLogTestHelper {
static void VerifyAudioNetworkAdaptation(
const ParsedRtcEventLog& parsed_log,
size_t index,
const AudioNetworkAdaptor::EncoderRuntimeConfig& config);
const AudioEncoderRuntimeConfig& config);
static void VerifyLogStartEvent(const ParsedRtcEventLog& parsed_log,
size_t index);

8
webrtc/modules/audio_coding/audio_network_adaptor/audio_network_adaptor.cc
View File

@ -12,11 +12,11 @@
namespace webrtc {
AudioNetworkAdaptor::EncoderRuntimeConfig::EncoderRuntimeConfig() = default;
AudioEncoderRuntimeConfig::AudioEncoderRuntimeConfig() = default;
AudioNetworkAdaptor::EncoderRuntimeConfig::~EncoderRuntimeConfig() = default;
AudioEncoderRuntimeConfig::~AudioEncoderRuntimeConfig() = default;
AudioNetworkAdaptor::EncoderRuntimeConfig::EncoderRuntimeConfig(
const EncoderRuntimeConfig& other) = default;
AudioEncoderRuntimeConfig::AudioEncoderRuntimeConfig(
const AudioEncoderRuntimeConfig& other) = default;
} // namespace webrtc

5
webrtc/modules/audio_coding/audio_network_adaptor/audio_network_adaptor_impl.cc
View File

@ -112,9 +112,8 @@ void AudioNetworkAdaptorImpl::SetOverhead(size_t overhead_bytes_per_packet) {
UpdateNetworkMetrics(network_metrics);
}
AudioNetworkAdaptor::EncoderRuntimeConfig
AudioNetworkAdaptorImpl::GetEncoderRuntimeConfig() {
EncoderRuntimeConfig config;
AudioEncoderRuntimeConfig AudioNetworkAdaptorImpl::GetEncoderRuntimeConfig() {
AudioEncoderRuntimeConfig config;
for (auto& controller :
controller_manager_->GetSortedControllers(last_metrics_))
controller->MakeDecision(&config);

2
webrtc/modules/audio_coding/audio_network_adaptor/audio_network_adaptor_impl.h
View File

@ -54,7 +54,7 @@ class AudioNetworkAdaptorImpl final : public AudioNetworkAdaptor {
void SetOverhead(size_t overhead_bytes_per_packet) override;
EncoderRuntimeConfig GetEncoderRuntimeConfig() override;
AudioEncoderRuntimeConfig GetEncoderRuntimeConfig() override;
void StartDebugDump(FILE* file_handle) override;

4
webrtc/modules/audio_coding/audio_network_adaptor/audio_network_adaptor_impl_unittest.cc
View File

@ -182,7 +182,7 @@ TEST(AudioNetworkAdaptorImplTest,
DumpEncoderRuntimeConfigIsCalledOnGetEncoderRuntimeConfig) {
auto states = CreateAudioNetworkAdaptor();
AudioNetworkAdaptor::EncoderRuntimeConfig config;
AudioEncoderRuntimeConfig config;
config.bitrate_bps = rtc::Optional<int>(32000);
config.enable_fec = rtc::Optional<bool>(true);
@ -255,7 +255,7 @@ TEST(AudioNetworkAdaptorImplTest,
TEST(AudioNetworkAdaptorImplTest, LogRuntimeConfigOnGetEncoderRuntimeConfig) {
auto states = CreateAudioNetworkAdaptor();
AudioNetworkAdaptor::EncoderRuntimeConfig config;
AudioEncoderRuntimeConfig config;
config.bitrate_bps = rtc::Optional<int>(32000);
config.enable_fec = rtc::Optional<bool>(true);

3
webrtc/modules/audio_coding/audio_network_adaptor/bitrate_controller.cc
View File

@ -43,8 +43,7 @@ void BitrateController::UpdateNetworkMetrics(
overhead_bytes_per_packet_ = network_metrics.overhead_bytes_per_packet;
}
void BitrateController::MakeDecision(
AudioNetworkAdaptor::EncoderRuntimeConfig* config) {
void BitrateController::MakeDecision(AudioEncoderRuntimeConfig* config) {
// Decision on |bitrate_bps| should not have been made.
RTC_DCHECK(!config->bitrate_bps);
if (target_audio_bitrate_bps_ && overhead_bytes_per_packet_) {

2
webrtc/modules/audio_coding/audio_network_adaptor/bitrate_controller.h
View File

@ -32,7 +32,7 @@ class BitrateController final : public Controller {
void UpdateNetworkMetrics(const NetworkMetrics& network_metrics) override;
void MakeDecision(AudioNetworkAdaptor::EncoderRuntimeConfig* config) override;
void MakeDecision(AudioEncoderRuntimeConfig* config) override;
private:
const Config config_;

2
webrtc/modules/audio_coding/audio_network_adaptor/bitrate_controller_unittest.cc
View File

@ -39,7 +39,7 @@ void UpdateNetworkMetrics(
void CheckDecision(BitrateController* controller,
const rtc::Optional<int>& frame_length_ms,
int expected_bitrate_bps) {
AudioNetworkAdaptor::EncoderRuntimeConfig config;
AudioEncoderRuntimeConfig config;
config.frame_length_ms = frame_length_ms;
controller->MakeDecision(&config);
EXPECT_EQ(rtc::Optional<int>(expected_bitrate_bps), config.bitrate_bps);

3
webrtc/modules/audio_coding/audio_network_adaptor/channel_controller.cc
View File

@ -41,8 +41,7 @@ void ChannelController::UpdateNetworkMetrics(
uplink_bandwidth_bps_ = network_metrics.uplink_bandwidth_bps;
}
void ChannelController::MakeDecision(
AudioNetworkAdaptor::EncoderRuntimeConfig* config) {
void ChannelController::MakeDecision(AudioEncoderRuntimeConfig* config) {
// Decision on |num_channels| should not have been made.
RTC_DCHECK(!config->num_channels);

2
webrtc/modules/audio_coding/audio_network_adaptor/channel_controller.h
View File

@ -39,7 +39,7 @@ class ChannelController final : public Controller {
void UpdateNetworkMetrics(const NetworkMetrics& network_metrics) override;
void MakeDecision(AudioNetworkAdaptor::EncoderRuntimeConfig* config) override;
void MakeDecision(AudioEncoderRuntimeConfig* config) override;
private:
const Config config_;

2
webrtc/modules/audio_coding/audio_network_adaptor/channel_controller_unittest.cc
View File

@ -39,7 +39,7 @@ void CheckDecision(ChannelController* controller,
network_metrics.uplink_bandwidth_bps = uplink_bandwidth_bps;
controller->UpdateNetworkMetrics(network_metrics);
}
AudioNetworkAdaptor::EncoderRuntimeConfig config;
AudioEncoderRuntimeConfig config;
controller->MakeDecision(&config);
EXPECT_EQ(rtc::Optional<size_t>(expected_num_channels), config.num_channels);
}

3
webrtc/modules/audio_coding/audio_network_adaptor/controller.h
View File

@ -35,8 +35,7 @@ class Controller {
// indicates an update on the corresponding network metric.
virtual void UpdateNetworkMetrics(const NetworkMetrics& network_metrics) = 0;
virtual void MakeDecision(
AudioNetworkAdaptor::EncoderRuntimeConfig* config) = 0;
virtual void MakeDecision(AudioEncoderRuntimeConfig* config) = 0;
};
} // namespace webrtc

4
webrtc/modules/audio_coding/audio_network_adaptor/controller_manager_unittest.cc
View File

@ -299,10 +299,10 @@ void CheckControllersOrder(const std::vector<Controller*>& controllers,
ASSERT_EQ(expected_types.size(), controllers.size());
// We also check that the controllers follow the initial settings.
AudioNetworkAdaptor::EncoderRuntimeConfig encoder_config;
AudioEncoderRuntimeConfig encoder_config;
for (size_t i = 0; i < controllers.size(); ++i) {
AudioNetworkAdaptor::EncoderRuntimeConfig encoder_config;
AudioEncoderRuntimeConfig encoder_config;
// We check the order of |controllers| by judging their decisions.
controllers[i]->MakeDecision(&encoder_config);

5
webrtc/modules/audio_coding/audio_network_adaptor/debug_dump_writer.cc
View File

@ -49,8 +49,7 @@ class DebugDumpWriterImpl final : public DebugDumpWriter {
explicit DebugDumpWriterImpl(FILE* file_handle);
~DebugDumpWriterImpl() override = default;
void DumpEncoderRuntimeConfig(
const AudioNetworkAdaptor::EncoderRuntimeConfig& config,
void DumpEncoderRuntimeConfig(const AudioEncoderRuntimeConfig& config,
int64_t timestamp) override;
void DumpNetworkMetrics(const Controller::NetworkMetrics& metrics,
@ -104,7 +103,7 @@ void DebugDumpWriterImpl::DumpNetworkMetrics(
}
void DebugDumpWriterImpl::DumpEncoderRuntimeConfig(
const AudioNetworkAdaptor::EncoderRuntimeConfig& config,
const AudioEncoderRuntimeConfig& config,
int64_t timestamp) {
#ifdef WEBRTC_AUDIO_NETWORK_ADAPTOR_DEBUG_DUMP
Event event;

3
webrtc/modules/audio_coding/audio_network_adaptor/debug_dump_writer.h
View File

@ -27,8 +27,7 @@ class DebugDumpWriter {
virtual ~DebugDumpWriter() = default;
virtual void DumpEncoderRuntimeConfig(
const AudioNetworkAdaptor::EncoderRuntimeConfig& config,
virtual void DumpEncoderRuntimeConfig(const AudioEncoderRuntimeConfig& config,
int64_t timestamp) = 0;
virtual void DumpNetworkMetrics(const Controller::NetworkMetrics& metrics,

3
webrtc/modules/audio_coding/audio_network_adaptor/dtx_controller.cc
View File

@ -31,8 +31,7 @@ void DtxController::UpdateNetworkMetrics(
uplink_bandwidth_bps_ = network_metrics.uplink_bandwidth_bps;
}
void DtxController::MakeDecision(
AudioNetworkAdaptor::EncoderRuntimeConfig* config) {
void DtxController::MakeDecision(AudioEncoderRuntimeConfig* config) {
// Decision on |enable_dtx| should not have been made.
RTC_DCHECK(!config->enable_dtx);

2
webrtc/modules/audio_coding/audio_network_adaptor/dtx_controller.h
View File

@ -35,7 +35,7 @@ class DtxController final : public Controller {
void UpdateNetworkMetrics(const NetworkMetrics& network_metrics) override;
void MakeDecision(AudioNetworkAdaptor::EncoderRuntimeConfig* config) override;
void MakeDecision(AudioEncoderRuntimeConfig* config) override;
private:
const Config config_;

2
webrtc/modules/audio_coding/audio_network_adaptor/dtx_controller_unittest.cc
View File

@ -37,7 +37,7 @@ void CheckDecision(DtxController* controller,
network_metrics.uplink_bandwidth_bps = uplink_bandwidth_bps;
controller->UpdateNetworkMetrics(network_metrics);
}
AudioNetworkAdaptor::EncoderRuntimeConfig config;
AudioEncoderRuntimeConfig config;
controller->MakeDecision(&config);
EXPECT_EQ(rtc::Optional<bool>(expected_dtx_enabled), config.enable_dtx);
}

5
webrtc/modules/audio_coding/audio_network_adaptor/event_log_writer.cc
View File

@ -30,7 +30,7 @@ EventLogWriter::EventLogWriter(RtcEventLog* event_log,
EventLogWriter::~EventLogWriter() = default;
void EventLogWriter::MaybeLogEncoderConfig(
const AudioNetworkAdaptor::EncoderRuntimeConfig& config) {
const AudioEncoderRuntimeConfig& config) {
if (last_logged_config_.num_channels != config.num_channels)
return LogEncoderConfig(config);
if (last_logged_config_.enable_dtx != config.enable_dtx)
@ -59,8 +59,7 @@ void EventLogWriter::MaybeLogEncoderConfig(
}
}
void EventLogWriter::LogEncoderConfig(
const AudioNetworkAdaptor::EncoderRuntimeConfig& config) {
void EventLogWriter::LogEncoderConfig(const AudioEncoderRuntimeConfig& config) {
event_log_->LogAudioNetworkAdaptation(config);
last_logged_config_ = config;
}

8
webrtc/modules/audio_coding/audio_network_adaptor/event_log_writer.h
View File

@ -24,18 +24,16 @@ class EventLogWriter final {
float min_bitrate_change_fraction,
float min_packet_loss_change_fraction);
~EventLogWriter();
void MaybeLogEncoderConfig(
const AudioNetworkAdaptor::EncoderRuntimeConfig& config);
void MaybeLogEncoderConfig(const AudioEncoderRuntimeConfig& config);
private:
void LogEncoderConfig(
const AudioNetworkAdaptor::EncoderRuntimeConfig& config);
void LogEncoderConfig(const AudioEncoderRuntimeConfig& config);
RtcEventLog* const event_log_;
const int min_bitrate_change_bps_;
const float min_bitrate_change_fraction_;
const float min_packet_loss_change_fraction_;
AudioNetworkAdaptor::EncoderRuntimeConfig last_logged_config_;
AudioEncoderRuntimeConfig last_logged_config_;
RTC_DISALLOW_COPY_AND_ASSIGN(EventLogWriter);
};

2
webrtc/modules/audio_coding/audio_network_adaptor/event_log_writer_unittest.cc
View File

@ -43,7 +43,7 @@ MATCHER_P(EncoderRuntimeConfigIs, config, "") {
struct EventLogWriterStates {
std::unique_ptr<EventLogWriter> event_log_writer;
std::unique_ptr<testing::StrictMock<MockRtcEventLog>> event_log;
AudioNetworkAdaptor::EncoderRuntimeConfig runtime_config;
AudioEncoderRuntimeConfig runtime_config;
};
EventLogWriterStates CreateEventLogWriter() {

3
webrtc/modules/audio_coding/audio_network_adaptor/fec_controller_plr_based.cc
View File

@ -79,8 +79,7 @@ void FecControllerPlrBased::UpdateNetworkMetrics(
}
}
void FecControllerPlrBased::MakeDecision(
AudioNetworkAdaptor::EncoderRuntimeConfig* config) {
void FecControllerPlrBased::MakeDecision(AudioEncoderRuntimeConfig* config) {
RTC_DCHECK(!config->enable_fec);
RTC_DCHECK(!config->uplink_packet_loss_fraction);

2
webrtc/modules/audio_coding/audio_network_adaptor/fec_controller_plr_based.h
View File

@ -55,7 +55,7 @@ class FecControllerPlrBased final : public Controller {
void UpdateNetworkMetrics(const NetworkMetrics& network_metrics) override;
void MakeDecision(AudioNetworkAdaptor::EncoderRuntimeConfig* config) override;
void MakeDecision(AudioEncoderRuntimeConfig* config) override;
private:
bool FecEnablingDecision(const rtc::Optional<float>& packet_loss) const;

2
webrtc/modules/audio_coding/audio_network_adaptor/fec_controller_plr_based_unittest.cc
View File

@ -96,7 +96,7 @@ void UpdateNetworkMetrics(FecControllerPlrBasedTestStates* states,
void CheckDecision(FecControllerPlrBasedTestStates* states,
bool expected_enable_fec,
float expected_uplink_packet_loss_fraction) {
AudioNetworkAdaptor::EncoderRuntimeConfig config;
AudioEncoderRuntimeConfig config;
states->controller->MakeDecision(&config);
EXPECT_EQ(rtc::Optional<bool>(expected_enable_fec), config.enable_fec);
EXPECT_EQ(rtc::Optional<float>(expected_uplink_packet_loss_fraction),

3
webrtc/modules/audio_coding/audio_network_adaptor/fec_controller_rplr_based.cc
View File

@ -42,8 +42,7 @@ void FecControllerRplrBased::UpdateNetworkMetrics(
}
}
void FecControllerRplrBased::MakeDecision(
AudioNetworkAdaptor::EncoderRuntimeConfig* config) {
void FecControllerRplrBased::MakeDecision(AudioEncoderRuntimeConfig* config) {
RTC_DCHECK(!config->enable_fec);
RTC_DCHECK(!config->uplink_packet_loss_fraction);

2
webrtc/modules/audio_coding/audio_network_adaptor/fec_controller_rplr_based.h
View File

@ -47,7 +47,7 @@ class FecControllerRplrBased final : public Controller {
void UpdateNetworkMetrics(const NetworkMetrics& network_metrics) override;
void MakeDecision(AudioNetworkAdaptor::EncoderRuntimeConfig* config) override;
void MakeDecision(AudioEncoderRuntimeConfig* config) override;
private:
bool FecEnablingDecision() const;

2
webrtc/modules/audio_coding/audio_network_adaptor/fec_controller_rplr_based_unittest.cc
View File

@ -113,7 +113,7 @@ void UpdateNetworkMetrics(
void CheckDecision(FecControllerRplrBased* controller,
bool expected_enable_fec,
float expected_uplink_packet_loss_fraction) {
AudioNetworkAdaptor::EncoderRuntimeConfig config;
AudioEncoderRuntimeConfig config;
controller->MakeDecision(&config);
// Less compact than comparing optionals, but yields more readable errors.

7
webrtc/modules/audio_coding/audio_network_adaptor/frame_length_controller.cc
View File

@ -65,8 +65,7 @@ void FrameLengthController::UpdateNetworkMetrics(
overhead_bytes_per_packet_ = network_metrics.overhead_bytes_per_packet;
}
void FrameLengthController::MakeDecision(
AudioNetworkAdaptor::EncoderRuntimeConfig* config) {
void FrameLengthController::MakeDecision(AudioEncoderRuntimeConfig* config) {
// Decision on |frame_length_ms| should not have been made.
RTC_DCHECK(!config->frame_length_ms);
@ -92,7 +91,7 @@ bool FrameLengthController::Config::FrameLengthChange::operator<(
}
bool FrameLengthController::FrameLengthIncreasingDecision(
const AudioNetworkAdaptor::EncoderRuntimeConfig& config) const {
const AudioEncoderRuntimeConfig& config) const {
// Increase frame length if
// 1. |uplink_bandwidth_bps| is known to be smaller or equal than
// |min_encoder_bitrate_bps| plus |prevent_overuse_margin_bps| plus the
@ -129,7 +128,7 @@ bool FrameLengthController::FrameLengthIncreasingDecision(
}
bool FrameLengthController::FrameLengthDecreasingDecision(
const AudioNetworkAdaptor::EncoderRuntimeConfig& config) const {
const AudioEncoderRuntimeConfig& config) const {
// Decrease frame length if
// 1. shorter frame length is available AND
// 2. |uplink_bandwidth_bps| is known to be bigger than

6
webrtc/modules/audio_coding/audio_network_adaptor/frame_length_controller.h
View File

@ -54,14 +54,14 @@ class FrameLengthController final : public Controller {
void UpdateNetworkMetrics(const NetworkMetrics& network_metrics) override;
void MakeDecision(AudioNetworkAdaptor::EncoderRuntimeConfig* config) override;
void MakeDecision(AudioEncoderRuntimeConfig* config) override;
private:
bool FrameLengthIncreasingDecision(
const AudioNetworkAdaptor::EncoderRuntimeConfig& config) const;
const AudioEncoderRuntimeConfig& config) const;
bool FrameLengthDecreasingDecision(
const AudioNetworkAdaptor::EncoderRuntimeConfig& config) const;
const AudioEncoderRuntimeConfig& config) const;
const Config config_;

2
webrtc/modules/audio_coding/audio_network_adaptor/frame_length_controller_unittest.cc
View File

@ -101,7 +101,7 @@ void UpdateNetworkMetrics(
void CheckDecision(FrameLengthController* controller,
const rtc::Optional<bool>& enable_fec,
int expected_frame_length_ms) {
AudioNetworkAdaptor::EncoderRuntimeConfig config;
AudioEncoderRuntimeConfig config;
config.enable_fec = enable_fec;
controller->MakeDecision(&config);
EXPECT_EQ(rtc::Optional<int>(expected_frame_length_ms),

23
webrtc/modules/audio_coding/audio_network_adaptor/include/audio_network_adaptor.h
View File

@ -15,15 +15,10 @@
namespace webrtc {
// An AudioNetworkAdaptor optimizes the audio experience by suggesting a
// suitable runtime configuration (bit rate, frame length, FEC, etc.) to the
// encoder based on network metrics.
class AudioNetworkAdaptor {
public:
struct EncoderRuntimeConfig {
EncoderRuntimeConfig();
EncoderRuntimeConfig(const EncoderRuntimeConfig& other);
~EncoderRuntimeConfig();
struct AudioEncoderRuntimeConfig {
AudioEncoderRuntimeConfig();
AudioEncoderRuntimeConfig(const AudioEncoderRuntimeConfig& other);
~AudioEncoderRuntimeConfig();
rtc::Optional<int> bitrate_bps;
rtc::Optional<int> frame_length_ms;
// Note: This is what we tell the encoder. It doesn't have to reflect
@ -36,7 +31,13 @@ class AudioNetworkAdaptor {
// better use of the bandwidth. |num_channels| sets the number of channels
// to encode.
rtc::Optional<size_t> num_channels;
};
};
// An AudioNetworkAdaptor optimizes the audio experience by suggesting a
// suitable runtime configuration (bit rate, frame length, FEC, etc.) to the
// encoder based on network metrics.
class AudioNetworkAdaptor {
public:
virtual ~AudioNetworkAdaptor() = default;
@ -54,7 +55,7 @@ class AudioNetworkAdaptor {
virtual void SetOverhead(size_t overhead_bytes_per_packet) = 0;
virtual EncoderRuntimeConfig GetEncoderRuntimeConfig() = 0;
virtual AudioEncoderRuntimeConfig GetEncoderRuntimeConfig() = 0;
virtual void StartDebugDump(FILE* file_handle) = 0;

2
webrtc/modules/audio_coding/audio_network_adaptor/mock/mock_audio_network_adaptor.h
View File

@ -35,7 +35,7 @@ class MockAudioNetworkAdaptor : public AudioNetworkAdaptor {
MOCK_METHOD1(SetOverhead, void(size_t overhead_bytes_per_packet));
MOCK_METHOD0(GetEncoderRuntimeConfig, EncoderRuntimeConfig());
MOCK_METHOD0(GetEncoderRuntimeConfig, AudioEncoderRuntimeConfig());
MOCK_METHOD1(StartDebugDump, void(FILE* file_handle));

3
webrtc/modules/audio_coding/audio_network_adaptor/mock/mock_controller.h
View File

@ -22,8 +22,7 @@ class MockController : public Controller {
MOCK_METHOD0(Die, void());
MOCK_METHOD1(UpdateNetworkMetrics,
void(const NetworkMetrics& network_metrics));
MOCK_METHOD1(MakeDecision,
void(AudioNetworkAdaptor::EncoderRuntimeConfig* config));
MOCK_METHOD1(MakeDecision, void(AudioEncoderRuntimeConfig* config));
};
} // namespace webrtc

2
webrtc/modules/audio_coding/audio_network_adaptor/mock/mock_debug_dump_writer.h
View File

@ -22,7 +22,7 @@ class MockDebugDumpWriter : public DebugDumpWriter {
MOCK_METHOD0(Die, void());
MOCK_METHOD2(DumpEncoderRuntimeConfig,
void(const AudioNetworkAdaptor::EncoderRuntimeConfig& config,
void(const AudioEncoderRuntimeConfig& config,
int64_t timestamp));
MOCK_METHOD2(DumpNetworkMetrics,
void(const Controller::NetworkMetrics& metrics,

11
webrtc/modules/audio_coding/codecs/opus/audio_encoder_opus_unittest.cc
View File

@ -87,14 +87,14 @@ AudioEncoderOpusStates CreateCodec(size_t num_channels) {
return states;
}
AudioNetworkAdaptor::EncoderRuntimeConfig CreateEncoderRuntimeConfig() {
AudioEncoderRuntimeConfig CreateEncoderRuntimeConfig() {
constexpr int kBitrate = 40000;
constexpr int kFrameLength = 60;
constexpr bool kEnableFec = true;
constexpr bool kEnableDtx = false;
constexpr size_t kNumChannels = 1;
constexpr float kPacketLossFraction = 0.1f;
AudioNetworkAdaptor::EncoderRuntimeConfig config;
AudioEncoderRuntimeConfig config;
config.bitrate_bps = rtc::Optional<int>(kBitrate);
config.frame_length_ms = rtc::Optional<int>(kFrameLength);
config.enable_fec = rtc::Optional<bool>(kEnableFec);
@ -105,9 +105,8 @@ AudioNetworkAdaptor::EncoderRuntimeConfig CreateEncoderRuntimeConfig() {
return config;
}
void CheckEncoderRuntimeConfig(
const AudioEncoderOpus* encoder,
const AudioNetworkAdaptor::EncoderRuntimeConfig& config) {
void CheckEncoderRuntimeConfig(const AudioEncoderOpus* encoder,
const AudioEncoderRuntimeConfig& config) {
EXPECT_EQ(*config.bitrate_bps, encoder->GetTargetBitrate());
EXPECT_EQ(*config.frame_length_ms, encoder->next_frame_length_ms());
EXPECT_EQ(*config.enable_fec, encoder->fec_enabled());
@ -472,7 +471,7 @@ TEST(AudioEncoderOpusTest, EmptyConfigDoesNotAffectEncoderSettings) {
states.encoder->EnableAudioNetworkAdaptor("", nullptr, nullptr);
auto config = CreateEncoderRuntimeConfig();
AudioNetworkAdaptor::EncoderRuntimeConfig empty_config;
AudioEncoderRuntimeConfig empty_config;
EXPECT_CALL(**states.mock_audio_network_adaptor, GetEncoderRuntimeConfig())
.WillOnce(Return(config))

1
webrtc/tools/DEPS
View File

@ -4,6 +4,7 @@ include_rules = [
"+webrtc/common_video",
"+webrtc/logging/rtc_event_log",
"+webrtc/modules/audio_device",
"+webrtc/modules/audio_coding/audio_network_adaptor",
"+webrtc/modules/audio_processing",
"+webrtc/modules/bitrate_controller",
"+webrtc/modules/congestion_controller",

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

@ -20,6 +20,7 @@
#include "webrtc/base/function_view.h"
#include "webrtc/logging/rtc_event_log/rtc_event_log_parser.h"
#include "webrtc/modules/audio_coding/audio_network_adaptor/include/audio_network_adaptor.h"
#include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet.h"
#include "webrtc/tools/event_log_visualizer/plot_base.h"
@ -55,7 +56,7 @@ struct LossBasedBweUpdate {
struct AudioNetworkAdaptationEvent {
uint64_t timestamp;
AudioNetworkAdaptor::EncoderRuntimeConfig config;
AudioEncoderRuntimeConfig config;
};
class EventLogAnalyzer {

2
webrtc/voice_engine/channel.cc
View File

@ -163,7 +163,7 @@ class RtcEventLogProxy final : public webrtc::RtcEventLog {
}
void LogAudioNetworkAdaptation(
const AudioNetworkAdaptor::EncoderRuntimeConfig& config) override {
const AudioEncoderRuntimeConfig& config) override {
rtc::CritScope lock(&crit_);
if (event_log_) {
event_log_->LogAudioNetworkAdaptation(config);