modules/remote_bitrate_estimator/test/bwe.cc - src/webrtc - Git at Google

 /*
  *  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 "webrtc/modules/remote_bitrate_estimator/test/bwe.h"

 #include <algorithm>
 #include <limits>
 #include <string>
 #include <vector>

 #include "testing/gtest/include/gtest/gtest.h"
 #include "webrtc/base/common.h"
 #include "webrtc/modules/remote_bitrate_estimator/rate_statistics.h"
 #include "webrtc/modules/remote_bitrate_estimator/test/bwe_test_logging.h"
 #include "webrtc/modules/rtp_rtcp/interface/receive_statistics.h"

 namespace webrtc {
 namespace testing {
 namespace bwe {

 const int kMinBitrateKbps = 150;
 const int kMaxBitrateKbps = 2000;

 class NullBweSender : public BweSender {
  public:
   NullBweSender() {}
   virtual ~NullBweSender() {}

   virtual int GetFeedbackIntervalMs() const OVERRIDE { return 1000; }
   virtual void GiveFeedback(const FeedbackPacket& feedback) OVERRIDE {}
   virtual int64_t TimeUntilNextProcess() OVERRIDE {
     return std::numeric_limits<int64_t>::max();
   }
   virtual int Process() OVERRIDE { return 0; }

  private:
   DISALLOW_COPY_AND_ASSIGN(NullBweSender);
 };

 class RembBweSender : public BweSender {
  public:
   RembBweSender(int kbps, BitrateObserver* observer, Clock* clock);
   virtual ~RembBweSender();

   virtual int GetFeedbackIntervalMs() const OVERRIDE { return 100; }
   virtual void GiveFeedback(const FeedbackPacket& feedback) OVERRIDE;
   virtual int64_t TimeUntilNextProcess() OVERRIDE;
   virtual int Process() OVERRIDE;

  protected:
   scoped_ptr<BitrateController> bitrate_controller_;
   scoped_ptr<RtcpBandwidthObserver> feedback_observer_;

  private:
   Clock* clock_;

   DISALLOW_IMPLICIT_CONSTRUCTORS(RembBweSender);
 };

 class FullBweSender : public BweSender, public RemoteBitrateObserver {
  public:
   FullBweSender(int kbps, BitrateObserver* observer, Clock* clock);
   virtual ~FullBweSender();

   virtual int GetFeedbackIntervalMs() const OVERRIDE { return 100; }
   virtual void GiveFeedback(const FeedbackPacket& feedback) OVERRIDE;
   virtual void OnReceiveBitrateChanged(const std::vector<unsigned int>& ssrcs,
                                        unsigned int bitrate) OVERRIDE;
   virtual int64_t TimeUntilNextProcess() OVERRIDE;
   virtual int Process() OVERRIDE;

  protected:
   scoped_ptr<BitrateController> bitrate_controller_;
   scoped_ptr<RemoteBitrateEstimator> rbe_;
   scoped_ptr<RtcpBandwidthObserver> feedback_observer_;

  private:
   Clock* const clock_;
   RTCPReportBlock report_block_;

   DISALLOW_IMPLICIT_CONSTRUCTORS(FullBweSender);
 };

 RembBweSender::RembBweSender(int kbps, BitrateObserver* observer, Clock* clock)
     : bitrate_controller_(
           BitrateController::CreateBitrateController(clock, false)),
       feedback_observer_(bitrate_controller_->CreateRtcpBandwidthObserver()),
       clock_(clock) {
   assert(kbps >= kMinBitrateKbps);
   assert(kbps <= kMaxBitrateKbps);
   bitrate_controller_->SetBitrateObserver(
       observer, 1000 * kbps, 1000 * kMinBitrateKbps, 1000 * kMaxBitrateKbps);
 }

 RembBweSender::~RembBweSender() {
 }

 void RembBweSender::GiveFeedback(const FeedbackPacket& feedback) {
   const RembFeedback& remb_feedback =
       static_cast<const RembFeedback&>(feedback);
   feedback_observer_->OnReceivedEstimatedBitrate(remb_feedback.estimated_bps());
   ReportBlockList report_blocks;
   report_blocks.push_back(remb_feedback.report_block());
   feedback_observer_->OnReceivedRtcpReceiverReport(
       report_blocks, 0, clock_->TimeInMilliseconds());
   bitrate_controller_->Process();
 }

 int64_t RembBweSender::TimeUntilNextProcess() {
   return bitrate_controller_->TimeUntilNextProcess();
 }

 int RembBweSender::Process() {
   return bitrate_controller_->Process();
 }

 FullBweSender::FullBweSender(int kbps, BitrateObserver* observer, Clock* clock)
     : bitrate_controller_(
           BitrateController::CreateBitrateController(clock, false)),
       rbe_(AbsoluteSendTimeRemoteBitrateEstimatorFactory()
                .Create(this, clock, kAimdControl, 1000 * kMinBitrateKbps)),
       feedback_observer_(bitrate_controller_->CreateRtcpBandwidthObserver()),
       clock_(clock) {
   assert(kbps >= kMinBitrateKbps);
   assert(kbps <= kMaxBitrateKbps);
   bitrate_controller_->SetBitrateObserver(
       observer, 1000 * kbps, 1000 * kMinBitrateKbps, 1000 * kMaxBitrateKbps);
 }

 FullBweSender::~FullBweSender() {
 }

 void FullBweSender::GiveFeedback(const FeedbackPacket& feedback) {
   const SendSideBweFeedback& fb =
       static_cast<const SendSideBweFeedback&>(feedback);
   if (fb.packet_feedback_vector().empty())
     return;
   rbe_->IncomingPacketFeedbackVector(fb.packet_feedback_vector());
   // TODO(holmer): Handle losses in between feedback packets.
   int expected_packets = fb.packet_feedback_vector().back().sequence_number -
                          fb.packet_feedback_vector().front().sequence_number +
                          1;
   // Assuming no reordering for now.
   if (expected_packets <= 0)
     return;
   int lost_packets = expected_packets - fb.packet_feedback_vector().size();
   report_block_.fractionLost = (lost_packets << 8) / expected_packets;
   report_block_.cumulativeLost += lost_packets;
   ReportBlockList report_blocks;
   report_blocks.push_back(report_block_);
   feedback_observer_->OnReceivedRtcpReceiverReport(
       report_blocks, 0, clock_->TimeInMilliseconds());
   bitrate_controller_->Process();
 }

 void FullBweSender::OnReceiveBitrateChanged(
     const std::vector<unsigned int>& ssrcs,
     unsigned int bitrate) {
   feedback_observer_->OnReceivedEstimatedBitrate(bitrate);
 }

 int64_t FullBweSender::TimeUntilNextProcess() {
   return bitrate_controller_->TimeUntilNextProcess();
 }

 int FullBweSender::Process() {
   rbe_->Process();
   return bitrate_controller_->Process();
 }

 int64_t GetAbsSendTimeInMs(uint32_t abs_send_time) {
   const int kInterArrivalShift = 26;
   const int kAbsSendTimeInterArrivalUpshift = 8;
   const double kTimestampToMs =
       1000.0 / static_cast<double>(1 << kInterArrivalShift);
   uint32_t timestamp = abs_send_time << kAbsSendTimeInterArrivalUpshift;
   return static_cast<int64_t>(timestamp) * kTimestampToMs;
 }

 class SendSideBweReceiver : public BweReceiver {
  public:
   explicit SendSideBweReceiver(int flow_id)
       : BweReceiver(flow_id), last_feedback_ms_(0) {}
   virtual void ReceivePacket(int64_t arrival_time_ms,
                              const MediaPacket& media_packet) OVERRIDE {
     packet_feedback_vector_.push_back(PacketInfo(
         arrival_time_ms,
         GetAbsSendTimeInMs(media_packet.header().extension.absoluteSendTime),
         media_packet.header().sequenceNumber, media_packet.payload_size()));
   }

   virtual FeedbackPacket* GetFeedback(int64_t now_ms) OVERRIDE {
     if (now_ms - last_feedback_ms_ < 100)
       return NULL;
     last_feedback_ms_ = now_ms;
     FeedbackPacket* fb = new SendSideBweFeedback(flow_id_, now_ms * 1000,
                                                  packet_feedback_vector_);
     packet_feedback_vector_.clear();
     return fb;
   }

  private:
   int64_t last_feedback_ms_;
   std::vector<PacketInfo> packet_feedback_vector_;
 };

 class RembReceiver : public BweReceiver, public RemoteBitrateObserver {
  public:
   static const uint32_t kRemoteBitrateEstimatorMinBitrateBps = 30000;

   RembReceiver(int flow_id, bool plot)
       : BweReceiver(flow_id),
         estimate_log_prefix_(),
         plot_estimate_(plot),
         clock_(0),
         recv_stats_(ReceiveStatistics::Create(&clock_)),
         latest_estimate_bps_(-1),
         estimator_(AbsoluteSendTimeRemoteBitrateEstimatorFactory().Create(
             this,
             &clock_,
             kAimdControl,
             kRemoteBitrateEstimatorMinBitrateBps)) {
     std::stringstream ss;
     ss << "Estimate_" << flow_id_ << "#1";
     estimate_log_prefix_ = ss.str();
     // Default RTT in RemoteRateControl is 200 ms ; 50 ms is more realistic.
     estimator_->OnRttUpdate(50);
   }

   virtual void ReceivePacket(int64_t arrival_time_ms,
                              const MediaPacket& media_packet) {
     recv_stats_->IncomingPacket(media_packet.header(),
                                 media_packet.payload_size(), false);

     latest_estimate_bps_ = -1;

     int64_t step_ms = std::max<int64_t>(estimator_->TimeUntilNextProcess(), 0);
     while ((clock_.TimeInMilliseconds() + step_ms) < arrival_time_ms) {
       clock_.AdvanceTimeMilliseconds(step_ms);
       estimator_->Process();
       step_ms = std::max<int64_t>(estimator_->TimeUntilNextProcess(), 0);
     }
     estimator_->IncomingPacket(arrival_time_ms, media_packet.payload_size(),
                                media_packet.header());
     clock_.AdvanceTimeMilliseconds(arrival_time_ms -
                                    clock_.TimeInMilliseconds());
     ASSERT_TRUE(arrival_time_ms == clock_.TimeInMilliseconds());
   }

   virtual FeedbackPacket* GetFeedback(int64_t now_ms) OVERRIDE {
     BWE_TEST_LOGGING_CONTEXT("Remb");
     uint32_t estimated_bps = 0;
     RembFeedback* feedback = NULL;
     if (LatestEstimate(&estimated_bps)) {
       StatisticianMap statisticians = recv_stats_->GetActiveStatisticians();
       RTCPReportBlock report_block;
       if (!statisticians.empty()) {
         report_block = BuildReportBlock(statisticians.begin()->second);
       }
       feedback = new RembFeedback(flow_id_, now_ms * 1000, estimated_bps,
                                   report_block);

       double estimated_kbps = static_cast<double>(estimated_bps) / 1000.0;
       RTC_UNUSED(estimated_kbps);
       if (plot_estimate_) {
         BWE_TEST_LOGGING_PLOT(estimate_log_prefix_, clock_.TimeInMilliseconds(),
                               estimated_kbps);
       }
     }
     return feedback;
   }

   // Implements RemoteBitrateObserver.
   virtual void OnReceiveBitrateChanged(const std::vector<unsigned int>& ssrcs,
                                        unsigned int bitrate) OVERRIDE {}

  private:
   static RTCPReportBlock BuildReportBlock(StreamStatistician* statistician) {
     RTCPReportBlock report_block;
     RtcpStatistics stats;
     if (!statistician->GetStatistics(&stats, true))
       return report_block;
     report_block.fractionLost = stats.fraction_lost;
     report_block.cumulativeLost = stats.cumulative_lost;
     report_block.extendedHighSeqNum = stats.extended_max_sequence_number;
     report_block.jitter = stats.jitter;
     return report_block;
   }

   bool LatestEstimate(uint32_t* estimate_bps) {
     if (latest_estimate_bps_ < 0) {
       std::vector<unsigned int> ssrcs;
       unsigned int bps = 0;
       if (!estimator_->LatestEstimate(&ssrcs, &bps)) {
         return false;
       }
       latest_estimate_bps_ = bps;
     }
     *estimate_bps = latest_estimate_bps_;
     return true;
   }

   std::string estimate_log_prefix_;
   bool plot_estimate_;
   SimulatedClock clock_;
   scoped_ptr<ReceiveStatistics> recv_stats_;
   int64_t latest_estimate_bps_;
   scoped_ptr<RemoteBitrateEstimator> estimator_;

   DISALLOW_IMPLICIT_CONSTRUCTORS(RembReceiver);
 };

 class NadaBweReceiver : public BweReceiver {
  public:
   explicit NadaBweReceiver(int flow_id)
       : BweReceiver(flow_id),
         clock_(0),
         last_feedback_ms_(0),
         recv_stats_(ReceiveStatistics::Create(&clock_)),
         baseline_delay_ms_(0),
         delay_signal_ms_(0),
         last_congestion_signal_ms_(0) {}

   virtual void ReceivePacket(int64_t arrival_time_ms,
                              const MediaPacket& media_packet) OVERRIDE {
     clock_.AdvanceTimeMilliseconds(arrival_time_ms -
                                    clock_.TimeInMilliseconds());
     recv_stats_->IncomingPacket(media_packet.header(),
                                 media_packet.payload_size(), false);
     int64_t delay_ms = arrival_time_ms - media_packet.creation_time_us() / 1000;
     // TODO(holmer): The min should time out after 10 minutes.
     if (delay_ms < baseline_delay_ms_) {
       baseline_delay_ms_ = delay_ms;
     }
     delay_signal_ms_ = delay_ms - baseline_delay_ms_;
   }

   virtual FeedbackPacket* GetFeedback(int64_t now_ms) OVERRIDE {
     if (now_ms - last_feedback_ms_ < 100)
       return NULL;

     StatisticianMap statisticians = recv_stats_->GetActiveStatisticians();
     int64_t loss_signal_ms = 0.0f;
     if (!statisticians.empty()) {
       RtcpStatistics stats;
       if (!statisticians.begin()->second->GetStatistics(&stats, true)) {
         const float kLossSignalWeight = 1000.0f;
         loss_signal_ms =
             (kLossSignalWeight * static_cast<float>(stats.fraction_lost) +
              127) /
             255;
       }
     }

     int64_t congestion_signal_ms = delay_signal_ms_ + loss_signal_ms;

     float derivative = 0.0f;
     if (last_feedback_ms_ > 0) {
       derivative = (congestion_signal_ms - last_congestion_signal_ms_) /
                    static_cast<float>(now_ms - last_feedback_ms_);
     }
     last_feedback_ms_ = now_ms;
     last_congestion_signal_ms_ = congestion_signal_ms;
     return new NadaFeedback(flow_id_, now_ms, congestion_signal_ms, derivative);
   }

  private:
   SimulatedClock clock_;
   int64_t last_feedback_ms_;
   scoped_ptr<ReceiveStatistics> recv_stats_;
   int64_t baseline_delay_ms_;
   int64_t delay_signal_ms_;
   int64_t last_congestion_signal_ms_;
 };

 class NadaBweSender : public BweSender {
  public:
   NadaBweSender(int kbps, BitrateObserver* observer, Clock* clock)
       : clock_(clock),
         observer_(observer),
         bitrate_kbps_(kbps),
         last_feedback_ms_(0) {}
   virtual ~NadaBweSender() {}

   virtual int GetFeedbackIntervalMs() const OVERRIDE { return 100; }

   virtual void GiveFeedback(const FeedbackPacket& feedback) {
     const NadaFeedback& fb = static_cast<const NadaFeedback&>(feedback);

     // TODO(holmer): Implement special start-up behavior.

     const float kEta = 2.0f;
     const float kTaoO = 500.0f;
     float x_hat = fb.congestion_signal() + kEta * kTaoO * fb.derivative();

     int64_t now_ms = clock_->TimeInMilliseconds();
     float delta_s = now_ms - last_feedback_ms_;
     last_feedback_ms_ = now_ms;

     const float kPriorityWeight = 1.0f;
     const float kReferenceDelayS = 10.0f;
     float kTheta = kPriorityWeight * (kMaxBitrateKbps - kMinBitrateKbps) *
                    kReferenceDelayS;

     const float kKappa = 1.0f;
     bitrate_kbps_ = bitrate_kbps_ +
                     kKappa * delta_s / (kTaoO * kTaoO) *
                         (kTheta - (bitrate_kbps_ - kMinBitrateKbps) * x_hat) +
                     0.5f;
     bitrate_kbps_ = std::min(bitrate_kbps_, kMaxBitrateKbps);
     bitrate_kbps_ = std::max(bitrate_kbps_, kMinBitrateKbps);

     observer_->OnNetworkChanged(1000 * bitrate_kbps_, 0, 0);
   }

   virtual int64_t TimeUntilNextProcess() OVERRIDE { return 100; }
   virtual int Process() OVERRIDE { return 0; }

  private:
   Clock* const clock_;
   BitrateObserver* const observer_;
   int bitrate_kbps_;
   int64_t last_feedback_ms_;

   DISALLOW_IMPLICIT_CONSTRUCTORS(NadaBweSender);
 };

 BweSender* CreateBweSender(BandwidthEstimatorType estimator,
                            int kbps,
                            BitrateObserver* observer,
                            Clock* clock) {
   switch (estimator) {
     case kRembEstimator:
       return new RembBweSender(kbps, observer, clock);
     case kFullSendSideEstimator:
       return new FullBweSender(kbps, observer, clock);
     case kNadaEstimator:
       return new NadaBweSender(kbps, observer, clock);
     case kNullEstimator:
       return new NullBweSender();
   }
   assert(false);
   return NULL;
 }

 BweReceiver* CreateBweReceiver(BandwidthEstimatorType type,
                                int flow_id,
                                bool plot) {
   switch (type) {
     case kRembEstimator:
       return new RembReceiver(flow_id, plot);
     case kFullSendSideEstimator:
       return new SendSideBweReceiver(flow_id);
     case kNadaEstimator:
       return new NadaBweReceiver(flow_id);
     case kNullEstimator:
       return new BweReceiver(flow_id);
   }
   assert(false);
   return NULL;
 }
 }  // namespace bwe
 }  // namespace testing
 }  // namespace webrtc
	/*
	* 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 "webrtc/modules/remote_bitrate_estimator/test/bwe.h"

	#include <algorithm>
	#include <limits>
	#include <string>
	#include <vector>

	#include "testing/gtest/include/gtest/gtest.h"
	#include "webrtc/base/common.h"
	#include "webrtc/modules/remote_bitrate_estimator/rate_statistics.h"
	#include "webrtc/modules/remote_bitrate_estimator/test/bwe_test_logging.h"
	#include "webrtc/modules/rtp_rtcp/interface/receive_statistics.h"

	namespace webrtc {
	namespace testing {
	namespace bwe {

	const int kMinBitrateKbps = 150;
	const int kMaxBitrateKbps = 2000;

	class NullBweSender : public BweSender {
	public:
	NullBweSender() {}
	virtual ~NullBweSender() {}

	virtual int GetFeedbackIntervalMs() const OVERRIDE { return 1000; }
	virtual void GiveFeedback(const FeedbackPacket& feedback) OVERRIDE {}
	virtual int64_t TimeUntilNextProcess() OVERRIDE {
	return std::numeric_limits<int64_t>::max();
	}
	virtual int Process() OVERRIDE { return 0; }

	private:
	DISALLOW_COPY_AND_ASSIGN(NullBweSender);
	};

	class RembBweSender : public BweSender {
	public:
	RembBweSender(int kbps, BitrateObserver* observer, Clock* clock);
	virtual ~RembBweSender();

	virtual int GetFeedbackIntervalMs() const OVERRIDE { return 100; }
	virtual void GiveFeedback(const FeedbackPacket& feedback) OVERRIDE;
	virtual int64_t TimeUntilNextProcess() OVERRIDE;
	virtual int Process() OVERRIDE;

	protected:
	scoped_ptr<BitrateController> bitrate_controller_;
	scoped_ptr<RtcpBandwidthObserver> feedback_observer_;

	private:
	Clock* clock_;

	DISALLOW_IMPLICIT_CONSTRUCTORS(RembBweSender);
	};

	class FullBweSender : public BweSender, public RemoteBitrateObserver {
	public:
	FullBweSender(int kbps, BitrateObserver* observer, Clock* clock);
	virtual ~FullBweSender();

	virtual int GetFeedbackIntervalMs() const OVERRIDE { return 100; }
	virtual void GiveFeedback(const FeedbackPacket& feedback) OVERRIDE;
	virtual void OnReceiveBitrateChanged(const std::vector<unsigned int>& ssrcs,
	unsigned int bitrate) OVERRIDE;
	virtual int64_t TimeUntilNextProcess() OVERRIDE;
	virtual int Process() OVERRIDE;

	protected:
	scoped_ptr<BitrateController> bitrate_controller_;
	scoped_ptr<RemoteBitrateEstimator> rbe_;
	scoped_ptr<RtcpBandwidthObserver> feedback_observer_;

	private:
	Clock* const clock_;
	RTCPReportBlock report_block_;

	DISALLOW_IMPLICIT_CONSTRUCTORS(FullBweSender);
	};

	RembBweSender::RembBweSender(int kbps, BitrateObserver* observer, Clock* clock)
	: bitrate_controller_(
	BitrateController::CreateBitrateController(clock, false)),
	feedback_observer_(bitrate_controller_->CreateRtcpBandwidthObserver()),
	clock_(clock) {
	assert(kbps >= kMinBitrateKbps);
	assert(kbps <= kMaxBitrateKbps);
	bitrate_controller_->SetBitrateObserver(
	observer, 1000 * kbps, 1000 * kMinBitrateKbps, 1000 * kMaxBitrateKbps);
	}

	RembBweSender::~RembBweSender() {
	}

	void RembBweSender::GiveFeedback(const FeedbackPacket& feedback) {
	const RembFeedback& remb_feedback =
	static_cast<const RembFeedback&>(feedback);
	feedback_observer_->OnReceivedEstimatedBitrate(remb_feedback.estimated_bps());
	ReportBlockList report_blocks;
	report_blocks.push_back(remb_feedback.report_block());
	feedback_observer_->OnReceivedRtcpReceiverReport(
	report_blocks, 0, clock_->TimeInMilliseconds());
	bitrate_controller_->Process();
	}

	int64_t RembBweSender::TimeUntilNextProcess() {
	return bitrate_controller_->TimeUntilNextProcess();
	}

	int RembBweSender::Process() {
	return bitrate_controller_->Process();
	}

	FullBweSender::FullBweSender(int kbps, BitrateObserver* observer, Clock* clock)
	: bitrate_controller_(
	BitrateController::CreateBitrateController(clock, false)),
	rbe_(AbsoluteSendTimeRemoteBitrateEstimatorFactory()
	.Create(this, clock, kAimdControl, 1000 * kMinBitrateKbps)),
	feedback_observer_(bitrate_controller_->CreateRtcpBandwidthObserver()),
	clock_(clock) {
	assert(kbps >= kMinBitrateKbps);
	assert(kbps <= kMaxBitrateKbps);
	bitrate_controller_->SetBitrateObserver(
	observer, 1000 * kbps, 1000 * kMinBitrateKbps, 1000 * kMaxBitrateKbps);
	}

	FullBweSender::~FullBweSender() {
	}

	void FullBweSender::GiveFeedback(const FeedbackPacket& feedback) {
	const SendSideBweFeedback& fb =
	static_cast<const SendSideBweFeedback&>(feedback);
	if (fb.packet_feedback_vector().empty())
	return;
	rbe_->IncomingPacketFeedbackVector(fb.packet_feedback_vector());
	// TODO(holmer): Handle losses in between feedback packets.
	int expected_packets = fb.packet_feedback_vector().back().sequence_number -
	fb.packet_feedback_vector().front().sequence_number +
	1;
	// Assuming no reordering for now.
	if (expected_packets <= 0)
	return;
	int lost_packets = expected_packets - fb.packet_feedback_vector().size();
	report_block_.fractionLost = (lost_packets << 8) / expected_packets;
	report_block_.cumulativeLost += lost_packets;
	ReportBlockList report_blocks;
	report_blocks.push_back(report_block_);
	feedback_observer_->OnReceivedRtcpReceiverReport(
	report_blocks, 0, clock_->TimeInMilliseconds());
	bitrate_controller_->Process();
	}

	void FullBweSender::OnReceiveBitrateChanged(
	const std::vector<unsigned int>& ssrcs,
	unsigned int bitrate) {
	feedback_observer_->OnReceivedEstimatedBitrate(bitrate);
	}

	int64_t FullBweSender::TimeUntilNextProcess() {
	return bitrate_controller_->TimeUntilNextProcess();
	}

	int FullBweSender::Process() {
	rbe_->Process();
	return bitrate_controller_->Process();
	}

	int64_t GetAbsSendTimeInMs(uint32_t abs_send_time) {
	const int kInterArrivalShift = 26;
	const int kAbsSendTimeInterArrivalUpshift = 8;
	const double kTimestampToMs =
	1000.0 / static_cast<double>(1 << kInterArrivalShift);
	uint32_t timestamp = abs_send_time << kAbsSendTimeInterArrivalUpshift;
	return static_cast<int64_t>(timestamp) * kTimestampToMs;
	}

	class SendSideBweReceiver : public BweReceiver {
	public:
	explicit SendSideBweReceiver(int flow_id)
	: BweReceiver(flow_id), last_feedback_ms_(0) {}
	virtual void ReceivePacket(int64_t arrival_time_ms,
	const MediaPacket& media_packet) OVERRIDE {
	packet_feedback_vector_.push_back(PacketInfo(
	arrival_time_ms,
	GetAbsSendTimeInMs(media_packet.header().extension.absoluteSendTime),
	media_packet.header().sequenceNumber, media_packet.payload_size()));
	}

	virtual FeedbackPacket* GetFeedback(int64_t now_ms) OVERRIDE {
	if (now_ms - last_feedback_ms_ < 100)
	return NULL;
	last_feedback_ms_ = now_ms;
	FeedbackPacket* fb = new SendSideBweFeedback(flow_id_, now_ms * 1000,
	packet_feedback_vector_);
	packet_feedback_vector_.clear();
	return fb;
	}

	private:
	int64_t last_feedback_ms_;
	std::vector<PacketInfo> packet_feedback_vector_;
	};

	class RembReceiver : public BweReceiver, public RemoteBitrateObserver {
	public:
	static const uint32_t kRemoteBitrateEstimatorMinBitrateBps = 30000;

	RembReceiver(int flow_id, bool plot)
	: BweReceiver(flow_id),
	estimate_log_prefix_(),
	plot_estimate_(plot),
	clock_(0),
	recv_stats_(ReceiveStatistics::Create(&clock_)),
	latest_estimate_bps_(-1),
	estimator_(AbsoluteSendTimeRemoteBitrateEstimatorFactory().Create(
	this,
	&clock_,
	kAimdControl,
	kRemoteBitrateEstimatorMinBitrateBps)) {
	std::stringstream ss;
	ss << "Estimate_" << flow_id_ << "#1";
	estimate_log_prefix_ = ss.str();
	// Default RTT in RemoteRateControl is 200 ms ; 50 ms is more realistic.
	estimator_->OnRttUpdate(50);
	}

	virtual void ReceivePacket(int64_t arrival_time_ms,
	const MediaPacket& media_packet) {
	recv_stats_->IncomingPacket(media_packet.header(),
	media_packet.payload_size(), false);

	latest_estimate_bps_ = -1;

	int64_t step_ms = std::max<int64_t>(estimator_->TimeUntilNextProcess(), 0);
	while ((clock_.TimeInMilliseconds() + step_ms) < arrival_time_ms) {
	clock_.AdvanceTimeMilliseconds(step_ms);
	estimator_->Process();
	step_ms = std::max<int64_t>(estimator_->TimeUntilNextProcess(), 0);
	}
	estimator_->IncomingPacket(arrival_time_ms, media_packet.payload_size(),
	media_packet.header());
	clock_.AdvanceTimeMilliseconds(arrival_time_ms -
	clock_.TimeInMilliseconds());
	ASSERT_TRUE(arrival_time_ms == clock_.TimeInMilliseconds());
	}

	virtual FeedbackPacket* GetFeedback(int64_t now_ms) OVERRIDE {
	BWE_TEST_LOGGING_CONTEXT("Remb");
	uint32_t estimated_bps = 0;
	RembFeedback* feedback = NULL;
	if (LatestEstimate(&estimated_bps)) {
	StatisticianMap statisticians = recv_stats_->GetActiveStatisticians();
	RTCPReportBlock report_block;
	if (!statisticians.empty()) {
	report_block = BuildReportBlock(statisticians.begin()->second);
	}
	feedback = new RembFeedback(flow_id_, now_ms * 1000, estimated_bps,
	report_block);

	double estimated_kbps = static_cast<double>(estimated_bps) / 1000.0;
	RTC_UNUSED(estimated_kbps);
	if (plot_estimate_) {
	BWE_TEST_LOGGING_PLOT(estimate_log_prefix_, clock_.TimeInMilliseconds(),
	estimated_kbps);
	}
	}
	return feedback;
	}

	// Implements RemoteBitrateObserver.
	virtual void OnReceiveBitrateChanged(const std::vector<unsigned int>& ssrcs,
	unsigned int bitrate) OVERRIDE {}

	private:
	static RTCPReportBlock BuildReportBlock(StreamStatistician* statistician) {
	RTCPReportBlock report_block;
	RtcpStatistics stats;
	if (!statistician->GetStatistics(&stats, true))
	return report_block;
	report_block.fractionLost = stats.fraction_lost;
	report_block.cumulativeLost = stats.cumulative_lost;
	report_block.extendedHighSeqNum = stats.extended_max_sequence_number;
	report_block.jitter = stats.jitter;
	return report_block;
	}

	bool LatestEstimate(uint32_t* estimate_bps) {
	if (latest_estimate_bps_ < 0) {
	std::vector<unsigned int> ssrcs;
	unsigned int bps = 0;
	if (!estimator_->LatestEstimate(&ssrcs, &bps)) {
	return false;
	}
	latest_estimate_bps_ = bps;
	}
	*estimate_bps = latest_estimate_bps_;
	return true;
	}

	std::string estimate_log_prefix_;
	bool plot_estimate_;
	SimulatedClock clock_;
	scoped_ptr<ReceiveStatistics> recv_stats_;
	int64_t latest_estimate_bps_;
	scoped_ptr<RemoteBitrateEstimator> estimator_;

	DISALLOW_IMPLICIT_CONSTRUCTORS(RembReceiver);
	};

	class NadaBweReceiver : public BweReceiver {
	public:
	explicit NadaBweReceiver(int flow_id)
	: BweReceiver(flow_id),
	clock_(0),
	last_feedback_ms_(0),
	recv_stats_(ReceiveStatistics::Create(&clock_)),
	baseline_delay_ms_(0),
	delay_signal_ms_(0),
	last_congestion_signal_ms_(0) {}

	virtual void ReceivePacket(int64_t arrival_time_ms,
	const MediaPacket& media_packet) OVERRIDE {
	clock_.AdvanceTimeMilliseconds(arrival_time_ms -
	clock_.TimeInMilliseconds());
	recv_stats_->IncomingPacket(media_packet.header(),
	media_packet.payload_size(), false);
	int64_t delay_ms = arrival_time_ms - media_packet.creation_time_us() / 1000;
	// TODO(holmer): The min should time out after 10 minutes.
	if (delay_ms < baseline_delay_ms_) {
	baseline_delay_ms_ = delay_ms;
	}
	delay_signal_ms_ = delay_ms - baseline_delay_ms_;
	}

	virtual FeedbackPacket* GetFeedback(int64_t now_ms) OVERRIDE {
	if (now_ms - last_feedback_ms_ < 100)
	return NULL;

	StatisticianMap statisticians = recv_stats_->GetActiveStatisticians();
	int64_t loss_signal_ms = 0.0f;
	if (!statisticians.empty()) {
	RtcpStatistics stats;
	if (!statisticians.begin()->second->GetStatistics(&stats, true)) {
	const float kLossSignalWeight = 1000.0f;
	loss_signal_ms =
	(kLossSignalWeight * static_cast<float>(stats.fraction_lost) +
	127) /
	255;
	}
	}

	int64_t congestion_signal_ms = delay_signal_ms_ + loss_signal_ms;

	float derivative = 0.0f;
	if (last_feedback_ms_ > 0) {
	derivative = (congestion_signal_ms - last_congestion_signal_ms_) /
	static_cast<float>(now_ms - last_feedback_ms_);
	}
	last_feedback_ms_ = now_ms;
	last_congestion_signal_ms_ = congestion_signal_ms;
	return new NadaFeedback(flow_id_, now_ms, congestion_signal_ms, derivative);
	}

	private:
	SimulatedClock clock_;
	int64_t last_feedback_ms_;
	scoped_ptr<ReceiveStatistics> recv_stats_;
	int64_t baseline_delay_ms_;
	int64_t delay_signal_ms_;
	int64_t last_congestion_signal_ms_;
	};

	class NadaBweSender : public BweSender {
	public:
	NadaBweSender(int kbps, BitrateObserver* observer, Clock* clock)
	: clock_(clock),
	observer_(observer),
	bitrate_kbps_(kbps),
	last_feedback_ms_(0) {}
	virtual ~NadaBweSender() {}

	virtual int GetFeedbackIntervalMs() const OVERRIDE { return 100; }

	virtual void GiveFeedback(const FeedbackPacket& feedback) {
	const NadaFeedback& fb = static_cast<const NadaFeedback&>(feedback);

	// TODO(holmer): Implement special start-up behavior.

	const float kEta = 2.0f;
	const float kTaoO = 500.0f;
	float x_hat = fb.congestion_signal() + kEta * kTaoO * fb.derivative();

	int64_t now_ms = clock_->TimeInMilliseconds();
	float delta_s = now_ms - last_feedback_ms_;
	last_feedback_ms_ = now_ms;

	const float kPriorityWeight = 1.0f;
	const float kReferenceDelayS = 10.0f;
	float kTheta = kPriorityWeight * (kMaxBitrateKbps - kMinBitrateKbps) *
	kReferenceDelayS;

	const float kKappa = 1.0f;
	bitrate_kbps_ = bitrate_kbps_ +
	kKappa * delta_s / (kTaoO * kTaoO) *
	(kTheta - (bitrate_kbps_ - kMinBitrateKbps) * x_hat) +
	0.5f;
	bitrate_kbps_ = std::min(bitrate_kbps_, kMaxBitrateKbps);
	bitrate_kbps_ = std::max(bitrate_kbps_, kMinBitrateKbps);

	observer_->OnNetworkChanged(1000 * bitrate_kbps_, 0, 0);
	}

	virtual int64_t TimeUntilNextProcess() OVERRIDE { return 100; }
	virtual int Process() OVERRIDE { return 0; }

	private:
	Clock* const clock_;
	BitrateObserver* const observer_;
	int bitrate_kbps_;
	int64_t last_feedback_ms_;

	DISALLOW_IMPLICIT_CONSTRUCTORS(NadaBweSender);
	};

	BweSender* CreateBweSender(BandwidthEstimatorType estimator,
	int kbps,
	BitrateObserver* observer,
	Clock* clock) {
	switch (estimator) {
	case kRembEstimator:
	return new RembBweSender(kbps, observer, clock);
	case kFullSendSideEstimator:
	return new FullBweSender(kbps, observer, clock);
	case kNadaEstimator:
	return new NadaBweSender(kbps, observer, clock);
	case kNullEstimator:
	return new NullBweSender();
	}
	assert(false);
	return NULL;
	}

	BweReceiver* CreateBweReceiver(BandwidthEstimatorType type,
	int flow_id,
	bool plot) {
	switch (type) {
	case kRembEstimator:
	return new RembReceiver(flow_id, plot);
	case kFullSendSideEstimator:
	return new SendSideBweReceiver(flow_id);
	case kNadaEstimator:
	return new NadaBweReceiver(flow_id);
	case kNullEstimator:
	return new BweReceiver(flow_id);
	}
	assert(false);
	return NULL;
	}
	} // namespace bwe
	} // namespace testing
	} // namespace webrtc