More Simulation Framework features

webrtc/modules/remote_bitrate_estimator/test/bwe_test_framework.cc

 /*
  *  Copyright (c) 2013 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 "webrtc/modules/remote_bitrate_estimator/test/bwe_test_framework.h"
 
 #include <stdio.h>
 
 #include <sstream>
 
 namespace webrtc {
 namespace testing {
 namespace bwe {
 
 class DelayCapHelper {
  public:
+  // Max delay = 0 stands for +infinite.
   DelayCapHelper() : max_delay_us_(0), delay_stats_() {}
 
-  void SetMaxDelay(int max_delay_ms) {
+  void SetMaxDelayMs(int64_t max_delay_ms) {
     BWE_TEST_LOGGING_ENABLE(false);
     BWE_TEST_LOGGING_LOG1("Max Delay", "%d ms", static_cast<int>(max_delay_ms));
     assert(max_delay_ms >= 0);
     max_delay_us_ = max_delay_ms * 1000;
   }
 
   bool ShouldSendPacket(int64_t send_time_us, int64_t arrival_time_us) {
     int64_t packet_delay_us = send_time_us - arrival_time_us;
     delay_stats_.Push(std::min(packet_delay_us, max_delay_us_) / 1000);
     return (max_delay_us_ == 0 || max_delay_us_ >= packet_delay_us);
   }
 
   const Stats<double>& delay_stats() const {
     return delay_stats_;
   }
 
  private:
   int64_t max_delay_us_;
   Stats<double> delay_stats_;
 
   DISALLOW_COPY_AND_ASSIGN(DelayCapHelper);
 };
 
 const FlowIds CreateFlowIds(const int *flow_ids_array, size_t num_flow_ids) {
   FlowIds flow_ids(&flow_ids_array[0], flow_ids_array + num_flow_ids);
   return flow_ids;
 }
 
-class RateCounter {
- public:
-  RateCounter()
-      : kWindowSizeUs(1000000),
-        packets_per_second_(0),
-        bytes_per_second_(0),
-        last_accumulated_us_(0),
-        window_() {}
+const FlowIds CreateFlowIdRange(int initial_value, int last_value) {
+  int size = last_value - initial_value + 1;
+  assert(size > 0);
+  int* flow_ids_array = new int[size];
+  for (int i = initial_value; i <= last_value; ++i) {
+    flow_ids_array[i - initial_value] = i;
+  }
+  return CreateFlowIds(flow_ids_array, size);
+}
 
-  void UpdateRates(int64_t send_time_us, uint32_t payload_size) {
-    packets_per_second_++;
-    bytes_per_second_ += payload_size;
-    last_accumulated_us_ = send_time_us;
-    window_.push_back(std::make_pair(send_time_us, payload_size));
-    while (!window_.empty()) {
-      const TimeSizePair& packet = window_.front();
-      if (packet.first > (last_accumulated_us_ - kWindowSizeUs)) {
-        break;
-      }
-      assert(packets_per_second_ >= 1);
-      assert(bytes_per_second_ >= packet.second);
-      packets_per_second_--;
-      bytes_per_second_ -= packet.second;
-      window_.pop_front();
+void RateCounter::UpdateRates(int64_t send_time_us, uint32_t payload_size) {
+  packets_per_second_++;
+  bytes_per_second_ += payload_size;
+  last_accumulated_us_ = send_time_us;
+  window_.push_back(std::make_pair(send_time_us, payload_size));
+  while (!window_.empty()) {
+    const TimeSizePair& packet = window_.front();
+    if (packet.first > (last_accumulated_us_ - kWindowSizeUs)) {
+      break;
     }
+    assert(packets_per_second_ >= 1);
+    assert(bytes_per_second_ >= packet.second);
+    packets_per_second_--;
+    bytes_per_second_ -= packet.second;
+    window_.pop_front();
   }
-
-  uint32_t bits_per_second() const {
-    return bytes_per_second_ * 8;
-  }
-
-  uint32_t packets_per_second() const { return packets_per_second_; }
-
- private:
-  typedef std::pair<int64_t, uint32_t> TimeSizePair;
-
-  const int64_t kWindowSizeUs;
-  uint32_t packets_per_second_;
-  uint32_t bytes_per_second_;
-  int64_t last_accumulated_us_;
-  std::list<TimeSizePair> window_;
-};
+}
 
 Random::Random(uint32_t seed)
     : a_(0x531FDB97 ^ seed),
       b_(0x6420ECA8 + seed) {
 }
 
 float Random::Rand() {
   const float kScale = 1.0f / 0xffffffff;
   float result = kScale * b_;
   a_ ^= b_;
   b_ += a_;
   return result;
 }
 
+int Random::Rand(int low, int high) {
+  float uniform = Rand() * (high - low + 1) + low;
+  return static_cast<int>(uniform);
+}
+
 int Random::Gaussian(int mean, int standard_deviation) {
   // Creating a Normal distribution variable from two independent uniform
   // variables based on the Box-Muller transform, which is defined on the
   // interval (0, 1], hence the mask+add below.
   const double kPi = 3.14159265358979323846;
   const double kScale = 1.0 / 0x80000000ul;
   double u1 = kScale * ((a_ & 0x7ffffffful) + 1);
   double u2 = kScale * ((b_ & 0x7ffffffful) + 1);
   a_ ^= b_;
   b_ += a_;
   return static_cast<int>(mean + standard_deviation *
       sqrt(-2 * log(u1)) * cos(2 * kPi * u2));
 }
 
+int Random::Exponential(float lambda) {
+  float uniform = Rand();
+  return static_cast<int>(-log(uniform) / lambda);
+}
+
 Packet::Packet()
-    : flow_id_(0), creation_time_us_(-1), send_time_us_(-1), payload_size_(0) {
+    : flow_id_(0),
+      creation_time_us_(-1),
+      send_time_us_(-1),
+      payload_size_(0),
+      sending_estimate_kbps_(0) {
 }
 
 Packet::Packet(int flow_id, int64_t send_time_us, size_t payload_size)
     : flow_id_(flow_id),
       creation_time_us_(send_time_us),
       send_time_us_(send_time_us),
-      payload_size_(payload_size) {
+      payload_size_(payload_size),
+      sending_estimate_kbps_(0),
+      total_capacity_kbps_(0),
+      capacity_per_flow_kbps_(0) {

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

As discussed offline, we should find a better way to do this. I currently don't
know exactly why you need it, so I can't yet propose a better way...

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

Fields removed from Packet class.

 }
 
 Packet::~Packet() {
 }
 
 bool Packet::operator<(const Packet& rhs) const {
   return send_time_us_ < rhs.send_time_us_;
 }
 
 void Packet::set_send_time_us(int64_t send_time_us) {
   assert(send_time_us >= 0);
   send_time_us_ = send_time_us;
 }
 
+void Packet::set_sending_estimate_kbps(uint32_t sending_estimate_kbps) {
+  sending_estimate_kbps_ = sending_estimate_kbps;
+}
+
+void Packet::set_total_capacity_kbps(uint32_t total_capacity_kbps) {
+  total_capacity_kbps_ = total_capacity_kbps;
+}
+
+void Packet::set_capacity_per_flow_kbps(uint32_t capacity_per_flow_kbps) {
+  capacity_per_flow_kbps_ = capacity_per_flow_kbps;
+}
+
 MediaPacket::MediaPacket() {
   memset(&header_, 0, sizeof(header_));
 }
 
 MediaPacket::MediaPacket(int flow_id,
                          int64_t send_time_us,
                          size_t payload_size,
                          uint16_t sequence_number)
     : Packet(flow_id, send_time_us, payload_size) {
   header_ = RTPHeader();
@@ skipping 45 matching lines @@
       return false;
     }
     last_it = it;
   }
   return true;
 }
 
 PacketProcessor::PacketProcessor(PacketProcessorListener* listener,
                                  int flow_id,
                                  ProcessorType type)
-    : listener_(listener), flow_ids_(&flow_id, &flow_id + 1) {
+    : rate_counter_(new RateCounter()),
+      listener_(listener),
+      flow_ids_(&flow_id, &flow_id + 1) {
   if (listener_) {
     listener_->AddPacketProcessor(this, type);
   }
 }
 
 PacketProcessor::PacketProcessor(PacketProcessorListener* listener,
                                  const FlowIds& flow_ids,
                                  ProcessorType type)
-    : listener_(listener), flow_ids_(flow_ids) {
+    : rate_counter_(new RateCounter()),
+      listener_(listener),
+      flow_ids_(flow_ids) {
   if (listener_) {
     listener_->AddPacketProcessor(this, type);
   }
 }
 
 PacketProcessor::~PacketProcessor() {
   if (listener_) {
     listener_->RemovePacketProcessor(this);
   }
 }
 
+uint32_t PacketProcessor::packets_per_second() const {
+  return rate_counter_->packets_per_second();
+}
+
+uint32_t PacketProcessor::bits_per_second() const {
+  return rate_counter_->bits_per_second();
+}
+
 RateCounterFilter::RateCounterFilter(PacketProcessorListener* listener,
                                      int flow_id,
                                      const char* name)
     : PacketProcessor(listener, flow_id, kRegular),
-      rate_counter_(new RateCounter()),
       packets_per_second_stats_(),
       kbps_stats_(),
-      name_() {
+      name_(),
+      start_plotting_ms_(0) {
   std::stringstream ss;
   ss << name << "_" << flow_id;
   name_ = ss.str();
 }
 
 RateCounterFilter::RateCounterFilter(PacketProcessorListener* listener,
                                      const FlowIds& flow_ids,
                                      const char* name)
     : PacketProcessor(listener, flow_ids, kRegular),
-      rate_counter_(new RateCounter()),
       packets_per_second_stats_(),
       kbps_stats_(),
-      name_() {
+      name_(),
+      start_plotting_ms_(0) {
   std::stringstream ss;
   ss << name << "_";
   for (int flow_id : flow_ids) {
     ss << flow_id << ",";
   }
   name_ = ss.str();
 }
 
+RateCounterFilter::RateCounterFilter(PacketProcessorListener* listener,
+                                     const FlowIds& flow_ids,
+                                     const char* name,
+                                     int64_t start_plotting_ms)
+    : RateCounterFilter(listener, flow_ids, name) {
+  start_plotting_ms_ = start_plotting_ms;
+}
+
 RateCounterFilter::~RateCounterFilter() {
   LogStats();
 }
 
-uint32_t RateCounterFilter::packets_per_second() const {
-  return rate_counter_->packets_per_second();
-}
-
-uint32_t RateCounterFilter::bits_per_second() const {
-  return rate_counter_->bits_per_second();
-}
 
 void RateCounterFilter::LogStats() {
   BWE_TEST_LOGGING_CONTEXT("RateCounterFilter");
   packets_per_second_stats_.Log("pps");
   kbps_stats_.Log("kbps");
 }
 
 Stats<double> RateCounterFilter::GetBitrateStats() const {
   return kbps_stats_;
 }
 
 void RateCounterFilter::Plot(int64_t timestamp_ms) {
+  uint32_t plot_kbps = rate_counter_->bits_per_second() / 1000.0;
+  if (timestamp_ms < start_plotting_ms_) {
+    plot_kbps = 0;

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

I prefer to swap this with 313, so you do
plot_kbps = 0;
if (timestamp >= start)
  plot_kbps = rate_counter->...;

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

Done.

+  }
   BWE_TEST_LOGGING_CONTEXT(name_.c_str());
-  BWE_TEST_LOGGING_PLOT(0, "Throughput_#1", timestamp_ms,
-                        rate_counter_->bits_per_second() / 1000.0);
+  BWE_TEST_LOGGING_PLOT(0, "Throughput_#1", timestamp_ms, plot_kbps);
+  // Silencing unused variable compiling error.
+  (void)plot_kbps;

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

RTC_UNUSED

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

Done.

 }
 
 void RateCounterFilter::RunFor(int64_t /*time_ms*/, Packets* in_out) {
   assert(in_out);
   for (const Packet* packet : *in_out) {
     rate_counter_->UpdateRates(packet->send_time_us(),
                                static_cast<int>(packet->payload_size()));
   }
   packets_per_second_stats_.Push(rate_counter_->packets_per_second());
   kbps_stats_.Push(rate_counter_->bits_per_second() / 1000.0);
@@ skipping 25 matching lines @@
   for (PacketsIt it = in_out->begin(); it != in_out->end(); ) {
     if (random_.Rand() < loss_fraction_) {
       delete *it;
       it = in_out->erase(it);
     } else {
       ++it;
     }
   }
 }
 
