admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Removes SendSideCongestionController.

Browse Source 
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}
This commit is contained in:
Sebastian Jansson 2019-06-11 11:24:40 +02:00 committed by Commit Bot
parent ab6fc1154f
commit 4ad51d8b31
24 changed files with 12 additions and 2142 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
call/BUILD.gn
View File

@ -189,7 +189,6 @@ rtc_source_set("bitrate_allocator") {
"../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 @@ rtc_static_library("call") {
"../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 @@ if (rtc_include_tests) {
"../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 @@ if (rtc_include_tests) {
deps = [
":rtp_interfaces",
"../api:libjingle_peerconnection_api",
"../modules/congestion_controller",
"../modules/pacing",
"../rtc_base",
"../rtc_base:rate_limiter",

1
call/bitrate_allocator.cc
View File

@ -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"

2
call/bitrate_allocator_unittest.cc
View File

@ -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"

1
call/call.cc
View File

@ -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"

3
call/rtp_transport_controller_send_interface.h
View File

@ -123,8 +123,7 @@ class RtpTransportControllerSendInterface {
// 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.

1
call/test/mock_rtp_transport_controller_send.h
View File

@ -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"

68
modules/congestion_controller/BUILD.gn
View File

@ -20,40 +20,16 @@ rtc_static_library("congestion_controller") {
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("congestion_controller") {
}
}
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 @@ if (rtc_include_tests) {
"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",
]
}
}

31
modules/congestion_controller/include/mock/mock_congestion_observer.h
View File

@ -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_

41
modules/congestion_controller/include/network_changed_observer.h
View File

@ -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_

1
modules/congestion_controller/include/receive_side_congestion_controller.h
View File

@ -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"

188
modules/congestion_controller/include/send_side_congestion_controller.h
View File

@ -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_

70
modules/congestion_controller/include/send_side_congestion_controller_interface.h
View File

@ -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_

6
modules/congestion_controller/rtp/BUILD.gn
View File

@ -24,20 +24,15 @@ rtc_source_set("control_handler") {
]
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 @@ if (rtc_include_tests) {
deps = [
":transport_feedback",
"../:congestion_controller",
"../:mock_congestion_controller",
"../../../api/transport:network_control",
"../../../logging:mocks",
"../../../rtc_base",

2
modules/congestion_controller/rtp/control_handler.h
View File

@ -25,7 +25,7 @@ namespace webrtc {
// 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:

544
modules/congestion_controller/send_side_congestion_controller.cc
View File

@ -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

374
modules/congestion_controller/send_side_congestion_controller_unittest.cc
View File

@ -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

213
modules/congestion_controller/transport_feedback_adapter.cc
View File

@ -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

83
modules/congestion_controller/transport_feedback_adapter.h
View File

@ -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_

390
modules/congestion_controller/transport_feedback_adapter_unittest.cc
View File

@ -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

5
modules/pacing/BUILD.gn
View File

@ -19,7 +19,6 @@ rtc_static_library("pacing") {
"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 @@ rtc_static_library("pacing") {
"../../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",

52
modules/pacing/paced_sender.cc
View File

@ -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 @@ PacedSender::PacedSender(Clock* clock,
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 @@ PacedSender::PacedSender(Clock* clock,
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 @@ void PacedSender::SetProbingEnabled(bool enabled) {
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 @@ int64_t PacedSender::ExpectedQueueTimeMs() const {
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 @@ void PacedSender::Process() {
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 @@ void PacedSender::Process() {
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 @@ void PacedSender::UpdateBudgetWithBytesSent(size_t bytes_sent) {
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;

33
modules/pacing/paced_sender.h
View File

@ -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 @@ class PacedSender : public Pacer {
// 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 @@ class PacedSender : public Pacer {
// 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 @@ class PacedSender : public Pacer {
// 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 @@ class PacedSender : public Pacer {
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 @@ class PacedSender : public Pacer {
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 @@ class PacedSender : public Pacer {
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;

39
modules/pacing/pacer.h
View File

@ -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_

2
rtc_tools/event_log_visualizer/analyzer.cc
View File

@ -1271,7 +1271,7 @@ void EventLogAnalyzer::CreateSendSideBweSimulationGraph(Plot* plot) {
// 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_));