More Simulation Framework features

webrtc/modules/remote_bitrate_estimator/test/packet_sender.cc

Index: webrtc/modules/remote_bitrate_estimator/test/packet_sender.cc
diff --git a/webrtc/modules/remote_bitrate_estimator/test/packet_sender.cc b/webrtc/modules/remote_bitrate_estimator/test/packet_sender.cc
index eeaec865898dd5cd48798cf38a3d40f848c935ba..82122d4f0004e9e948138f9abfa6dbebff94b78d 100644
--- a/webrtc/modules/remote_bitrate_estimator/test/packet_sender.cc
+++ b/webrtc/modules/remote_bitrate_estimator/test/packet_sender.cc
@@ -44,12 +44,14 @@ VideoSender::VideoSender(PacketProcessorListener* listener,
                          VideoSource* source,
                          BandwidthEstimatorType estimator_type)
     : PacketSender(listener, source->flow_id()),
+      running_(true),
       source_(source),
       bwe_(CreateBweSender(estimator_type,
                            source_->bits_per_second() / 1000,
                            this,
                            &clock_)) {
   modules_.push_back(bwe_.get());
+  source->set_alg_name(bwe_names[estimator_type]);
 }
 
 VideoSender::~VideoSender() {
@@ -76,16 +78,22 @@ void VideoSender::ProcessFeedbackAndGeneratePackets(
           std::max<int64_t>(std::min(time_ms, time_until_feedback_ms), 0);
     }
     Packets generated;
+
     source_->RunFor(time_to_run_ms, &generated);
     bwe_->OnPacketsSent(generated);
+
     packets->merge(generated, DereferencingComparator<Packet>);
+
     clock_.AdvanceTimeMilliseconds(time_to_run_ms);
+
     if (!feedbacks->empty()) {
       bwe_->GiveFeedback(*feedbacks->front());
       delete feedbacks->front();
       feedbacks->pop_front();
     }
+
     bwe_->Process();
+
     time_ms -= time_to_run_ms;
   } while (time_ms > 0);
   assert(feedbacks->empty());
@@ -101,6 +109,18 @@ void VideoSender::OnNetworkChanged(uint32_t target_bitrate_bps,
   source_->SetBitrateBps(target_bitrate_bps);
 }
 
+void VideoSender::Pause() {
+  running_ = false;
+  source_->Pause();
+  bwe_->Pause();
+}
+
+void VideoSender::Resume() {
+  running_ = true;
+  source_->Resume();
+  bwe_->Resume();
+}
+
 PacedVideoSender::PacedVideoSender(PacketProcessorListener* listener,
                                    VideoSource* source,
                                    BandwidthEstimatorType estimator)
@@ -262,11 +282,56 @@ void PacedVideoSender::OnNetworkChanged(uint32_t target_bitrate_bps,
       PacedSender::kDefaultPaceMultiplier * target_bitrate_bps / 1000, 0);
 }
 
+const int kNoLimit = std::numeric_limits<int>::max();
+const int kPacketSizeBytes = 1200;
+
+TcpSender::TcpSender(PacketProcessorListener* listener,
+                     int flow_id,
+                     int64_t offset_ms)
+    : PacketSender(listener, flow_id),
+      cwnd_(10),
+      ssthresh_(kNoLimit),
+      ack_received_(false),
+      last_acked_seq_num_(0),
+      next_sequence_number_(0),
+      offset_ms_(offset_ms),
+      last_reduction_time_ms_(-1),
+      last_rtt_ms_(0),
+      total_sent_bytes_(0),
+      send_limit_bytes_(kNoLimit),
+      running_(true),
+      last_generated_packets_ms_(0),
+      estimated_kbps_(0),

[stefan-webrtc, 2015/06/25 14:44:05]

bitrate_kbps_?

[magalhaesc, 2015/07/01 12:48:41]

Done.

+      num_recent_sent_packets_(0) {
+}
+
+TcpSender::TcpSender(PacketProcessorListener* listener,
+                     int flow_id,
+                     int64_t offset_ms,
+                     int send_limit_bytes)
+    : TcpSender(listener, flow_id, offset_ms) {
+  send_limit_bytes_ = send_limit_bytes;
+}
+
+void TcpSender::set_choke_filter(ChokeFilter* choke_filter) {
+  choke_filter_ = choke_filter;
+}
+
 void TcpSender::RunFor(int64_t time_ms, Packets* in_out) {
   if (clock_.TimeInMilliseconds() + time_ms < offset_ms_) {
     clock_.AdvanceTimeMilliseconds(time_ms);
+    if (running_) {
+      choke_filter_->PauseFlow(*flow_ids().begin());
+      running_ = false;
+    }
     return;
   }
+
+  if (!running_) {
+    choke_filter_->ResumeFlow(*flow_ids().begin());
+    running_ = true;
+  }
+
   int64_t start_time_ms = clock_.TimeInMilliseconds();
   BWE_TEST_LOGGING_CONTEXT("Sender");
   BWE_TEST_LOGGING_CONTEXT(*flow_ids().begin());
@@ -359,13 +424,39 @@ void TcpSender::HandleLoss() {
 
 Packets TcpSender::GeneratePackets(size_t num_packets) {
   Packets generated;
+
+  num_recent_sent_packets_ += num_packets;
+
+  // Used to update estimated bitrate.
+  const int kTimeWindowMs = 500;
+
+  int64_t delta_ms = clock_.TimeInMilliseconds() - last_generated_packets_ms_;
+  if (delta_ms >= kTimeWindowMs) {
+    estimated_kbps_ =
+        static_cast<uint32_t>(8 * num_recent_sent_packets_ * kPacketSizeBytes) /
+        delta_ms;
+    last_generated_packets_ms_ = clock_.TimeInMilliseconds();
+    num_recent_sent_packets_ = 0;
+  }

[stefan-webrtc, 2015/06/25 14:44:05]

Can we break this out to a method UpdateSendBitrateEstimate()?

[magalhaesc, 2015/07/01 12:48:41]

Sure

+
   for (size_t i = 0; i < num_packets; ++i) {
-    generated.push_back(new MediaPacket(*flow_ids().begin(),
-                                        1000 * clock_.TimeInMilliseconds(),
-                                        1200, next_sequence_number_++));
+    if ((total_sent_bytes_ + kPacketSizeBytes) > send_limit_bytes_) {
+      if (running_) {
+        choke_filter_->PauseFlow(*flow_ids().begin());
+        running_ = false;
+      }
+      break;
+    }
+    generated.push_back(
+        new MediaPacket(*flow_ids().begin(), 1000 * clock_.TimeInMilliseconds(),
+                        kPacketSizeBytes, next_sequence_number_++));
     generated.back()->set_sender_timestamp_us(
         1000 * clock_.TimeInMilliseconds());
+
+    generated.back()->set_sending_estimate_kbps(estimated_kbps_);
+    total_sent_bytes_ += kPacketSizeBytes;
   }
+
   return generated;
 }
 }  // namespace bwe