+const int64_t kDefaultOneWayDelayUs = 0;
+
 DelayFilter::DelayFilter(PacketProcessorListener* listener, int flow_id)
     : PacketProcessor(listener, flow_id, kRegular),
-      delay_us_(0),
+      one_way_delay_us_(kDefaultOneWayDelayUs),
       last_send_time_us_(0) {
 }
 
 DelayFilter::DelayFilter(PacketProcessorListener* listener,
                          const FlowIds& flow_ids)
     : PacketProcessor(listener, flow_ids, kRegular),
-      delay_us_(0),
+      one_way_delay_us_(kDefaultOneWayDelayUs),
       last_send_time_us_(0) {
 }
 
-void DelayFilter::SetDelayMs(int64_t delay_ms) {
+void DelayFilter::SetOneWayDelayMs(int64_t one_way_delay_ms) {
   BWE_TEST_LOGGING_ENABLE(false);
-  BWE_TEST_LOGGING_LOG1("Delay", "%d ms", static_cast<int>(delay_ms));
-  assert(delay_ms >= 0);
-  delay_us_ = delay_ms * 1000;
+  BWE_TEST_LOGGING_LOG1("Delay", "%d ms", static_cast<int>(one_way_delay_ms));
+  assert(one_way_delay_ms >= 0);
+  one_way_delay_us_ = one_way_delay_ms * 1000;
 }
 
 void DelayFilter::RunFor(int64_t /*time_ms*/, Packets* in_out) {
   assert(in_out);
   for (Packet* packet : *in_out) {
-    int64_t new_send_time_us = packet->send_time_us() + delay_us_;
+    int64_t new_send_time_us = packet->send_time_us() + one_way_delay_us_;
     last_send_time_us_ = std::max(last_send_time_us_, new_send_time_us);
     packet->set_send_time_us(last_send_time_us_);
   }
 }
 
 JitterFilter::JitterFilter(PacketProcessorListener* listener, int flow_id)
     : PacketProcessor(listener, flow_id, kRegular),
       random_(0x89674523),
       stddev_jitter_us_(0),
       last_send_time_us_(0) {
@@ skipping 57 matching lines @@
         int64_t t2 = (*it)->send_time_us();
         std::swap(*last_it, *it);
         (*last_it)->set_send_time_us(t1);
         (*it)->set_send_time_us(t2);
       }
       last_it = it;
     }
   }
 }
 
