[fix] fix pacer rate setting

src/qos/bitrate_prober.cc

@@ -60,7 +60,6 @@ void BitrateProber::MaybeSetActiveState(DataSize packet_size) {
   if (ReadyToSetActiveState(packet_size)) {
     next_probe_time_ = Timestamp::MinusInfinity();
     probing_state_ = ProbingState::kActive;
-    LOG_WARN("Probing set to active");
   }
 }
 
@@ -111,14 +110,8 @@ void BitrateProber::CreateProbeCluster(
   cluster.pace_info.send_bitrate = cluster_config.target_data_rate;
   cluster.pace_info.probe_cluster_id = cluster_config.id;
   clusters_.push(cluster);
-  LOG_WARN("a1 clusters size = {}", clusters_.size());
-  MaybeSetActiveState(/*packet_size=*/DataSize::Zero());
 
-  LOG_INFO("Probe cluster (bitrate_bps:min bytes:min packets): ({}:{}:{}, {})",
-           cluster.pace_info.send_bitrate.bps(),
-           cluster.pace_info.probe_cluster_min_bytes,
-           cluster.pace_info.probe_cluster_min_probes,
-           probing_state_ == ProbingState::kInactive ? "Inactive" : "Active");
+  MaybeSetActiveState(/*packet_size=*/DataSize::Zero());
 }
 
 Timestamp BitrateProber::NextProbeTime(Timestamp /* now */) const {

src/qos/pacing_controller.cc

@@ -169,8 +169,8 @@ void PacingController::SetPacingRates(DataRate pacing_rate,
   padding_rate_ = padding_rate;
   MaybeUpdateMediaRateDueToLongQueue(CurrentTime());
 
-  LOG_INFO("bwe:pacer_updated pacing_kbps={} padding_budget_kbps={}",
-           pacing_rate_.kbps(), padding_rate.kbps());
+  // LOG_INFO("bwe:pacer_updated pacing_kbps={} padding_budget_kbps={}",
+  //          pacing_rate_.kbps(), padding_rate.kbps());
 }
 
 void PacingController::EnqueuePacket(std::unique_ptr<RtpPacketToSend> packet) {
@@ -200,6 +200,7 @@ void PacingController::EnqueuePacket(std::unique_ptr<RtpPacketToSend> packet) {
     }
     UpdateBudgetWithElapsedTime(UpdateTimeAndGetElapsed(target_process_time));
   }
+
   packet_queue_.Push(now, std::move(packet));
   seen_first_packet_ = true;
 
@@ -361,7 +362,6 @@ void PacingController::ProcessPackets() {
       });
   const Timestamp now = CurrentTime();
   Timestamp target_send_time = now;
