mollyim/webrtc
1
0
Fork 0
mirror of https://github.com/mollyim/webrtc.git synced 2025-05-12 21:30:45 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

Enables feature to account for unacknowledged data.

Browse source 
By enabling this trial, we can also remove reporting of packet
feedback status from send streams that was used before.

Bug: webrtc:9718
Change-Id: I3e7c4656b0ac6592a834617e044f23a072454181
Reviewed-on: https://webrtc-review.googlesource.com/c/118281
Reviewed-by: Oskar Sundbom <ossu@webrtc.org>
Reviewed-by: Erik Språng <sprang@webrtc.org>
Reviewed-by: Christoffer Rodbro <crodbro@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#26363}
This commit is contained in:
Sebastian Jansson 2019-01-23 09:41:43 +01:00
parent 7e4341db60
commit 79f0d4d0c7
20 changed files with 36 additions and 170 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
api/transport/network_types.h
View file

@ -36,8 +36,6 @@ struct StreamsConfig {
absl::optional<DataRate> min_pacing_rate;
absl::optional<DataRate> max_padding_rate;
absl::optional<DataRate> max_total_allocated_bitrate;
// The send rate of traffic for which feedback is not received.
DataRate unacknowledged_rate_allocation = DataRate::Zero();
};
struct TargetRateConstraints {

20
audio/audio_send_stream.cc
View file

@ -320,8 +320,7 @@ void AudioSendStream::Start() {
rtp_transport_->packet_sender()->SetAccountForAudioPackets(true);
rtp_rtcp_module_->SetAsPartOfAllocation(true);
ConfigureBitrateObserver(config_.min_bitrate_bps, config_.max_bitrate_bps,
config_.bitrate_priority,
has_transport_sequence_number);
config_.bitrate_priority);
} else {
rtp_rtcp_module_->SetAsPartOfAllocation(false);
}
@ -729,10 +728,10 @@ void AudioSendStream::ReconfigureBitrateObserver(
(has_transport_sequence_number ||
!webrtc::field_trial::IsEnabled("WebRTC-Audio-SendSideBwe"))) {
stream->rtp_transport_->packet_sender()->SetAccountForAudioPackets(true);
stream->ConfigureBitrateObserver(
new_config.min_bitrate_bps, new_config.max_bitrate_bps,
new_config.bitrate_priority, has_transport_sequence_number);
stream->rtp_rtcp_module_->SetAsPartOfAllocation(true);
stream->ConfigureBitrateObserver(new_config.min_bitrate_bps,
new_config.max_bitrate_bps,
new_config.bitrate_priority);
} else {
stream->rtp_transport_->packet_sender()->SetAccountForAudioPackets(false);
stream->RemoveBitrateObserver();
@ -742,8 +741,7 @@ void AudioSendStream::ReconfigureBitrateObserver(
void AudioSendStream::ConfigureBitrateObserver(int min_bitrate_bps,
int max_bitrate_bps,
double bitrate_priority,
bool has_packet_feedback) {
double bitrate_priority) {
RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
RTC_DCHECK_GE(max_bitrate_bps, min_bitrate_bps);
rtc::Event thread_sync_event;
@ -755,10 +753,10 @@ void AudioSendStream::ConfigureBitrateObserver(int min_bitrate_bps,
config_.bitrate_priority = bitrate_priority;
// This either updates the current observer or adds a new observer.
bitrate_allocator_->AddObserver(
this, MediaStreamAllocationConfig{
static_cast<uint32_t>(min_bitrate_bps),
static_cast<uint32_t>(max_bitrate_bps), 0, true,
config_.track_id, bitrate_priority, has_packet_feedback});
this,
MediaStreamAllocationConfig{static_cast<uint32_t>(min_bitrate_bps),
static_cast<uint32_t>(max_bitrate_bps), 0,
true, config_.track_id, bitrate_priority});
thread_sync_event.Set();
});
thread_sync_event.Wait(rtc::Event::kForever);

3
audio/audio_send_stream.h
View file

@ -112,8 +112,7 @@ class AudioSendStream final : public webrtc::AudioSendStream,
void ConfigureBitrateObserver(int min_bitrate_bps,
int max_bitrate_bps,
double bitrate_priority,
bool has_packet_feedback);
double bitrate_priority);
void RemoveBitrateObserver();
void RegisterCngPayloadType(int payload_type, int clockrate_hz);

