Reland "Moved BitrateConfig out of Call::Config."
This is a reland of 5897fe27abcbe70f706cc23adc26147e0581f97e.
Adding back CallConfig::kDefaultStartBitrateBps as deprecated.
Also making BitrateContraints::kDefaultStartBitrateBps private to stop
it from being used in other places.
Original change's description:
> Moved BitrateConfig out of Call::Config.
>
> This prepares for a CL extracting the bitrate configuration logic from
> the Call class.
>
> Also renaming BitrateConfig to BitrateConstraints.
>
> Bug: webrtc:8415
> Change-Id: I7e472683034c57bdc8093cdf5e78e477d1732480
> Reviewed-on: https://webrtc-review.googlesource.com/54400
> Commit-Queue: Sebastian Jansson <srte@webrtc.org>
> Reviewed-by: Stefan Holmer <stefan@webrtc.org>
> Reviewed-by: Niels Moller <nisse@webrtc.org>
> Cr-Commit-Position: refs/heads/master@{#22104}
Bug: webrtc:8415
Change-Id: Iacfe2d6daedff710832ab89210c7c66d4403c93b
Reviewed-on: https://webrtc-review.googlesource.com/55980
Commit-Queue: Sebastian Jansson <srte@webrtc.org>
Reviewed-by: Stefan Holmer <stefan@webrtc.org>
Reviewed-by: Niels Moller <nisse@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#22123}diff --git a/call/BUILD.gn b/call/BUILD.gn
index 993be20..a3d2316 100644
--- a/call/BUILD.gn
+++ b/call/BUILD.gn
@@ -42,6 +42,8 @@
# when interfaces have stabilized. See also TODO for |mock_rtp_interfaces|.
rtc_source_set("rtp_interfaces") {
sources = [
+ "bitrate_constraints.cc",
+ "bitrate_constraints.h",
"rtcp_packet_sink_interface.h",
"rtp_config.cc",
"rtp_config.h",
@@ -51,6 +53,7 @@
]
deps = [
"../api:array_view",
+ "../api:optional",
"../rtc_base:rtc_base_approved",
]
}
diff --git a/call/bitrate_constraints.cc b/call/bitrate_constraints.cc
new file mode 100644
index 0000000..1e6264e
--- /dev/null
+++ b/call/bitrate_constraints.cc
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2018 The WebRTC project authors. All Rights Reserved.
+ *
+ * Use of this source code is governed by a BSD-style license
+ * that can be found in the LICENSE file in the root of the source
+ * tree. An additional intellectual property rights grant can be found
+ * in the file PATENTS. All contributing project authors may
+ * be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "call/bitrate_constraints.h"
+
+namespace webrtc {
+BitrateConstraintsMask::BitrateConstraintsMask() = default;
+BitrateConstraintsMask::~BitrateConstraintsMask() = default;
+BitrateConstraintsMask::BitrateConstraintsMask(const BitrateConstraintsMask&) =
+ default;
+} // namespace webrtc
diff --git a/call/bitrate_constraints.h b/call/bitrate_constraints.h
new file mode 100644
index 0000000..7898a78
--- /dev/null
+++ b/call/bitrate_constraints.h
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2018 The WebRTC project authors. All Rights Reserved.
+ *
+ * Use of this source code is governed by a BSD-style license
+ * that can be found in the LICENSE file in the root of the source
+ * tree. An additional intellectual property rights grant can be found
+ * in the file PATENTS. All contributing project authors may
+ * be found in the AUTHORS file in the root of the source tree.
+ */
+
+#ifndef CALL_BITRATE_CONSTRAINTS_H_
+#define CALL_BITRATE_CONSTRAINTS_H_
+
+#include <algorithm>
+
+#include "api/optional.h"
+
+namespace webrtc {
+// TODO(srte): BitrateConstraints and BitrateConstraintsMask should be merged.
+// Both represent the same kind data, but are using different default
+// initializer and representation of unset values.
+struct BitrateConstraints {
+ int min_bitrate_bps = 0;
+ int start_bitrate_bps = kDefaultStartBitrateBps;
+ int max_bitrate_bps = -1;
+
+ private:
+ static constexpr int kDefaultStartBitrateBps = 300000;
+};
+
+// BitrateConstraintsMask is used for the local client's bitrate preferences.
+// Semantically it carries the same kind of information as BitrateConstraints,
+// but is used in a slightly different way.
+struct BitrateConstraintsMask {
+ BitrateConstraintsMask();
+ ~BitrateConstraintsMask();
+ BitrateConstraintsMask(const BitrateConstraintsMask&);
+ rtc::Optional<int> min_bitrate_bps;
+ rtc::Optional<int> start_bitrate_bps;
+ rtc::Optional<int> max_bitrate_bps;
+};
+
+// Like std::min, but considers non-positive values to be unset.
+template <typename T>
+static T MinPositive(T a, T b) {
+ if (a <= 0) {
+ return b;
+ }
+ if (b <= 0) {
+ return a;
+ }
+ return std::min(a, b);
+}
+} // namespace webrtc
+#endif // CALL_BITRATE_CONSTRAINTS_H_
diff --git a/call/call.cc b/call/call.cc
index 3a72040..750718a 100644
--- a/call/call.cc
+++ b/call/call.cc
@@ -213,10 +213,10 @@
void OnRecoveredPacket(const uint8_t* packet, size_t length) override;
void SetBitrateConfig(
- const webrtc::Call::Config::BitrateConfig& bitrate_config) override;
+ const webrtc::BitrateConstraints& bitrate_config) override;
void SetBitrateConfigMask(
- const webrtc::Call::Config::BitrateConfigMask& bitrate_config) override;
+ const webrtc::BitrateConstraintsMask& bitrate_config) override;
void SetBitrateAllocationStrategy(
std::unique_ptr<rtc::BitrateAllocationStrategy>
@@ -261,7 +261,7 @@
void UpdateHistograms();
void UpdateAggregateNetworkState();
- // Applies update to the BitrateConfig cached in |config_|, restarting
+ // Applies update to the BitrateConstraints cached in |config_|, restarting
// bandwidth estimation from |new_start| if set.
void UpdateCurrentBitrateConfig(const rtc::Optional<int>& new_start);
@@ -374,11 +374,11 @@
// The config mask set by SetBitrateConfigMask.
// 0 <= min <= start <= max
- Config::BitrateConfigMask bitrate_config_mask_;
+ BitrateConstraintsMask bitrate_config_mask_;
// The config set by SetBitrateConfig.
// min >= 0, start != 0, max == -1 || max > 0
- Config::BitrateConfig base_bitrate_config_;
+ BitrateConstraints base_bitrate_config_;
RTC_DISALLOW_COPY_AND_ASSIGN(Call);
};
@@ -954,8 +954,7 @@
return stats;
}
-void Call::SetBitrateConfig(
- const webrtc::Call::Config::BitrateConfig& bitrate_config) {
+void Call::SetBitrateConfig(const BitrateConstraints& bitrate_config) {
TRACE_EVENT0("webrtc", "Call::SetBitrateConfig");
RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_);
RTC_DCHECK_GE(bitrate_config.min_bitrate_bps, 0);
@@ -978,8 +977,7 @@
UpdateCurrentBitrateConfig(new_start);
}
-void Call::SetBitrateConfigMask(
- const webrtc::Call::Config::BitrateConfigMask& mask) {
+void Call::SetBitrateConfigMask(const BitrateConstraintsMask& mask) {
TRACE_EVENT0("webrtc", "Call::SetBitrateConfigMask");
RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_);
@@ -988,7 +986,7 @@
}
void Call::UpdateCurrentBitrateConfig(const rtc::Optional<int>& new_start) {
- Config::BitrateConfig updated;
+ BitrateConstraints updated;
updated.min_bitrate_bps =
std::max(bitrate_config_mask_.min_bitrate_bps.value_or(0),
base_bitrate_config_.min_bitrate_bps);
diff --git a/call/call.h b/call/call.h
index 1155aaf..117c40c 100644
--- a/call/call.h
+++ b/call/call.h
@@ -20,6 +20,7 @@
#include "call/audio_receive_stream.h"
#include "call/audio_send_stream.h"
#include "call/audio_state.h"
+#include "call/bitrate_constraints.h"
#include "call/flexfec_receive_stream.h"
#include "call/rtp_transport_controller_send_interface.h"
#include "call/video_receive_stream.h"
@@ -43,19 +44,6 @@
DATA
};
-// Like std::min, but considers non-positive values to be unset.
-// TODO(zstein): Remove once all callers use rtc::Optional.
-template <typename T>
-static T MinPositive(T a, T b) {
- if (a <= 0) {
- return b;
- }
- if (b <= 0) {
- return a;
- }
- return std::min(a, b);
-}
-
class PacketReceiver {
public:
enum DeliveryStatus {
@@ -77,26 +65,11 @@
RTC_DCHECK(event_log);
}
- static constexpr int kDefaultStartBitrateBps = 300000;
+ RTC_DEPRECATED static constexpr int kDefaultStartBitrateBps = 300000;
// Bitrate config used until valid bitrate estimates are calculated. Also
// used to cap total bitrate used. This comes from the remote connection.
- struct BitrateConfig {
- int min_bitrate_bps = 0;
- int start_bitrate_bps = kDefaultStartBitrateBps;
- int max_bitrate_bps = -1;
- } bitrate_config;
-
- // The local client's bitrate preferences. The actual configuration used
- // is a combination of this and |bitrate_config|. The combination is
- // currently more complicated than a simple mask operation (see
- // SetBitrateConfig and SetBitrateConfigMask). Assumes that 0 <= min <=
- // start <= max holds for set parameters.
- struct BitrateConfigMask {
- rtc::Optional<int> min_bitrate_bps;
- rtc::Optional<int> start_bitrate_bps;
- rtc::Optional<int> max_bitrate_bps;
- };
+ BitrateConstraints bitrate_config;
// AudioState which is possibly shared between multiple calls.
// TODO(solenberg): Change this to a shared_ptr once we can use C++11.
@@ -184,15 +157,14 @@
// This is due to how the 'x-google-start-bitrate' flag is currently
// implemented. Passing -1 leaves the start bitrate unchanged. Behavior is not
// guaranteed for other negative values or 0.
- virtual void SetBitrateConfig(
- const Config::BitrateConfig& bitrate_config) = 0;
+ virtual void SetBitrateConfig(const BitrateConstraints& bitrate_config) = 0;
// The greater min and smaller max set by this and SetBitrateConfig will be
// used. The latest non-negative start value form either call will be used.
// Specifying a start bitrate will reset the current bitrate estimate.
// Assumes 0 <= min <= start <= max holds for set parameters.
virtual void SetBitrateConfigMask(
- const Config::BitrateConfigMask& bitrate_mask) = 0;
+ const BitrateConstraintsMask& bitrate_mask) = 0;
virtual void SetBitrateAllocationStrategy(
std::unique_ptr<rtc::BitrateAllocationStrategy>
diff --git a/call/call_perf_tests.cc b/call/call_perf_tests.cc
index ddeaf12..e8c3601 100644
--- a/call/call_perf_tests.cc
+++ b/call/call_perf_tests.cc
@@ -888,7 +888,7 @@
void OnCallsCreated(Call* sender_call, Call* receiver_call) override {
sender_call_ = sender_call;
- Call::Config::BitrateConfig bitrate_config;
+ BitrateConstraints bitrate_config;
bitrate_config.min_bitrate_bps = min_bwe_;
bitrate_config.start_bitrate_bps = start_bwe_;
bitrate_config.max_bitrate_bps = max_bwe_;
diff --git a/call/call_unittest.cc b/call/call_unittest.cc
index dc36ce2..cf44f14 100644
--- a/call/call_unittest.cc
+++ b/call/call_unittest.cc
@@ -254,9 +254,9 @@
namespace {
struct CallBitrateHelper {
- CallBitrateHelper() : CallBitrateHelper(Call::Config::BitrateConfig()) {}
+ CallBitrateHelper() : CallBitrateHelper(BitrateConstraints()) {}
- explicit CallBitrateHelper(const Call::Config::BitrateConfig& bitrate_config)
+ explicit CallBitrateHelper(const BitrateConstraints& bitrate_config)
: mock_cc_(Clock::GetRealTimeClock(), &event_log_, &pacer_) {
Call::Config config(&event_log_);
config.bitrate_config = bitrate_config;
@@ -282,7 +282,7 @@
TEST(CallBitrateTest, SetBitrateConfigWithValidConfigCallsSetBweBitrates) {
CallBitrateHelper call;
- Call::Config::BitrateConfig bitrate_config;
+ BitrateConstraints bitrate_config;
bitrate_config.min_bitrate_bps = 1;
bitrate_config.start_bitrate_bps = 2;
bitrate_config.max_bitrate_bps = 3;
@@ -294,7 +294,7 @@
TEST(CallBitrateTest, SetBitrateConfigWithDifferentMinCallsSetBweBitrates) {
CallBitrateHelper call;
- Call::Config::BitrateConfig bitrate_config;
+ BitrateConstraints bitrate_config;
bitrate_config.min_bitrate_bps = 10;
bitrate_config.start_bitrate_bps = 20;
bitrate_config.max_bitrate_bps = 30;
@@ -308,7 +308,7 @@
TEST(CallBitrateTest, SetBitrateConfigWithDifferentStartCallsSetBweBitrates) {
CallBitrateHelper call;
- Call::Config::BitrateConfig bitrate_config;
+ BitrateConstraints bitrate_config;
bitrate_config.min_bitrate_bps = 10;
bitrate_config.start_bitrate_bps = 20;
bitrate_config.max_bitrate_bps = 30;
@@ -322,7 +322,7 @@
TEST(CallBitrateTest, SetBitrateConfigWithDifferentMaxCallsSetBweBitrates) {
CallBitrateHelper call;
- Call::Config::BitrateConfig bitrate_config;
+ BitrateConstraints bitrate_config;
bitrate_config.min_bitrate_bps = 10;
bitrate_config.start_bitrate_bps = 20;
bitrate_config.max_bitrate_bps = 30;
@@ -335,7 +335,7 @@
TEST(CallBitrateTest, SetBitrateConfigWithSameConfigElidesSecondCall) {
CallBitrateHelper call;
- Call::Config::BitrateConfig bitrate_config;
+ BitrateConstraints bitrate_config;
bitrate_config.min_bitrate_bps = 1;
bitrate_config.start_bitrate_bps = 2;
bitrate_config.max_bitrate_bps = 3;
@@ -349,7 +349,7 @@
SetBitrateConfigWithSameMinMaxAndNegativeStartElidesSecondCall) {
CallBitrateHelper call;
- Call::Config::BitrateConfig bitrate_config;
+ BitrateConstraints bitrate_config;
bitrate_config.min_bitrate_bps = 1;
bitrate_config.start_bitrate_bps = 2;
bitrate_config.max_bitrate_bps = 3;
@@ -389,7 +389,7 @@
TEST(CallBitrateTest, BiggerMaskMinUsed) {
CallBitrateHelper call;
- Call::Config::BitrateConfigMask mask;
+ BitrateConstraintsMask mask;
mask.min_bitrate_bps = 1234;
EXPECT_CALL(call.mock_cc(),
@@ -399,12 +399,12 @@
TEST(CallBitrateTest, BiggerConfigMinUsed) {
CallBitrateHelper call;
- Call::Config::BitrateConfigMask mask;
+ BitrateConstraintsMask mask;
mask.min_bitrate_bps = 1000;
EXPECT_CALL(call.mock_cc(), SetBweBitrates(1000, testing::_, testing::_));
call->SetBitrateConfigMask(mask);
- Call::Config::BitrateConfig config;
+ BitrateConstraints config;
config.min_bitrate_bps = 1234;
EXPECT_CALL(call.mock_cc(), SetBweBitrates(1234, testing::_, testing::_));
@@ -414,14 +414,14 @@
// The last call to set start should be used.
TEST(CallBitrateTest, LatestStartMaskPreferred) {
CallBitrateHelper call;
- Call::Config::BitrateConfigMask mask;
+ BitrateConstraintsMask mask;
mask.start_bitrate_bps = 1300;
EXPECT_CALL(call.mock_cc(),
SetBweBitrates(testing::_, *mask.start_bitrate_bps, testing::_));
call->SetBitrateConfigMask(mask);
- Call::Config::BitrateConfig bitrate_config;
+ BitrateConstraints bitrate_config;
bitrate_config.start_bitrate_bps = 1200;
EXPECT_CALL(
@@ -431,11 +431,11 @@
}
TEST(CallBitrateTest, SmallerMaskMaxUsed) {
- Call::Config::BitrateConfig bitrate_config;
+ BitrateConstraints bitrate_config;
bitrate_config.max_bitrate_bps = bitrate_config.start_bitrate_bps + 2000;
CallBitrateHelper call(bitrate_config);
- Call::Config::BitrateConfigMask mask;
+ BitrateConstraintsMask mask;
mask.max_bitrate_bps = bitrate_config.start_bitrate_bps + 1000;
EXPECT_CALL(call.mock_cc(),
@@ -444,11 +444,11 @@
}
TEST(CallBitrateTest, SmallerConfigMaxUsed) {
- Call::Config::BitrateConfig bitrate_config;
+ BitrateConstraints bitrate_config;
bitrate_config.max_bitrate_bps = bitrate_config.start_bitrate_bps + 1000;
CallBitrateHelper call(bitrate_config);
- Call::Config::BitrateConfigMask mask;
+ BitrateConstraintsMask mask;
mask.max_bitrate_bps = bitrate_config.start_bitrate_bps + 2000;
// Expect no calls because nothing changes
@@ -459,11 +459,11 @@
}
TEST(CallBitrateTest, MaskStartLessThanConfigMinClamped) {
- Call::Config::BitrateConfig bitrate_config;
+ BitrateConstraints bitrate_config;
bitrate_config.min_bitrate_bps = 2000;
CallBitrateHelper call(bitrate_config);
- Call::Config::BitrateConfigMask mask;
+ BitrateConstraintsMask mask;
mask.start_bitrate_bps = 1000;
EXPECT_CALL(call.mock_cc(), SetBweBitrates(2000, 2000, testing::_));
@@ -471,11 +471,11 @@
}
TEST(CallBitrateTest, MaskStartGreaterThanConfigMaxClamped) {
- Call::Config::BitrateConfig bitrate_config;
+ BitrateConstraints bitrate_config;
bitrate_config.start_bitrate_bps = 2000;
CallBitrateHelper call(bitrate_config);
- Call::Config::BitrateConfigMask mask;
+ BitrateConstraintsMask mask;
mask.max_bitrate_bps = 1000;
EXPECT_CALL(call.mock_cc(), SetBweBitrates(testing::_, -1, 1000));
@@ -483,11 +483,11 @@
}
TEST(CallBitrateTest, MaskMinGreaterThanConfigMaxClamped) {
- Call::Config::BitrateConfig bitrate_config;
+ BitrateConstraints bitrate_config;
bitrate_config.min_bitrate_bps = 2000;
CallBitrateHelper call(bitrate_config);
- Call::Config::BitrateConfigMask mask;
+ BitrateConstraintsMask mask;
mask.max_bitrate_bps = 1000;
EXPECT_CALL(call.mock_cc(), SetBweBitrates(1000, testing::_, 1000));
@@ -497,7 +497,7 @@
TEST(CallBitrateTest, SettingMaskStartForcesUpdate) {
CallBitrateHelper call;
- Call::Config::BitrateConfigMask mask;
+ BitrateConstraintsMask mask;
mask.start_bitrate_bps = 1000;
// SetBweBitrates should be called twice with the same params since
@@ -511,12 +511,12 @@
TEST(CallBitrateTest, SetBitrateConfigWithNoChangesDoesNotCallSetBweBitrates) {
CallBitrateHelper call;
- Call::Config::BitrateConfig config1;
+ BitrateConstraints config1;
config1.min_bitrate_bps = 0;
config1.start_bitrate_bps = 1000;
config1.max_bitrate_bps = -1;
- Call::Config::BitrateConfig config2;
+ BitrateConstraints config2;
config2.min_bitrate_bps = 0;
config2.start_bitrate_bps = -1;
config2.max_bitrate_bps = -1;
@@ -534,7 +534,7 @@
TEST(CallBitrateTest, SetBweBitratesNotCalledWhenEffectiveMaxUnchanged) {
CallBitrateHelper call;
- Call::Config::BitrateConfig config;
+ BitrateConstraints config;
config.min_bitrate_bps = 0;
config.start_bitrate_bps = -1;
config.max_bitrate_bps = 2000;
@@ -542,7 +542,7 @@
call->SetBitrateConfig(config);
// Reduce effective max to 1000 with the mask.
- Call::Config::BitrateConfigMask mask;
+ BitrateConstraintsMask mask;
mask.max_bitrate_bps = 1000;
EXPECT_CALL(call.mock_cc(), SetBweBitrates(testing::_, testing::_, 1000));
call->SetBitrateConfigMask(mask);
@@ -558,7 +558,7 @@
TEST(CallBitrateTest, SetBweBitratesNotCalledWhenStartMaskRemoved) {
CallBitrateHelper call;
- Call::Config::BitrateConfigMask mask;
+ BitrateConstraintsMask mask;
mask.start_bitrate_bps = 1000;
EXPECT_CALL(call.mock_cc(), SetBweBitrates(0, 1000, -1));
call->SetBitrateConfigMask(mask);
@@ -573,12 +573,12 @@
TEST(CallBitrateTest, SetBitrateConfigAfterSetBitrateConfigMaskWithStart) {
CallBitrateHelper call;
- Call::Config::BitrateConfigMask mask;
+ BitrateConstraintsMask mask;
mask.start_bitrate_bps = 1000;
EXPECT_CALL(call.mock_cc(), SetBweBitrates(0, 1000, -1));
call->SetBitrateConfigMask(mask);
- Call::Config::BitrateConfig config;
+ BitrateConstraints config;
config.min_bitrate_bps = 0;
config.start_bitrate_bps = -1;
config.max_bitrate_bps = 5000;
@@ -589,13 +589,13 @@
}
TEST(CallBitrateTest, SetBweBitratesNotCalledWhenClampedMinUnchanged) {
- Call::Config::BitrateConfig bitrate_config;
+ BitrateConstraints bitrate_config;
bitrate_config.start_bitrate_bps = 500;
bitrate_config.max_bitrate_bps = 1000;
CallBitrateHelper call(bitrate_config);
// Set min to 2000; it is clamped to the max (1000).
- Call::Config::BitrateConfigMask mask;
+ BitrateConstraintsMask mask;
mask.min_bitrate_bps = 2000;
EXPECT_CALL(call.mock_cc(), SetBweBitrates(1000, -1, 1000));
call->SetBitrateConfigMask(mask);