-
   if (ShouldSendKeepalive(now)) {
     DataSize keepalive_data_sent = DataSize::Zero();
     // We can not send padding unless a normal packet has first been sent. If
@@ -464,7 +464,6 @@ void PacingController::ProcessPackets() {
                        transport_overhead_per_packet_;
       }
 
-      // LOG_ERROR("Send packet_size {}", rtp_packet->Size());
       packet_sender_->SendPacket(std::move(rtp_packet), pacing_info);
       for (auto& packet : packet_sender_->FetchFec()) {
         EnqueuePacket(std::move(packet));

src/qos/probe_controller.cc

@@ -108,7 +108,6 @@ std::vector<ProbeClusterConfig> ProbeController::SetBitrates(
   if (start_bitrate > DataRate::Zero()) {
     start_bitrate_ = start_bitrate;
     estimated_bitrate_ = start_bitrate;
-    LOG_WARN("1 setting estimated_bitrate_ = {}", estimated_bitrate_.bps());
   } else if (start_bitrate_.IsZero()) {
     start_bitrate_ = min_bitrate;
   }
@@ -235,7 +234,7 @@ std::vector<ProbeClusterConfig> ProbeController::InitiateExponentialProbing(
     LOG_INFO("Repeated initial probing enabled, last allowed probe: {} now: {}",
              last_allowed_repeated_initial_probe_.ms(), at_time.ms());
   }
-  LOG_WARN("InitiateExponentialProbing");
+
   return InitiateProbing(at_time, probes, true);
 }
 
@@ -344,7 +343,6 @@ void ProbeController::Reset(Timestamp at_time) {
   min_bitrate_to_probe_further_ = DataRate::PlusInfinity();
   time_last_probing_initiated_ = Timestamp::Zero();
   estimated_bitrate_ = DataRate::Zero();
-  LOG_WARN("3 setting estimated_bitrate_ = {}", estimated_bitrate_.bps());
   network_estimate_ = std::nullopt;
   start_bitrate_ = DataRate::Zero();
   max_bitrate_ = kDefaultMaxProbingBitrate;
@@ -422,16 +420,11 @@ std::vector<ProbeClusterConfig> ProbeController::Process(Timestamp at_time) {
     return {};
   }
   if (TimeForNextRepeatedInitialProbe(at_time)) {
-    LOG_WARN(
-        "InitiateProbing TimeForNextRepeatedInitialProbe, estimated_bitrate_ = "
-        "{}",
-        estimated_bitrate_.bps());
     return InitiateProbing(
         at_time, {estimated_bitrate_ * config_.first_exponential_probe_scale},
         true);
   }
   if (TimeForAlrProbe(at_time) || TimeForNetworkStateProbe(at_time)) {
-    LOG_WARN("InitiateProbing TimeForNetworkStateProbe");
     return InitiateProbing(
         at_time, {estimated_bitrate_ * config_.alr_probe_scale}, true);
   }

src/transport/ice_transport_controller.cpp

@@ -17,6 +17,7 @@ IceTransportController::IceTransportController(
       audio_codec_inited_(false),
       load_nvcodec_dll_success_(false),
       hardware_acceleration_(false),
+      congestion_window_size_(DataSize::PlusInfinity()),
       clock_(clock),
       webrtc_clock_(webrtc::Clock::GetWebrtcClockShared(clock)) {
   SetPeriod(std::chrono::milliseconds(25));
@@ -515,7 +516,20 @@ void IceTransportController::OnSentRtpPacket(
 }
 
 void IceTransportController::PostUpdates(webrtc::NetworkControlUpdate update) {
-  // UpdateControlState();
+  if (update.congestion_window) {
+    congestion_window_size_ = *update.congestion_window;
+    UpdateCongestedState();
+  }
+
+  if (update.pacer_config) {
+    packet_sender_->SetPacingRates(update.pacer_config->data_rate(),
+                                   update.pacer_config->pad_rate());
+  }
+
+  if (!update.probe_cluster_configs.empty()) {
+    packet_sender_->CreateProbeClusters(
+        std::move(update.probe_cluster_configs));
+  }
 
   if (update.target_rate) {
     int target_bitrate = update.target_rate.has_value()
@@ -543,11 +557,7 @@ void IceTransportController::PostUpdates(webrtc::NetworkControlUpdate update) {
       video_encoder_->SetTargetBitrate(target_bitrate_);
       // LOG_WARN("Set target bitrate [{}]bps", target_bitrate_);
     }
-  }
-
-  if (!update.probe_cluster_configs.empty()) {
-    packet_sender_->CreateProbeClusters(
-        std::move(update.probe_cluster_configs));
+    UpdateControlState();
   }
 }
 
@@ -557,10 +567,19 @@ void IceTransportController::UpdateControlState() {
 }
 
 void IceTransportController::UpdateCongestedState() {
-  if (controller_) {
+  if (auto update = GetCongestedStateUpdate()) {
+    is_congested_ = update.value();
+    packet_sender_->SetCongested(update.value());
   }
 }
 
+std::optional<bool> IceTransportController::GetCongestedStateUpdate() const {
+  bool congested = transport_feedback_adapter_.GetOutstandingData() >=
+                   congestion_window_size_;
+  if (congested != is_congested_) return congested;
+  return std::nullopt;
+}
+
 bool IceTransportController::Process() {
   webrtc::ProcessInterval msg;
   msg.at_time = Timestamp::Millis(webrtc_clock_->TimeInMilliseconds());

src/transport/ice_transport_controller.h

@@ -88,6 +88,7 @@ class IceTransportController
   void PostUpdates(webrtc::NetworkControlUpdate update);
   void UpdateControlState();
   void UpdateCongestedState();
+  std::optional<bool> GetCongestedStateUpdate() const;
 
  private:
   bool Process() override;
@@ -119,6 +120,8 @@ class IceTransportController
   webrtc::TransportFeedbackAdapter transport_feedback_adapter_;
   std::unique_ptr<CongestionControl> controller_;
   BitrateProber prober_;
+  webrtc::DataSize congestion_window_size_;
+  bool is_congested_ = false;
 
  private:
   std::unique_ptr<VideoEncoder> video_encoder_ = nullptr;

src/transport/packet_sender/packet_sender_imp.cpp

@@ -17,7 +17,8 @@ PacketSenderImp::PacketSenderImp(std::shared_ptr<IceAgent> ice_agent,
       is_shutdown_(false),
       packet_size_(/*alpha=*/0.95),
       include_overhead_(false),
-      last_send_time_(webrtc::Timestamp::Millis(0)) {}
+      last_send_time_(webrtc::Timestamp::Millis(0)),
+      last_call_time_(webrtc::Timestamp::Millis(0)) {}
 
 PacketSenderImp::~PacketSenderImp() {}
 
@@ -281,6 +282,9 @@ int PacketSenderImp::EnqueueRtpPacket(
         break;
     }
 
+    // webrtc::PacedPacketInfo cluster_info;
+    // SendPacket(std::move(rtp_packet_to_send), cluster_info);
+
     to_send_rtp_packets.push_back(std::move(rtp_packet_to_send));
   }
 

src/transport/packet_sender/packet_sender_imp.h

@@ -60,7 +60,6 @@ class PacketSenderImp : public PacketSender,
       }
 
       packet->UpdateSequenceNumber(ssrc_seq_[packet->Ssrc()]++);
-
       on_sent_packet_func_(*packet);
     }
   }
@@ -218,6 +217,7 @@ class PacketSenderImp : public PacketSender,
   std::map<int32_t, int16_t> ssrc_seq_;
 
   webrtc::Timestamp last_send_time_;
+  webrtc::Timestamp last_call_time_;
 };
 
 #endif