6
audio/audio_send_stream_unittest.cc
View file

@ -72,12 +72,10 @@ const AudioCodecSpec kCodecSpecs[] = {
class MockLimitObserver : public BitrateAllocator::LimitObserver {
public:
MOCK_METHOD5(OnAllocationLimitsChanged,
MOCK_METHOD3(OnAllocationLimitsChanged,
void(uint32_t min_send_bitrate_bps,
uint32_t max_padding_bitrate_bps,
uint32_t total_bitrate_bps,
uint32_t allocated_without_feedback_bps,
bool has_packet_feedback));
uint32_t total_bitrate_bps));
};
std::unique_ptr<MockAudioEncoder> SetupAudioEncoderMock(

31
call/bitrate_allocator.cc
View file

@ -64,8 +64,6 @@ BitrateAllocator::BitrateAllocator(LimitObserver* limit_observer)
total_requested_padding_bitrate_(0),
total_requested_min_bitrate_(0),
total_requested_max_bitrate_(0),
allocated_without_feedback_(0),
has_packet_feedback_(false),
bitrate_allocation_strategy_(nullptr),
transmission_max_bitrate_multiplier_(
GetTransmissionMaxBitrateMultiplier()) {
@ -175,10 +173,10 @@ void BitrateAllocator::AddObserver(BitrateAllocatorObserver* observer,
it->enforce_min_bitrate = config.enforce_min_bitrate;
it->bitrate_priority = config.bitrate_priority;
} else {
bitrate_observer_configs_.push_back(ObserverConfig(
observer, config.min_bitrate_bps, config.max_bitrate_bps,
config.pad_up_bitrate_bps, config.enforce_min_bitrate, config.track_id,
config.bitrate_priority, config.has_packet_feedback));
bitrate_observer_configs_.push_back(
ObserverConfig(observer, config.min_bitrate_bps, config.max_bitrate_bps,
config.pad_up_bitrate_bps, config.enforce_min_bitrate,
config.track_id, config.bitrate_priority));
}
if (last_target_bps_ > 0) {
@ -221,8 +219,6 @@ void BitrateAllocator::UpdateAllocationLimits() {
uint32_t total_requested_padding_bitrate = 0;
uint32_t total_requested_min_bitrate = 0;
uint32_t total_requested_max_bitrate = 0;
bool has_packet_feedback = false;
uint32_t allocated_without_feedback = 0;
for (const auto& config : bitrate_observer_configs_) {
uint32_t stream_padding = config.pad_up_bitrate_bps;
if (config.enforce_min_bitrate) {
@ -240,27 +236,17 @@ void BitrateAllocator::UpdateAllocationLimits() {
max_bitrate_bps *= 2;
}
total_requested_max_bitrate += max_bitrate_bps;
if (config.allocated_bitrate_bps > 0 && config.has_packet_feedback)
has_packet_feedback = true;
// TODO(srte): Remove field trial check.
if (!config.has_packet_feedback &&
field_trial::IsEnabled("WebRTC-Audio-ABWENoTWCC"))
allocated_without_feedback += config.allocated_bitrate_bps;
}
if (total_requested_padding_bitrate == total_requested_padding_bitrate_ &&
total_requested_min_bitrate == total_requested_min_bitrate_ &&
total_requested_max_bitrate == total_requested_max_bitrate_ &&
allocated_without_feedback == allocated_without_feedback_ &&
has_packet_feedback == has_packet_feedback_) {
total_requested_max_bitrate == total_requested_max_bitrate_) {
return;
}
total_requested_min_bitrate_ = total_requested_min_bitrate;
total_requested_padding_bitrate_ = total_requested_padding_bitrate;
total_requested_max_bitrate_ = total_requested_max_bitrate;
allocated_without_feedback_ = allocated_without_feedback;
has_packet_feedback_ = has_packet_feedback;
RTC_LOG(LS_INFO) << "UpdateAllocationLimits : total_requested_min_bitrate: "
<< total_requested_min_bitrate
@ -268,10 +254,9 @@ void BitrateAllocator::UpdateAllocationLimits() {
<< total_requested_padding_bitrate
<< "bps, total_requested_max_bitrate: "
<< total_requested_max_bitrate << "bps";
limit_observer_->OnAllocationLimitsChanged(
total_requested_min_bitrate, total_requested_padding_bitrate,
total_requested_max_bitrate, allocated_without_feedback,
has_packet_feedback);
limit_observer_->OnAllocationLimitsChanged(total_requested_min_bitrate,
total_requested_padding_bitrate,
total_requested_max_bitrate);
}
void BitrateAllocator::RemoveObserver(BitrateAllocatorObserver* observer) {

25
call/bitrate_allocator.h
View file

@ -47,11 +47,7 @@ class BitrateAllocatorObserver {
// |enforce_min_bitrate| = 'true' will allocate at least |min_bitrate_bps| for
// this observer, even if the BWE is too low, 'false' will allocate 0 to
// the observer if BWE doesn't allow |min_bitrate_bps|.
// |has_packet_feedback| indicates whether the data produced by the
// corresponding media stream will receive per packet feedback. This is
// tracked here to communicate to limit observers whether packet feedback can
// be expected, which is true if any of the active observers has packet
// feedback enabled. Note that |observer|->OnBitrateUpdated() will be called
// Note that |observer|->OnBitrateUpdated() will be called
// within the scope of this method with the current rtt, fraction_loss and
// available bitrate and that the bitrate in OnBitrateUpdated will be zero if
// the |observer| is currently not allowed to send data.
@ -62,7 +58,6 @@ struct MediaStreamAllocationConfig {
bool enforce_min_bitrate;
std::string track_id;
double bitrate_priority;
bool has_packet_feedback;
};
// Interface used for mocking
@ -86,12 +81,9 @@ class BitrateAllocator : public BitrateAllocatorInterface {
// bitrate and max padding bitrate is changed.
class LimitObserver {
public:
virtual void OnAllocationLimitsChanged(
uint32_t min_send_bitrate_bps,
uint32_t max_padding_bitrate_bps,
uint32_t total_bitrate_bps,
uint32_t allocated_without_feedback_bps,
bool has_packet_feedback) = 0;
virtual void OnAllocationLimitsChanged(uint32_t min_send_bitrate_bps,
uint32_t max_padding_bitrate_bps,
uint32_t total_bitrate_bps) = 0;
protected:
virtual ~LimitObserver() = default;
@ -138,8 +130,7 @@ class BitrateAllocator : public BitrateAllocatorInterface {
uint32_t pad_up_bitrate_bps,
bool enforce_min_bitrate,
std::string track_id,
double bitrate_priority,
bool has_packet_feedback)
double bitrate_priority)
: TrackConfig(min_bitrate_bps,
max_bitrate_bps,
enforce_min_bitrate,
@ -148,8 +139,7 @@ class BitrateAllocator : public BitrateAllocatorInterface {
pad_up_bitrate_bps(pad_up_bitrate_bps),
allocated_bitrate_bps(-1),
media_ratio(1.0),
bitrate_priority(bitrate_priority),
has_packet_feedback(has_packet_feedback) {}
bitrate_priority(bitrate_priority) {}
BitrateAllocatorObserver* observer;
uint32_t pad_up_bitrate_bps;
@ -159,7 +149,6 @@ class BitrateAllocator : public BitrateAllocatorInterface {
// observers. If an observer has twice the bitrate_priority of other
// observers, it should be allocated twice the bitrate above its min.
double bitrate_priority;
bool has_packet_feedback;
uint32_t LastAllocatedBitrate() const;
// The minimum bitrate required by this observer, including
@ -250,8 +239,6 @@ class BitrateAllocator : public BitrateAllocatorInterface {
uint32_t total_requested_padding_bitrate_ RTC_GUARDED_BY(&sequenced_checker_);
uint32_t total_requested_min_bitrate_ RTC_GUARDED_BY(&sequenced_checker_);
uint32_t total_requested_max_bitrate_ RTC_GUARDED_BY(&sequenced_checker_);
uint32_t allocated_without_feedback_ RTC_GUARDED_BY(&sequenced_checker_);
bool has_packet_feedback_ RTC_GUARDED_BY(&sequenced_checker_);
std::unique_ptr<rtc::BitrateAllocationStrategy> bitrate_allocation_strategy_
RTC_GUARDED_BY(&sequenced_checker_);
const uint8_t transmission_max_bitrate_multiplier_;

12
call/bitrate_allocator_unittest.cc
View file

@ -25,14 +25,6 @@ namespace webrtc {
// TODO(srte): Update tests to reflect new interface.
class LimitObserverWrapper : public BitrateAllocator::LimitObserver {
public:
void OnAllocationLimitsChanged(uint32_t min_send_bitrate_bps,
uint32_t max_padding_bitrate_bps,
uint32_t total_bitrate_bps,
uint32_t allocated_without_feedback_bps,
bool has_packet_feedback) override {
OnAllocationLimitsChanged(min_send_bitrate_bps, max_padding_bitrate_bps,
total_bitrate_bps);
}
virtual void OnAllocationLimitsChanged(uint32_t min_send_bitrate_bps,
uint32_t max_padding_bitrate_bps,
uint32_t total_bitrate_bps) = 0;
@ -107,7 +99,7 @@ class BitrateAllocatorTest : public ::testing::Test {
double bitrate_priority) {
allocator_->AddObserver(
observer, {min_bitrate_bps, max_bitrate_bps, pad_up_bitrate_bps,
enforce_min_bitrate, track_id, bitrate_priority, false});
enforce_min_bitrate, track_id, bitrate_priority});
}
NiceMock<MockLimitObserver> limit_observer_;
@ -240,7 +232,7 @@ class BitrateAllocatorTestNoEnforceMin : public ::testing::Test {
double bitrate_priority) {
allocator_->AddObserver(
observer, {min_bitrate_bps, max_bitrate_bps, pad_up_bitrate_bps,
enforce_min_bitrate, track_id, bitrate_priority, false});
enforce_min_bitrate, track_id, bitrate_priority});
}
NiceMock<MockLimitObserver> limit_observer_;
std::unique_ptr<BitrateAllocatorForTest> allocator_;

11
call/call.cc
View file

@ -220,9 +220,7 @@ class Call final : public webrtc::Call,
// Implements BitrateAllocator::LimitObserver.
void OnAllocationLimitsChanged(uint32_t min_send_bitrate_bps,
uint32_t max_padding_bitrate_bps,
uint32_t total_bitrate_bps,
uint32_t allocated_without_feedback_bps,
bool has_packet_feedback) override;
uint32_t total_bitrate_bps) override;
// This method is invoked when the media transport is created and when the
// media transport is being destructed.
@ -1178,14 +1176,9 @@ void Call::OnTargetTransferRate(TargetTransferRate msg) {
void Call::OnAllocationLimitsChanged(uint32_t min_send_bitrate_bps,
uint32_t max_padding_bitrate_bps,
uint32_t total_bitrate_bps,
uint32_t allocated_without_feedback_bps,
bool has_packet_feedback) {
uint32_t total_bitrate_bps) {
transport_send_ptr_->SetAllocatedSendBitrateLimits(
min_send_bitrate_bps, max_padding_bitrate_bps, total_bitrate_bps);
transport_send_ptr_->SetPerPacketFeedbackAvailable(has_packet_feedback);
transport_send_ptr_->SetAllocatedBitrateWithoutFeedback(
allocated_without_feedback_bps);
rtc::CritScope lock(&bitrate_crit_);
min_allocated_send_bitrate_bps_ = min_send_bitrate_bps;

23
call/rtp_transport_controller_send.cc
View file

@ -78,7 +78,6 @@ RtpTransportControllerSend::RtpTransportControllerSend(
field_trial::IsEnabled("WebRTC-AddPacingToCongestionWindowPushback")),
transport_overhead_bytes_per_packet_(0),
network_available_(false),
packet_feedback_available_(false),
retransmission_rate_limiter_(clock, kRetransmitWindowSizeMs),
task_queue_("rtp_send_controller") {
initial_config_.constraints = ConvertConstraints(bitrate_config, clock_);
@ -303,12 +302,6 @@ int64_t RtpTransportControllerSend::GetPacerQueuingDelayMs() const {
int64_t RtpTransportControllerSend::GetFirstPacketTimeMs() const {
return pacer_.FirstSentPacketTimeMs();
}
void RtpTransportControllerSend::SetPerPacketFeedbackAvailable(bool available) {
RTC_DCHECK_RUN_ON(&task_queue_);
packet_feedback_available_ = available;
if (!controller_)
MaybeCreateControllers();
}
void RtpTransportControllerSend::EnablePeriodicAlrProbing(bool enable) {
task_queue_.PostTask([this, enable]() {
RTC_DCHECK_RUN_ON(&task_queue_);
@ -373,22 +366,6 @@ void RtpTransportControllerSend::SetClientBitratePreferences(
}
}
void RtpTransportControllerSend::SetAllocatedBitrateWithoutFeedback(
uint32_t bitrate_bps) {
// Audio transport feedback will not be reported in this mode, instead update
// acknowledged bitrate estimator with the bitrate allocated for audio.
if (field_trial::IsEnabled("WebRTC-Audio-ABWENoTWCC")) {
// TODO(srte): Make sure it's safe to always report this and remove the
// field trial check.
task_queue_.PostTask([this, bitrate_bps]() {
RTC_DCHECK_RUN_ON(&task_queue_);
streams_config_.unacknowledged_rate_allocation =
DataRate::bps(bitrate_bps);
UpdateStreamsConfig();
});
}
}
void RtpTransportControllerSend::OnTransportOverheadChanged(
size_t transport_overhead_bytes_per_packet) {
if (transport_overhead_bytes_per_packet >= kMaxOverheadBytes) {

4
call/rtp_transport_controller_send.h
View file

@ -94,15 +94,12 @@ class RtpTransportControllerSend final
RtcpBandwidthObserver* GetBandwidthObserver() override;
int64_t GetPacerQueuingDelayMs() const override;
int64_t GetFirstPacketTimeMs() const override;
void SetPerPacketFeedbackAvailable(bool available) override;
void EnablePeriodicAlrProbing(bool enable) override;
void OnSentPacket(const rtc::SentPacket& sent_packet) override;
void SetSdpBitrateParameters(const BitrateConstraints& constraints) override;
void SetClientBitratePreferences(const BitrateSettings& preferences) override;
void SetAllocatedBitrateWithoutFeedback(uint32_t bitrate_bps) override;
void OnTransportOverheadChanged(
size_t transport_overhead_per_packet) override;
@ -178,7 +175,6 @@ class RtpTransportControllerSend final
// TODO(srte): Remove atomic when feedback adapter runs on task queue.
std::atomic<size_t> transport_overhead_bytes_per_packet_;
bool network_available_ RTC_GUARDED_BY(task_queue_);
bool packet_feedback_available_ RTC_GUARDED_BY(task_queue_);
RepeatingTaskHandle pacer_queue_update_task_ RTC_GUARDED_BY(task_queue_);
RepeatingTaskHandle controller_task_ RTC_GUARDED_BY(task_queue_);
// Protects access to last_packet_feedback_vector_ in feedback adapter.

3
call/rtp_transport_controller_send_interface.h
View file

@ -151,15 +151,12 @@ class RtpTransportControllerSendInterface {
virtual int64_t GetFirstPacketTimeMs() const = 0;
virtual void EnablePeriodicAlrProbing(bool enable) = 0;
virtual void OnSentPacket(const rtc::SentPacket& sent_packet) = 0;
virtual void SetPerPacketFeedbackAvailable(bool available) = 0;
virtual void SetSdpBitrateParameters(
const BitrateConstraints& constraints) = 0;
virtual void SetClientBitratePreferences(
const BitrateSettings& preferences) = 0;
virtual void SetAllocatedBitrateWithoutFeedback(uint32_t bitrate_bps) = 0;
virtual void OnTransportOverheadChanged(
size_t transport_overhead_per_packet) = 0;
};

2
call/test/mock_rtp_transport_controller_send.h
View file

@ -63,12 +63,10 @@ class MockRtpTransportControllerSend
MOCK_METHOD0(GetBandwidthObserver, RtcpBandwidthObserver*());
MOCK_CONST_METHOD0(GetPacerQueuingDelayMs, int64_t());
MOCK_CONST_METHOD0(GetFirstPacketTimeMs, int64_t());
MOCK_METHOD1(SetPerPacketFeedbackAvailable, void(bool));
MOCK_METHOD1(EnablePeriodicAlrProbing, void(bool));
MOCK_METHOD1(OnSentPacket, void(const rtc::SentPacket&));
MOCK_METHOD1(SetSdpBitrateParameters, void(const BitrateConstraints&));
MOCK_METHOD1(SetClientBitratePreferences, void(const BitrateSettings&));
MOCK_METHOD1(SetAllocatedBitrateWithoutFeedback, void(uint32_t));
MOCK_METHOD1(OnTransportOverheadChanged, void(size_t));
};
} // namespace webrtc

2
modules/congestion_controller/bbr/bbr_network_controller.cc
View file

@ -323,8 +323,6 @@ NetworkControlUpdate BbrNetworkController::OnProcessInterval(
}
NetworkControlUpdate BbrNetworkController::OnStreamsConfig(StreamsConfig msg) {
// TODO(srte): Handle unacknowledged rate allocation.
RTC_DCHECK(msg.unacknowledged_rate_allocation.IsZero());
return NetworkControlUpdate();
}

24
modules/congestion_controller/goog_cc/acknowledged_bitrate_estimator.cc
View file

@ -38,10 +38,7 @@ AcknowledgedBitrateEstimator::~AcknowledgedBitrateEstimator() {}
AcknowledgedBitrateEstimator::AcknowledgedBitrateEstimator(
const WebRtcKeyValueConfig* key_value_config,
std::unique_ptr<BitrateEstimator> bitrate_estimator)
: account_for_unacknowledged_traffic_(
key_value_config->Lookup("WebRTC-Bwe-AccountForUnacked")
.find("Enabled") == 0),
bitrate_estimator_(std::move(bitrate_estimator)) {}
: bitrate_estimator_(std::move(bitrate_estimator)) {}
void AcknowledgedBitrateEstimator::IncomingPacketFeedbackVector(
const std::vector<PacketFeedback>& packet_feedback_vector) {
@ -52,24 +49,14 @@ void AcknowledgedBitrateEstimator::IncomingPacketFeedbackVector(
if (IsInSendTimeHistory(packet)) {
MaybeExpectFastRateChange(packet.send_time_ms);
int acknowledged_estimate = rtc::dchecked_cast<int>(packet.payload_size);
if (account_for_unacknowledged_traffic_)
acknowledged_estimate += packet.unacknowledged_data;
acknowledged_estimate += packet.unacknowledged_data;
bitrate_estimator_->Update(packet.arrival_time_ms, acknowledged_estimate);
}
}
}
absl::optional<uint32_t> AcknowledgedBitrateEstimator::bitrate_bps() const {
auto estimated_bitrate = bitrate_estimator_->bitrate_bps();
// If we account for unacknowledged traffic, we should not add the allocated
// bitrate for unallocated stream as we expect it to be included already.
if (account_for_unacknowledged_traffic_) {
return estimated_bitrate;
} else {
return estimated_bitrate
? *estimated_bitrate + allocated_bitrate_without_feedback_bps_
: estimated_bitrate;
}
return bitrate_estimator_->bitrate_bps();
}
absl::optional<uint32_t> AcknowledgedBitrateEstimator::PeekBps() const {
@ -93,11 +80,6 @@ void AcknowledgedBitrateEstimator::SetAlrEndedTimeMs(
alr_ended_time_ms_.emplace(alr_ended_time_ms);
}
void AcknowledgedBitrateEstimator::SetAllocatedBitrateWithoutFeedback(
uint32_t bitrate_bps) {
allocated_bitrate_without_feedback_bps_ = bitrate_bps;
}
void AcknowledgedBitrateEstimator::MaybeExpectFastRateChange(
int64_t packet_send_time_ms) {
if (alr_ended_time_ms_ && packet_send_time_ms > *alr_ended_time_ms_) {

3
modules/congestion_controller/goog_cc/acknowledged_bitrate_estimator.h
View file

@ -40,14 +40,11 @@ class AcknowledgedBitrateEstimator {
absl::optional<DataRate> bitrate() const;
absl::optional<DataRate> PeekRate() const;
void SetAlrEndedTimeMs(int64_t alr_ended_time_ms);
void SetAllocatedBitrateWithoutFeedback(uint32_t bitrate_bps);
private:
void MaybeExpectFastRateChange(int64_t packet_arrival_time_ms);
const bool account_for_unacknowledged_traffic_;
absl::optional<int64_t> alr_ended_time_ms_;
std::unique_ptr<BitrateEstimator> bitrate_estimator_;
uint32_t allocated_bitrate_without_feedback_bps_ = 0;
};
} // namespace webrtc

2
modules/congestion_controller/goog_cc/goog_cc_network_control.cc
View file

@ -333,8 +333,6 @@ NetworkControlUpdate GoogCcNetworkController::OnStreamsConfig(
max_padding_rate_ = *msg.max_padding_rate;
pacing_changed = true;
}
acknowledged_bitrate_estimator_->SetAllocatedBitrateWithoutFeedback(
msg.unacknowledged_rate_allocation.bps());
if (pacing_changed)
update.pacer_config = GetPacingRates(msg.at_time);

2
modules/congestion_controller/pcc/pcc_network_controller.cc
View file

@ -373,8 +373,6 @@ NetworkControlUpdate PccNetworkController::OnTransportLossReport(
}
NetworkControlUpdate PccNetworkController::OnStreamsConfig(StreamsConfig msg) {
// TODO(srte): Handle unacknowledged rate allocation.
RTC_DCHECK(msg.unacknowledged_rate_allocation.IsZero());
return NetworkControlUpdate();
}

2
modules/congestion_controller/send_side_congestion_controller.cc
View file

@ -475,8 +475,6 @@ void DEPRECATED_SendSideCongestionController::SetPacingFactor(
void DEPRECATED_SendSideCongestionController::
SetAllocatedBitrateWithoutFeedback(uint32_t bitrate_bps) {
acknowledged_bitrate_estimator_->SetAllocatedBitrateWithoutFeedback(
bitrate_bps);
}
void DEPRECATED_SendSideCongestionController::MaybeTriggerOnNetworkChanged() {

6
video/video_send_stream_impl.cc
View file

@ -375,7 +375,7 @@ void VideoSendStreamImpl::StartupVideoSendStream() {
static_cast<uint32_t>(encoder_min_bitrate_bps_),
encoder_max_bitrate_bps_, static_cast<uint32_t>(max_padding_bitrate_),
!config_->suspend_below_min_bitrate, config_->track_id,
encoder_bitrate_priority_, has_packet_feedback_});
encoder_bitrate_priority_});
// Start monitoring encoder activity.
{
RTC_DCHECK(!check_encoder_activity_task_.Running());
@ -488,7 +488,7 @@ void VideoSendStreamImpl::SignalEncoderActive() {
static_cast<uint32_t>(encoder_min_bitrate_bps_),
encoder_max_bitrate_bps_, static_cast<uint32_t>(max_padding_bitrate_),
!config_->suspend_below_min_bitrate, config_->track_id,
encoder_bitrate_priority_, has_packet_feedback_});
encoder_bitrate_priority_});
}
void VideoSendStreamImpl::OnEncoderConfigurationChanged(
@ -557,7 +557,7 @@ void VideoSendStreamImpl::OnEncoderConfigurationChanged(
encoder_max_bitrate_bps_,
static_cast<uint32_t>(max_padding_bitrate_),
!config_->suspend_below_min_bitrate, config_->track_id,
encoder_bitrate_priority_, has_packet_feedback_});
encoder_bitrate_priority_});
}
}

23
video/video_send_stream_impl_unittest.cc
View file

@ -166,7 +166,6 @@ TEST_F(VideoSendStreamImplTest, RegistersAsBitrateObserverOnStart) {
EXPECT_EQ(config.enforce_min_bitrate, !kSuspend);
EXPECT_EQ(config.track_id, "test");
EXPECT_EQ(config.bitrate_priority, kDefaultBitratePriority);
EXPECT_EQ(config.has_packet_feedback, false);
}));
vss_impl->Start();
EXPECT_CALL(bitrate_allocator_, RemoveObserver(vss_impl.get())).Times(1);
@ -224,7 +223,6 @@ TEST_F(VideoSendStreamImplTest, UpdatesObserverOnConfigurationChange) {
static_cast<uint32_t>(qvga_stream.target_bitrate_bps +
vga_stream.min_bitrate_bps));
EXPECT_EQ(config.enforce_min_bitrate, !kSuspend);
EXPECT_EQ(config.has_packet_feedback, true);
}));
static_cast<VideoStreamEncoderInterface::EncoderSink*>(vss_impl.get())
@ -289,7 +287,6 @@ TEST_F(VideoSendStreamImplTest, UpdatesObserverOnConfigurationChangeWithAlr) {
EXPECT_EQ(config.pad_up_bitrate_bps,
static_cast<uint32_t>(min_transmit_bitrate_bps));
EXPECT_EQ(config.enforce_min_bitrate, !kSuspend);
EXPECT_EQ(config.has_packet_feedback, true);
}));
static_cast<VideoStreamEncoderInterface::EncoderSink*>(vss_impl.get())
@ -300,26 +297,6 @@ TEST_F(VideoSendStreamImplTest, UpdatesObserverOnConfigurationChangeWithAlr) {
});
}
TEST_F(VideoSendStreamImplTest, ReportFeedbackAvailability) {
test_queue_.SendTask([this] {
config_.rtp.extensions.emplace_back(
RtpExtension::kTransportSequenceNumberUri,
RtpExtension::kTransportSequenceNumberDefaultId);
auto vss_impl = CreateVideoSendStreamImpl(
kDefaultInitialBitrateBps, kDefaultBitratePriority,
VideoEncoderConfig::ContentType::kRealtimeVideo);
EXPECT_CALL(bitrate_allocator_, AddObserver(vss_impl.get(), _))
.WillOnce(Invoke(
[&](BitrateAllocatorObserver*, MediaStreamAllocationConfig config) {
EXPECT_EQ(config.has_packet_feedback, true);
}));
vss_impl->Start();
EXPECT_CALL(bitrate_allocator_, RemoveObserver(vss_impl.get())).Times(1);
vss_impl->Stop();
});
}
TEST_F(VideoSendStreamImplTest, SetsScreensharePacingFactorWithFeedback) {
test::ScopedFieldTrials alr_experiment(GetAlrProbingExperimentString());