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

Replace rtc::Optional with absl::optional in modules/audio_coding

Browse Source 
This is a no-op change because rtc::Optional is an alias to absl::optional

This CL generated by running script with parameter 'modules/audio_coding'

find $@ -type f \( -name \*.h -o -name \*.cc \) \
-exec sed -i 's|rtc::Optional|absl::optional|g' {} \+ \
-exec sed -i 's|rtc::nullopt|absl::nullopt|g' {} \+ \
-exec sed -i 's|#include "api/optional.h"|#include "absl/types/optional.h"|' {} \+

find $@ -type f -name BUILD.gn \
-exec sed -r -i 's|"[\./api]*:optional"|"//third_party/abseil-cpp/absl/types:optional"|' {} \+;

git cl format

Bug: webrtc:9078
Change-Id: Ic980ee605148fdb160666d4aa03cc87175e48fe8
Reviewed-on: https://webrtc-review.googlesource.com/84130
Reviewed-by: Oskar Sundbom <ossu@webrtc.org>
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#23659}
This commit is contained in:
Danil Chapovalov
2018-06-19 13:26:36 +02:00
committed by Commit Bot
parent bbfcc703ad
commit b602123a5a
82 changed files with 452 additions and 459 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
modules/audio_coding/audio_network_adaptor/audio_network_adaptor_impl.cc
View File

