Removes SendSideCongestionController.
Bug: webrtc:9586
Change-Id: Id6f3508eb19f277d74c34edfbcaeb8a22320b030
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/140286
Commit-Queue: Sebastian Jansson <srte@webrtc.org>
Reviewed-by: Björn Terelius <terelius@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#28222}
diff --git a/call/BUILD.gn b/call/BUILD.gn
index 9ee0520..df10933 100644
--- a/call/BUILD.gn
+++ b/call/BUILD.gn
@@ -189,7 +189,6 @@
"../api:bitrate_allocation",
"../api/units:data_rate",
"../api/units:time_delta",
- "../modules/bitrate_controller",
"../rtc_base:checks",
"../rtc_base:rtc_base_approved",
"../rtc_base/synchronization:sequence_checker",
@@ -239,7 +238,6 @@
"../logging:rtc_event_video",
"../logging:rtc_stream_config",
"../modules:module_api",
- "../modules/bitrate_controller",
"../modules/congestion_controller",
"../modules/pacing",
"../modules/rtp_rtcp",
@@ -384,7 +382,6 @@
"../modules/audio_mixer",
"../modules/audio_mixer:audio_mixer_impl",
"../modules/audio_processing:mocks",
- "../modules/bitrate_controller",
"../modules/congestion_controller",
"../modules/pacing",
"../modules/pacing:mock_paced_sender",
@@ -474,7 +471,6 @@
deps = [
":rtp_interfaces",
"../api:libjingle_peerconnection_api",
- "../modules/congestion_controller",
"../modules/pacing",
"../rtc_base",
"../rtc_base:rate_limiter",
diff --git a/call/bitrate_allocator.cc b/call/bitrate_allocator.cc
index 7d5b52d..97a2bb6 100644
--- a/call/bitrate_allocator.cc
+++ b/call/bitrate_allocator.cc
@@ -18,7 +18,6 @@
#include "api/units/data_rate.h"
#include "api/units/time_delta.h"
-#include "modules/bitrate_controller/include/bitrate_controller.h"
#include "rtc_base/checks.h"
#include "rtc_base/logging.h"
#include "system_wrappers/include/clock.h"
diff --git a/call/bitrate_allocator_unittest.cc b/call/bitrate_allocator_unittest.cc
index 56344ac..e73a449 100644
--- a/call/bitrate_allocator_unittest.cc
+++ b/call/bitrate_allocator_unittest.cc
@@ -13,7 +13,7 @@
#include <vector>
#include "call/bitrate_allocator.h"
-#include "modules/bitrate_controller/include/bitrate_controller.h"
+#include "system_wrappers/include/clock.h"
#include "test/gmock.h"
#include "test/gtest.h"
diff --git a/call/call.cc b/call/call.cc
index af8e5d7..e50ac97 100644
--- a/call/call.cc
+++ b/call/call.cc
@@ -36,7 +36,6 @@
#include "logging/rtc_event_log/events/rtc_event_video_send_stream_config.h"
#include "logging/rtc_event_log/rtc_event_log.h"
#include "logging/rtc_event_log/rtc_stream_config.h"
-#include "modules/bitrate_controller/include/bitrate_controller.h"
#include "modules/congestion_controller/include/receive_side_congestion_controller.h"
#include "modules/rtp_rtcp/include/flexfec_receiver.h"
#include "modules/rtp_rtcp/include/rtp_header_extension_map.h"
diff --git a/call/rtp_transport_controller_send_interface.h b/call/rtp_transport_controller_send_interface.h
index 611edad..597e934 100644
--- a/call/rtp_transport_controller_send_interface.h
+++ b/call/rtp_transport_controller_send_interface.h
@@ -123,8 +123,7 @@
// settings.
// |min_send_bitrate_bps| is the total minimum send bitrate required by all
// sending streams. This is the minimum bitrate the PacedSender will use.
- // Note that SendSideCongestionController::OnNetworkChanged can still be
- // called with a lower bitrate estimate. |max_padding_bitrate_bps| is the max
+ // |max_padding_bitrate_bps| is the max
// bitrate the send streams request for padding. This can be higher than the
// current network estimate and tells the PacedSender how much it should max
// pad unless there is real packets to send.
diff --git a/call/test/mock_rtp_transport_controller_send.h b/call/test/mock_rtp_transport_controller_send.h
index 625ba64..38fbb93 100644
--- a/call/test/mock_rtp_transport_controller_send.h
+++ b/call/test/mock_rtp_transport_controller_send.h
@@ -20,7 +20,6 @@
#include "api/crypto/crypto_options.h"
#include "api/crypto/frame_encryptor_interface.h"
#include "call/rtp_transport_controller_send_interface.h"
-#include "modules/congestion_controller/include/network_changed_observer.h"
#include "modules/pacing/packet_router.h"
#include "rtc_base/network/sent_packet.h"
#include "rtc_base/network_route.h"
diff --git a/modules/congestion_controller/BUILD.gn b/modules/congestion_controller/BUILD.gn
index ac720ff..bb13093 100644
--- a/modules/congestion_controller/BUILD.gn
+++ b/modules/congestion_controller/BUILD.gn
@@ -20,40 +20,16 @@
visibility = [ "*" ]
configs += [ ":bwe_test_logging" ]
sources = [
- "include/network_changed_observer.h",
"include/receive_side_congestion_controller.h",
- "include/send_side_congestion_controller.h",
- "include/send_side_congestion_controller_interface.h",
"receive_side_congestion_controller.cc",
- "send_side_congestion_controller.cc",
]
deps = [
- ":transport_feedback",
"..:module_api",
- "../../api:scoped_refptr",
"../../api/transport:field_trial_based_config",
- "../../api/transport:network_control",
- "../../api/transport:webrtc_key_value_config",
- "../../api/units:data_rate",
- "../../api/units:timestamp",
- "../../rtc_base:checks",
- "../../rtc_base:deprecation",
- "../../rtc_base:rate_limiter",
- "../../rtc_base/experiments:rate_control_settings",
- "../../rtc_base/network:sent_packet",
- "../../system_wrappers",
- "../../system_wrappers:field_trial",
- "../bitrate_controller",
"../pacing",
"../remote_bitrate_estimator",
"../rtp_rtcp:rtp_rtcp_format",
- "goog_cc:delay_based_bwe",
- "goog_cc:estimators",
- "goog_cc:probe_controller",
- "goog_cc:pushback_controller",
- "//third_party/abseil-cpp/absl/memory",
- "//third_party/abseil-cpp/absl/types:optional",
]
if (!build_with_mozilla) {
@@ -61,52 +37,19 @@
}
}
-rtc_static_library("transport_feedback") {
- visibility = [ "*" ]
- sources = [
- "transport_feedback_adapter.cc",
- "transport_feedback_adapter.h",
- ]
-
- deps = [
- "../../api/transport:network_control",
- "../../api/units:data_size",
- "../../modules:module_api",
- "../../rtc_base:checks",
- "../../rtc_base:rtc_base_approved",
- "../../system_wrappers",
- "../rtp_rtcp:rtp_rtcp_format",
- "rtp:transport_feedback",
- ]
-}
-
if (rtc_include_tests) {
rtc_source_set("congestion_controller_unittests") {
testonly = true
sources = [
"receive_side_congestion_controller_unittest.cc",
- "send_side_congestion_controller_unittest.cc",
- "transport_feedback_adapter_unittest.cc",
]
deps = [
":congestion_controller",
- ":mock_congestion_controller",
- ":transport_feedback",
- "../../logging:mocks",
- "../../rtc_base",
- "../../rtc_base:checks",
- "../../rtc_base:rtc_base_approved",
- "../../rtc_base/network:sent_packet",
"../../system_wrappers",
- "../../test:field_trial",
"../../test:test_support",
"../../test/scenario",
- "../bitrate_controller",
"../pacing",
- "../pacing:mock_paced_sender",
- "../remote_bitrate_estimator",
- "../rtp_rtcp:rtp_rtcp_format",
"bbr:bbr_unittests",
"goog_cc:estimators",
"goog_cc:goog_cc_unittests",
@@ -114,15 +57,4 @@
"rtp:congestion_controller_unittests",
]
}
-
- rtc_source_set("mock_congestion_controller") {
- testonly = true
- sources = [
- "include/mock/mock_congestion_observer.h",
- ]
- deps = [
- ":congestion_controller",
- "../../test:test_support",
- ]
- }
}
diff --git a/modules/congestion_controller/include/mock/mock_congestion_observer.h b/modules/congestion_controller/include/mock/mock_congestion_observer.h
deleted file mode 100644
index d9c24a2..0000000
--- a/modules/congestion_controller/include/mock/mock_congestion_observer.h
+++ /dev/null
@@ -1,31 +0,0 @@
-/*
- * Copyright (c) 2015 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 MODULES_CONGESTION_CONTROLLER_INCLUDE_MOCK_MOCK_CONGESTION_OBSERVER_H_
-#define MODULES_CONGESTION_CONTROLLER_INCLUDE_MOCK_MOCK_CONGESTION_OBSERVER_H_
-
-#include "modules/congestion_controller/include/network_changed_observer.h"
-#include "test/gmock.h"
-
-namespace webrtc {
-namespace test {
-
-class MockCongestionObserver : public NetworkChangedObserver {
- public:
- MOCK_METHOD4(OnNetworkChanged,
- void(uint32_t bitrate_bps,
- uint8_t fraction_loss,
- int64_t rtt_ms,
- int64_t probing_interval_ms));
-};
-
-} // namespace test
-} // namespace webrtc
-#endif // MODULES_CONGESTION_CONTROLLER_INCLUDE_MOCK_MOCK_CONGESTION_OBSERVER_H_
diff --git a/modules/congestion_controller/include/network_changed_observer.h b/modules/congestion_controller/include/network_changed_observer.h
deleted file mode 100644
index 34ac32a..0000000
--- a/modules/congestion_controller/include/network_changed_observer.h
+++ /dev/null
@@ -1,41 +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 MODULES_CONGESTION_CONTROLLER_INCLUDE_NETWORK_CHANGED_OBSERVER_H_
-#define MODULES_CONGESTION_CONTROLLER_INCLUDE_NETWORK_CHANGED_OBSERVER_H_
-
-#include <stdint.h>
-
-namespace webrtc {
-
-// Note: This interface will be deprecated in favor of the
-// TargetTransferRateObserver interface. The new interface provides more
-// information about the network connection and uses structs to make it easier
-// to add fields.
-
-// Observer class for bitrate changes announced due to change in bandwidth
-// estimate or due to that the send pacer is full. Fraction loss and rtt is
-// also part of this callback to allow the observer to optimize its settings
-// for different types of network environments. The bitrate does not include
-// packet headers and is measured in bits per second.
-// TODO(srte): Deprecate and remove this class when SendSideCongestionController
-// is no longer using this as part of our public API.
-class NetworkChangedObserver {
- public:
- virtual void OnNetworkChanged(uint32_t bitrate_bps,
- uint8_t fraction_loss, // 0 - 255.
- int64_t rtt_ms,
- int64_t probing_interval_ms) = 0;
-
- protected:
- virtual ~NetworkChangedObserver() {}
-};
-} // namespace webrtc
-#endif // MODULES_CONGESTION_CONTROLLER_INCLUDE_NETWORK_CHANGED_OBSERVER_H_
diff --git a/modules/congestion_controller/include/receive_side_congestion_controller.h b/modules/congestion_controller/include/receive_side_congestion_controller.h
index 1f798b6..dd8a0cf 100644
--- a/modules/congestion_controller/include/receive_side_congestion_controller.h
+++ b/modules/congestion_controller/include/receive_side_congestion_controller.h
@@ -15,6 +15,7 @@
#include <vector>
#include "api/transport/field_trial_based_config.h"
+#include "modules/include/module.h"
#include "modules/remote_bitrate_estimator/remote_estimator_proxy.h"
#include "rtc_base/constructor_magic.h"
#include "rtc_base/critical_section.h"
diff --git a/modules/congestion_controller/include/send_side_congestion_controller.h b/modules/congestion_controller/include/send_side_congestion_controller.h
deleted file mode 100644
index f78763a..0000000
--- a/modules/congestion_controller/include/send_side_congestion_controller.h
+++ /dev/null
@@ -1,188 +0,0 @@
-/*
- * Copyright (c) 2012 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 MODULES_CONGESTION_CONTROLLER_INCLUDE_SEND_SIDE_CONGESTION_CONTROLLER_H_
-#define MODULES_CONGESTION_CONTROLLER_INCLUDE_SEND_SIDE_CONGESTION_CONTROLLER_H_
-
-#include <memory>
-#include <vector>
-
-#include "api/transport/field_trial_based_config.h"
-#include "api/transport/webrtc_key_value_config.h"
-#include "modules/congestion_controller/goog_cc/delay_based_bwe.h"
-#include "modules/congestion_controller/include/network_changed_observer.h"
-#include "modules/congestion_controller/include/send_side_congestion_controller_interface.h"
-#include "modules/congestion_controller/transport_feedback_adapter.h"
-#include "modules/include/module.h"
-#include "modules/include/module_common_types.h"
-#include "modules/pacing/paced_sender.h"
-#include "rtc_base/constructor_magic.h"
-#include "rtc_base/critical_section.h"
-#include "rtc_base/deprecation.h"
-#include "rtc_base/network_route.h"
-#include "rtc_base/race_checker.h"
-
-namespace rtc {
-struct SentPacket;
-}
-
-namespace webrtc {
-
-class BitrateController;
-class Clock;
-class AcknowledgedBitrateEstimator;
-class ProbeController;
-class RateLimiter;
-class RtcEventLog;
-class CongestionWindowPushbackController;
-
-// Deprecated, for somewhat similar functionality GoogCcNetworkController can be
-// used via GoogCcNetworkControllerFactory.
-class DEPRECATED_SendSideCongestionController
- : public SendSideCongestionControllerInterface {
- public:
- using Observer = NetworkChangedObserver;
- DEPRECATED_SendSideCongestionController(
- Clock* clock,
- Observer* observer,
- RtcEventLog* event_log,
- PacedSender* pacer,
- const WebRtcKeyValueConfig* key_value_config = nullptr);
- ~DEPRECATED_SendSideCongestionController() override;
-
- void RegisterPacketFeedbackObserver(
- PacketFeedbackObserver* observer) override;
- void DeRegisterPacketFeedbackObserver(
- PacketFeedbackObserver* observer) override;
-
- // Currently, there can be at most one observer.
- // TODO(nisse): The RegisterNetworkObserver method is needed because we first
- // construct this object (as part of RtpTransportControllerSend), then pass a
- // reference to Call, which then registers itself as the observer. We should
- // try to break this circular chain of references, and make the observer a
- // construction time constant.
- void RegisterNetworkObserver(Observer* observer) override;
- virtual void DeRegisterNetworkObserver(Observer* observer);
-
- void SetBweBitrates(int min_bitrate_bps,
- int start_bitrate_bps,
- int max_bitrate_bps) override;
-
- void SetAllocatedSendBitrateLimits(int64_t min_send_bitrate_bps,
- int64_t max_padding_bitrate_bps,
- int64_t max_total_bitrate_bps) override;
-
- // Resets the BWE state. Note the first argument is the bitrate_bps.
- void OnNetworkRouteChanged(const rtc::NetworkRoute& network_route,
- int bitrate_bps,
- int min_bitrate_bps,
- int max_bitrate_bps) override;
- void SignalNetworkState(NetworkState state) override;
-
- RtcpBandwidthObserver* GetBandwidthObserver() override;
-
- bool AvailableBandwidth(uint32_t* bandwidth) const override;
- virtual int64_t GetPacerQueuingDelayMs() const;
- virtual int64_t GetFirstPacketTimeMs() const;
-
- TransportFeedbackObserver* GetTransportFeedbackObserver() override;
-
- void SetPerPacketFeedbackAvailable(bool available) override;
- void EnablePeriodicAlrProbing(bool enable) override;
-
- void OnSentPacket(const rtc::SentPacket& sent_packet) override;
-
- // Implements CallStatsObserver.
- void OnRttUpdate(int64_t avg_rtt_ms, int64_t max_rtt_ms) override;
-
- // Implements Module.
- int64_t TimeUntilNextProcess() override;
- void Process() override;
-
- // Implements TransportFeedbackObserver.
- void OnAddPacket(const RtpPacketSendInfo& packet_info) override;
- void OnTransportFeedback(const rtcp::TransportFeedback& feedback) override;
-
- std::vector<PacketFeedback> GetTransportFeedbackVector() const;
-
- void SetPacingFactor(float pacing_factor) override;
-
- void SetAllocatedBitrateWithoutFeedback(uint32_t bitrate_bps) override;
-
- void EnableCongestionWindowPushback(int64_t accepted_queue_ms,
- uint32_t min_pushback_target_bitrate_bps);
-
- void SetAlrLimitedBackoffExperiment(bool enable);
-
- void SetMaxProbingBitrate(int64_t max_probing_bitrate_bps);
-
- private:
- void MaybeTriggerOnNetworkChanged();
-
- bool IsSendQueueFull() const;
- bool IsNetworkDown() const;
- bool HasNetworkParametersToReportChanged(uint32_t bitrate_bps,
- uint8_t fraction_loss,
- int64_t rtt);
- void LimitOutstandingBytes(size_t num_outstanding_bytes);
- void SendProbes(std::vector<ProbeClusterConfig> probe_configs)
- RTC_EXCLUSIVE_LOCKS_REQUIRED(&probe_lock_);
- const FieldTrialBasedConfig field_trial_config_;
- const WebRtcKeyValueConfig* const key_value_config_;
- Clock* const clock_;
- rtc::CriticalSection observer_lock_;
- Observer* observer_ RTC_GUARDED_BY(observer_lock_);
- RtcEventLog* const event_log_;
- PacedSender* const pacer_;
- const std::unique_ptr<BitrateController> bitrate_controller_;
- std::unique_ptr<AcknowledgedBitrateEstimator> acknowledged_bitrate_estimator_;
- rtc::CriticalSection probe_lock_;
- const std::unique_ptr<ProbeController> probe_controller_
- RTC_GUARDED_BY(probe_lock_);
-
- const std::unique_ptr<RateLimiter> retransmission_rate_limiter_;
- LegacyTransportFeedbackAdapter transport_feedback_adapter_;
- rtc::CriticalSection network_state_lock_;
- uint32_t last_reported_bitrate_bps_ RTC_GUARDED_BY(network_state_lock_);
- uint8_t last_reported_fraction_loss_ RTC_GUARDED_BY(network_state_lock_);
- int64_t last_reported_rtt_ RTC_GUARDED_BY(network_state_lock_);
- NetworkState network_state_ RTC_GUARDED_BY(network_state_lock_);
- bool pause_pacer_ RTC_GUARDED_BY(network_state_lock_);
- // Duplicate the pacer paused state to avoid grabbing a lock when
- // pausing the pacer. This can be removed when we move this class
- // over to the task queue.
- bool pacer_paused_;
- rtc::CriticalSection bwe_lock_;
- int min_bitrate_bps_ RTC_GUARDED_BY(bwe_lock_);
- std::unique_ptr<ProbeBitrateEstimator> probe_bitrate_estimator_
- RTC_GUARDED_BY(bwe_lock_);
- std::unique_ptr<DelayBasedBwe> delay_based_bwe_ RTC_GUARDED_BY(bwe_lock_);
- absl::optional<int64_t> cwnd_experiment_parameter_;
- bool was_in_alr_;
- const bool send_side_bwe_with_overhead_;
- size_t transport_overhead_bytes_per_packet_ RTC_GUARDED_BY(bwe_lock_);
-
- rtc::RaceChecker worker_race_;
-
- std::unique_ptr<CongestionWindowPushbackController>
- congestion_window_pushback_controller_;
-
- RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(DEPRECATED_SendSideCongestionController);
-};
-class RTC_DEPRECATED SendSideCongestionController
- : public DEPRECATED_SendSideCongestionController {
- public:
- using DEPRECATED_SendSideCongestionController::
- DEPRECATED_SendSideCongestionController;
-};
-
-} // namespace webrtc
-
-#endif // MODULES_CONGESTION_CONTROLLER_INCLUDE_SEND_SIDE_CONGESTION_CONTROLLER_H_
diff --git a/modules/congestion_controller/include/send_side_congestion_controller_interface.h b/modules/congestion_controller/include/send_side_congestion_controller_interface.h
deleted file mode 100644
index 588c00b..0000000
--- a/modules/congestion_controller/include/send_side_congestion_controller_interface.h
+++ /dev/null
@@ -1,70 +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 MODULES_CONGESTION_CONTROLLER_INCLUDE_SEND_SIDE_CONGESTION_CONTROLLER_INTERFACE_H_
-#define MODULES_CONGESTION_CONTROLLER_INCLUDE_SEND_SIDE_CONGESTION_CONTROLLER_INTERFACE_H_
-
-#include <memory>
-#include <vector>
-
-#include "modules/congestion_controller/include/network_changed_observer.h"
-#include "modules/congestion_controller/transport_feedback_adapter.h"
-#include "modules/include/module.h"
-#include "modules/include/module_common_types.h"
-#include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
-#include "rtc_base/constructor_magic.h"
-#include "rtc_base/network/sent_packet.h"
-#include "rtc_base/network_route.h"
-
-namespace webrtc {
-
-class BitrateController;
-class Clock;
-class AcknowledgedBitrateEstimator;
-class ProbeController;
-class RateLimiter;
-class RtcEventLog;
-
-class SendSideCongestionControllerInterface : public CallStatsObserver,
- public Module,
- public TransportFeedbackObserver {
- public:
- SendSideCongestionControllerInterface() = default;
- ~SendSideCongestionControllerInterface() override = default;
- virtual void RegisterPacketFeedbackObserver(
- PacketFeedbackObserver* observer) = 0;
- virtual void DeRegisterPacketFeedbackObserver(
- PacketFeedbackObserver* observer) = 0;
- virtual void RegisterNetworkObserver(NetworkChangedObserver* observer) = 0;
- virtual void SetBweBitrates(int min_bitrate_bps,
- int start_bitrate_bps,
- int max_bitrate_bps) = 0;
- virtual void SetAllocatedSendBitrateLimits(int64_t min_send_bitrate_bps,
- int64_t max_padding_bitrate_bps,
- int64_t max_total_bitrate_bps) = 0;
- virtual void OnNetworkRouteChanged(const rtc::NetworkRoute& network_route,
- int bitrate_bps,
- int min_bitrate_bps,
- int max_bitrate_bps) = 0;
- virtual void SignalNetworkState(NetworkState state) = 0;
- virtual RtcpBandwidthObserver* GetBandwidthObserver() = 0;
- virtual bool AvailableBandwidth(uint32_t* bandwidth) const = 0;
- virtual TransportFeedbackObserver* GetTransportFeedbackObserver() = 0;
- virtual void SetPerPacketFeedbackAvailable(bool available) = 0;
- virtual void EnablePeriodicAlrProbing(bool enable) = 0;
- virtual void OnSentPacket(const rtc::SentPacket& sent_packet) = 0;
- virtual void SetPacingFactor(float pacing_factor) = 0;
- virtual void SetAllocatedBitrateWithoutFeedback(uint32_t bitrate_bps) = 0;
- RTC_DISALLOW_COPY_AND_ASSIGN(SendSideCongestionControllerInterface);
-};
-
-} // namespace webrtc
-
-#endif // MODULES_CONGESTION_CONTROLLER_INCLUDE_SEND_SIDE_CONGESTION_CONTROLLER_INTERFACE_H_
diff --git a/modules/congestion_controller/rtp/BUILD.gn b/modules/congestion_controller/rtp/BUILD.gn
index bb3fe1a..04c4234 100644
--- a/modules/congestion_controller/rtp/BUILD.gn
+++ b/modules/congestion_controller/rtp/BUILD.gn
@@ -24,20 +24,15 @@
]
deps = [
- "../:congestion_controller",
"../../../api/transport:network_control",
"../../../api/units:data_rate",
"../../../api/units:data_size",
"../../../api/units:time_delta",
"../../../rtc_base:checks",
- "../../../rtc_base:rate_limiter",
"../../../rtc_base:safe_minmax",
"../../../rtc_base/synchronization:sequence_checker",
- "../../../system_wrappers",
"../../../system_wrappers:field_trial",
"../../pacing",
- "../../remote_bitrate_estimator",
- "../../rtp_rtcp:rtp_rtcp_format",
"//third_party/abseil-cpp/absl/memory",
"//third_party/abseil-cpp/absl/types:optional",
]
@@ -82,7 +77,6 @@
deps = [
":transport_feedback",
"../:congestion_controller",
- "../:mock_congestion_controller",
"../../../api/transport:network_control",
"../../../logging:mocks",
"../../../rtc_base",
diff --git a/modules/congestion_controller/rtp/control_handler.h b/modules/congestion_controller/rtp/control_handler.h
index 554c9e8..9cce0d7 100644
--- a/modules/congestion_controller/rtp/control_handler.h
+++ b/modules/congestion_controller/rtp/control_handler.h
@@ -25,7 +25,7 @@
// This is used to observe the network controller state and route calls to
// the proper handler. It also keeps cached values for safe asynchronous use.
// This makes sure that things running on the worker queue can't access state
-// in SendSideCongestionController, which would risk causing data race on
+// in RtpTransportControllerSend, which would risk causing data race on
// destruction unless members are properly ordered.
class CongestionControlHandler {
public:
diff --git a/modules/congestion_controller/send_side_congestion_controller.cc b/modules/congestion_controller/send_side_congestion_controller.cc
deleted file mode 100644
index 5a9d3d8..0000000
--- a/modules/congestion_controller/send_side_congestion_controller.cc
+++ /dev/null
@@ -1,544 +0,0 @@
-/*
- * Copyright (c) 2012 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 "modules/congestion_controller/include/send_side_congestion_controller.h"
-
-#include <inttypes.h>
-#include <algorithm>
-#include <cstdio>
-#include <iterator>
-#include <memory>
-#include <string>
-#include <vector>
-
-#include "absl/memory/memory.h"
-#include "absl/types/optional.h"
-#include "api/units/data_rate.h"
-#include "api/units/timestamp.h"
-#include "modules/bitrate_controller/include/bitrate_controller.h"
-#include "modules/congestion_controller/goog_cc/acknowledged_bitrate_estimator.h"
-#include "modules/congestion_controller/goog_cc/congestion_window_pushback_controller.h"
-#include "modules/congestion_controller/goog_cc/probe_controller.h"
-#include "modules/remote_bitrate_estimator/include/bwe_defines.h"
-#include "rtc_base/checks.h"
-#include "rtc_base/experiments/rate_control_settings.h"
-#include "rtc_base/logging.h"
-#include "rtc_base/network/sent_packet.h"
-#include "rtc_base/rate_limiter.h"
-#include "rtc_base/time_utils.h"
-
-namespace webrtc {
-namespace {
-
-static const int64_t kRetransmitWindowSizeMs = 500;
-
-// Makes sure that the bitrate and the min, max values are in valid range.
-static void ClampBitrates(int* bitrate_bps,
- int* min_bitrate_bps,
- int* max_bitrate_bps) {
- // TODO(holmer): We should make sure the default bitrates are set to 10 kbps,
- // and that we don't try to set the min bitrate to 0 from any applications.
- // The congestion controller should allow a min bitrate of 0.
- if (*min_bitrate_bps < congestion_controller::GetMinBitrateBps())
- *min_bitrate_bps = congestion_controller::GetMinBitrateBps();
- if (*max_bitrate_bps > 0)
- *max_bitrate_bps = std::max(*min_bitrate_bps, *max_bitrate_bps);
- if (*bitrate_bps > 0)
- *bitrate_bps = std::max(*min_bitrate_bps, *bitrate_bps);
-}
-
-std::vector<webrtc::PacketFeedback> ReceivedPacketFeedbackVector(
- const std::vector<webrtc::PacketFeedback>& input) {
- std::vector<PacketFeedback> received_packet_feedback_vector;
- auto is_received = [](const webrtc::PacketFeedback& packet_feedback) {
- return packet_feedback.arrival_time_ms !=
- webrtc::PacketFeedback::kNotReceived;
- };
- std::copy_if(input.begin(), input.end(),
- std::back_inserter(received_packet_feedback_vector),
- is_received);
- return received_packet_feedback_vector;
-}
-
-void SortPacketFeedbackVector(
- std::vector<webrtc::PacketFeedback>* const input) {
- RTC_DCHECK(input);
- std::sort(input->begin(), input->end(), PacketFeedbackComparator());
-}
-
-} // namespace
-
-DEPRECATED_SendSideCongestionController::
- DEPRECATED_SendSideCongestionController(
- Clock* clock,
- Observer* observer,
- RtcEventLog* event_log,
- PacedSender* pacer,
- const WebRtcKeyValueConfig* key_value_config)
- : key_value_config_(key_value_config ? key_value_config
- : &field_trial_config_),
- clock_(clock),
- observer_(observer),
- event_log_(event_log),
- pacer_(pacer),
- bitrate_controller_(
- BitrateController::CreateBitrateController(clock_, event_log)),
- acknowledged_bitrate_estimator_(
- absl::make_unique<AcknowledgedBitrateEstimator>(key_value_config_)),
- probe_controller_(new ProbeController(key_value_config_, event_log)),
- retransmission_rate_limiter_(
- new RateLimiter(clock, kRetransmitWindowSizeMs)),
- transport_feedback_adapter_(clock_),
- last_reported_bitrate_bps_(0),
- last_reported_fraction_loss_(0),
- last_reported_rtt_(0),
- network_state_(kNetworkUp),
- pause_pacer_(false),
- pacer_paused_(false),
- min_bitrate_bps_(congestion_controller::GetMinBitrateBps()),
- probe_bitrate_estimator_(new ProbeBitrateEstimator(event_log_)),
- delay_based_bwe_(
- new DelayBasedBwe(key_value_config_, event_log_, nullptr)),
- was_in_alr_(false),
- send_side_bwe_with_overhead_(
- key_value_config_->Lookup("WebRTC-SendSideBwe-WithOverhead")
- .find("Enabled") == 0),
- transport_overhead_bytes_per_packet_(0) {
- RateControlSettings experiment_params =
- RateControlSettings::ParseFromKeyValueConfig(key_value_config);
- if (experiment_params.UseCongestionWindow()) {
- cwnd_experiment_parameter_ =
- experiment_params.GetCongestionWindowAdditionalTimeMs();
- }
- if (experiment_params.UseCongestionWindowPushback()) {
- congestion_window_pushback_controller_ =
- absl::make_unique<CongestionWindowPushbackController>(
- key_value_config_);
- }
- delay_based_bwe_->SetMinBitrate(DataRate::bps(min_bitrate_bps_));
-}
-
-DEPRECATED_SendSideCongestionController::
- ~DEPRECATED_SendSideCongestionController() {}
-
-void DEPRECATED_SendSideCongestionController::EnableCongestionWindowPushback(
- int64_t accepted_queue_ms,
- uint32_t min_pushback_target_bitrate_bps) {
- RTC_DCHECK(!congestion_window_pushback_controller_)
- << "The congestion pushback is already enabled.";
- RTC_CHECK_GE(accepted_queue_ms, 0)
- << "Accepted must be greater than or equal to 0.";
- RTC_CHECK_GE(min_pushback_target_bitrate_bps, 0)
- << "Min pushback target bitrate must be greater than or equal to 0.";
-
- cwnd_experiment_parameter_ = accepted_queue_ms;
- congestion_window_pushback_controller_ =
- absl::make_unique<CongestionWindowPushbackController>(
- key_value_config_, min_pushback_target_bitrate_bps);
-}
-
-void DEPRECATED_SendSideCongestionController::SetAlrLimitedBackoffExperiment(
- bool enable) {
- rtc::CritScope cs(&bwe_lock_);
- delay_based_bwe_->SetAlrLimitedBackoffExperiment(enable);
-}
-
-void DEPRECATED_SendSideCongestionController::SetMaxProbingBitrate(
- int64_t max_probing_bitrate_bps) {
- rtc::CritScope cs(&probe_lock_);
- probe_controller_->SetMaxBitrate(max_probing_bitrate_bps);
-}
-
-void DEPRECATED_SendSideCongestionController::RegisterPacketFeedbackObserver(
- PacketFeedbackObserver* observer) {
- transport_feedback_adapter_.RegisterPacketFeedbackObserver(observer);
-}
-
-void DEPRECATED_SendSideCongestionController::DeRegisterPacketFeedbackObserver(
- PacketFeedbackObserver* observer) {
- transport_feedback_adapter_.DeRegisterPacketFeedbackObserver(observer);
-}
-
-void DEPRECATED_SendSideCongestionController::RegisterNetworkObserver(
- Observer* observer) {
- rtc::CritScope cs(&observer_lock_);
- RTC_DCHECK(observer_ == nullptr);
- observer_ = observer;
-}
-
-void DEPRECATED_SendSideCongestionController::DeRegisterNetworkObserver(
- Observer* observer) {
- rtc::CritScope cs(&observer_lock_);
- RTC_DCHECK_EQ(observer_, observer);
- observer_ = nullptr;
-}
-
-void DEPRECATED_SendSideCongestionController::SetBweBitrates(
- int min_bitrate_bps,
- int start_bitrate_bps,
- int max_bitrate_bps) {
- ClampBitrates(&start_bitrate_bps, &min_bitrate_bps, &max_bitrate_bps);
- bitrate_controller_->SetBitrates(start_bitrate_bps, min_bitrate_bps,
- max_bitrate_bps);
-
- {
- rtc::CritScope cs(&probe_lock_);
- SendProbes(probe_controller_->SetBitrates(
- min_bitrate_bps, start_bitrate_bps, max_bitrate_bps,
- clock_->TimeInMilliseconds()));
- }
-
- {
- rtc::CritScope cs(&bwe_lock_);
- if (start_bitrate_bps > 0)
- delay_based_bwe_->SetStartBitrate(DataRate::bps(start_bitrate_bps));
- min_bitrate_bps_ = min_bitrate_bps;
- delay_based_bwe_->SetMinBitrate(DataRate::bps(min_bitrate_bps_));
- }
- MaybeTriggerOnNetworkChanged();
-}
-
-void DEPRECATED_SendSideCongestionController::SetAllocatedSendBitrateLimits(
- int64_t min_send_bitrate_bps,
- int64_t max_padding_bitrate_bps,
- int64_t max_total_bitrate_bps) {
- pacer_->SetSendBitrateLimits(min_send_bitrate_bps, max_padding_bitrate_bps);
-
- rtc::CritScope cs(&probe_lock_);
- SendProbes(probe_controller_->OnMaxTotalAllocatedBitrate(
- max_total_bitrate_bps, clock_->TimeInMilliseconds()));
-}
-
-// TODO(holmer): Split this up and use SetBweBitrates in combination with
-// OnNetworkRouteChanged.
-void DEPRECATED_SendSideCongestionController::OnNetworkRouteChanged(
- const rtc::NetworkRoute& network_route,
- int bitrate_bps,
- int min_bitrate_bps,
- int max_bitrate_bps) {
- ClampBitrates(&bitrate_bps, &min_bitrate_bps, &max_bitrate_bps);
- // TODO(honghaiz): Recreate this object once the bitrate controller is
- // no longer exposed outside SendSideCongestionController.
- bitrate_controller_->ResetBitrates(bitrate_bps, min_bitrate_bps,
- max_bitrate_bps);
-
- transport_feedback_adapter_.SetNetworkIds(network_route.local_network_id,
- network_route.remote_network_id);
- {
- rtc::CritScope cs(&bwe_lock_);
- transport_overhead_bytes_per_packet_ = network_route.packet_overhead;
- min_bitrate_bps_ = min_bitrate_bps;
- probe_bitrate_estimator_.reset(new ProbeBitrateEstimator(event_log_));
- delay_based_bwe_.reset(
- new DelayBasedBwe(key_value_config_, event_log_, nullptr));
- acknowledged_bitrate_estimator_.reset(
- new AcknowledgedBitrateEstimator(key_value_config_));
- if (bitrate_bps > 0) {
- delay_based_bwe_->SetStartBitrate(DataRate::bps(bitrate_bps));
- }
- delay_based_bwe_->SetMinBitrate(DataRate::bps(min_bitrate_bps));
- }
- {
- rtc::CritScope cs(&probe_lock_);
- probe_controller_->Reset(clock_->TimeInMilliseconds());
- SendProbes(probe_controller_->SetBitrates(min_bitrate_bps, bitrate_bps,
- max_bitrate_bps,
- clock_->TimeInMilliseconds()));
- }
-
- MaybeTriggerOnNetworkChanged();
-}
-
-bool DEPRECATED_SendSideCongestionController::AvailableBandwidth(
- uint32_t* bandwidth) const {
- return bitrate_controller_->AvailableBandwidth(bandwidth);
-}
-
-RtcpBandwidthObserver*
-DEPRECATED_SendSideCongestionController::GetBandwidthObserver() {
- return bitrate_controller_.get();
-}
-
-void DEPRECATED_SendSideCongestionController::SetPerPacketFeedbackAvailable(
- bool available) {}
-
-void DEPRECATED_SendSideCongestionController::EnablePeriodicAlrProbing(
- bool enable) {
- rtc::CritScope cs(&probe_lock_);
- probe_controller_->EnablePeriodicAlrProbing(enable);
-}
-
-int64_t DEPRECATED_SendSideCongestionController::GetPacerQueuingDelayMs()
- const {
- return IsNetworkDown() ? 0 : pacer_->QueueInMs();
-}
-
-int64_t DEPRECATED_SendSideCongestionController::GetFirstPacketTimeMs() const {
- return pacer_->FirstSentPacketTimeMs();
-}
-
-TransportFeedbackObserver*
-DEPRECATED_SendSideCongestionController::GetTransportFeedbackObserver() {
- return this;
-}
-
-void DEPRECATED_SendSideCongestionController::SignalNetworkState(
- NetworkState state) {
- RTC_LOG(LS_INFO) << "SignalNetworkState "
- << (state == kNetworkUp ? "Up" : "Down");
- {
- rtc::CritScope cs(&network_state_lock_);
- pause_pacer_ = state == kNetworkDown;
- network_state_ = state;
- }
-
- {
- rtc::CritScope cs(&probe_lock_);
- NetworkAvailability msg;
- msg.at_time = Timestamp::ms(clock_->TimeInMilliseconds());
- msg.network_available = state == kNetworkUp;
- SendProbes(probe_controller_->OnNetworkAvailability(msg));
- }
- MaybeTriggerOnNetworkChanged();
-}
-
-void DEPRECATED_SendSideCongestionController::OnSentPacket(
- const rtc::SentPacket& sent_packet) {
- // We're not interested in packets without an id, which may be stun packets,
- // etc, sent on the same transport.
- if (sent_packet.packet_id == -1)
- return;
- transport_feedback_adapter_.OnSentPacket(sent_packet.packet_id,
- sent_packet.send_time_ms);
- if (cwnd_experiment_parameter_)
- LimitOutstandingBytes(transport_feedback_adapter_.GetOutstandingBytes());
-}
-
-void DEPRECATED_SendSideCongestionController::OnRttUpdate(int64_t avg_rtt_ms,
- int64_t max_rtt_ms) {
- rtc::CritScope cs(&bwe_lock_);
- delay_based_bwe_->OnRttUpdate(TimeDelta::ms(avg_rtt_ms));
-}
-
-int64_t DEPRECATED_SendSideCongestionController::TimeUntilNextProcess() {
- return bitrate_controller_->TimeUntilNextProcess();
-}
-
-void DEPRECATED_SendSideCongestionController::SendProbes(
- std::vector<ProbeClusterConfig> probe_configs) {
- for (auto probe_config : probe_configs) {
- pacer_->CreateProbeCluster(probe_config.target_data_rate.bps(),
- probe_config.id);
- }
-}
-
-void DEPRECATED_SendSideCongestionController::Process() {
- bool pause_pacer;
- // TODO(holmer): Once this class is running on a task queue we should
- // replace this with a task instead.
- {
- rtc::CritScope lock(&network_state_lock_);
- pause_pacer = pause_pacer_;
- }
- if (pause_pacer && !pacer_paused_) {
- pacer_->Pause();
- pacer_paused_ = true;
- } else if (!pause_pacer && pacer_paused_) {
- pacer_->Resume();
- pacer_paused_ = false;
- }
- bitrate_controller_->Process();
-
- {
- rtc::CritScope cs(&probe_lock_);
- probe_controller_->SetAlrStartTimeMs(
- pacer_->GetApplicationLimitedRegionStartTime());
- SendProbes(probe_controller_->Process(clock_->TimeInMilliseconds()));
- }
- MaybeTriggerOnNetworkChanged();
-}
-
-void DEPRECATED_SendSideCongestionController::OnAddPacket(
- const RtpPacketSendInfo& packet_info) {
- size_t overhead_bytes = 0;
- if (send_side_bwe_with_overhead_) {
- rtc::CritScope cs(&bwe_lock_);
- overhead_bytes = transport_overhead_bytes_per_packet_;
- }
- transport_feedback_adapter_.AddPacket(
- packet_info.ssrc, packet_info.transport_sequence_number,
- packet_info.length + overhead_bytes, packet_info.pacing_info);
-}
-
-void DEPRECATED_SendSideCongestionController::OnTransportFeedback(
- const rtcp::TransportFeedback& feedback) {
- RTC_DCHECK_RUNS_SERIALIZED(&worker_race_);
- transport_feedback_adapter_.OnTransportFeedback(feedback);
- std::vector<PacketFeedback> feedback_vector = ReceivedPacketFeedbackVector(
- transport_feedback_adapter_.GetTransportFeedbackVector());
- SortPacketFeedbackVector(&feedback_vector);
-
- bool currently_in_alr =
- pacer_->GetApplicationLimitedRegionStartTime().has_value();
- if (was_in_alr_ && !currently_in_alr) {
- int64_t now_ms = rtc::TimeMillis();
- acknowledged_bitrate_estimator_->SetAlrEndedTimeMs(now_ms);
- rtc::CritScope cs(&probe_lock_);
- probe_controller_->SetAlrEndedTimeMs(now_ms);
- }
- was_in_alr_ = currently_in_alr;
-
- acknowledged_bitrate_estimator_->IncomingPacketFeedbackVector(
- feedback_vector);
- DelayBasedBwe::Result result;
- {
- rtc::CritScope cs(&bwe_lock_);
- for (const auto& packet : feedback_vector) {
- if (packet.send_time_ms != PacketFeedback::kNoSendTime &&
- packet.pacing_info.probe_cluster_id != PacedPacketInfo::kNotAProbe) {
- probe_bitrate_estimator_->HandleProbeAndEstimateBitrate(packet);
- }
- }
- result = delay_based_bwe_->IncomingPacketFeedbackVector(
- feedback_vector, acknowledged_bitrate_estimator_->bitrate(),
- probe_bitrate_estimator_->FetchAndResetLastEstimatedBitrate(),
- absl::nullopt, currently_in_alr,
- Timestamp::ms(clock_->TimeInMilliseconds()));
- }
- if (result.updated) {
- bitrate_controller_->OnDelayBasedBweResult(result);
- // Update the estimate in the ProbeController, in case we want to probe.
- MaybeTriggerOnNetworkChanged();
- }
- if (result.recovered_from_overuse) {
- rtc::CritScope cs(&probe_lock_);
- probe_controller_->SetAlrStartTimeMs(
- pacer_->GetApplicationLimitedRegionStartTime());
- SendProbes(probe_controller_->RequestProbe(clock_->TimeInMilliseconds()));
- } else if (result.backoff_in_alr) {
- rtc::CritScope cs(&probe_lock_);
- SendProbes(probe_controller_->RequestProbe(clock_->TimeInMilliseconds()));
- }
- if (cwnd_experiment_parameter_) {
- LimitOutstandingBytes(transport_feedback_adapter_.GetOutstandingBytes());
- }
-}
-
-void DEPRECATED_SendSideCongestionController::LimitOutstandingBytes(
- size_t num_outstanding_bytes) {
- RTC_DCHECK(cwnd_experiment_parameter_);
- rtc::CritScope lock(&network_state_lock_);
- absl::optional<int64_t> min_rtt_ms =
- transport_feedback_adapter_.GetMinFeedbackLoopRtt();
- // No valid RTT. Could be because send-side BWE isn't used, in which case
- // we don't try to limit the outstanding packets.
- if (!min_rtt_ms)
- return;
- const size_t kMinCwndBytes = 2 * 1500;
- size_t max_outstanding_bytes =
- std::max<size_t>((*min_rtt_ms + *cwnd_experiment_parameter_) *
- last_reported_bitrate_bps_ / 1000 / 8,
- kMinCwndBytes);
- if (congestion_window_pushback_controller_) {
- congestion_window_pushback_controller_->UpdateOutstandingData(
- num_outstanding_bytes);
- congestion_window_pushback_controller_->UpdateMaxOutstandingData(
- max_outstanding_bytes);
- } else {
- pause_pacer_ = num_outstanding_bytes > max_outstanding_bytes;
- }
-}
-
-std::vector<PacketFeedback>
-DEPRECATED_SendSideCongestionController::GetTransportFeedbackVector() const {
- RTC_DCHECK_RUNS_SERIALIZED(&worker_race_);
- return transport_feedback_adapter_.GetTransportFeedbackVector();
-}
-
-void DEPRECATED_SendSideCongestionController::SetPacingFactor(
- float pacing_factor) {
- pacer_->SetPacingFactor(pacing_factor);
-}
-
-void DEPRECATED_SendSideCongestionController::
- SetAllocatedBitrateWithoutFeedback(uint32_t bitrate_bps) {
-}
-
-void DEPRECATED_SendSideCongestionController::MaybeTriggerOnNetworkChanged() {
- uint32_t bitrate_bps;
- uint8_t fraction_loss;
- int64_t rtt;
- bool estimate_changed = bitrate_controller_->GetNetworkParameters(
- &bitrate_bps, &fraction_loss, &rtt);
- if (estimate_changed) {
- pacer_->SetEstimatedBitrate(bitrate_bps);
- {
- rtc::CritScope cs(&probe_lock_);
- SendProbes(probe_controller_->SetEstimatedBitrate(
- bitrate_bps, clock_->TimeInMilliseconds()));
- }
- retransmission_rate_limiter_->SetMaxRate(bitrate_bps);
- }
-
- if (IsNetworkDown()) {
- bitrate_bps = 0;
- } else if (congestion_window_pushback_controller_) {
- rtc::CritScope lock(&network_state_lock_);
- bitrate_bps = congestion_window_pushback_controller_->UpdateTargetBitrate(
- bitrate_bps);
- } else {
- bitrate_bps = IsSendQueueFull() ? 0 : bitrate_bps;
- }
-
- if (HasNetworkParametersToReportChanged(bitrate_bps, fraction_loss, rtt)) {
- int64_t probing_interval_ms;
- {
- rtc::CritScope cs(&bwe_lock_);
- probing_interval_ms = delay_based_bwe_->GetExpectedBwePeriod().ms();
- }
- {
- rtc::CritScope cs(&observer_lock_);
- if (observer_) {
- observer_->OnNetworkChanged(bitrate_bps, fraction_loss, rtt,
- probing_interval_ms);
- }
- }
- }
-}
-
-bool DEPRECATED_SendSideCongestionController::
- HasNetworkParametersToReportChanged(uint32_t bitrate_bps,
- uint8_t fraction_loss,
- int64_t rtt) {
- rtc::CritScope cs(&network_state_lock_);
- bool changed =
- last_reported_bitrate_bps_ != bitrate_bps ||
- (bitrate_bps > 0 && (last_reported_fraction_loss_ != fraction_loss ||
- last_reported_rtt_ != rtt));
- if (changed && (last_reported_bitrate_bps_ == 0 || bitrate_bps == 0)) {
- RTC_LOG(LS_INFO) << "Bitrate estimate state changed, BWE: " << bitrate_bps
- << " bps.";
- }
- last_reported_bitrate_bps_ = bitrate_bps;
- last_reported_fraction_loss_ = fraction_loss;
- last_reported_rtt_ = rtt;
- return changed;
-}
-
-bool DEPRECATED_SendSideCongestionController::IsSendQueueFull() const {
- return pacer_->ExpectedQueueTimeMs() > PacedSender::kMaxQueueLengthMs;
-}
-
-bool DEPRECATED_SendSideCongestionController::IsNetworkDown() const {
- rtc::CritScope cs(&network_state_lock_);
- return network_state_ == kNetworkDown;
-}
-
-} // namespace webrtc
diff --git a/modules/congestion_controller/send_side_congestion_controller_unittest.cc b/modules/congestion_controller/send_side_congestion_controller_unittest.cc
deleted file mode 100644
index bb4cb7d..0000000
--- a/modules/congestion_controller/send_side_congestion_controller_unittest.cc
+++ /dev/null
@@ -1,374 +0,0 @@
-/*
- * Copyright (c) 2016 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 "modules/congestion_controller/include/send_side_congestion_controller.h"
-#include "logging/rtc_event_log/mock/mock_rtc_event_log.h"
-#include "modules/bitrate_controller/include/bitrate_controller.h"
-#include "modules/congestion_controller/include/mock/mock_congestion_observer.h"
-#include "modules/congestion_controller/rtp/congestion_controller_unittests_helper.h"
-#include "modules/pacing/mock/mock_paced_sender.h"
-#include "modules/pacing/packet_router.h"
-#include "modules/remote_bitrate_estimator/include/bwe_defines.h"
-#include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
-#include "modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h"
-#include "rtc_base/network/sent_packet.h"
-#include "system_wrappers/include/clock.h"
-#include "test/field_trial.h"
-#include "test/gmock.h"
-#include "test/gtest.h"
-
-using ::testing::_;
-using ::testing::AtLeast;
-using ::testing::Ge;
-using ::testing::NiceMock;
-using ::testing::Return;
-using ::testing::SaveArg;
-using ::testing::StrictMock;
-
-namespace webrtc {
-
-namespace {
-const webrtc::PacedPacketInfo kPacingInfo0(0, 5, 2000);
-const webrtc::PacedPacketInfo kPacingInfo1(1, 8, 4000);
-
-const uint32_t kInitialBitrateBps = 60000;
-
-} // namespace
-
-namespace test {
-
-class LegacySendSideCongestionControllerTest : public ::testing::Test {
- protected:
- LegacySendSideCongestionControllerTest()
- : clock_(123456),
- target_bitrate_observer_(this),
- bandwidth_observer_(nullptr) {}
- ~LegacySendSideCongestionControllerTest() override {}
-
- void SetUp() override {
- pacer_.reset(new NiceMock<MockPacedSender>());
- controller_.reset(new DEPRECATED_SendSideCongestionController(
- &clock_, &observer_, &event_log_, pacer_.get()));
- bandwidth_observer_ = controller_->GetBandwidthObserver();
-
- // Set the initial bitrate estimate and expect the |observer| and |pacer_|
- // to be updated.
- EXPECT_CALL(observer_, OnNetworkChanged(kInitialBitrateBps, _, _, _));
- EXPECT_CALL(*pacer_, SetEstimatedBitrate(kInitialBitrateBps));
- EXPECT_CALL(*pacer_, CreateProbeCluster(kInitialBitrateBps * 3, 1));
- EXPECT_CALL(*pacer_, CreateProbeCluster(kInitialBitrateBps * 5, 2));
- controller_->SetBweBitrates(0, kInitialBitrateBps, 5 * kInitialBitrateBps);
- }
-
- // Custom setup - use an observer that tracks the target bitrate, without
- // prescribing on which iterations it must change (like a mock would).
- void TargetBitrateTrackingSetup() {
- pacer_.reset(new NiceMock<MockPacedSender>());
- controller_.reset(new DEPRECATED_SendSideCongestionController(
- &clock_, &target_bitrate_observer_, &event_log_, pacer_.get()));
- controller_->SetBweBitrates(0, kInitialBitrateBps, 5 * kInitialBitrateBps);
- }
-
- void OnSentPacket(const PacketFeedback& packet_feedback) {
- RtpPacketSendInfo packet_info;
- packet_info.ssrc = 0;
- packet_info.transport_sequence_number = packet_feedback.sequence_number;
- packet_info.rtp_sequence_number = 0;
- packet_info.has_rtp_sequence_number = true;
- packet_info.length = packet_feedback.payload_size;
- packet_info.pacing_info = packet_feedback.pacing_info;
-
- controller_->OnAddPacket(packet_info);
- controller_->OnSentPacket(rtc::SentPacket(packet_feedback.sequence_number,
- packet_feedback.send_time_ms));
- }
-
- // Allows us to track the target bitrate, without prescribing the exact
- // iterations when this would hapen, like a mock would.
- class TargetBitrateObserver : public NetworkChangedObserver {
- public:
- explicit TargetBitrateObserver(
- LegacySendSideCongestionControllerTest* owner)
- : owner_(owner) {}
- ~TargetBitrateObserver() override = default;
- void OnNetworkChanged(uint32_t bitrate_bps,
- uint8_t fraction_loss, // 0 - 255.
- int64_t rtt_ms,
- int64_t probing_interval_ms) override {
- owner_->target_bitrate_bps_ = bitrate_bps;
- }
-
- private:
- LegacySendSideCongestionControllerTest* owner_;
- };
-
- void PacketTransmissionAndFeedbackBlock(uint16_t* seq_num,
- int64_t runtime_ms,
- int64_t delay) {
- int64_t delay_buildup = 0;
- int64_t start_time_ms = clock_.TimeInMilliseconds();
- while (clock_.TimeInMilliseconds() - start_time_ms < runtime_ms) {
- constexpr size_t kPayloadSize = 1000;
- PacketFeedback packet(clock_.TimeInMilliseconds() + delay_buildup,
- clock_.TimeInMilliseconds(), *seq_num, kPayloadSize,
- PacedPacketInfo());
- delay_buildup += delay; // Delay has to increase, or it's just RTT.
- OnSentPacket(packet);
- // Create expected feedback and send into adapter.
- std::unique_ptr<rtcp::TransportFeedback> feedback(
- new rtcp::TransportFeedback());
- feedback->SetBase(packet.sequence_number, packet.arrival_time_ms * 1000);
- EXPECT_TRUE(feedback->AddReceivedPacket(packet.sequence_number,
- packet.arrival_time_ms * 1000));
- rtc::Buffer raw_packet = feedback->Build();
- feedback = rtcp::TransportFeedback::ParseFrom(raw_packet.data(),
- raw_packet.size());
- EXPECT_TRUE(feedback.get() != nullptr);
- controller_->OnTransportFeedback(*feedback.get());
- clock_.AdvanceTimeMilliseconds(50);
- controller_->Process();
- ++(*seq_num);
- }
- }
-
- SimulatedClock clock_;
- StrictMock<MockCongestionObserver> observer_;
- TargetBitrateObserver target_bitrate_observer_;
- NiceMock<MockRtcEventLog> event_log_;
- RtcpBandwidthObserver* bandwidth_observer_;
- PacketRouter packet_router_;
- std::unique_ptr<NiceMock<MockPacedSender>> pacer_;
- std::unique_ptr<DEPRECATED_SendSideCongestionController> controller_;
-
- absl::optional<uint32_t> target_bitrate_bps_;
-};
-
-TEST_F(LegacySendSideCongestionControllerTest, OnNetworkChanged) {
- // Test no change.
- clock_.AdvanceTimeMilliseconds(25);
- controller_->Process();
-
- EXPECT_CALL(observer_, OnNetworkChanged(kInitialBitrateBps * 2, _, _, _));
- EXPECT_CALL(*pacer_, SetEstimatedBitrate(kInitialBitrateBps * 2));
- bandwidth_observer_->OnReceivedEstimatedBitrate(kInitialBitrateBps * 2);
- clock_.AdvanceTimeMilliseconds(25);
- controller_->Process();
-
- EXPECT_CALL(observer_, OnNetworkChanged(kInitialBitrateBps, _, _, _));
- EXPECT_CALL(*pacer_, SetEstimatedBitrate(kInitialBitrateBps));
- bandwidth_observer_->OnReceivedEstimatedBitrate(kInitialBitrateBps);
- clock_.AdvanceTimeMilliseconds(25);
- controller_->Process();
-}
-
-TEST_F(LegacySendSideCongestionControllerTest, OnSendQueueFull) {
- EXPECT_CALL(*pacer_, ExpectedQueueTimeMs())
- .WillOnce(Return(PacedSender::kMaxQueueLengthMs + 1));
-
- EXPECT_CALL(observer_, OnNetworkChanged(0, _, _, _));
- controller_->Process();
-
- // Let the pacer not be full next time the controller checks.
- EXPECT_CALL(*pacer_, ExpectedQueueTimeMs())
- .WillOnce(Return(PacedSender::kMaxQueueLengthMs - 1));
-
- EXPECT_CALL(observer_, OnNetworkChanged(kInitialBitrateBps, _, _, _));
- controller_->Process();
-}
-
-TEST_F(LegacySendSideCongestionControllerTest,
- OnSendQueueFullAndEstimateChange) {
- EXPECT_CALL(*pacer_, ExpectedQueueTimeMs())
- .WillOnce(Return(PacedSender::kMaxQueueLengthMs + 1));
- EXPECT_CALL(observer_, OnNetworkChanged(0, _, _, _));
- controller_->Process();
-
- // Receive new estimate but let the queue still be full.
- bandwidth_observer_->OnReceivedEstimatedBitrate(kInitialBitrateBps * 2);
- EXPECT_CALL(*pacer_, ExpectedQueueTimeMs())
- .WillOnce(Return(PacedSender::kMaxQueueLengthMs + 1));
- // The send pacer should get the new estimate though.
- EXPECT_CALL(*pacer_, SetEstimatedBitrate(kInitialBitrateBps * 2));
- clock_.AdvanceTimeMilliseconds(25);
- controller_->Process();
-
- // Let the pacer not be full next time the controller checks.
- // |OnNetworkChanged| should be called with the new estimate.
- EXPECT_CALL(*pacer_, ExpectedQueueTimeMs())
- .WillOnce(Return(PacedSender::kMaxQueueLengthMs - 1));
- EXPECT_CALL(observer_, OnNetworkChanged(kInitialBitrateBps * 2, _, _, _));
- clock_.AdvanceTimeMilliseconds(25);
- controller_->Process();
-}
-
-TEST_F(LegacySendSideCongestionControllerTest, SignalNetworkState) {
- EXPECT_CALL(observer_, OnNetworkChanged(0, _, _, _));
- controller_->SignalNetworkState(kNetworkDown);
-
- EXPECT_CALL(observer_, OnNetworkChanged(kInitialBitrateBps, _, _, _));
- controller_->SignalNetworkState(kNetworkUp);
-
- EXPECT_CALL(observer_, OnNetworkChanged(0, _, _, _));
- controller_->SignalNetworkState(kNetworkDown);
-}
-
-TEST_F(LegacySendSideCongestionControllerTest, OnNetworkRouteChanged) {
- int new_bitrate = 200000;
- ::testing::Mock::VerifyAndClearExpectations(pacer_.get());
- EXPECT_CALL(observer_, OnNetworkChanged(new_bitrate, _, _, _));
- EXPECT_CALL(*pacer_, SetEstimatedBitrate(new_bitrate));
- rtc::NetworkRoute route;
- route.local_network_id = 1;
- controller_->OnNetworkRouteChanged(route, new_bitrate, -1, -1);
-
- // If the bitrate is reset to -1, the new starting bitrate will be
- // the minimum default bitrate kMinBitrateBps.
- EXPECT_CALL(
- observer_,
- OnNetworkChanged(congestion_controller::GetMinBitrateBps(), _, _, _));
- EXPECT_CALL(*pacer_,
- SetEstimatedBitrate(congestion_controller::GetMinBitrateBps()));
- route.local_network_id = 2;
- controller_->OnNetworkRouteChanged(route, -1, -1, -1);
-}
-
-TEST_F(LegacySendSideCongestionControllerTest, OldFeedback) {
- int new_bitrate = 200000;
- ::testing::Mock::VerifyAndClearExpectations(pacer_.get());
- EXPECT_CALL(observer_, OnNetworkChanged(new_bitrate, _, _, _));
- EXPECT_CALL(*pacer_, SetEstimatedBitrate(new_bitrate));
-
- // Send a few packets on the first network route.
- std::vector<PacketFeedback> packets;
- packets.push_back(PacketFeedback(0, 0, 0, 1500, kPacingInfo0));
- packets.push_back(PacketFeedback(10, 10, 1, 1500, kPacingInfo0));
- packets.push_back(PacketFeedback(20, 20, 2, 1500, kPacingInfo0));
- packets.push_back(PacketFeedback(30, 30, 3, 1500, kPacingInfo1));
- packets.push_back(PacketFeedback(40, 40, 4, 1500, kPacingInfo1));
-
- for (const PacketFeedback& packet : packets)
- OnSentPacket(packet);
-
- // Change route and then insert a number of feedback packets.
- rtc::NetworkRoute route;
- route.local_network_id = 1;
- controller_->OnNetworkRouteChanged(route, new_bitrate, -1, -1);
-
- for (const PacketFeedback& packet : packets) {
- rtcp::TransportFeedback feedback;
- feedback.SetBase(packet.sequence_number, packet.arrival_time_ms * 1000);
-
- EXPECT_TRUE(feedback.AddReceivedPacket(packet.sequence_number,
- packet.arrival_time_ms * 1000));
- feedback.Build();
- controller_->OnTransportFeedback(feedback);
- }
-
- // If the bitrate is reset to -1, the new starting bitrate will be
- // the minimum default bitrate kMinBitrateBps.
- EXPECT_CALL(
- observer_,
- OnNetworkChanged(congestion_controller::GetMinBitrateBps(), _, _, _));
- EXPECT_CALL(*pacer_,
- SetEstimatedBitrate(congestion_controller::GetMinBitrateBps()));
- route.local_network_id = 2;
- controller_->OnNetworkRouteChanged(route, -1, -1, -1);
-}
-
-TEST_F(LegacySendSideCongestionControllerTest,
- SignalNetworkStateAndQueueIsFullAndEstimateChange) {
- // Send queue is full
- EXPECT_CALL(*pacer_, ExpectedQueueTimeMs())
- .WillRepeatedly(Return(PacedSender::kMaxQueueLengthMs + 1));
- EXPECT_CALL(observer_, OnNetworkChanged(0, _, _, _));
- controller_->Process();
-
- // Queue is full and network is down. Expect no bitrate change.
- controller_->SignalNetworkState(kNetworkDown);
- controller_->Process();
-
- // Queue is full but network is up. Expect no bitrate change.
- controller_->SignalNetworkState(kNetworkUp);
- controller_->Process();
-
- // Receive new estimate but let the queue still be full.
- EXPECT_CALL(*pacer_, SetEstimatedBitrate(kInitialBitrateBps * 2));
- bandwidth_observer_->OnReceivedEstimatedBitrate(kInitialBitrateBps * 2);
- clock_.AdvanceTimeMilliseconds(25);
- controller_->Process();
-
- // Let the pacer not be full next time the controller checks.
- EXPECT_CALL(*pacer_, ExpectedQueueTimeMs())
- .WillOnce(Return(PacedSender::kMaxQueueLengthMs - 1));
- EXPECT_CALL(observer_, OnNetworkChanged(kInitialBitrateBps * 2, _, _, _));
- controller_->Process();
-}
-
-TEST_F(LegacySendSideCongestionControllerTest, GetPacerQueuingDelayMs) {
- EXPECT_CALL(observer_, OnNetworkChanged(_, _, _, _)).Times(AtLeast(1));
-
- const int64_t kQueueTimeMs = 123;
- EXPECT_CALL(*pacer_, QueueInMs()).WillRepeatedly(Return(kQueueTimeMs));
- EXPECT_EQ(kQueueTimeMs, controller_->GetPacerQueuingDelayMs());
-
- // Expect zero pacer delay when network is down.
- controller_->SignalNetworkState(kNetworkDown);
- EXPECT_EQ(0, controller_->GetPacerQueuingDelayMs());
-
- // Network is up, pacer delay should be reported.
- controller_->SignalNetworkState(kNetworkUp);
- EXPECT_EQ(kQueueTimeMs, controller_->GetPacerQueuingDelayMs());
-}
-
-TEST_F(LegacySendSideCongestionControllerTest, GetProbingInterval) {
- clock_.AdvanceTimeMilliseconds(25);
- controller_->Process();
-
- EXPECT_CALL(observer_, OnNetworkChanged(_, _, _, ::testing::Ne(0)));
- EXPECT_CALL(*pacer_, SetEstimatedBitrate(_));
- bandwidth_observer_->OnReceivedEstimatedBitrate(kInitialBitrateBps * 2);
- clock_.AdvanceTimeMilliseconds(25);
- controller_->Process();
-}
-
-TEST_F(LegacySendSideCongestionControllerTest, ProbeOnRouteChange) {
- ::testing::Mock::VerifyAndClearExpectations(pacer_.get());
- EXPECT_CALL(*pacer_, CreateProbeCluster(kInitialBitrateBps * 6, _));
- EXPECT_CALL(*pacer_, CreateProbeCluster(kInitialBitrateBps * 12, _));
- EXPECT_CALL(observer_, OnNetworkChanged(kInitialBitrateBps * 2, _, _, _));
- rtc::NetworkRoute route;
- route.local_network_id = 1;
- controller_->OnNetworkRouteChanged(route, 2 * kInitialBitrateBps, 0,
- 20 * kInitialBitrateBps);
-}
-
-// Bandwidth estimation is updated when feedbacks are received.
-// Feedbacks which show an increasing delay cause the estimation to be reduced.
-TEST_F(LegacySendSideCongestionControllerTest, UpdatesDelayBasedEstimate) {
- TargetBitrateTrackingSetup();
-
- const int64_t kRunTimeMs = 6000;
- uint16_t seq_num = 0;
-
- // The test must run and insert packets/feedback long enough that the
- // BWE computes a valid estimate. This is first done in an environment which
- // simulates no bandwidth limitation, and therefore not built-up delay.
- PacketTransmissionAndFeedbackBlock(&seq_num, kRunTimeMs, 0);
- ASSERT_TRUE(target_bitrate_bps_);
-
- // Repeat, but this time with a building delay, and make sure that the
- // estimation is adjusted downwards.
- uint32_t bitrate_before_delay = *target_bitrate_bps_;
- PacketTransmissionAndFeedbackBlock(&seq_num, kRunTimeMs, 50);
- EXPECT_LT(*target_bitrate_bps_, bitrate_before_delay);
-}
-
-} // namespace test
-} // namespace webrtc
diff --git a/modules/congestion_controller/transport_feedback_adapter.cc b/modules/congestion_controller/transport_feedback_adapter.cc
deleted file mode 100644
index 5977fe5..0000000
--- a/modules/congestion_controller/transport_feedback_adapter.cc
+++ /dev/null
@@ -1,213 +0,0 @@
-/*
- * Copyright (c) 2015 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 "modules/congestion_controller/transport_feedback_adapter.h"
-
-#include <stdlib.h>
-#include <algorithm>
-#include <cmath>
-#include <cstdint>
-
-#include "api/units/data_size.h"
-#include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
-#include "modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h"
-#include "rtc_base/checks.h"
-#include "rtc_base/logging.h"
-
-namespace webrtc {
-
-const int64_t kNoTimestamp = -1;
-const int64_t kSendTimeHistoryWindowMs = 60000;
-const int64_t kBaseTimestampScaleFactor =
- rtcp::TransportFeedback::kDeltaScaleFactor * (1 << 8);
-const int64_t kBaseTimestampRangeSizeUs = kBaseTimestampScaleFactor * (1 << 24);
-
-LegacyTransportFeedbackAdapter::LegacyTransportFeedbackAdapter(Clock* clock)
- : send_time_history_(kSendTimeHistoryWindowMs),
- clock_(clock),
- current_offset_ms_(kNoTimestamp),
- last_timestamp_us_(kNoTimestamp),
- local_net_id_(0),
- remote_net_id_(0) {}
-
-LegacyTransportFeedbackAdapter::~LegacyTransportFeedbackAdapter() {
- RTC_DCHECK(observers_.empty());
-}
-
-void LegacyTransportFeedbackAdapter::RegisterPacketFeedbackObserver(
- PacketFeedbackObserver* observer) {
- rtc::CritScope cs(&observers_lock_);
- RTC_DCHECK(observer);
- RTC_DCHECK(std::find(observers_.begin(), observers_.end(), observer) ==
- observers_.end());
- observers_.push_back(observer);
-}
-
-void LegacyTransportFeedbackAdapter::DeRegisterPacketFeedbackObserver(
- PacketFeedbackObserver* observer) {
- rtc::CritScope cs(&observers_lock_);
- RTC_DCHECK(observer);
- const auto it = std::find(observers_.begin(), observers_.end(), observer);
- RTC_DCHECK(it != observers_.end());
- observers_.erase(it);
-}
-
-void LegacyTransportFeedbackAdapter::AddPacket(
- uint32_t ssrc,
- uint16_t sequence_number,
- size_t length,
- const PacedPacketInfo& pacing_info) {
- {
- rtc::CritScope cs(&lock_);
- const int64_t creation_time_ms = clock_->TimeInMilliseconds();
- send_time_history_.AddAndRemoveOld(
- PacketFeedback(creation_time_ms, sequence_number, length, local_net_id_,
- remote_net_id_, pacing_info),
- creation_time_ms);
- }
-
- {
- rtc::CritScope cs(&observers_lock_);
- for (auto* observer : observers_) {
- observer->OnPacketAdded(ssrc, sequence_number);
- }
- }
-}
-
-void LegacyTransportFeedbackAdapter::OnSentPacket(uint16_t sequence_number,
- int64_t send_time_ms) {
- rtc::CritScope cs(&lock_);
- send_time_history_.OnSentPacket(sequence_number, send_time_ms);
-}
-
-void LegacyTransportFeedbackAdapter::SetNetworkIds(uint16_t local_id,
- uint16_t remote_id) {
- rtc::CritScope cs(&lock_);
- local_net_id_ = local_id;
- remote_net_id_ = remote_id;
-}
-
-std::vector<PacketFeedback>
-LegacyTransportFeedbackAdapter::GetPacketFeedbackVector(
- const rtcp::TransportFeedback& feedback) {
- int64_t timestamp_us = feedback.GetBaseTimeUs();
- int64_t now_ms = clock_->TimeInMilliseconds();
- // Add timestamp deltas to a local time base selected on first packet arrival.
- // This won't be the true time base, but makes it easier to manually inspect
- // time stamps.
- if (last_timestamp_us_ == kNoTimestamp) {
- current_offset_ms_ = now_ms;
- } else {
- int64_t delta = timestamp_us - last_timestamp_us_;
-
- // Detect and compensate for wrap-arounds in base time.
- if (std::abs(delta - kBaseTimestampRangeSizeUs) < std::abs(delta)) {
- delta -= kBaseTimestampRangeSizeUs; // Wrap backwards.
- } else if (std::abs(delta + kBaseTimestampRangeSizeUs) < std::abs(delta)) {
- delta += kBaseTimestampRangeSizeUs; // Wrap forwards.
- }
-
- current_offset_ms_ += delta / 1000;
- }
- last_timestamp_us_ = timestamp_us;
-
- std::vector<PacketFeedback> packet_feedback_vector;
- if (feedback.GetPacketStatusCount() == 0) {
- RTC_LOG(LS_INFO) << "Empty transport feedback packet received.";
- return packet_feedback_vector;
- }
- packet_feedback_vector.reserve(feedback.GetPacketStatusCount());
- int64_t feedback_rtt = -1;
- {
- rtc::CritScope cs(&lock_);
- size_t failed_lookups = 0;
- int64_t offset_us = 0;
- int64_t timestamp_ms = 0;
- uint16_t seq_num = feedback.GetBaseSequence();
- for (const auto& packet : feedback.GetReceivedPackets()) {
- // Insert into the vector those unreceived packets which precede this
- // iteration's received packet.
- for (; seq_num != packet.sequence_number(); ++seq_num) {
- PacketFeedback packet_feedback(PacketFeedback::kNotReceived, seq_num);
- // Note: Element not removed from history because it might be reported
- // as received by another feedback.
- if (!send_time_history_.GetFeedback(&packet_feedback, false))
- ++failed_lookups;
- if (packet_feedback.local_net_id == local_net_id_ &&
- packet_feedback.remote_net_id == remote_net_id_) {
- packet_feedback_vector.push_back(packet_feedback);
- }
- }
-
- // Handle this iteration's received packet.
- offset_us += packet.delta_us();
- timestamp_ms = current_offset_ms_ + (offset_us / 1000);
- PacketFeedback packet_feedback(timestamp_ms, packet.sequence_number());
- if (!send_time_history_.GetFeedback(&packet_feedback, true))
- ++failed_lookups;
- if (packet_feedback.local_net_id == local_net_id_ &&
- packet_feedback.remote_net_id == remote_net_id_) {
- if (packet_feedback.send_time_ms >= 0) {
- int64_t rtt = now_ms - packet_feedback.send_time_ms;
- // max() is used to account for feedback being delayed by the
- // receiver.
- feedback_rtt = std::max(rtt, feedback_rtt);
- }
- packet_feedback_vector.push_back(packet_feedback);
- }
-
- ++seq_num;
- }
-
- if (failed_lookups > 0) {
- RTC_LOG(LS_WARNING) << "Failed to lookup send time for " << failed_lookups
- << " packet" << (failed_lookups > 1 ? "s" : "")
- << ". Send time history too small?";
- }
- if (feedback_rtt > -1) {
- feedback_rtts_.push_back(feedback_rtt);
- const size_t kFeedbackRttWindow = 32;
- if (feedback_rtts_.size() > kFeedbackRttWindow)
- feedback_rtts_.pop_front();
- min_feedback_rtt_.emplace(
- *std::min_element(feedback_rtts_.begin(), feedback_rtts_.end()));
- }
- }
- return packet_feedback_vector;
-}
-
-void LegacyTransportFeedbackAdapter::OnTransportFeedback(
- const rtcp::TransportFeedback& feedback) {
- last_packet_feedback_vector_ = GetPacketFeedbackVector(feedback);
- {
- rtc::CritScope cs(&observers_lock_);
- for (auto* observer : observers_) {
- observer->OnPacketFeedbackVector(last_packet_feedback_vector_);
- }
- }
-}
-
-std::vector<PacketFeedback>
-LegacyTransportFeedbackAdapter::GetTransportFeedbackVector() const {
- return last_packet_feedback_vector_;
-}
-
-absl::optional<int64_t> LegacyTransportFeedbackAdapter::GetMinFeedbackLoopRtt()
- const {
- rtc::CritScope cs(&lock_);
- return min_feedback_rtt_;
-}
-
-size_t LegacyTransportFeedbackAdapter::GetOutstandingBytes() const {
- rtc::CritScope cs(&lock_);
- return send_time_history_.GetOutstandingData(local_net_id_, remote_net_id_)
- .bytes();
-}
-} // namespace webrtc
diff --git a/modules/congestion_controller/transport_feedback_adapter.h b/modules/congestion_controller/transport_feedback_adapter.h
deleted file mode 100644
index 8ea5234..0000000
--- a/modules/congestion_controller/transport_feedback_adapter.h
+++ /dev/null
@@ -1,83 +0,0 @@
-/*
- * Copyright (c) 2015 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 MODULES_CONGESTION_CONTROLLER_TRANSPORT_FEEDBACK_ADAPTER_H_
-#define MODULES_CONGESTION_CONTROLLER_TRANSPORT_FEEDBACK_ADAPTER_H_
-
-#include <deque>
-#include <vector>
-
-#include "api/transport/network_types.h"
-#include "modules/congestion_controller/rtp/send_time_history.h"
-#include "rtc_base/critical_section.h"
-#include "rtc_base/thread_annotations.h"
-#include "rtc_base/thread_checker.h"
-#include "system_wrappers/include/clock.h"
-
-namespace webrtc {
-
-class PacketFeedbackObserver;
-
-namespace rtcp {
-class TransportFeedback;
-} // namespace rtcp
-
-// Deprecated, use version in
-// modules/congeestion_controller/rtp/transport_feedback_adapter.h
-class LegacyTransportFeedbackAdapter {
- public:
- explicit LegacyTransportFeedbackAdapter(Clock* clock);
- virtual ~LegacyTransportFeedbackAdapter();
-
- void RegisterPacketFeedbackObserver(PacketFeedbackObserver* observer);
- void DeRegisterPacketFeedbackObserver(PacketFeedbackObserver* observer);
-
- void AddPacket(uint32_t ssrc,
- uint16_t sequence_number,
- size_t length,
- const PacedPacketInfo& pacing_info);
- void OnSentPacket(uint16_t sequence_number, int64_t send_time_ms);
-
- // TODO(holmer): This method should return DelayBasedBwe::Result so that we
- // can get rid of the dependency on BitrateController. Requires changes
- // to the CongestionController interface.
- void OnTransportFeedback(const rtcp::TransportFeedback& feedback);
- std::vector<PacketFeedback> GetTransportFeedbackVector() const;
- absl::optional<int64_t> GetMinFeedbackLoopRtt() const;
-
- void SetTransportOverhead(size_t transport_overhead_bytes_per_packet);
-
- void SetNetworkIds(uint16_t local_id, uint16_t remote_id);
-
- size_t GetOutstandingBytes() const;
-
- private:
- std::vector<PacketFeedback> GetPacketFeedbackVector(
- const rtcp::TransportFeedback& feedback);
-
- rtc::CriticalSection lock_;
- SendTimeHistory send_time_history_ RTC_GUARDED_BY(&lock_);
- Clock* const clock_;
- int64_t current_offset_ms_;
- int64_t last_timestamp_us_;
- std::vector<PacketFeedback> last_packet_feedback_vector_;
- uint16_t local_net_id_ RTC_GUARDED_BY(&lock_);
- uint16_t remote_net_id_ RTC_GUARDED_BY(&lock_);
- std::deque<int64_t> feedback_rtts_ RTC_GUARDED_BY(&lock_);
- absl::optional<int64_t> min_feedback_rtt_ RTC_GUARDED_BY(&lock_);
-
- rtc::CriticalSection observers_lock_;
- std::vector<PacketFeedbackObserver*> observers_
- RTC_GUARDED_BY(&observers_lock_);
-};
-
-} // namespace webrtc
-
-#endif // MODULES_CONGESTION_CONTROLLER_TRANSPORT_FEEDBACK_ADAPTER_H_
diff --git a/modules/congestion_controller/transport_feedback_adapter_unittest.cc b/modules/congestion_controller/transport_feedback_adapter_unittest.cc
deleted file mode 100644
index eca4a94..0000000
--- a/modules/congestion_controller/transport_feedback_adapter_unittest.cc
+++ /dev/null
@@ -1,390 +0,0 @@
-/*
- * Copyright (c) 2015 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 <limits>
-#include <memory>
-#include <vector>
-
-#include "modules/congestion_controller/rtp/congestion_controller_unittests_helper.h"
-#include "modules/congestion_controller/transport_feedback_adapter.h"
-#include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
-#include "modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h"
-#include "rtc_base/checks.h"
-#include "rtc_base/numerics/safe_conversions.h"
-#include "system_wrappers/include/clock.h"
-#include "test/gmock.h"
-#include "test/gtest.h"
-
-using ::testing::_;
-using ::testing::Invoke;
-
-namespace webrtc {
-
-namespace {
-const PacedPacketInfo kPacingInfo0(0, 5, 2000);
-const PacedPacketInfo kPacingInfo1(1, 8, 4000);
-const PacedPacketInfo kPacingInfo2(2, 14, 7000);
-const PacedPacketInfo kPacingInfo3(3, 20, 10000);
-const PacedPacketInfo kPacingInfo4(4, 22, 10000);
-} // namespace
-
-namespace test {
-
-class MockPacketFeedbackObserver : public webrtc::PacketFeedbackObserver {
- public:
- MOCK_METHOD2(OnPacketAdded, void(uint32_t ssrc, uint16_t seq_num));
- MOCK_METHOD1(OnPacketFeedbackVector,
- void(const std::vector<PacketFeedback>& packet_feedback_vector));
-};
-
-class LegacyTransportFeedbackAdapterTest : public ::testing::Test {
- public:
- LegacyTransportFeedbackAdapterTest() : clock_(0) {}
-
- virtual ~LegacyTransportFeedbackAdapterTest() {}
-
- virtual void SetUp() {
- adapter_.reset(new LegacyTransportFeedbackAdapter(&clock_));
- }
-
- virtual void TearDown() { adapter_.reset(); }
-
- protected:
- void OnReceivedEstimatedBitrate(uint32_t bitrate) {}
-
- void OnReceivedRtcpReceiverReport(const ReportBlockList& report_blocks,
- int64_t rtt,
- int64_t now_ms) {}
-
- void OnSentPacket(const PacketFeedback& packet_feedback) {
- adapter_->AddPacket(kSsrc, packet_feedback.sequence_number,
- packet_feedback.payload_size,
- packet_feedback.pacing_info);
- adapter_->OnSentPacket(packet_feedback.sequence_number,
- packet_feedback.send_time_ms);
- }
-
- static constexpr uint32_t kSsrc = 8492;
-
- SimulatedClock clock_;
- std::unique_ptr<LegacyTransportFeedbackAdapter> adapter_;
-};
-
-TEST_F(LegacyTransportFeedbackAdapterTest, ObserverSanity) {
- MockPacketFeedbackObserver mock;
- adapter_->RegisterPacketFeedbackObserver(&mock);
-
- const std::vector<PacketFeedback> packets = {
- PacketFeedback(100, 200, 0, 1000, kPacingInfo0),
- PacketFeedback(110, 210, 1, 2000, kPacingInfo0),
- PacketFeedback(120, 220, 2, 3000, kPacingInfo0)};
-
- rtcp::TransportFeedback feedback;
- feedback.SetBase(packets[0].sequence_number,
- packets[0].arrival_time_ms * 1000);
-
- for (const PacketFeedback& packet : packets) {
- EXPECT_CALL(mock, OnPacketAdded(kSsrc, packet.sequence_number)).Times(1);
- OnSentPacket(packet);
- EXPECT_TRUE(feedback.AddReceivedPacket(packet.sequence_number,
- packet.arrival_time_ms * 1000));
- }
-
- EXPECT_CALL(mock, OnPacketFeedbackVector(_)).Times(1);
- adapter_->OnTransportFeedback(feedback);
-
- adapter_->DeRegisterPacketFeedbackObserver(&mock);
-
- // After deregistration, the observer no longers gets indications.
- EXPECT_CALL(mock, OnPacketAdded(_, _)).Times(0);
- const PacketFeedback new_packet(130, 230, 3, 4000, kPacingInfo0);
- OnSentPacket(new_packet);
-
- rtcp::TransportFeedback second_feedback;
- second_feedback.SetBase(new_packet.sequence_number,
- new_packet.arrival_time_ms * 1000);
- EXPECT_TRUE(feedback.AddReceivedPacket(new_packet.sequence_number,
- new_packet.arrival_time_ms * 1000));
- EXPECT_CALL(mock, OnPacketFeedbackVector(_)).Times(0);
- adapter_->OnTransportFeedback(second_feedback);
-}
-
-#if RTC_DCHECK_IS_ON && GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID)
-TEST_F(LegacyTransportFeedbackAdapterTest,
- ObserverDoubleRegistrationDeathTest) {
- MockPacketFeedbackObserver mock;
- adapter_->RegisterPacketFeedbackObserver(&mock);
- EXPECT_DEATH(adapter_->RegisterPacketFeedbackObserver(&mock), "");
- adapter_->DeRegisterPacketFeedbackObserver(&mock);
-}
-
-TEST_F(LegacyTransportFeedbackAdapterTest,
- ObserverMissingDeRegistrationDeathTest) {
- MockPacketFeedbackObserver mock;
- adapter_->RegisterPacketFeedbackObserver(&mock);
- EXPECT_DEATH(adapter_.reset(), "");
- adapter_->DeRegisterPacketFeedbackObserver(&mock);
-}
-#endif
-
-TEST_F(LegacyTransportFeedbackAdapterTest,
- AdaptsFeedbackAndPopulatesSendTimes) {
- std::vector<PacketFeedback> packets;
- packets.push_back(PacketFeedback(100, 200, 0, 1500, kPacingInfo0));
- packets.push_back(PacketFeedback(110, 210, 1, 1500, kPacingInfo0));
- packets.push_back(PacketFeedback(120, 220, 2, 1500, kPacingInfo0));
- packets.push_back(PacketFeedback(130, 230, 3, 1500, kPacingInfo1));
- packets.push_back(PacketFeedback(140, 240, 4, 1500, kPacingInfo1));
-
- for (const PacketFeedback& packet : packets)
- OnSentPacket(packet);
-
- rtcp::TransportFeedback feedback;
- feedback.SetBase(packets[0].sequence_number,
- packets[0].arrival_time_ms * 1000);
-
- for (const PacketFeedback& packet : packets) {
- EXPECT_TRUE(feedback.AddReceivedPacket(packet.sequence_number,
- packet.arrival_time_ms * 1000));
- }
-
- feedback.Build();
-
- adapter_->OnTransportFeedback(feedback);
- ComparePacketFeedbackVectors(packets, adapter_->GetTransportFeedbackVector());
-}
-
-TEST_F(LegacyTransportFeedbackAdapterTest, FeedbackVectorReportsUnreceived) {
- std::vector<PacketFeedback> sent_packets = {
- PacketFeedback(100, 220, 0, 1500, kPacingInfo0),
- PacketFeedback(110, 210, 1, 1500, kPacingInfo0),
- PacketFeedback(120, 220, 2, 1500, kPacingInfo0),
- PacketFeedback(130, 230, 3, 1500, kPacingInfo0),
- PacketFeedback(140, 240, 4, 1500, kPacingInfo0),
- PacketFeedback(150, 250, 5, 1500, kPacingInfo0),
- PacketFeedback(160, 260, 6, 1500, kPacingInfo0)};
-
- for (const PacketFeedback& packet : sent_packets)
- OnSentPacket(packet);
-
- // Note: Important to include the last packet, as only unreceived packets in
- // between received packets can be inferred.
- std::vector<PacketFeedback> received_packets = {
- sent_packets[0], sent_packets[2], sent_packets[6]};
-
- rtcp::TransportFeedback feedback;
- feedback.SetBase(received_packets[0].sequence_number,
- received_packets[0].arrival_time_ms * 1000);
-
- for (const PacketFeedback& packet : received_packets) {
- EXPECT_TRUE(feedback.AddReceivedPacket(packet.sequence_number,
- packet.arrival_time_ms * 1000));
- }
-
- feedback.Build();
-
- adapter_->OnTransportFeedback(feedback);
- ComparePacketFeedbackVectors(sent_packets,
- adapter_->GetTransportFeedbackVector());
-}
-
-TEST_F(LegacyTransportFeedbackAdapterTest, HandlesDroppedPackets) {
- std::vector<PacketFeedback> packets;
- packets.push_back(PacketFeedback(100, 200, 0, 1500, kPacingInfo0));
- packets.push_back(PacketFeedback(110, 210, 1, 1500, kPacingInfo1));
- packets.push_back(PacketFeedback(120, 220, 2, 1500, kPacingInfo2));
- packets.push_back(PacketFeedback(130, 230, 3, 1500, kPacingInfo3));
- packets.push_back(PacketFeedback(140, 240, 4, 1500, kPacingInfo4));
-
- const uint16_t kSendSideDropBefore = 1;
- const uint16_t kReceiveSideDropAfter = 3;
-
- for (const PacketFeedback& packet : packets) {
- if (packet.sequence_number >= kSendSideDropBefore)
- OnSentPacket(packet);
- }
-
- rtcp::TransportFeedback feedback;
- feedback.SetBase(packets[0].sequence_number,
- packets[0].arrival_time_ms * 1000);
-
- for (const PacketFeedback& packet : packets) {
- if (packet.sequence_number <= kReceiveSideDropAfter) {
- EXPECT_TRUE(feedback.AddReceivedPacket(packet.sequence_number,
- packet.arrival_time_ms * 1000));
- }
- }
-
- feedback.Build();
-
- std::vector<PacketFeedback> expected_packets(
- packets.begin(), packets.begin() + kReceiveSideDropAfter + 1);
- // Packets that have timed out on the send-side have lost the
- // information stored on the send-side.
- for (size_t i = 0; i < kSendSideDropBefore; ++i) {
- expected_packets[i].send_time_ms = -1;
- expected_packets[i].payload_size = 0;
- expected_packets[i].pacing_info = PacedPacketInfo();
- }
-
- adapter_->OnTransportFeedback(feedback);
- ComparePacketFeedbackVectors(expected_packets,
- adapter_->GetTransportFeedbackVector());
-}
-
-TEST_F(LegacyTransportFeedbackAdapterTest, SendTimeWrapsBothWays) {
- int64_t kHighArrivalTimeMs = rtcp::TransportFeedback::kDeltaScaleFactor *
- static_cast<int64_t>(1 << 8) *
- static_cast<int64_t>((1 << 23) - 1) / 1000;
- std::vector<PacketFeedback> packets;
- packets.push_back(
- PacketFeedback(kHighArrivalTimeMs - 64, 200, 0, 1500, PacedPacketInfo()));
- packets.push_back(
- PacketFeedback(kHighArrivalTimeMs + 64, 210, 1, 1500, PacedPacketInfo()));
- packets.push_back(
- PacketFeedback(kHighArrivalTimeMs, 220, 2, 1500, PacedPacketInfo()));
-
- for (const PacketFeedback& packet : packets)
- OnSentPacket(packet);
-
- for (size_t i = 0; i < packets.size(); ++i) {
- std::unique_ptr<rtcp::TransportFeedback> feedback(
- new rtcp::TransportFeedback());
- feedback->SetBase(packets[i].sequence_number,
- packets[i].arrival_time_ms * 1000);
-
- EXPECT_TRUE(feedback->AddReceivedPacket(packets[i].sequence_number,
- packets[i].arrival_time_ms * 1000));
-
- rtc::Buffer raw_packet = feedback->Build();
- feedback = rtcp::TransportFeedback::ParseFrom(raw_packet.data(),
- raw_packet.size());
-
- std::vector<PacketFeedback> expected_packets;
- expected_packets.push_back(packets[i]);
-
- adapter_->OnTransportFeedback(*feedback.get());
- ComparePacketFeedbackVectors(expected_packets,
- adapter_->GetTransportFeedbackVector());
- }
-}
-
-TEST_F(LegacyTransportFeedbackAdapterTest, HandlesArrivalReordering) {
- std::vector<PacketFeedback> packets;
- packets.push_back(PacketFeedback(120, 200, 0, 1500, kPacingInfo0));
- packets.push_back(PacketFeedback(110, 210, 1, 1500, kPacingInfo0));
- packets.push_back(PacketFeedback(100, 220, 2, 1500, kPacingInfo0));
-
- for (const PacketFeedback& packet : packets)
- OnSentPacket(packet);
-
- rtcp::TransportFeedback feedback;
- feedback.SetBase(packets[0].sequence_number,
- packets[0].arrival_time_ms * 1000);
-
- for (const PacketFeedback& packet : packets) {
- EXPECT_TRUE(feedback.AddReceivedPacket(packet.sequence_number,
- packet.arrival_time_ms * 1000));
- }
-
- feedback.Build();
-
- // Adapter keeps the packets ordered by sequence number (which is itself
- // assigned by the order of transmission). Reordering by some other criteria,
- // eg. arrival time, is up to the observers.
- adapter_->OnTransportFeedback(feedback);
- ComparePacketFeedbackVectors(packets, adapter_->GetTransportFeedbackVector());
-}
-
-TEST_F(LegacyTransportFeedbackAdapterTest, TimestampDeltas) {
- std::vector<PacketFeedback> sent_packets;
- const int64_t kSmallDeltaUs =
- rtcp::TransportFeedback::kDeltaScaleFactor * ((1 << 8) - 1);
- const int64_t kLargePositiveDeltaUs =
- rtcp::TransportFeedback::kDeltaScaleFactor *
- std::numeric_limits<int16_t>::max();
- const int64_t kLargeNegativeDeltaUs =
- rtcp::TransportFeedback::kDeltaScaleFactor *
- std::numeric_limits<int16_t>::min();
-
- PacketFeedback packet_feedback(100, 200, 0, 1500, true, 0, 0,
- PacedPacketInfo());
- sent_packets.push_back(packet_feedback);
-
- packet_feedback.send_time_ms += kSmallDeltaUs / 1000;
- packet_feedback.arrival_time_ms += kSmallDeltaUs / 1000;
- ++packet_feedback.sequence_number;
- sent_packets.push_back(packet_feedback);
-
- packet_feedback.send_time_ms += kLargePositiveDeltaUs / 1000;
- packet_feedback.arrival_time_ms += kLargePositiveDeltaUs / 1000;
- ++packet_feedback.sequence_number;
- sent_packets.push_back(packet_feedback);
-
- packet_feedback.send_time_ms += kLargeNegativeDeltaUs / 1000;
- packet_feedback.arrival_time_ms += kLargeNegativeDeltaUs / 1000;
- ++packet_feedback.sequence_number;
- sent_packets.push_back(packet_feedback);
-
- // Too large, delta - will need two feedback messages.
- packet_feedback.send_time_ms += (kLargePositiveDeltaUs + 1000) / 1000;
- packet_feedback.arrival_time_ms += (kLargePositiveDeltaUs + 1000) / 1000;
- ++packet_feedback.sequence_number;
-
- // Packets will be added to send history.
- for (const PacketFeedback& packet : sent_packets)
- OnSentPacket(packet);
- OnSentPacket(packet_feedback);
-
- // Create expected feedback and send into adapter.
- std::unique_ptr<rtcp::TransportFeedback> feedback(
- new rtcp::TransportFeedback());
- feedback->SetBase(sent_packets[0].sequence_number,
- sent_packets[0].arrival_time_ms * 1000);
-
- for (const PacketFeedback& packet : sent_packets) {
- EXPECT_TRUE(feedback->AddReceivedPacket(packet.sequence_number,
- packet.arrival_time_ms * 1000));
- }
- EXPECT_FALSE(feedback->AddReceivedPacket(
- packet_feedback.sequence_number, packet_feedback.arrival_time_ms * 1000));
-
- rtc::Buffer raw_packet = feedback->Build();
- feedback =
- rtcp::TransportFeedback::ParseFrom(raw_packet.data(), raw_packet.size());
-
- std::vector<PacketFeedback> received_feedback;
-
- EXPECT_TRUE(feedback.get() != nullptr);
- adapter_->OnTransportFeedback(*feedback.get());
- ComparePacketFeedbackVectors(sent_packets,
- adapter_->GetTransportFeedbackVector());
-
- // Create a new feedback message and add the trailing item.
- feedback.reset(new rtcp::TransportFeedback());
- feedback->SetBase(packet_feedback.sequence_number,
- packet_feedback.arrival_time_ms * 1000);
- EXPECT_TRUE(feedback->AddReceivedPacket(
- packet_feedback.sequence_number, packet_feedback.arrival_time_ms * 1000));
- raw_packet = feedback->Build();
- feedback =
- rtcp::TransportFeedback::ParseFrom(raw_packet.data(), raw_packet.size());
-
- EXPECT_TRUE(feedback.get() != nullptr);
- adapter_->OnTransportFeedback(*feedback.get());
- {
- std::vector<PacketFeedback> expected_packets;
- expected_packets.push_back(packet_feedback);
- ComparePacketFeedbackVectors(expected_packets,
- adapter_->GetTransportFeedbackVector());
- }
-}
-} // namespace test
-} // namespace webrtc
diff --git a/modules/pacing/BUILD.gn b/modules/pacing/BUILD.gn
index 26e60c9..a35ba85 100644
--- a/modules/pacing/BUILD.gn
+++ b/modules/pacing/BUILD.gn
@@ -19,7 +19,6 @@
"bitrate_prober.h",
"paced_sender.cc",
"paced_sender.h",
- "pacer.h",
"packet_router.cc",
"packet_router.h",
"round_robin_packet_queue.cc",
@@ -36,14 +35,10 @@
"../../logging:rtc_event_log_api",
"../../logging:rtc_event_pacing",
"../../rtc_base:checks",
- "../../rtc_base:deprecation",
"../../rtc_base:rtc_base_approved",
- "../../rtc_base/experiments:alr_experiment",
"../../rtc_base/experiments:field_trial_parser",
"../../system_wrappers",
- "../../system_wrappers:field_trial",
"../../system_wrappers:metrics",
- "../congestion_controller/goog_cc:alr_detector",
"../remote_bitrate_estimator",
"../rtp_rtcp",
"../rtp_rtcp:rtp_rtcp_format",
diff --git a/modules/pacing/paced_sender.cc b/modules/pacing/paced_sender.cc
index 27dfc5a..bcda710 100644
--- a/modules/pacing/paced_sender.cc
+++ b/modules/pacing/paced_sender.cc
@@ -15,7 +15,6 @@
#include "absl/memory/memory.h"
#include "logging/rtc_event_log/rtc_event_log.h"
-#include "modules/congestion_controller/goog_cc/alr_detector.h"
#include "modules/pacing/bitrate_prober.h"
#include "modules/pacing/interval_budget.h"
#include "modules/utility/include/process_thread.h"
@@ -58,7 +57,6 @@
fallback_field_trials_(
!field_trials ? absl::make_unique<FieldTrialBasedConfig>() : nullptr),
field_trials_(field_trials ? field_trials : fallback_field_trials_.get()),
- alr_detector_(),
drain_large_queues_(
!IsDisabled(*field_trials_, "WebRTC-Pacer-DrainQueue")),
send_padding_if_silent_(
@@ -71,16 +69,12 @@
padding_budget_(0),
prober_(*field_trials_),
probing_send_failure_(false),
- estimated_bitrate_bps_(0),
- min_send_bitrate_kbps_(0u),
- max_padding_bitrate_kbps_(0u),
pacing_bitrate_kbps_(0),
time_last_process_us_(clock->TimeInMicroseconds()),
last_send_time_us_(clock->TimeInMicroseconds()),
first_sent_packet_ms_(-1),
packets_(clock->TimeInMicroseconds()),
packet_counter_(0),
- pacing_factor_(kDefaultPaceMultiplier),
queue_time_limit(kMaxQueueLengthMs),
account_for_audio_(false) {
if (!drain_large_queues_) {
@@ -164,33 +158,6 @@
prober_.SetEnabled(enabled);
}
-void PacedSender::SetEstimatedBitrate(uint32_t bitrate_bps) {
- if (bitrate_bps == 0)
- RTC_LOG(LS_ERROR) << "PacedSender is not designed to handle 0 bitrate.";
- rtc::CritScope cs(&critsect_);
- estimated_bitrate_bps_ = bitrate_bps;
- padding_budget_.set_target_rate_kbps(
- std::min(estimated_bitrate_bps_ / 1000, max_padding_bitrate_kbps_));
- pacing_bitrate_kbps_ =
- std::max(min_send_bitrate_kbps_, estimated_bitrate_bps_ / 1000) *
- pacing_factor_;
- if (!alr_detector_)
- alr_detector_ = absl::make_unique<AlrDetector>(field_trials_);
- alr_detector_->SetEstimatedBitrate(bitrate_bps);
-}
-
-void PacedSender::SetSendBitrateLimits(int min_send_bitrate_bps,
- int padding_bitrate) {
- rtc::CritScope cs(&critsect_);
- min_send_bitrate_kbps_ = min_send_bitrate_bps / 1000;
- pacing_bitrate_kbps_ =
- std::max(min_send_bitrate_kbps_, estimated_bitrate_bps_ / 1000) *
- pacing_factor_;
- max_padding_bitrate_kbps_ = padding_bitrate / 1000;
- padding_budget_.set_target_rate_kbps(
- std::min(estimated_bitrate_bps_ / 1000, max_padding_bitrate_kbps_));
-}
-
void PacedSender::SetPacingRates(uint32_t pacing_rate_bps,
uint32_t padding_rate_bps) {
rtc::CritScope cs(&critsect_);
@@ -236,13 +203,6 @@
pacing_bitrate_kbps_);
}
-absl::optional<int64_t> PacedSender::GetApplicationLimitedRegionStartTime() {
- rtc::CritScope cs(&critsect_);
- if (!alr_detector_)
- alr_detector_ = absl::make_unique<AlrDetector>(field_trials_);
- return alr_detector_->GetApplicationLimitedRegionStartTime();
-}
-
size_t PacedSender::QueueSizePackets() const {
rtc::CritScope cs(&critsect_);
return packets_.SizeInPackets();
@@ -323,8 +283,6 @@
size_t bytes_sent = packet_sender_->TimeToSendPadding(1, PacedPacketInfo());
critsect_.Enter();
OnPaddingSent(bytes_sent);
- if (alr_detector_)
- alr_detector_->OnBytesSent(bytes_sent, now_us / 1000);
}
if (paused_)
@@ -413,8 +371,6 @@
if (!probing_send_failure_)
prober_.ProbeSent(TimeMilliseconds(), bytes_sent);
}
- if (alr_detector_)
- alr_detector_->OnBytesSent(bytes_sent, now_us / 1000);
}
void PacedSender::ProcessThreadAttached(ProcessThread* process_thread) {
@@ -472,14 +428,6 @@
padding_budget_.UseBudget(bytes_sent);
}
-void PacedSender::SetPacingFactor(float pacing_factor) {
- rtc::CritScope cs(&critsect_);
- pacing_factor_ = pacing_factor;
- // Make sure new padding factor is applied immediately, otherwise we need to
- // wait for the send bitrate estimate to be updated before this takes effect.
- SetEstimatedBitrate(estimated_bitrate_bps_);
-}
-
void PacedSender::SetQueueTimeLimit(int limit_ms) {
rtc::CritScope cs(&critsect_);
queue_time_limit = limit_ms;
diff --git a/modules/pacing/paced_sender.h b/modules/pacing/paced_sender.h
index 58c1200..5266cd9 100644
--- a/modules/pacing/paced_sender.h
+++ b/modules/pacing/paced_sender.h
@@ -20,23 +20,21 @@
#include "api/transport/field_trial_based_config.h"
#include "api/transport/network_types.h"
#include "api/transport/webrtc_key_value_config.h"
+#include "modules/include/module.h"
#include "modules/pacing/bitrate_prober.h"
#include "modules/pacing/interval_budget.h"
-#include "modules/pacing/pacer.h"
#include "modules/pacing/round_robin_packet_queue.h"
#include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
#include "modules/utility/include/process_thread.h"
#include "rtc_base/critical_section.h"
-#include "rtc_base/deprecation.h"
#include "rtc_base/experiments/field_trial_parser.h"
#include "rtc_base/thread_annotations.h"
namespace webrtc {
-class AlrDetector;
class Clock;
class RtcEventLog;
-class PacedSender : public Pacer {
+class PacedSender : public Module, public RtpPacketSender {
public:
class PacketSender {
public:
@@ -95,15 +93,8 @@
// effect.
void SetProbingEnabled(bool enabled);
- // Deprecated, SetPacingRates should be used instead.
- void SetEstimatedBitrate(uint32_t bitrate_bps) override;
- // Deprecated, SetPacingRates should be used instead.
- void SetSendBitrateLimits(int min_send_bitrate_bps,
- int max_padding_bitrate_bps);
-
// Sets the pacing rates. Must be called once before packets can be sent.
- void SetPacingRates(uint32_t pacing_rate_bps,
- uint32_t padding_rate_bps) override;
+ void SetPacingRates(uint32_t pacing_rate_bps, uint32_t padding_rate_bps);
// Returns true if we send the packet now, else it will add the packet
// information to the queue and call TimeToSendPacket when it's time to send.
@@ -134,9 +125,6 @@
// packets in the queue, given the current size and bitrate, ignoring prio.
virtual int64_t ExpectedQueueTimeMs() const;
- // Deprecated, alr detection will be moved out of the pacer.
- virtual absl::optional<int64_t> GetApplicationLimitedRegionStartTime();
-
// Returns the number of milliseconds until the module want a worker thread
// to call Process.
int64_t TimeUntilNextProcess() override;
@@ -146,8 +134,6 @@
// Called when the prober is associated with a process thread.
void ProcessThreadAttached(ProcessThread* process_thread) override;
- // Deprecated, SetPacingRates should be used instead.
- void SetPacingFactor(float pacing_factor);
void SetQueueTimeLimit(int limit_ms);
private:
@@ -177,7 +163,6 @@
PacketSender* const packet_sender_;
const std::unique_ptr<FieldTrialBasedConfig> fallback_field_trials_;
const WebRtcKeyValueConfig* field_trials_;
- std::unique_ptr<AlrDetector> alr_detector_ RTC_PT_GUARDED_BY(critsect_);
const bool drain_large_queues_;
const bool send_padding_if_silent_;
@@ -199,11 +184,7 @@
BitrateProber prober_ RTC_GUARDED_BY(critsect_);
bool probing_send_failure_ RTC_GUARDED_BY(critsect_);
- // Actual configured bitrates (media_budget_ may temporarily be higher in
- // order to meet pace time constraint).
- uint32_t estimated_bitrate_bps_ RTC_GUARDED_BY(critsect_);
- uint32_t min_send_bitrate_kbps_ RTC_GUARDED_BY(critsect_);
- uint32_t max_padding_bitrate_kbps_ RTC_GUARDED_BY(critsect_);
+
uint32_t pacing_bitrate_kbps_ RTC_GUARDED_BY(critsect_);
int64_t time_last_process_us_ RTC_GUARDED_BY(critsect_);
@@ -216,11 +197,11 @@
int64_t congestion_window_bytes_ RTC_GUARDED_BY(critsect_) =
kNoCongestionWindow;
int64_t outstanding_bytes_ RTC_GUARDED_BY(critsect_) = 0;
- float pacing_factor_ RTC_GUARDED_BY(critsect_);
+
// Lock to avoid race when attaching process thread. This can happen due to
- // the Call class setting network state on SendSideCongestionController, which
+ // the Call class setting network state on RtpTransportControllerSend, which
// in turn calls Pause/Resume on Pacedsender, before actually starting the
- // pacer process thread. If SendSideCongestionController is running on a task
+ // pacer process thread. If RtpTransportControllerSend is running on a task
// queue separate from the thread used by Call, this causes a race.
rtc::CriticalSection process_thread_lock_;
ProcessThread* process_thread_ RTC_GUARDED_BY(process_thread_lock_) = nullptr;
diff --git a/modules/pacing/pacer.h b/modules/pacing/pacer.h
deleted file mode 100644
index d7d5ea5..0000000
--- a/modules/pacing/pacer.h
+++ /dev/null
@@ -1,39 +0,0 @@
-/*
- * Copyright (c) 2017 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 MODULES_PACING_PACER_H_
-#define MODULES_PACING_PACER_H_
-
-#include "modules/include/module.h"
-#include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
-
-namespace webrtc {
-class Pacer : public Module, public RtpPacketSender {
- public:
- virtual void SetEstimatedBitrate(uint32_t bitrate_bps) {}
- virtual void SetPacingRates(uint32_t pacing_rate_bps,
- uint32_t padding_rate_bps) {}
- virtual void SetEstimatedBitrateAndCongestionWindow(
- uint32_t bitrate_bps,
- bool in_probe_rtt,
- uint64_t congestion_window) {}
- virtual void OnBytesAcked(size_t bytes) {}
- void InsertPacket(RtpPacketSender::Priority priority,
- uint32_t ssrc,
- uint16_t sequence_number,
- int64_t capture_time_ms,
- size_t bytes,
- bool retransmission) override = 0;
- int64_t TimeUntilNextProcess() override = 0;
- void Process() override = 0;
- ~Pacer() override {}
-};
-} // namespace webrtc
-#endif // MODULES_PACING_PACER_H_
diff --git a/rtc_tools/event_log_visualizer/analyzer.cc b/rtc_tools/event_log_visualizer/analyzer.cc
index b194207..c15454b 100644
--- a/rtc_tools/event_log_visualizer/analyzer.cc
+++ b/rtc_tools/event_log_visualizer/analyzer.cc
@@ -1271,7 +1271,7 @@
// and piping the output to plot_dynamics.py can be used as a hack to get the
// internal state of various BWE components. In this case, it is important
// we don't instantiate the AcknowledgedBitrateEstimator both here and in
- // SendSideCongestionController since that would lead to duplicate outputs.
+ // GoogCcNetworkController since that would lead to duplicate outputs.
AcknowledgedBitrateEstimator acknowledged_bitrate_estimator(
&field_trial_config_,
absl::make_unique<BitrateEstimator>(&field_trial_config_));