+const uint32_t kDefaultKbps = 1200;
+
 ChokeFilter::ChokeFilter(PacketProcessorListener* listener, int flow_id)
     : PacketProcessor(listener, flow_id, kRegular),
-      kbps_(1200),
+      available_capacity_kbps_(kDefaultKbps),
       last_send_time_us_(0),
       delay_cap_helper_(new DelayCapHelper()) {
+  running_flows_.insert(flow_id);
 }
 
 ChokeFilter::ChokeFilter(PacketProcessorListener* listener,
                          const FlowIds& flow_ids)
     : PacketProcessor(listener, flow_ids, kRegular),
-      kbps_(1200),
+      available_capacity_kbps_(kDefaultKbps),

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

Just capacity_kbps_

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

Done.

       last_send_time_us_(0),
-      delay_cap_helper_(new DelayCapHelper()) {
+      delay_cap_helper_(new DelayCapHelper()),
+      running_flows_(flow_ids) {
+}
+
+void ChokeFilter::PauseFlow(int flow_id) {
+  running_flows_.erase(flow_id);
+}
+
+void ChokeFilter::ResumeFlow(int flow_id) {
+  running_flows_.insert(flow_id);
 }
 
 ChokeFilter::~ChokeFilter() {}
 
-void ChokeFilter::SetCapacity(uint32_t kbps) {
+void ChokeFilter::SetCapacityKbps(uint32_t kbps) {
   BWE_TEST_LOGGING_ENABLE(false);
   BWE_TEST_LOGGING_LOG1("BitrateChoke", "%d kbps", kbps);
-  kbps_ = kbps;
+  available_capacity_kbps_ = kbps;
 }
 
 void ChokeFilter::RunFor(int64_t /*time_ms*/, Packets* in_out) {
   assert(in_out);
   for (PacketsIt it = in_out->begin(); it != in_out->end(); ) {
     int64_t earliest_send_time_us =
         last_send_time_us_ +
-        ((*it)->payload_size() * 8 * 1000 + kbps_ / 2) / kbps_;
+        ((*it)->payload_size() * 8 * 1000 + available_capacity_kbps_ / 2) /
+            available_capacity_kbps_;
     int64_t new_send_time_us =
         std::max((*it)->send_time_us(), earliest_send_time_us);
     if (delay_cap_helper_->ShouldSendPacket(new_send_time_us,
                                             (*it)->send_time_us())) {
       (*it)->set_send_time_us(new_send_time_us);
+
+      (*it)->set_total_capacity_kbps(
+          static_cast<uint32_t>(available_capacity_kbps_));
+      uint32_t available_capacity_per_flow_kbps = 0;
+      if (running_flows_.find((*it)->flow_id()) != running_flows_.end()) {
+        available_capacity_per_flow_kbps =
+            available_capacity_kbps_ /
+            static_cast<uint32_t>(running_flows_.size());
+      }
+      (*it)->set_capacity_per_flow_kbps(available_capacity_per_flow_kbps);

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

If we are going to pass the capacity per flow with a packet, we should make sure
to update it only if it's lower than the previously set capacity per flow, so
that we in the end get the capacity available on the bottleneck.

I think that can be useful for plotting.

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

Right,
actually the capacity_per_flow field was removed from Packet class.
Now the MetricRecorder can directly read it from the ChokeFilter whenever needed
to plot.

+
       last_send_time_us_ = new_send_time_us;
       ++it;
     } else {
       delete *it;
       it = in_out->erase(it);
     }
   }
 }
 
-void ChokeFilter::SetMaxDelay(int max_delay_ms) {
-  delay_cap_helper_->SetMaxDelay(max_delay_ms);
+void ChokeFilter::SetMaxDelayMs(int64_t max_delay_ms) {
+  delay_cap_helper_->SetMaxDelayMs(max_delay_ms);
 }
 
 Stats<double> ChokeFilter::GetDelayStats() const {
   return delay_cap_helper_->delay_stats();
 }
 
 TraceBasedDeliveryFilter::TraceBasedDeliveryFilter(
     PacketProcessorListener* listener,
     int flow_id)
     : PacketProcessor(listener, flow_id, kRegular),
@@ skipping 96 matching lines @@
     if (local_time_us_ >= (*it)->send_time_us()) {
       (*it)->set_send_time_us(local_time_us_);
       ProceedToNextSlot();
     }
     ++it;
   }
   packets_per_second_stats_.Push(rate_counter_->packets_per_second());
   kbps_stats_.Push(rate_counter_->bits_per_second() / 1000.0);
 }
 
-void TraceBasedDeliveryFilter::SetMaxDelay(int max_delay_ms) {
-  delay_cap_helper_->SetMaxDelay(max_delay_ms);
+void TraceBasedDeliveryFilter::SetMaxDelayMs(int64_t max_delay_ms) {
+  delay_cap_helper_->SetMaxDelayMs(max_delay_ms);
 }
 
 Stats<double> TraceBasedDeliveryFilter::GetDelayStats() const {
   return delay_cap_helper_->delay_stats();
 }
 
 Stats<double> TraceBasedDeliveryFilter::GetBitrateStats() const {
   return kbps_stats_;
 }
 
@@ skipping 17 matching lines @@
 VideoSource::VideoSource(int flow_id,
                          float fps,
                          uint32_t kbps,
                          uint32_t ssrc,
                          int64_t first_frame_offset_ms)
     : kMaxPayloadSizeBytes(1200),
       kTimestampBase(0xff80ff00ul),
       frame_period_ms_(1000.0 / fps),
       bits_per_second_(1000 * kbps),
       frame_size_bytes_(bits_per_second_ / 8 / fps),
+      running_(true),
       flow_id_(flow_id),
       next_frame_ms_(first_frame_offset_ms),
       now_ms_(0),
-      prototype_header_() {
+      prototype_header_(),
+      start_plotting_ms_(first_frame_offset_ms),
+      alg_name_() {
   memset(&prototype_header_, 0, sizeof(prototype_header_));
   prototype_header_.ssrc = ssrc;
   prototype_header_.sequenceNumber = 0xf000u;
 }
 
 uint32_t VideoSource::NextFrameSize() {
   return frame_size_bytes_;
 }
 
 uint32_t VideoSource::NextPacketSize(uint32_t frame_size,
                                      uint32_t remaining_payload) {
   return std::min(kMaxPayloadSizeBytes, remaining_payload);
 }
 
 void VideoSource::RunFor(int64_t time_ms, Packets* in_out) {
   assert(in_out);
-  std::stringstream ss;
-  ss << "SendEstimate_" << flow_id_ << "#1";
-  BWE_TEST_LOGGING_PLOT(0, ss.str(), now_ms_, bits_per_second_ / 1000);
+
+  if (plot_sending_estimate_) {
+    std::stringstream ss;
+    ss << "SendEstimate_" << flow_id_ << "#1";
+    uint32_t plot_kbps = bits_per_second_ / 1000;
+    if (now_ms_ < start_plotting_ms_) {
+      plot_kbps = 0;
+    }
+    BWE_TEST_LOGGING_PLOT_WITH_NAME(0, ss.str(), now_ms_, plot_kbps, alg_name_);
+    // Silencing unused variable compiling error.
+    (void)plot_kbps;

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

RTC_UNUSED

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

This plot_sending_estimate, which was set false by default, was removed from
VideoSource.

Now the MetricRecorder has access to a method
PacketSender::GetTargetBitrateKbps() and can plot it if we want so.

+  }
+
   now_ms_ += time_ms;
   Packets new_packets;
+
   while (now_ms_ >= next_frame_ms_) {
     prototype_header_.timestamp = kTimestampBase +
         static_cast<uint32_t>(next_frame_ms_ * 90.0);
     prototype_header_.extension.transmissionTimeOffset = 0;
 
     // Generate new packets for this frame, all with the same timestamp,
     // but the payload size is capped, so if the whole frame doesn't fit in
     // one packet, we will see a number of equally sized packets followed by
     // one smaller at the tail.
+
     int64_t send_time_us = next_frame_ms_ * 1000.0;
-    uint32_t frame_size = NextFrameSize();
-    uint32_t payload_size = frame_size;
 
-    while (payload_size > 0) {
+    if (running_) {
+      uint32_t frame_size = NextFrameSize();
+      uint32_t payload_size = frame_size;
+
+      while (payload_size > 0) {
+        ++prototype_header_.sequenceNumber;
+        uint32_t size = NextPacketSize(frame_size, payload_size);
+        MediaPacket* new_packet =
+            new MediaPacket(flow_id_, send_time_us, size, prototype_header_);
+        new_packets.push_back(new_packet);
+        new_packet->SetAbsSendTimeMs(next_frame_ms_);
+        new_packet->set_sender_timestamp_us(send_time_us);
+        new_packet->set_sending_estimate_kbps(bits_per_second_ / 1000);
+        payload_size -= size;
+      }
+    } else {
+      int64_t send_time_us = next_frame_ms_ * 1000.0;
       ++prototype_header_.sequenceNumber;
-      uint32_t size = NextPacketSize(frame_size, payload_size);
+      uint32_t size = 0;
       MediaPacket* new_packet =
           new MediaPacket(flow_id_, send_time_us, size, prototype_header_);
       new_packets.push_back(new_packet);
       new_packet->SetAbsSendTimeMs(next_frame_ms_);
       new_packet->set_sender_timestamp_us(send_time_us);
-      payload_size -= size;
+      new_packet->set_sending_estimate_kbps(bits_per_second_ / 1000);

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

If possible, I'd prefer to not have to set this.

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

Removed.

     }
 
-    next_frame_ms_ += frame_period_ms_;
+    next_frame_ms_ +=

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

Add a comment saying that this adds a 1 ms uniform variance to the frame period.

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

Done.

+        frame_period_ms_ - 1 + 2 * static_cast<float>(rand()) / RAND_MAX;
   }
+
   in_out->merge(new_packets, DereferencingComparator<Packet>);
 }
 
+void VideoSource::Pause() {
+  running_ = false;
+  SetBitrateBps(0);

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

I'm not sure it's correct to set to 0 here? I'd suggest leaving it unchanged.

[magalhaesc, 2015/07/01 13:44:55]

Done.

+}
+
+void VideoSource::Resume() {
+  running_ = true;
+  const int kResumeBitrateBps = 300 * 1000;
+  SetBitrateBps(kResumeBitrateBps);

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

I would actually suspect that we would resume at the same bitrate as before
after a pause in webrtc. Or does the evaluation draft specify that it should be
reset to the initial bitrate?

[magalhaesc, 2015/07/01 13:44:55]

Ok, it will be left unchanged.

+}
+
+void AdaptiveVideoSource::SetBitrateBps(int bitrate_bps) {
+  if (!running_) {
+    bitrate_bps = 0;
+  }
+  bits_per_second_ = std::min(bitrate_bps, 2500000);
+  frame_size_bytes_ = (bits_per_second_ / 8 * frame_period_ms_ + 500) / 1000;
+}
+
 AdaptiveVideoSource::AdaptiveVideoSource(int flow_id,
                                          float fps,
                                          uint32_t kbps,
                                          uint32_t ssrc,
                                          int64_t first_frame_offset_ms)
     : VideoSource(flow_id, fps, kbps, ssrc, first_frame_offset_ms) {
 }
 
-void AdaptiveVideoSource::SetBitrateBps(int bitrate_bps) {
-  bits_per_second_ = std::min(bitrate_bps, 2500000);
-  frame_size_bytes_ = (bits_per_second_ / 8 * frame_period_ms_ + 500) / 1000;
-}
-
 PeriodicKeyFrameSource::PeriodicKeyFrameSource(int flow_id,
                                                float fps,
                                                uint32_t kbps,
                                                uint32_t ssrc,
                                                int64_t first_frame_offset_ms,
                                                int key_frame_interval)
     : AdaptiveVideoSource(flow_id, fps, kbps, ssrc, first_frame_offset_ms),
       key_frame_interval_(key_frame_interval),
       frame_counter_(0),
       compensation_bytes_(0),
@@ skipping 30 matching lines @@
 uint32_t PeriodicKeyFrameSource::NextPacketSize(uint32_t frame_size,
                                                 uint32_t remaining_payload) {
   uint32_t fragments =
       (frame_size + (kMaxPayloadSizeBytes - 1)) / kMaxPayloadSizeBytes;
   uint32_t avg_size = (frame_size + fragments - 1) / fragments;
   return std::min(avg_size, remaining_payload);
 }
 }  // namespace bwe
 }  // namespace testing
 }  // namespace webrtc