@ -123,7 +123,7 @@ AudioEncoderRuntimeConfig AudioNetworkAdaptorImpl::GetEncoderRuntimeConfig() {
controller->MakeDecision(&config);
// Update ANA stats.
auto increment_opt = [](rtc::Optional<uint32_t>& a) {
auto increment_opt = [](absl::optional<uint32_t>& a) {
a = a.value_or(0) + 1;
};
if (prev_config_) {

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

@ -75,7 +75,7 @@ class AudioNetworkAdaptorImpl final : public AudioNetworkAdaptor {
Controller::NetworkMetrics last_metrics_;
rtc::Optional<AudioEncoderRuntimeConfig> prev_config_;
absl::optional<AudioEncoderRuntimeConfig> prev_config_;
ANAStats stats_;

4
modules/audio_coding/audio_network_adaptor/bitrate_controller.h
View File

@ -43,8 +43,8 @@ class BitrateController final : public Controller {
const Config config_;
int bitrate_bps_;
int frame_length_ms_;
rtc::Optional<int> target_audio_bitrate_bps_;
rtc::Optional<size_t> overhead_bytes_per_packet_;
absl::optional<int> target_audio_bitrate_bps_;
absl::optional<size_t> overhead_bytes_per_packet_;
RTC_DISALLOW_COPY_AND_ASSIGN(BitrateController);
};

16
modules/audio_coding/audio_network_adaptor/bitrate_controller_unittest.cc
View File

@ -20,8 +20,8 @@ namespace {
void UpdateNetworkMetrics(
BitrateController* controller,
const rtc::Optional<int>& target_audio_bitrate_bps,
const rtc::Optional<size_t>& overhead_bytes_per_packet) {
const absl::optional<int>& target_audio_bitrate_bps,
const absl::optional<size_t>& overhead_bytes_per_packet) {
// UpdateNetworkMetrics can accept multiple network metric updates at once.
// However, currently, the most used case is to update one metric at a time.
// To reflect this fact, we separate the calls.
@ -38,7 +38,7 @@ void UpdateNetworkMetrics(
}
void CheckDecision(BitrateController* controller,
const rtc::Optional<int>& frame_length_ms,
const absl::optional<int>& frame_length_ms,
int expected_bitrate_bps) {
AudioEncoderRuntimeConfig config;
config.frame_length_ms = frame_length_ms;
@ -58,7 +58,7 @@ TEST(AnaBitrateControllerTest, OutputInitValueWhenTargetBitrateUnknown) {
constexpr size_t kOverheadBytesPerPacket = 64;
BitrateController controller(BitrateController::Config(
kInitialBitrateBps, kInitialFrameLengthMs, 0, 0));
UpdateNetworkMetrics(&controller, rtc::nullopt, kOverheadBytesPerPacket);
UpdateNetworkMetrics(&controller, absl::nullopt, kOverheadBytesPerPacket);
CheckDecision(&controller, kInitialFrameLengthMs * 2, kInitialBitrateBps);
}
@ -68,7 +68,7 @@ TEST(AnaBitrateControllerTest, OutputInitValueWhenOverheadUnknown) {
constexpr int kTargetBitrateBps = 48000;
BitrateController controller(BitrateController::Config(
kInitialBitrateBps, kInitialFrameLengthMs, 0, 0));
UpdateNetworkMetrics(&controller, kTargetBitrateBps, rtc::nullopt);
UpdateNetworkMetrics(&controller, kTargetBitrateBps, absl::nullopt);
CheckDecision(&controller, kInitialFrameLengthMs * 2, kInitialBitrateBps);
}
@ -126,7 +126,7 @@ TEST(AnaBitrateControllerTest, TreatUnknownFrameLengthAsFrameLengthUnchanged) {
kTargetBitrateBps -
kOverheadBytesPerPacket * 8 * 1000 / kInitialFrameLengthMs;
UpdateNetworkMetrics(&controller, kTargetBitrateBps, kOverheadBytesPerPacket);
CheckDecision(&controller, rtc::nullopt, kBitrateBps);
CheckDecision(&controller, absl::nullopt, kBitrateBps);
}
TEST(AnaBitrateControllerTest, IncreaseBitrateOnFrameLengthIncreased) {
@ -142,7 +142,7 @@ TEST(AnaBitrateControllerTest, IncreaseBitrateOnFrameLengthIncreased) {
kTargetBitrateBps -
kOverheadBytesPerPacket * 8 * 1000 / kInitialFrameLengthMs;
UpdateNetworkMetrics(&controller, kTargetBitrateBps, kOverheadBytesPerPacket);
CheckDecision(&controller, rtc::nullopt, kBitrateBps);
CheckDecision(&controller, absl::nullopt, kBitrateBps);
constexpr int kFrameLengthMs = 60;
constexpr size_t kPacketOverheadRateDiff =
@ -166,7 +166,7 @@ TEST(AnaBitrateControllerTest, DecreaseBitrateOnFrameLengthDecreased) {
kTargetBitrateBps -
kOverheadBytesPerPacket * 8 * 1000 / kInitialFrameLengthMs;
UpdateNetworkMetrics(&controller, kTargetBitrateBps, kOverheadBytesPerPacket);
CheckDecision(&controller, rtc::nullopt, kBitrateBps);
CheckDecision(&controller, absl::nullopt, kBitrateBps);
constexpr int kFrameLengthMs = 20;
constexpr size_t kPacketOverheadRateDiff =

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

@ -44,7 +44,7 @@ class ChannelController final : public Controller {
private:
const Config config_;
size_t channels_to_encode_;
rtc::Optional<int> uplink_bandwidth_bps_;
absl::optional<int> uplink_bandwidth_bps_;
RTC_DISALLOW_COPY_AND_ASSIGN(ChannelController);
};

4
modules/audio_coding/audio_network_adaptor/channel_controller_unittest.cc
View File

@ -32,7 +32,7 @@ std::unique_ptr<ChannelController> CreateChannelController(int init_channels) {
}
void CheckDecision(ChannelController* controller,
const rtc::Optional<int>& uplink_bandwidth_bps,
const absl::optional<int>& uplink_bandwidth_bps,
size_t expected_num_channels) {
if (uplink_bandwidth_bps) {
Controller::NetworkMetrics network_metrics;
@ -49,7 +49,7 @@ void CheckDecision(ChannelController* controller,
TEST(ChannelControllerTest, OutputInitValueWhenUplinkBandwidthUnknown) {
constexpr int kInitChannels = 2;
auto controller = CreateChannelController(kInitChannels);
CheckDecision(controller.get(), rtc::nullopt, kInitChannels);
CheckDecision(controller.get(), absl::nullopt, kInitChannels);
}
TEST(ChannelControllerTest, SwitchTo2ChannelsOnHighUplinkBandwidth) {

14
modules/audio_coding/audio_network_adaptor/controller.h
View File

@ -11,7 +11,7 @@
#ifndef MODULES_AUDIO_CODING_AUDIO_NETWORK_ADAPTOR_CONTROLLER_H_
#define MODULES_AUDIO_CODING_AUDIO_NETWORK_ADAPTOR_CONTROLLER_H_
#include "api/optional.h"
#include "absl/types/optional.h"
#include "modules/audio_coding/audio_network_adaptor/include/audio_network_adaptor.h"
namespace webrtc {
@ -21,12 +21,12 @@ class Controller {
struct NetworkMetrics {
NetworkMetrics();
~NetworkMetrics();
rtc::Optional<int> uplink_bandwidth_bps;
rtc::Optional<float> uplink_packet_loss_fraction;
rtc::Optional<float> uplink_recoverable_packet_loss_fraction;
rtc::Optional<int> target_audio_bitrate_bps;
rtc::Optional<int> rtt_ms;
rtc::Optional<size_t> overhead_bytes_per_packet;
absl::optional<int> uplink_bandwidth_bps;
absl::optional<float> uplink_packet_loss_fraction;
absl::optional<float> uplink_recoverable_packet_loss_fraction;
absl::optional<int> target_audio_bitrate_bps;
absl::optional<int> rtt_ms;
absl::optional<size_t> overhead_bytes_per_packet;
};
virtual ~Controller() = default;

2
modules/audio_coding/audio_network_adaptor/controller_manager.cc
View File

@ -327,7 +327,7 @@ ControllerManagerImpl::ControllerManagerImpl(
const std::map<const Controller*, std::pair<int, float>>& scoring_points)
: config_(config),
controllers_(std::move(controllers)),
last_reordering_time_ms_(rtc::nullopt),
last_reordering_time_ms_(absl::nullopt),
last_scoring_point_(0, 0.0) {
for (auto& controller : controllers_)
default_sorted_controllers_.push_back(controller.get());

2
modules/audio_coding/audio_network_adaptor/controller_manager.h
View File

@ -104,7 +104,7 @@ class ControllerManagerImpl final : public ControllerManager {
std::vector<std::unique_ptr<Controller>> controllers_;
rtc::Optional<int64_t> last_reordering_time_ms_;
absl::optional<int64_t> last_reordering_time_ms_;
ScoringPoint last_scoring_point_;
std::vector<Controller*> default_sorted_controllers_;

7
modules/audio_coding/audio_network_adaptor/controller_manager_unittest.cc
View File

@ -87,8 +87,8 @@ ControllerManagerStates CreateControllerManager() {
// exists in the vector.
void CheckControllersOrder(
ControllerManagerStates* states,
const rtc::Optional<int>& uplink_bandwidth_bps,
const rtc::Optional<float>& uplink_packet_loss_fraction,
const absl::optional<int>& uplink_bandwidth_bps,
const absl::optional<float>& uplink_packet_loss_fraction,
const std::vector<int>& expected_order) {
RTC_DCHECK_EQ(kNumControllers, expected_order.size());
Controller::NetworkMetrics metrics;
@ -124,8 +124,7 @@ TEST(ControllerManagerTest, ControllersInDefaultOrderOnEmptyNetworkMetrics) {
auto states = CreateControllerManager();
// |network_metrics| are empty, and the controllers are supposed to follow the
// default order.
CheckControllersOrder(&states, rtc::nullopt, rtc::nullopt,
{0, 1, 2, 3});
CheckControllersOrder(&states, absl::nullopt, absl::nullopt, {0, 1, 2, 3});
}
TEST(ControllerManagerTest, ControllersWithoutCharPointAtEndAndInDefaultOrder) {

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

@ -40,7 +40,7 @@ class DtxController final : public Controller {
private:
const Config config_;
bool dtx_enabled_;
rtc::Optional<int> uplink_bandwidth_bps_;
absl::optional<int> uplink_bandwidth_bps_;
RTC_DISALLOW_COPY_AND_ASSIGN(DtxController);
};

4
modules/audio_coding/audio_network_adaptor/dtx_controller_unittest.cc
View File

@ -30,7 +30,7 @@ std::unique_ptr<DtxController> CreateController(int initial_dtx_enabled) {
}
void CheckDecision(DtxController* controller,
const rtc::Optional<int>& uplink_bandwidth_bps,
const absl::optional<int>& uplink_bandwidth_bps,
bool expected_dtx_enabled) {
if (uplink_bandwidth_bps) {
Controller::NetworkMetrics network_metrics;
@ -47,7 +47,7 @@ void CheckDecision(DtxController* controller,
TEST(DtxControllerTest, OutputInitValueWhenUplinkBandwidthUnknown) {
constexpr bool kInitialDtxEnabled = true;
auto controller = CreateController(kInitialDtxEnabled);
CheckDecision(controller.get(), rtc::nullopt, kInitialDtxEnabled);
CheckDecision(controller.get(), absl::nullopt, kInitialDtxEnabled);
}
TEST(DtxControllerTest, TurnOnDtxForLowUplinkBandwidth) {

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

@ -23,7 +23,7 @@ class NullSmoothingFilter final : public SmoothingFilter {
public:
void AddSample(float sample) override { last_sample_ = sample; }
rtc::Optional<float> GetAverage() override { return last_sample_; }
absl::optional<float> GetAverage() override { return last_sample_; }
bool SetTimeConstantMs(int time_constant_ms) override {
RTC_NOTREACHED();
@ -31,7 +31,7 @@ class NullSmoothingFilter final : public SmoothingFilter {
}
private:
rtc::Optional<float> last_sample_;
absl::optional<float> last_sample_;
};
}
@ -89,7 +89,7 @@ void FecControllerPlrBased::MakeDecision(AudioEncoderRuntimeConfig* config) {
}
bool FecControllerPlrBased::FecEnablingDecision(
const rtc::Optional<float>& packet_loss) const {
const absl::optional<float>& packet_loss) const {
if (!uplink_bandwidth_bps_ || !packet_loss) {
return false;
} else {
@ -100,7 +100,7 @@ bool FecControllerPlrBased::FecEnablingDecision(
}
bool FecControllerPlrBased::FecDisablingDecision(
const rtc::Optional<float>& packet_loss) const {
const absl::optional<float>& packet_loss) const {
if (!uplink_bandwidth_bps_ || !packet_loss) {
return false;
} else {

6
modules/audio_coding/audio_network_adaptor/fec_controller_plr_based.h
View File

@ -56,12 +56,12 @@ class FecControllerPlrBased final : public Controller {
void MakeDecision(AudioEncoderRuntimeConfig* config) override;
private:
bool FecEnablingDecision(const rtc::Optional<float>& packet_loss) const;
bool FecDisablingDecision(const rtc::Optional<float>& packet_loss) const;
bool FecEnablingDecision(const absl::optional<float>& packet_loss) const;
bool FecDisablingDecision(const absl::optional<float>& packet_loss) const;
const Config config_;
bool fec_enabled_;
rtc::Optional<int> uplink_bandwidth_bps_;
absl::optional<int> uplink_bandwidth_bps_;
const std::unique_ptr<SmoothingFilter> packet_loss_smoother_;
RTC_DISALLOW_COPY_AND_ASSIGN(FecControllerPlrBased);

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

@ -78,8 +78,8 @@ FecControllerPlrBasedTestStates CreateFecControllerPlrBased(
}
void UpdateNetworkMetrics(FecControllerPlrBasedTestStates* states,
const rtc::Optional<int>& uplink_bandwidth_bps,
const rtc::Optional<float>& uplink_packet_loss) {
const absl::optional<int>& uplink_bandwidth_bps,
const absl::optional<float>& uplink_packet_loss) {
// UpdateNetworkMetrics can accept multiple network metric updates at once.
// However, currently, the most used case is to update one metric at a time.
// To reflect this fact, we separate the calls.
@ -131,7 +131,7 @@ TEST(FecControllerPlrBasedTest, OutputInitValueWhenUplinkBandwidthUnknown) {
kEnablingPacketLossAtLowBw - kEpsilon, kEnablingPacketLossAtLowBw,
kEnablingPacketLossAtLowBw + kEpsilon}) {
auto states = CreateFecControllerPlrBased(initial_fec_enabled);
UpdateNetworkMetrics(&states, rtc::nullopt, packet_loss);
UpdateNetworkMetrics(&states, absl::nullopt, packet_loss);
CheckDecision(&states, initial_fec_enabled, packet_loss);
}
}
@ -146,7 +146,7 @@ TEST(FecControllerPlrBasedTest,
kDisablingBandwidthLow + 1, kEnablingBandwidthLow - 1,
kEnablingBandwidthLow, kEnablingBandwidthLow + 1}) {
auto states = CreateFecControllerPlrBased(initial_fec_enabled);
UpdateNetworkMetrics(&states, bandwidth, rtc::nullopt);
UpdateNetworkMetrics(&states, bandwidth, absl::nullopt);
CheckDecision(&states, initial_fec_enabled, 0.0);
}
}

4
modules/audio_coding/audio_network_adaptor/fec_controller_rplr_based.h
View File

@ -55,8 +55,8 @@ class FecControllerRplrBased final : public Controller {
const Config config_;
bool fec_enabled_;
rtc::Optional<int> uplink_bandwidth_bps_;
rtc::Optional<float> uplink_recoverable_packet_loss_;
absl::optional<int> uplink_bandwidth_bps_;
absl::optional<float> uplink_recoverable_packet_loss_;
RTC_DISALLOW_COPY_AND_ASSIGN(FecControllerRplrBased);
};

20
modules/audio_coding/audio_network_adaptor/fec_controller_rplr_based_unittest.cc
View File

@ -44,14 +44,14 @@ constexpr float kEnablingRecoverablePacketLossAtHighBw = 0.05f;
constexpr float kEpsilon = 1e-5f;
rtc::Optional<float> GetRandomProbabilityOrUnknown() {
absl::optional<float> GetRandomProbabilityOrUnknown() {
std::random_device rd;
std::mt19937 generator(rd());
std::uniform_real_distribution<> distribution(0, 1);
return (distribution(generator) < 0.2)
? rtc::nullopt
: rtc::Optional<float>(distribution(generator));
? absl::nullopt
: absl::optional<float>(distribution(generator));
}
std::unique_ptr<FecControllerRplrBased> CreateFecControllerRplrBased(
@ -70,9 +70,9 @@ std::unique_ptr<FecControllerRplrBased> CreateFecControllerRplrBased(
void UpdateNetworkMetrics(
FecControllerRplrBased* controller,
const rtc::Optional<int>& uplink_bandwidth_bps,
const rtc::Optional<float>& uplink_packet_loss,
const rtc::Optional<float>& uplink_recoveralbe_packet_loss) {
const absl::optional<int>& uplink_bandwidth_bps,
const absl::optional<float>& uplink_packet_loss,
const absl::optional<float>& uplink_recoveralbe_packet_loss) {
// UpdateNetworkMetrics can accept multiple network metric updates at once.
// However, currently, the most used case is to update one metric at a time.
// To reflect this fact, we separate the calls.
@ -96,8 +96,8 @@ void UpdateNetworkMetrics(
void UpdateNetworkMetrics(
FecControllerRplrBased* controller,
const rtc::Optional<int>& uplink_bandwidth_bps,
const rtc::Optional<float>& uplink_recoveralbe_packet_loss) {
const absl::optional<int>& uplink_bandwidth_bps,
const absl::optional<float>& uplink_recoveralbe_packet_loss) {
// FecControllerRplrBased doesn't currently use the PLR (general packet-loss
// rate) at all. (This might be changed in the future.) The unit-tests will
// use a random value (including unknown), to show this does not interfere.
@ -148,7 +148,7 @@ TEST(FecControllerRplrBasedTest, OutputInitValueWhenUplinkBandwidthUnknown) {
kEnablingRecoverablePacketLossAtHighBw,
kEnablingRecoverablePacketLossAtHighBw + kEpsilon}) {
auto controller = CreateFecControllerRplrBased(initial_fec_enabled);
UpdateNetworkMetrics(controller.get(), rtc::nullopt,
UpdateNetworkMetrics(controller.get(), absl::nullopt,
recoverable_packet_loss);
CheckDecision(controller.get(), initial_fec_enabled,
recoverable_packet_loss);
@ -165,7 +165,7 @@ TEST(FecControllerRplrBasedTest,
kDisablingBandwidthLow + 1, kEnablingBandwidthLow - 1,
kEnablingBandwidthLow, kEnablingBandwidthLow + 1}) {
auto controller = CreateFecControllerRplrBased(initial_fec_enabled);
UpdateNetworkMetrics(controller.get(), bandwidth, rtc::nullopt);
UpdateNetworkMetrics(controller.get(), bandwidth, absl::nullopt);
CheckDecision(controller.get(), initial_fec_enabled, 0.0);
}
}

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

@ -73,11 +73,11 @@ class FrameLengthController final : public Controller {
std::vector<int>::const_iterator frame_length_ms_;
rtc::Optional<int> uplink_bandwidth_bps_;
absl::optional<int> uplink_bandwidth_bps_;
rtc::Optional<float> uplink_packet_loss_fraction_;
absl::optional<float> uplink_packet_loss_fraction_;
rtc::Optional<size_t> overhead_bytes_per_packet_;
absl::optional<size_t> overhead_bytes_per_packet_;
// True if the previous frame length decision was an increase, otherwise
// false.

26
modules/audio_coding/audio_network_adaptor/frame_length_controller_unittest.cc
View File

@ -78,9 +78,9 @@ CreateChangeCriteriaFor20ms60msAnd120ms() {
void UpdateNetworkMetrics(
FrameLengthController* controller,
const rtc::Optional<int>& uplink_bandwidth_bps,
const rtc::Optional<float>& uplink_packet_loss_fraction,
const rtc::Optional<size_t>& overhead_bytes_per_packet) {
const absl::optional<int>& uplink_bandwidth_bps,
const absl::optional<float>& uplink_packet_loss_fraction,
const absl::optional<size_t>& overhead_bytes_per_packet) {
// UpdateNetworkMetrics can accept multiple network metric updates at once.
// However, currently, the most used case is to update one metric at a time.
// To reflect this fact, we separate the calls.
@ -114,14 +114,14 @@ TEST(FrameLengthControllerTest, DecreaseTo20MsOnHighUplinkBandwidth) {
auto controller =
CreateController(CreateChangeCriteriaFor20msAnd60ms(), {20, 60}, 60);
UpdateNetworkMetrics(controller.get(), kFl60msTo20msBandwidthBps,
rtc::nullopt, kOverheadBytesPerPacket);
absl::nullopt, kOverheadBytesPerPacket);
CheckDecision(controller.get(), 20);
}
TEST(FrameLengthControllerTest, DecreaseTo20MsOnHighUplinkPacketLossFraction) {
auto controller =
CreateController(CreateChangeCriteriaFor20msAnd60ms(), {20, 60}, 60);
UpdateNetworkMetrics(controller.get(), rtc::nullopt,
UpdateNetworkMetrics(controller.get(), absl::nullopt,
kFlDecreasingPacketLossFraction,
kOverheadBytesPerPacket);
CheckDecision(controller.get(), 20);
@ -252,16 +252,12 @@ TEST(FrameLengthControllerTest, From120MsTo20MsOnHighUplinkBandwidth) {
auto controller = CreateController(CreateChangeCriteriaFor20ms60msAnd120ms(),
{20, 60, 120}, 120);
// It takes two steps for frame length to go from 120ms to 20ms.
UpdateNetworkMetrics(controller.get(),
kFl60msTo20msBandwidthBps,
rtc::nullopt,
kOverheadBytesPerPacket);
UpdateNetworkMetrics(controller.get(), kFl60msTo20msBandwidthBps,
absl::nullopt, kOverheadBytesPerPacket);
CheckDecision(controller.get(), 60);
UpdateNetworkMetrics(controller.get(),
kFl60msTo20msBandwidthBps,
rtc::nullopt,
kOverheadBytesPerPacket);
UpdateNetworkMetrics(controller.get(), kFl60msTo20msBandwidthBps,
absl::nullopt, kOverheadBytesPerPacket);
CheckDecision(controller.get(), 20);
}
@ -269,12 +265,12 @@ TEST(FrameLengthControllerTest, From120MsTo20MsOnHighUplinkPacketLossFraction) {
auto controller = CreateController(CreateChangeCriteriaFor20ms60msAnd120ms(),
{20, 60, 120}, 120);
// It takes two steps for frame length to go from 120ms to 20ms.
UpdateNetworkMetrics(controller.get(), rtc::nullopt,
UpdateNetworkMetrics(controller.get(), absl::nullopt,
kFlDecreasingPacketLossFraction,
kOverheadBytesPerPacket);
CheckDecision(controller.get(), 60);
UpdateNetworkMetrics(controller.get(), rtc::nullopt,
UpdateNetworkMetrics(controller.get(), absl::nullopt,
kFlDecreasingPacketLossFraction,
kOverheadBytesPerPacket);
CheckDecision(controller.get(), 20);

2
modules/audio_coding/audio_network_adaptor/include/audio_network_adaptor.h
View File

@ -11,8 +11,8 @@
#ifndef MODULES_AUDIO_CODING_AUDIO_NETWORK_ADAPTOR_INCLUDE_AUDIO_NETWORK_ADAPTOR_H_
#define MODULES_AUDIO_CODING_AUDIO_NETWORK_ADAPTOR_INCLUDE_AUDIO_NETWORK_ADAPTOR_H_
#include "absl/types/optional.h"
#include "api/audio_codecs/audio_encoder.h"
#include "api/optional.h"
#include "modules/audio_coding/audio_network_adaptor/include/audio_network_adaptor_config.h"
namespace webrtc {

14
modules/audio_coding/audio_network_adaptor/include/audio_network_adaptor_config.h
View File

@ -11,7 +11,7 @@
#ifndef MODULES_AUDIO_CODING_AUDIO_NETWORK_ADAPTOR_INCLUDE_AUDIO_NETWORK_ADAPTOR_CONFIG_H_
#define MODULES_AUDIO_CODING_AUDIO_NETWORK_ADAPTOR_INCLUDE_AUDIO_NETWORK_ADAPTOR_CONFIG_H_
#include "api/optional.h"
#include "absl/types/optional.h"
namespace webrtc {
@ -21,18 +21,18 @@ struct AudioEncoderRuntimeConfig {
~AudioEncoderRuntimeConfig();
AudioEncoderRuntimeConfig& operator=(const AudioEncoderRuntimeConfig& other);
bool operator==(const AudioEncoderRuntimeConfig& other) const;
rtc::Optional<int> bitrate_bps;
rtc::Optional<int> frame_length_ms;
absl::optional<int> bitrate_bps;
absl::optional<int> frame_length_ms;
// Note: This is what we tell the encoder. It doesn't have to reflect
// the actual NetworkMetrics; it's subject to our decision.
rtc::Optional<float> uplink_packet_loss_fraction;
rtc::Optional<bool> enable_fec;
rtc::Optional<bool> enable_dtx;
absl::optional<float> uplink_packet_loss_fraction;
absl::optional<bool> enable_fec;
absl::optional<bool> enable_dtx;
// Some encoders can encode fewer channels than the actual input to make
// better use of the bandwidth. |num_channels| sets the number of channels
// to encode.
rtc::Optional<size_t> num_channels;
absl::optional<size_t> num_channels;
// This is true if the last frame length change was an increase, and otherwise
// false.