diff --git a/call/BUILD.gn b/call/BUILD.gn index a3d23164ef..993be206b8 100644 --- a/call/BUILD.gn +++ b/call/BUILD.gn @@ -42,8 +42,6 @@ rtc_source_set("call_interfaces") { # 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", @@ -53,7 +51,6 @@ rtc_source_set("rtp_interfaces") { ] deps = [ "../api:array_view", - "../api:optional", "../rtc_base:rtc_base_approved", ] } diff --git a/call/bitrate_constraints.cc b/call/bitrate_constraints.cc deleted file mode 100644 index 1e6264e2e9..0000000000 --- a/call/bitrate_constraints.cc +++ /dev/null @@ -1,18 +0,0 @@ -/* - * 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 deleted file mode 100644 index 5f6602457b..0000000000 --- a/call/bitrate_constraints.h +++ /dev/null @@ -1,53 +0,0 @@ -/* - * 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 - -#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 { - static constexpr int kDefaultStartBitrateBps = 300000; - int min_bitrate_bps = 0; - int start_bitrate_bps = kDefaultStartBitrateBps; - int max_bitrate_bps = -1; -}; - -// 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 min_bitrate_bps; - rtc::Optional start_bitrate_bps; - rtc::Optional max_bitrate_bps; -}; - -// Like std::min, but considers non-positive values to be unset. -template -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 750718a67d..3a72040a9a 100644 --- a/call/call.cc +++ b/call/call.cc @@ -213,10 +213,10 @@ class Call : public webrtc::Call, void OnRecoveredPacket(const uint8_t* packet, size_t length) override; void SetBitrateConfig( - const webrtc::BitrateConstraints& bitrate_config) override; + const webrtc::Call::Config::BitrateConfig& bitrate_config) override; void SetBitrateConfigMask( - const webrtc::BitrateConstraintsMask& bitrate_config) override; + const webrtc::Call::Config::BitrateConfigMask& bitrate_config) override; void SetBitrateAllocationStrategy( std::unique_ptr @@ -261,7 +261,7 @@ class Call : public webrtc::Call, void UpdateHistograms(); void UpdateAggregateNetworkState(); - // Applies update to the BitrateConstraints cached in |config_|, restarting + // Applies update to the BitrateConfig cached in |config_|, restarting // bandwidth estimation from |new_start| if set. void UpdateCurrentBitrateConfig(const rtc::Optional& new_start); @@ -374,11 +374,11 @@ class Call : public webrtc::Call, // The config mask set by SetBitrateConfigMask. // 0 <= min <= start <= max - BitrateConstraintsMask bitrate_config_mask_; + Config::BitrateConfigMask bitrate_config_mask_; // The config set by SetBitrateConfig. // min >= 0, start != 0, max == -1 || max > 0 - BitrateConstraints base_bitrate_config_; + Config::BitrateConfig base_bitrate_config_; RTC_DISALLOW_COPY_AND_ASSIGN(Call); }; @@ -954,7 +954,8 @@ Call::Stats Call::GetStats() const { return stats; } -void Call::SetBitrateConfig(const BitrateConstraints& bitrate_config) { +void Call::SetBitrateConfig( + const webrtc::Call::Config::BitrateConfig& bitrate_config) { TRACE_EVENT0("webrtc", "Call::SetBitrateConfig"); RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_); RTC_DCHECK_GE(bitrate_config.min_bitrate_bps, 0); @@ -977,7 +978,8 @@ void Call::SetBitrateConfig(const BitrateConstraints& bitrate_config) { UpdateCurrentBitrateConfig(new_start); } -void Call::SetBitrateConfigMask(const BitrateConstraintsMask& mask) { +void Call::SetBitrateConfigMask( + const webrtc::Call::Config::BitrateConfigMask& mask) { TRACE_EVENT0("webrtc", "Call::SetBitrateConfigMask"); RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_); @@ -986,7 +988,7 @@ void Call::SetBitrateConfigMask(const BitrateConstraintsMask& mask) { } void Call::UpdateCurrentBitrateConfig(const rtc::Optional& new_start) { - BitrateConstraints updated; + Config::BitrateConfig 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 5474bccfac..1155aaf4b2 100644 --- a/call/call.h +++ b/call/call.h @@ -20,7 +20,6 @@ #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" @@ -44,6 +43,19 @@ enum class MediaType { DATA }; +// Like std::min, but considers non-positive values to be unset. +// TODO(zstein): Remove once all callers use rtc::Optional. +template +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 { @@ -65,9 +77,26 @@ struct CallConfig { RTC_DCHECK(event_log); } + 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. - BitrateConstraints bitrate_config; + 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 min_bitrate_bps; + rtc::Optional start_bitrate_bps; + rtc::Optional max_bitrate_bps; + }; // AudioState which is possibly shared between multiple calls. // TODO(solenberg): Change this to a shared_ptr once we can use C++11. @@ -155,14 +184,15 @@ class Call { // 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 BitrateConstraints& bitrate_config) = 0; + virtual void SetBitrateConfig( + const Config::BitrateConfig& 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 BitrateConstraintsMask& bitrate_mask) = 0; + const Config::BitrateConfigMask& bitrate_mask) = 0; virtual void SetBitrateAllocationStrategy( std::unique_ptr diff --git a/call/call_perf_tests.cc b/call/call_perf_tests.cc index e8c3601a66..ddeaf127c9 100644 --- a/call/call_perf_tests.cc +++ b/call/call_perf_tests.cc @@ -888,7 +888,7 @@ void CallPerfTest::TestMinAudioVideoBitrate( void OnCallsCreated(Call* sender_call, Call* receiver_call) override { sender_call_ = sender_call; - BitrateConstraints bitrate_config; + Call::Config::BitrateConfig 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 cf44f1480e..dc36ce2072 100644 --- a/call/call_unittest.cc +++ b/call/call_unittest.cc @@ -254,9 +254,9 @@ TEST(CallTest, MultipleFlexfecReceiveStreamsProtectingSingleVideoStream) { namespace { struct CallBitrateHelper { - CallBitrateHelper() : CallBitrateHelper(BitrateConstraints()) {} + CallBitrateHelper() : CallBitrateHelper(Call::Config::BitrateConfig()) {} - explicit CallBitrateHelper(const BitrateConstraints& bitrate_config) + explicit CallBitrateHelper(const Call::Config::BitrateConfig& bitrate_config) : mock_cc_(Clock::GetRealTimeClock(), &event_log_, &pacer_) { Call::Config config(&event_log_); config.bitrate_config = bitrate_config; @@ -282,7 +282,7 @@ struct CallBitrateHelper { TEST(CallBitrateTest, SetBitrateConfigWithValidConfigCallsSetBweBitrates) { CallBitrateHelper call; - BitrateConstraints bitrate_config; + Call::Config::BitrateConfig 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, SetBitrateConfigWithValidConfigCallsSetBweBitrates) { TEST(CallBitrateTest, SetBitrateConfigWithDifferentMinCallsSetBweBitrates) { CallBitrateHelper call; - BitrateConstraints bitrate_config; + Call::Config::BitrateConfig 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, SetBitrateConfigWithDifferentMinCallsSetBweBitrates) { TEST(CallBitrateTest, SetBitrateConfigWithDifferentStartCallsSetBweBitrates) { CallBitrateHelper call; - BitrateConstraints bitrate_config; + Call::Config::BitrateConfig 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, SetBitrateConfigWithDifferentStartCallsSetBweBitrates) { TEST(CallBitrateTest, SetBitrateConfigWithDifferentMaxCallsSetBweBitrates) { CallBitrateHelper call; - BitrateConstraints bitrate_config; + Call::Config::BitrateConfig 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, SetBitrateConfigWithDifferentMaxCallsSetBweBitrates) { TEST(CallBitrateTest, SetBitrateConfigWithSameConfigElidesSecondCall) { CallBitrateHelper call; - BitrateConstraints bitrate_config; + Call::Config::BitrateConfig bitrate_config; bitrate_config.min_bitrate_bps = 1; bitrate_config.start_bitrate_bps = 2; bitrate_config.max_bitrate_bps = 3; @@ -349,7 +349,7 @@ TEST(CallBitrateTest, SetBitrateConfigWithSameMinMaxAndNegativeStartElidesSecondCall) { CallBitrateHelper call; - BitrateConstraints bitrate_config; + Call::Config::BitrateConfig 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(CallTest, RecreatingAudioStreamWithSameSsrcReusesRtpState) { TEST(CallBitrateTest, BiggerMaskMinUsed) { CallBitrateHelper call; - BitrateConstraintsMask mask; + Call::Config::BitrateConfigMask mask; mask.min_bitrate_bps = 1234; EXPECT_CALL(call.mock_cc(), @@ -399,12 +399,12 @@ TEST(CallBitrateTest, BiggerMaskMinUsed) { TEST(CallBitrateTest, BiggerConfigMinUsed) { CallBitrateHelper call; - BitrateConstraintsMask mask; + Call::Config::BitrateConfigMask mask; mask.min_bitrate_bps = 1000; EXPECT_CALL(call.mock_cc(), SetBweBitrates(1000, testing::_, testing::_)); call->SetBitrateConfigMask(mask); - BitrateConstraints config; + Call::Config::BitrateConfig config; config.min_bitrate_bps = 1234; EXPECT_CALL(call.mock_cc(), SetBweBitrates(1234, testing::_, testing::_)); @@ -414,14 +414,14 @@ TEST(CallBitrateTest, BiggerConfigMinUsed) { // The last call to set start should be used. TEST(CallBitrateTest, LatestStartMaskPreferred) { CallBitrateHelper call; - BitrateConstraintsMask mask; + Call::Config::BitrateConfigMask mask; mask.start_bitrate_bps = 1300; EXPECT_CALL(call.mock_cc(), SetBweBitrates(testing::_, *mask.start_bitrate_bps, testing::_)); call->SetBitrateConfigMask(mask); - BitrateConstraints bitrate_config; + Call::Config::BitrateConfig bitrate_config; bitrate_config.start_bitrate_bps = 1200; EXPECT_CALL( @@ -431,11 +431,11 @@ TEST(CallBitrateTest, LatestStartMaskPreferred) { } TEST(CallBitrateTest, SmallerMaskMaxUsed) { - BitrateConstraints bitrate_config; + Call::Config::BitrateConfig bitrate_config; bitrate_config.max_bitrate_bps = bitrate_config.start_bitrate_bps + 2000; CallBitrateHelper call(bitrate_config); - BitrateConstraintsMask mask; + Call::Config::BitrateConfigMask mask; mask.max_bitrate_bps = bitrate_config.start_bitrate_bps + 1000; EXPECT_CALL(call.mock_cc(), @@ -444,11 +444,11 @@ TEST(CallBitrateTest, SmallerMaskMaxUsed) { } TEST(CallBitrateTest, SmallerConfigMaxUsed) { - BitrateConstraints bitrate_config; + Call::Config::BitrateConfig bitrate_config; bitrate_config.max_bitrate_bps = bitrate_config.start_bitrate_bps + 1000; CallBitrateHelper call(bitrate_config); - BitrateConstraintsMask mask; + Call::Config::BitrateConfigMask mask; mask.max_bitrate_bps = bitrate_config.start_bitrate_bps + 2000; // Expect no calls because nothing changes @@ -459,11 +459,11 @@ TEST(CallBitrateTest, SmallerConfigMaxUsed) { } TEST(CallBitrateTest, MaskStartLessThanConfigMinClamped) { - BitrateConstraints bitrate_config; + Call::Config::BitrateConfig bitrate_config; bitrate_config.min_bitrate_bps = 2000; CallBitrateHelper call(bitrate_config); - BitrateConstraintsMask mask; + Call::Config::BitrateConfigMask mask; mask.start_bitrate_bps = 1000; EXPECT_CALL(call.mock_cc(), SetBweBitrates(2000, 2000, testing::_)); @@ -471,11 +471,11 @@ TEST(CallBitrateTest, MaskStartLessThanConfigMinClamped) { } TEST(CallBitrateTest, MaskStartGreaterThanConfigMaxClamped) { - BitrateConstraints bitrate_config; + Call::Config::BitrateConfig bitrate_config; bitrate_config.start_bitrate_bps = 2000; CallBitrateHelper call(bitrate_config); - BitrateConstraintsMask mask; + Call::Config::BitrateConfigMask mask; mask.max_bitrate_bps = 1000; EXPECT_CALL(call.mock_cc(), SetBweBitrates(testing::_, -1, 1000)); @@ -483,11 +483,11 @@ TEST(CallBitrateTest, MaskStartGreaterThanConfigMaxClamped) { } TEST(CallBitrateTest, MaskMinGreaterThanConfigMaxClamped) { - BitrateConstraints bitrate_config; + Call::Config::BitrateConfig bitrate_config; bitrate_config.min_bitrate_bps = 2000; CallBitrateHelper call(bitrate_config); - BitrateConstraintsMask mask; + Call::Config::BitrateConfigMask mask; mask.max_bitrate_bps = 1000; EXPECT_CALL(call.mock_cc(), SetBweBitrates(1000, testing::_, 1000)); @@ -497,7 +497,7 @@ TEST(CallBitrateTest, MaskMinGreaterThanConfigMaxClamped) { TEST(CallBitrateTest, SettingMaskStartForcesUpdate) { CallBitrateHelper call; - BitrateConstraintsMask mask; + Call::Config::BitrateConfigMask mask; mask.start_bitrate_bps = 1000; // SetBweBitrates should be called twice with the same params since @@ -511,12 +511,12 @@ TEST(CallBitrateTest, SettingMaskStartForcesUpdate) { TEST(CallBitrateTest, SetBitrateConfigWithNoChangesDoesNotCallSetBweBitrates) { CallBitrateHelper call; - BitrateConstraints config1; + Call::Config::BitrateConfig config1; config1.min_bitrate_bps = 0; config1.start_bitrate_bps = 1000; config1.max_bitrate_bps = -1; - BitrateConstraints config2; + Call::Config::BitrateConfig config2; config2.min_bitrate_bps = 0; config2.start_bitrate_bps = -1; config2.max_bitrate_bps = -1; @@ -534,7 +534,7 @@ TEST(CallBitrateTest, SetBitrateConfigWithNoChangesDoesNotCallSetBweBitrates) { TEST(CallBitrateTest, SetBweBitratesNotCalledWhenEffectiveMaxUnchanged) { CallBitrateHelper call; - BitrateConstraints config; + Call::Config::BitrateConfig config; config.min_bitrate_bps = 0; config.start_bitrate_bps = -1; config.max_bitrate_bps = 2000; @@ -542,7 +542,7 @@ TEST(CallBitrateTest, SetBweBitratesNotCalledWhenEffectiveMaxUnchanged) { call->SetBitrateConfig(config); // Reduce effective max to 1000 with the mask. - BitrateConstraintsMask mask; + Call::Config::BitrateConfigMask mask; mask.max_bitrate_bps = 1000; EXPECT_CALL(call.mock_cc(), SetBweBitrates(testing::_, testing::_, 1000)); call->SetBitrateConfigMask(mask); @@ -558,7 +558,7 @@ TEST(CallBitrateTest, SetBweBitratesNotCalledWhenEffectiveMaxUnchanged) { TEST(CallBitrateTest, SetBweBitratesNotCalledWhenStartMaskRemoved) { CallBitrateHelper call; - BitrateConstraintsMask mask; + Call::Config::BitrateConfigMask mask; mask.start_bitrate_bps = 1000; EXPECT_CALL(call.mock_cc(), SetBweBitrates(0, 1000, -1)); call->SetBitrateConfigMask(mask); @@ -573,12 +573,12 @@ TEST(CallBitrateTest, SetBweBitratesNotCalledWhenStartMaskRemoved) { TEST(CallBitrateTest, SetBitrateConfigAfterSetBitrateConfigMaskWithStart) { CallBitrateHelper call; - BitrateConstraintsMask mask; + Call::Config::BitrateConfigMask mask; mask.start_bitrate_bps = 1000; EXPECT_CALL(call.mock_cc(), SetBweBitrates(0, 1000, -1)); call->SetBitrateConfigMask(mask); - BitrateConstraints config; + Call::Config::BitrateConfig config; config.min_bitrate_bps = 0; config.start_bitrate_bps = -1; config.max_bitrate_bps = 5000; @@ -589,13 +589,13 @@ TEST(CallBitrateTest, SetBitrateConfigAfterSetBitrateConfigMaskWithStart) { } TEST(CallBitrateTest, SetBweBitratesNotCalledWhenClampedMinUnchanged) { - BitrateConstraints bitrate_config; + Call::Config::BitrateConfig 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). - BitrateConstraintsMask mask; + Call::Config::BitrateConfigMask mask; mask.min_bitrate_bps = 2000; EXPECT_CALL(call.mock_cc(), SetBweBitrates(1000, -1, 1000)); call->SetBitrateConfigMask(mask); diff --git a/media/engine/fakewebrtccall.cc b/media/engine/fakewebrtccall.cc index c742a677d4..d7826509ff 100644 --- a/media/engine/fakewebrtccall.cc +++ b/media/engine/fakewebrtccall.cc @@ -618,12 +618,12 @@ webrtc::Call::Stats FakeCall::GetStats() const { } void FakeCall::SetBitrateConfig( - const webrtc::BitrateConstraints& bitrate_config) { + const webrtc::Call::Config::BitrateConfig& bitrate_config) { config_.bitrate_config = bitrate_config; } void FakeCall::SetBitrateConfigMask( - const webrtc::BitrateConstraintsMask& mask) { + const webrtc::Call::Config::BitrateConfigMask& mask) { // TODO(zstein): not implemented } diff --git a/media/engine/fakewebrtccall.h b/media/engine/fakewebrtccall.h index dca061938e..9eb238a6fa 100644 --- a/media/engine/fakewebrtccall.h +++ b/media/engine/fakewebrtccall.h @@ -302,9 +302,9 @@ class FakeCall final : public webrtc::Call, public webrtc::PacketReceiver { webrtc::Call::Stats GetStats() const override; void SetBitrateConfig( - const webrtc::BitrateConstraints& bitrate_config) override; + const webrtc::Call::Config::BitrateConfig& bitrate_config) override; void SetBitrateConfigMask( - const webrtc::BitrateConstraintsMask& mask) override; + const webrtc::Call::Config::BitrateConfigMask& mask) override; void SetBitrateAllocationStrategy( std::unique_ptr bitrate_allocation_strategy) override; diff --git a/media/engine/webrtcmediaengine.cc b/media/engine/webrtcmediaengine.cc index 7b01c3ffb3..338c0d9ed9 100644 --- a/media/engine/webrtcmediaengine.cc +++ b/media/engine/webrtcmediaengine.cc @@ -202,8 +202,9 @@ std::vector FilterRtpExtensions( return result; } -webrtc::BitrateConstraints GetBitrateConfigForCodec(const Codec& codec) { - webrtc::BitrateConstraints config; +webrtc::Call::Config::BitrateConfig GetBitrateConfigForCodec( + const Codec& codec) { + webrtc::Call::Config::BitrateConfig config; int bitrate_kbps = 0; if (codec.GetParam(kCodecParamMinBitrate, &bitrate_kbps) && bitrate_kbps > 0) { diff --git a/media/engine/webrtcmediaengine.h b/media/engine/webrtcmediaengine.h index 55f29b71bd..632e730478 100644 --- a/media/engine/webrtcmediaengine.h +++ b/media/engine/webrtcmediaengine.h @@ -85,7 +85,8 @@ std::vector FilterRtpExtensions( bool (*supported)(const std::string&), bool filter_redundant_extensions); -webrtc::BitrateConstraints GetBitrateConfigForCodec(const Codec& codec); +webrtc::Call::Config::BitrateConfig GetBitrateConfigForCodec( + const Codec& codec); } // namespace cricket diff --git a/media/engine/webrtcvideoengine.cc b/media/engine/webrtcvideoengine.cc index 9c555c60b4..8aa5aa222a 100644 --- a/media/engine/webrtcvideoengine.cc +++ b/media/engine/webrtcvideoengine.cc @@ -771,7 +771,7 @@ bool WebRtcVideoChannel::SetSendParameters(const VideoSendParameters& params) { // codec target bitrate. // TODO(pbos): Figure out whether b=AS means max bitrate for this // WebRtcVideoChannel (in which case we're good), or per sender (SSRC), - // in which case this should not set a BitrateConstraints but rather + // in which case this should not set a Call::BitrateConfig but rather // reconfigure all senders. bitrate_config_.max_bitrate_bps = params.max_bandwidth_bps == 0 ? -1 : params.max_bandwidth_bps; diff --git a/media/engine/webrtcvideoengine.h b/media/engine/webrtcvideoengine.h index f481b8bd5f..f1264932a1 100644 --- a/media/engine/webrtcvideoengine.h +++ b/media/engine/webrtcvideoengine.h @@ -501,7 +501,7 @@ class WebRtcVideoChannel : public VideoMediaChannel, public webrtc::Transport { // See reason for keeping track of the FlexFEC payload type separately in // comment in WebRtcVideoChannel::ChangedRecvParameters. int recv_flexfec_payload_type_; - webrtc::BitrateConstraints bitrate_config_; + webrtc::Call::Config::BitrateConfig bitrate_config_; // TODO(deadbeef): Don't duplicate information between // send_params/recv_params, rtp_extensions, options, etc. VideoSendParameters send_params_; diff --git a/media/engine/webrtcvoiceengine.cc b/media/engine/webrtcvoiceengine.cc index 0b09ed1294..d96bb1d019 100644 --- a/media/engine/webrtcvoiceengine.cc +++ b/media/engine/webrtcvoiceengine.cc @@ -1591,7 +1591,7 @@ bool WebRtcVoiceMediaChannel::SetSendCodecs( // Scan through the list to figure out the codec to use for sending. rtc::Optional send_codec_spec; - webrtc::BitrateConstraints bitrate_config; + webrtc::Call::Config::BitrateConfig bitrate_config; rtc::Optional voice_codec_info; for (const AudioCodec& voice_codec : codecs) { if (!(IsCodec(voice_codec, kCnCodecName) || diff --git a/pc/peerconnection.cc b/pc/peerconnection.cc index 90c664f599..73f79c8a11 100644 --- a/pc/peerconnection.cc +++ b/pc/peerconnection.cc @@ -2861,7 +2861,7 @@ RTCError PeerConnection::SetBitrate(const BitrateParameters& bitrate) { } } - BitrateConstraintsMask mask; + Call::Config::BitrateConfigMask mask; mask.min_bitrate_bps = bitrate.min_bitrate_bps; mask.start_bitrate_bps = bitrate.current_bitrate_bps; mask.max_bitrate_bps = bitrate.max_bitrate_bps; diff --git a/pc/peerconnectioninterface_unittest.cc b/pc/peerconnectioninterface_unittest.cc index 18903d4412..fa37348c91 100644 --- a/pc/peerconnectioninterface_unittest.cc +++ b/pc/peerconnectioninterface_unittest.cc @@ -3724,10 +3724,10 @@ TEST_P(PeerConnectionInterfaceTest, CreatePeerConnection(config, nullptr); } -// The current bitrate from Call's BitrateConstraintsMask is currently clamped -// by Call's BitrateConstraints, which comes from the SDP or a default value. -// This test checks that a call to SetBitrate with a current bitrate that will -// be clamped succeeds. +// The current bitrate from Call's BitrateConfigMask is currently clamped by +// Call's BitrateConfig, which comes from the SDP or a default value. This test +// checks that a call to SetBitrate with a current bitrate that will be clamped +// succeeds. TEST_P(PeerConnectionInterfaceTest, SetBitrateCurrentLessThanImplicitMin) { CreatePeerConnection(); PeerConnectionInterface::BitrateParameters bitrate; diff --git a/video/end_to_end_tests/probing_tests.cc b/video/end_to_end_tests/probing_tests.cc index 209ffc94bc..58a5b82774 100644 --- a/video/end_to_end_tests/probing_tests.cc +++ b/video/end_to_end_tests/probing_tests.cc @@ -137,7 +137,7 @@ TEST_P(ProbingEndToEndTest, TriggerMidCallProbing) { switch (state_) { case 0: if (stats.send_bandwidth_bps > 5 * 300000) { - BitrateConstraints bitrate_config; + Call::Config::BitrateConfig bitrate_config; bitrate_config.max_bitrate_bps = 100000; task_queue_->SendTask([this, &bitrate_config]() { sender_call_->SetBitrateConfig(bitrate_config); @@ -147,7 +147,7 @@ TEST_P(ProbingEndToEndTest, TriggerMidCallProbing) { break; case 1: if (stats.send_bandwidth_bps < 110000) { - BitrateConstraints bitrate_config; + Call::Config::BitrateConfig bitrate_config; bitrate_config.max_bitrate_bps = 2500000; task_queue_->SendTask([this, &bitrate_config]() { sender_call_->SetBitrateConfig(bitrate_config); diff --git a/video/screenshare_loopback.cc b/video/screenshare_loopback.cc index 8c0ef8af82..315753799d 100644 --- a/video/screenshare_loopback.cc +++ b/video/screenshare_loopback.cc @@ -43,7 +43,7 @@ int MinBitrateKbps() { } DEFINE_int(start_bitrate, - BitrateConstraints::kDefaultStartBitrateBps / 1000, + Call::Config::kDefaultStartBitrateBps / 1000, "Call start bitrate in kbps."); int StartBitrateKbps() { return static_cast(FLAG_start_bitrate); @@ -267,7 +267,7 @@ void Loopback() { pipe_config.delay_standard_deviation_ms = flags::StdPropagationDelayMs(); pipe_config.allow_reordering = flags::FLAG_allow_reordering; - BitrateConstraints call_bitrate_config; + Call::Config::BitrateConfig call_bitrate_config; call_bitrate_config.min_bitrate_bps = flags::MinBitrateKbps() * 1000; call_bitrate_config.start_bitrate_bps = flags::StartBitrateKbps() * 1000; call_bitrate_config.max_bitrate_bps = flags::MaxBitrateKbps() * 1000; diff --git a/video/sv_loopback.cc b/video/sv_loopback.cc index 509c6c16a9..c8e0d740d7 100644 --- a/video/sv_loopback.cc +++ b/video/sv_loopback.cc @@ -454,7 +454,7 @@ void Loopback() { pipe_config.delay_standard_deviation_ms = flags::StdPropagationDelayMs(); pipe_config.allow_reordering = flags::FLAG_allow_reordering; - BitrateConstraints call_bitrate_config; + Call::Config::BitrateConfig call_bitrate_config; call_bitrate_config.min_bitrate_bps = (flags::ScreenshareMinBitrateKbps() + flags::VideoMinBitrateKbps()) * 1000; diff --git a/video/video_loopback.cc b/video/video_loopback.cc index 2401691503..d195ceb38f 100644 --- a/video/video_loopback.cc +++ b/video/video_loopback.cc @@ -264,7 +264,7 @@ void Loopback() { pipe_config.delay_standard_deviation_ms = flags::StdPropagationDelayMs(); pipe_config.allow_reordering = flags::FLAG_allow_reordering; - BitrateConstraints call_bitrate_config; + Call::Config::BitrateConfig call_bitrate_config; call_bitrate_config.min_bitrate_bps = flags::MinBitrateKbps() * 1000; call_bitrate_config.start_bitrate_bps = flags::StartBitrateKbps() * 1000; call_bitrate_config.max_bitrate_bps = flags::MaxBitrateKbps() * 1000; diff --git a/video/video_quality_test.cc b/video/video_quality_test.cc index 70221b05c5..ed3531dafc 100644 --- a/video/video_quality_test.cc +++ b/video/video_quality_test.cc @@ -1093,7 +1093,7 @@ VideoQualityTest::VideoQualityTest( } VideoQualityTest::Params::Params() - : call({false, BitrateConstraints(), 0}), + : call({false, Call::Config::BitrateConfig(), 0}), video{{false, 640, 480, 30, 50, 800, 800, false, "VP8", 1, -1, 0, false, false, ""}, {false, 640, 480, 30, 50, 800, 800, false, "VP8", 1, -1, 0, false, diff --git a/video/video_quality_test.h b/video/video_quality_test.h index 66a9fdbaf4..da79894163 100644 --- a/video/video_quality_test.h +++ b/video/video_quality_test.h @@ -33,7 +33,7 @@ class VideoQualityTest : public test::CallTest { ~Params(); struct CallConfig { bool send_side_bwe; - BitrateConstraints call_bitrate_config; + Call::Config::BitrateConfig call_bitrate_config; int num_thumbnails; // Indicates if secondary_(video|ss|screenshare) structures are used. bool dual_video; diff --git a/video/video_send_stream_tests.cc b/video/video_send_stream_tests.cc index 193505f676..7a64ac1ced 100644 --- a/video/video_send_stream_tests.cc +++ b/video/video_send_stream_tests.cc @@ -1590,7 +1590,7 @@ TEST_F(VideoSendStreamTest, ChangingNetworkRoute) { void PerformTest() override { rtc::NetworkRoute new_route(true, 10, 20, -1); - BitrateConstraints bitrate_config; + Call::Config::BitrateConfig bitrate_config; task_queue_->SendTask([this, &new_route, &bitrate_config]() { call_->OnNetworkRouteChanged("transport", new_route); @@ -1955,7 +1955,7 @@ TEST_F(VideoSendStreamTest, CanReconfigureToUseStartBitrateAbovePreviousMax) { test::NullTransport transport; CreateSendConfig(1, 0, 0, &transport); - BitrateConstraints bitrate_config; + Call::Config::BitrateConfig bitrate_config; bitrate_config.start_bitrate_bps = 2 * video_encoder_config_.max_bitrate_bps; sender_call_->SetBitrateConfig(bitrate_config); @@ -2864,7 +2864,7 @@ TEST_F(VideoSendStreamTest, ReconfigureBitratesSetsEncoderBitratesCorrectly) { init_encode_event_.Wait(VideoSendStreamTest::kDefaultTimeoutMs)) << "Timed out while waiting for encoder to be configured."; WaitForSetRates(kStartBitrateKbps); - BitrateConstraints bitrate_config; + Call::Config::BitrateConfig bitrate_config; bitrate_config.start_bitrate_bps = kIncreasedStartBitrateKbps * 1000; bitrate_config.max_bitrate_bps = kIncreasedMaxBitrateKbps * 1000; task_queue_->SendTask([this, &bitrate_config]() { @@ -3560,7 +3560,7 @@ TEST_F(VideoSendStreamTest, RemoveOverheadFromBandwidth) { } void PerformTest() override { - BitrateConstraints bitrate_config; + Call::Config::BitrateConfig bitrate_config; constexpr int kStartBitrateBps = 60000; constexpr int kMaxBitrateBps = 60000; constexpr int kMinBitrateBps = 10000;