Index: webrtc/modules/remote_bitrate_estimator/test/estimators/nada.cc |
diff --git a/webrtc/modules/remote_bitrate_estimator/test/estimators/nada.cc b/webrtc/modules/remote_bitrate_estimator/test/estimators/nada.cc |
index ccbc522b7e375d2e065fe337e6da0038ac237097..2500679343a52c37da87f6ec6ff4fc59e0e225fe 100644 |
--- a/webrtc/modules/remote_bitrate_estimator/test/estimators/nada.cc |
+++ b/webrtc/modules/remote_bitrate_estimator/test/estimators/nada.cc |
@@ -17,7 +17,6 @@ |
#include <math.h> |
#include <algorithm> |
#include <vector> |
-#include <iostream> |
#include "webrtc/base/common.h" |
#include "webrtc/modules/remote_bitrate_estimator/test/estimators/nada.h" |
@@ -28,16 +27,14 @@ namespace webrtc { |
namespace testing { |
namespace bwe { |
-const int NadaBweSender::kMinRefRateKbps = 150; |
-const int NadaBweSender::kMaxRefRateKbps = 1500; |
const int64_t NadaBweReceiver::kReceivingRateTimeWindowMs = 500; |
NadaBweReceiver::NadaBweReceiver(int flow_id) |
- : BweReceiver(flow_id), |
+ : BweReceiver(flow_id, kReceivingRateTimeWindowMs), |
clock_(0), |
last_feedback_ms_(0), |
recv_stats_(ReceiveStatistics::Create(&clock_)), |
- baseline_delay_ms_(0), |
+ baseline_delay_ms_(10000), // Initialized as an upper bound. |
delay_signal_ms_(0), |
last_congestion_signal_ms_(0), |
last_delays_index_(0), |
@@ -57,16 +54,19 @@ void NadaBweReceiver::ReceivePacket(int64_t arrival_time_ms, |
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; // Refered as x_n. |
+ // Refered as x_n. |
+ int64_t delay_ms = arrival_time_ms - media_packet.sender_timestamp_ms(); |
+ |
// The min should be updated within the first 10 minutes. |
if (clock_.TimeInMilliseconds() < 10 * 60 * 1000) { |
baseline_delay_ms_ = std::min(baseline_delay_ms_, delay_ms); |
} |
+ |
delay_signal_ms_ = delay_ms - baseline_delay_ms_; // Refered as d_n. |
const int kMedian = ARRAY_SIZE(last_delays_ms_); |
last_delays_ms_[(last_delays_index_++) % kMedian] = delay_signal_ms_; |
int size = std::min(last_delays_index_, kMedian); |
+ |
int64_t median_filtered_delay_ms_ = MedianFilter(last_delays_ms_, size); |
exp_smoothed_delay_ms_ = ExponentialSmoothingFilter( |
median_filtered_delay_ms_, exp_smoothed_delay_ms_, kAlpha); |
@@ -84,9 +84,8 @@ void NadaBweReceiver::ReceivePacket(int64_t arrival_time_ms, |
est_queuing_delay_signal_ms_ = 0; |
} |
- received_packets_.Insert(media_packet.sequence_number(), |
- media_packet.send_time_ms(), arrival_time_ms, |
- media_packet.payload_size()); |
+ // Log received packet information. |
+ BweReceiver::ReceivePacket(arrival_time_ms, media_packet); |
} |
FeedbackPacket* NadaBweReceiver::GetFeedback(int64_t now_ms) { |
@@ -110,67 +109,19 @@ FeedbackPacket* NadaBweReceiver::GetFeedback(int64_t now_ms) { |
last_feedback_ms_ = now_ms; |
last_congestion_signal_ms_ = congestion_signal_ms; |
- PacketIdentifierNode* latest = *(received_packets_.begin()); |
- int64_t corrected_send_time_ms = |
- latest->send_time_ms + now_ms - latest->arrival_time_ms; |
+ int64_t corrected_send_time_ms = 0L; |
+ |
+ if (!received_packets_.empty()) { |
+ PacketIdentifierNode* latest = *(received_packets_.begin()); |
+ corrected_send_time_ms = |
+ latest->send_time_ms + now_ms - latest->arrival_time_ms; |
+ } |
// Sends a tuple containing latest values of <d_hat_n, d_tilde_n, x_n, x'_n, |
// R_r> and additional information. |
- return new NadaFeedback(flow_id_, now_ms, exp_smoothed_delay_ms_, |
+ return new NadaFeedback(flow_id_, now_ms * 1000, exp_smoothed_delay_ms_, |
est_queuing_delay_signal_ms_, congestion_signal_ms, |
- derivative, RecentReceivingRate(), |
- corrected_send_time_ms); |
-} |
- |
-// For a given time window, compute the receiving speed rate in kbps. |
-// As described below, three cases are considered depending on the number of |
-// packets received. |
-size_t NadaBweReceiver::RecentReceivingRate() { |
- // If the receiver didn't receive any packet, return 0. |
- if (received_packets_.empty()) { |
- return 0.0f; |
- } |
- size_t total_size = 0; |
- int number_packets = 0; |
- |
- PacketNodeIt node_it = received_packets_.begin(); |
- |
- int64_t last_time_ms = (*node_it)->arrival_time_ms; |
- int64_t start_time_ms = last_time_ms; |
- PacketNodeIt end = received_packets_.end(); |
- |
- // Stops after including the first packet out of the timeWindow. |
- // Ameliorates results when there are wide gaps between packets. |
- // E.g. Large packets : p1(0ms), p2(3000ms). |
- while (node_it != end) { |
- total_size += (*node_it)->payload_size; |
- last_time_ms = (*node_it)->arrival_time_ms; |
- ++number_packets; |
- if ((*node_it)->arrival_time_ms < |
- start_time_ms - kReceivingRateTimeWindowMs) { |
- break; |
- } |
- ++node_it; |
- } |
- |
- int64_t corrected_time_ms; |
- // If the receiver received a single packet, return its size*8/timeWindow. |
- if (number_packets == 1) { |
- corrected_time_ms = kReceivingRateTimeWindowMs; |
- } |
- // If the receiver received multiple packets, use as time interval the gap |
- // between first and last packet falling in the timeWindow corrected by the |
- // factor number_packets/(number_packets-1). |
- // E.g: Let timeWindow = 500ms, payload_size = 500 bytes, number_packets = 2, |
- // packets received at t1(0ms) and t2(499 or 501ms). This prevent the function |
- // from returning ~2*8, sending instead a more likely ~1*8 kbps. |
- else { |
- corrected_time_ms = (number_packets * (start_time_ms - last_time_ms)) / |
- (number_packets - 1); |
- } |
- |
- // Converting from bytes/ms to kbits/s. |
- return static_cast<size_t>(8 * total_size / corrected_time_ms); |
+ derivative, RecentKbps(), corrected_send_time_ms); |
} |
int64_t NadaBweReceiver::MedianFilter(int64_t* last_delays_ms, int size) { |
@@ -193,16 +144,16 @@ int64_t NadaBweReceiver::ExponentialSmoothingFilter(int64_t new_value, |
// Implementation according to Cisco's proposal by default. |
NadaBweSender::NadaBweSender(int kbps, BitrateObserver* observer, Clock* clock) |
- : clock_(clock), |
+ : BweSender(kbps), // Referred as "Reference Rate" = R_n., |
+ clock_(clock), |
observer_(observer), |
- bitrate_kbps_(kbps), |
original_operating_mode_(true) { |
} |
NadaBweSender::NadaBweSender(BitrateObserver* observer, Clock* clock) |
- : clock_(clock), |
+ : BweSender(kMinBitrateKbps), // Referred as "Reference Rate" = R_n. |
+ clock_(clock), |
observer_(observer), |
- bitrate_kbps_(kMinRefRateKbps), |
original_operating_mode_(true) { |
} |
@@ -252,23 +203,23 @@ void NadaBweSender::GiveFeedback(const FeedbackPacket& feedback) { |
if (fb.congestion_signal() == fb.est_queuing_delay_signal_ms() && |
fb.est_queuing_delay_signal_ms() < kQueuingDelayUpperBoundMs && |
fb.exp_smoothed_delay_ms() < |
- kMinRefRateKbps / kProportionalityDelayBits && |
+ kMinBitrateKbps / kProportionalityDelayBits && |
fb.derivative() < kDerivativeUpperBound && |
- fb.receiving_rate() > kMinRefRateKbps) { |
+ fb.receiving_rate() > kMinBitrateKbps) { |
AcceleratedRampUp(fb); |
} else if (fb.congestion_signal() > kMaxCongestionSignalMs || |
fb.exp_smoothed_delay_ms() > kMaxCongestionSignalMs) { |
AcceleratedRampDown(fb); |
} else { |
double bitrate_reference = |
- (2.0 * bitrate_kbps_) / (kMaxRefRateKbps + kMinRefRateKbps); |
+ (2.0 * bitrate_kbps_) / (kMaxBitrateKbps + kMinBitrateKbps); |
double smoothing_factor = pow(bitrate_reference, 0.75); |
GradualRateUpdate(fb, delta_s, smoothing_factor); |
} |
} |
- bitrate_kbps_ = std::min(bitrate_kbps_, kMaxRefRateKbps); |
- bitrate_kbps_ = std::max(bitrate_kbps_, kMinRefRateKbps); |
+ bitrate_kbps_ = std::min(bitrate_kbps_, kMaxBitrateKbps); |
+ bitrate_kbps_ = std::max(bitrate_kbps_, kMinBitrateKbps); |
observer_->OnNetworkChanged(1000 * bitrate_kbps_, 0, rtt_ms); |
} |
@@ -312,11 +263,11 @@ void NadaBweSender::GradualRateUpdate(const NadaFeedback& fb, |
float x_hat = fb.congestion_signal() + kEta * kTauOMs * fb.derivative(); |
float kTheta = |
- kPriorityWeight * (kMaxRefRateKbps - kMinRefRateKbps) * kReferenceDelayMs; |
+ kPriorityWeight * (kMaxBitrateKbps - kMinBitrateKbps) * kReferenceDelayMs; |
int original_increase = |
static_cast<int>((kKappa * delta_s * |
- (kTheta - (bitrate_kbps_ - kMinRefRateKbps) * x_hat)) / |
+ (kTheta - (bitrate_kbps_ - kMinBitrateKbps) * x_hat)) / |
(kTauOMs * kTauOMs) + |
0.5f); |