OLD | NEW |
---|---|
1 /* | 1 /* |
2 * Copyright (c) 2015 The WebRTC project authors. All Rights Reserved. | 2 * Copyright (c) 2015 The WebRTC project authors. All Rights Reserved. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license | 4 * Use of this source code is governed by a BSD-style license |
5 * that can be found in the LICENSE file in the root of the source | 5 * that can be found in the LICENSE file in the root of the source |
6 * tree. An additional intellectual property rights grant can be found | 6 * tree. An additional intellectual property rights grant can be found |
7 * in the file PATENTS. All contributing project authors may | 7 * in the file PATENTS. All contributing project authors may |
8 * be found in the AUTHORS file in the root of the source tree. | 8 * be found in the AUTHORS file in the root of the source tree. |
9 * | 9 * |
10 */ | 10 */ |
11 | 11 |
12 // Implementation of Network-Assisted Dynamic Adaptation's (NADA's) proposal. | 12 // Implementation of Network-Assisted Dynamic Adaptation's (NADA's) proposal. |
13 // Version according to Draft Document (mentioned in references) | 13 // Version according to Draft Document (mentioned in references) |
14 // http://tools.ietf.org/html/draft-zhu-rmcat-nada-06 | 14 // http://tools.ietf.org/html/draft-zhu-rmcat-nada-06 |
15 // From March 26, 2015. | 15 // From March 26, 2015. |
16 | 16 |
17 #include <math.h> | 17 #include <math.h> |
18 #include <algorithm> | 18 #include <algorithm> |
19 #include <vector> | 19 #include <vector> |
20 | |
21 // DEBUG | |
20 #include <iostream> | 22 #include <iostream> |
stefan-webrtc
2015/07/15 11:35:54
Remove
magalhaesc
2015/07/15 11:41:59
Done.
| |
21 | 23 |
22 #include "webrtc/base/common.h" | 24 #include "webrtc/base/common.h" |
23 #include "webrtc/modules/remote_bitrate_estimator/test/estimators/nada.h" | 25 #include "webrtc/modules/remote_bitrate_estimator/test/estimators/nada.h" |
24 #include "webrtc/modules/remote_bitrate_estimator/test/bwe_test_logging.h" | 26 #include "webrtc/modules/remote_bitrate_estimator/test/bwe_test_logging.h" |
25 #include "webrtc/modules/rtp_rtcp/interface/receive_statistics.h" | 27 #include "webrtc/modules/rtp_rtcp/interface/receive_statistics.h" |
26 | 28 |
27 namespace webrtc { | 29 namespace webrtc { |
28 namespace testing { | 30 namespace testing { |
29 namespace bwe { | 31 namespace bwe { |
30 | 32 |
31 const int NadaBweSender::kMinRefRateKbps = 150; | |
32 const int NadaBweSender::kMaxRefRateKbps = 1500; | |
33 const int64_t NadaBweReceiver::kReceivingRateTimeWindowMs = 500; | 33 const int64_t NadaBweReceiver::kReceivingRateTimeWindowMs = 500; |
34 | 34 |
35 NadaBweReceiver::NadaBweReceiver(int flow_id) | 35 NadaBweReceiver::NadaBweReceiver(int flow_id) |
36 : BweReceiver(flow_id), | 36 : BweReceiver(flow_id, kReceivingRateTimeWindowMs), |
37 clock_(0), | 37 clock_(0), |
38 last_feedback_ms_(0), | 38 last_feedback_ms_(0), |
39 recv_stats_(ReceiveStatistics::Create(&clock_)), | 39 recv_stats_(ReceiveStatistics::Create(&clock_)), |
40 baseline_delay_ms_(0), | 40 baseline_delay_ms_(10000), // Initialized as an upper bound. |
41 delay_signal_ms_(0), | 41 delay_signal_ms_(0), |
42 last_congestion_signal_ms_(0), | 42 last_congestion_signal_ms_(0), |
43 last_delays_index_(0), | 43 last_delays_index_(0), |
44 exp_smoothed_delay_ms_(-1), | 44 exp_smoothed_delay_ms_(-1), |
45 est_queuing_delay_signal_ms_(0) { | 45 est_queuing_delay_signal_ms_(0) { |
46 } | 46 } |
47 | 47 |
48 NadaBweReceiver::~NadaBweReceiver() { | 48 NadaBweReceiver::~NadaBweReceiver() { |
49 } | 49 } |
50 | 50 |
51 void NadaBweReceiver::ReceivePacket(int64_t arrival_time_ms, | 51 void NadaBweReceiver::ReceivePacket(int64_t arrival_time_ms, |
52 const MediaPacket& media_packet) { | 52 const MediaPacket& media_packet) { |
53 const float kAlpha = 0.1f; // Used for exponential smoothing. | 53 const float kAlpha = 0.1f; // Used for exponential smoothing. |
54 const int64_t kDelayLowThresholdMs = 50; // Referred as d_th. | 54 const int64_t kDelayLowThresholdMs = 50; // Referred as d_th. |
55 const int64_t kDelayMaxThresholdMs = 400; // Referred as d_max. | 55 const int64_t kDelayMaxThresholdMs = 400; // Referred as d_max. |
56 | 56 |
57 clock_.AdvanceTimeMilliseconds(arrival_time_ms - clock_.TimeInMilliseconds()); | 57 clock_.AdvanceTimeMilliseconds(arrival_time_ms - clock_.TimeInMilliseconds()); |
58 recv_stats_->IncomingPacket(media_packet.header(), | 58 recv_stats_->IncomingPacket(media_packet.header(), |
59 media_packet.payload_size(), false); | 59 media_packet.payload_size(), false); |
60 int64_t delay_ms = arrival_time_ms - | 60 // Refered as x_n. |
61 media_packet.creation_time_us() / 1000; // Refered as x_n. | 61 int64_t delay_ms = arrival_time_ms - media_packet.sender_timestamp_ms(); |
62 | |
62 // The min should be updated within the first 10 minutes. | 63 // The min should be updated within the first 10 minutes. |
63 if (clock_.TimeInMilliseconds() < 10 * 60 * 1000) { | 64 if (clock_.TimeInMilliseconds() < 10 * 60 * 1000) { |
64 baseline_delay_ms_ = std::min(baseline_delay_ms_, delay_ms); | 65 baseline_delay_ms_ = std::min(baseline_delay_ms_, delay_ms); |
65 } | 66 } |
67 | |
66 delay_signal_ms_ = delay_ms - baseline_delay_ms_; // Refered as d_n. | 68 delay_signal_ms_ = delay_ms - baseline_delay_ms_; // Refered as d_n. |
67 const int kMedian = ARRAY_SIZE(last_delays_ms_); | 69 const int kMedian = ARRAY_SIZE(last_delays_ms_); |
68 last_delays_ms_[(last_delays_index_++) % kMedian] = delay_signal_ms_; | 70 last_delays_ms_[(last_delays_index_++) % kMedian] = delay_signal_ms_; |
69 int size = std::min(last_delays_index_, kMedian); | 71 int size = std::min(last_delays_index_, kMedian); |
72 | |
70 int64_t median_filtered_delay_ms_ = MedianFilter(last_delays_ms_, size); | 73 int64_t median_filtered_delay_ms_ = MedianFilter(last_delays_ms_, size); |
71 exp_smoothed_delay_ms_ = ExponentialSmoothingFilter( | 74 exp_smoothed_delay_ms_ = ExponentialSmoothingFilter( |
72 median_filtered_delay_ms_, exp_smoothed_delay_ms_, kAlpha); | 75 median_filtered_delay_ms_, exp_smoothed_delay_ms_, kAlpha); |
73 | 76 |
74 if (exp_smoothed_delay_ms_ < kDelayLowThresholdMs) { | 77 if (exp_smoothed_delay_ms_ < kDelayLowThresholdMs) { |
75 est_queuing_delay_signal_ms_ = exp_smoothed_delay_ms_; | 78 est_queuing_delay_signal_ms_ = exp_smoothed_delay_ms_; |
76 } else if (exp_smoothed_delay_ms_ < kDelayMaxThresholdMs) { | 79 } else if (exp_smoothed_delay_ms_ < kDelayMaxThresholdMs) { |
77 est_queuing_delay_signal_ms_ = static_cast<int64_t>( | 80 est_queuing_delay_signal_ms_ = static_cast<int64_t>( |
78 pow((static_cast<double>(kDelayMaxThresholdMs - | 81 pow((static_cast<double>(kDelayMaxThresholdMs - |
79 exp_smoothed_delay_ms_)) / | 82 exp_smoothed_delay_ms_)) / |
(...skipping 23 matching lines...) Expand all Loading... | |
103 int64_t congestion_signal_ms = est_queuing_delay_signal_ms_ + loss_signal_ms; | 106 int64_t congestion_signal_ms = est_queuing_delay_signal_ms_ + loss_signal_ms; |
104 | 107 |
105 float derivative = 0.0f; | 108 float derivative = 0.0f; |
106 if (last_feedback_ms_ > 0) { | 109 if (last_feedback_ms_ > 0) { |
107 derivative = (congestion_signal_ms - last_congestion_signal_ms_) / | 110 derivative = (congestion_signal_ms - last_congestion_signal_ms_) / |
108 static_cast<float>(now_ms - last_feedback_ms_); | 111 static_cast<float>(now_ms - last_feedback_ms_); |
109 } | 112 } |
110 last_feedback_ms_ = now_ms; | 113 last_feedback_ms_ = now_ms; |
111 last_congestion_signal_ms_ = congestion_signal_ms; | 114 last_congestion_signal_ms_ = congestion_signal_ms; |
112 | 115 |
113 PacketIdentifierNode* latest = *(received_packets_.begin()); | 116 int64_t corrected_send_time_ms = 0L; |
114 int64_t corrected_send_time_ms = | 117 |
115 latest->send_time_ms + now_ms - latest->arrival_time_ms; | 118 if (!received_packets_.empty()) { |
119 PacketIdentifierNode* latest = *(received_packets_.begin()); | |
120 corrected_send_time_ms = | |
121 latest->send_time_ms + now_ms - latest->arrival_time_ms; | |
122 } | |
116 | 123 |
117 // Sends a tuple containing latest values of <d_hat_n, d_tilde_n, x_n, x'_n, | 124 // Sends a tuple containing latest values of <d_hat_n, d_tilde_n, x_n, x'_n, |
118 // R_r> and additional information. | 125 // R_r> and additional information. |
119 return new NadaFeedback(flow_id_, now_ms, exp_smoothed_delay_ms_, | 126 return new NadaFeedback(flow_id_, now_ms * 1000, exp_smoothed_delay_ms_, |
120 est_queuing_delay_signal_ms_, congestion_signal_ms, | 127 est_queuing_delay_signal_ms_, congestion_signal_ms, |
121 derivative, RecentReceivingRate(), | 128 derivative, RecentKbps(), corrected_send_time_ms); |
122 corrected_send_time_ms); | |
123 } | |
124 | |
125 // For a given time window, compute the receiving speed rate in kbps. | |
126 // As described below, three cases are considered depending on the number of | |
127 // packets received. | |
128 size_t NadaBweReceiver::RecentReceivingRate() { | |
129 // If the receiver didn't receive any packet, return 0. | |
130 if (received_packets_.empty()) { | |
131 return 0.0f; | |
132 } | |
133 size_t total_size = 0; | |
134 int number_packets = 0; | |
135 | |
136 PacketNodeIt node_it = received_packets_.begin(); | |
137 | |
138 int64_t last_time_ms = (*node_it)->arrival_time_ms; | |
139 int64_t start_time_ms = last_time_ms; | |
140 PacketNodeIt end = received_packets_.end(); | |
141 | |
142 // Stops after including the first packet out of the timeWindow. | |
143 // Ameliorates results when there are wide gaps between packets. | |
144 // E.g. Large packets : p1(0ms), p2(3000ms). | |
145 while (node_it != end) { | |
146 total_size += (*node_it)->payload_size; | |
147 last_time_ms = (*node_it)->arrival_time_ms; | |
148 ++number_packets; | |
149 if ((*node_it)->arrival_time_ms < | |
150 start_time_ms - kReceivingRateTimeWindowMs) { | |
151 break; | |
152 } | |
153 ++node_it; | |
154 } | |
155 | |
156 int64_t corrected_time_ms; | |
157 // If the receiver received a single packet, return its size*8/timeWindow. | |
158 if (number_packets == 1) { | |
159 corrected_time_ms = kReceivingRateTimeWindowMs; | |
160 } | |
161 // If the receiver received multiple packets, use as time interval the gap | |
162 // between first and last packet falling in the timeWindow corrected by the | |
163 // factor number_packets/(number_packets-1). | |
164 // E.g: Let timeWindow = 500ms, payload_size = 500 bytes, number_packets = 2, | |
165 // packets received at t1(0ms) and t2(499 or 501ms). This prevent the function | |
166 // from returning ~2*8, sending instead a more likely ~1*8 kbps. | |
167 else { | |
168 corrected_time_ms = (number_packets * (start_time_ms - last_time_ms)) / | |
169 (number_packets - 1); | |
170 } | |
171 | |
172 // Converting from bytes/ms to kbits/s. | |
173 return static_cast<size_t>(8 * total_size / corrected_time_ms); | |
174 } | 129 } |
175 | 130 |
176 int64_t NadaBweReceiver::MedianFilter(int64_t* last_delays_ms, int size) { | 131 int64_t NadaBweReceiver::MedianFilter(int64_t* last_delays_ms, int size) { |
177 // Typically, size = 5. | 132 // Typically, size = 5. |
178 std::vector<int64_t> array_copy(last_delays_ms, last_delays_ms + size); | 133 std::vector<int64_t> array_copy(last_delays_ms, last_delays_ms + size); |
179 std::nth_element(array_copy.begin(), array_copy.begin() + size / 2, | 134 std::nth_element(array_copy.begin(), array_copy.begin() + size / 2, |
180 array_copy.end()); | 135 array_copy.end()); |
181 return array_copy.at(size / 2); | 136 return array_copy.at(size / 2); |
182 } | 137 } |
183 | 138 |
184 int64_t NadaBweReceiver::ExponentialSmoothingFilter(int64_t new_value, | 139 int64_t NadaBweReceiver::ExponentialSmoothingFilter(int64_t new_value, |
185 int64_t last_smoothed_value, | 140 int64_t last_smoothed_value, |
186 float alpha) { | 141 float alpha) { |
187 if (last_smoothed_value < 0) { | 142 if (last_smoothed_value < 0) { |
188 return new_value; // Handling initial case. | 143 return new_value; // Handling initial case. |
189 } | 144 } |
190 return static_cast<int64_t>(alpha * new_value + | 145 return static_cast<int64_t>(alpha * new_value + |
191 (1.0f - alpha) * last_smoothed_value + 0.5f); | 146 (1.0f - alpha) * last_smoothed_value + 0.5f); |
192 } | 147 } |
193 | 148 |
194 // Implementation according to Cisco's proposal by default. | 149 // Implementation according to Cisco's proposal by default. |
195 NadaBweSender::NadaBweSender(int kbps, BitrateObserver* observer, Clock* clock) | 150 NadaBweSender::NadaBweSender(int kbps, BitrateObserver* observer, Clock* clock) |
196 : clock_(clock), | 151 : BweSender(kbps), // Referred as "Reference Rate" = R_n., |
152 clock_(clock), | |
197 observer_(observer), | 153 observer_(observer), |
198 bitrate_kbps_(kbps), | |
199 original_operating_mode_(true) { | 154 original_operating_mode_(true) { |
200 } | 155 } |
201 | 156 |
202 NadaBweSender::NadaBweSender(BitrateObserver* observer, Clock* clock) | 157 NadaBweSender::NadaBweSender(BitrateObserver* observer, Clock* clock) |
203 : clock_(clock), | 158 : BweSender(kMinBitrateKbps), // Referred as "Reference Rate" = R_n. |
159 clock_(clock), | |
204 observer_(observer), | 160 observer_(observer), |
205 bitrate_kbps_(kMinRefRateKbps), | |
206 original_operating_mode_(true) { | 161 original_operating_mode_(true) { |
207 } | 162 } |
208 | 163 |
209 NadaBweSender::~NadaBweSender() { | 164 NadaBweSender::~NadaBweSender() { |
210 } | 165 } |
211 | 166 |
212 int NadaBweSender::GetFeedbackIntervalMs() const { | 167 int NadaBweSender::GetFeedbackIntervalMs() const { |
213 return 100; | 168 return 100; |
214 } | 169 } |
215 | 170 |
(...skipping 29 matching lines...) Expand all Loading... | |
245 fb.derivative() < kDerivativeUpperBound) { | 200 fb.derivative() < kDerivativeUpperBound) { |
246 AcceleratedRampUp(fb); | 201 AcceleratedRampUp(fb); |
247 } else { | 202 } else { |
248 GradualRateUpdate(fb, delta_s, 1.0); | 203 GradualRateUpdate(fb, delta_s, 1.0); |
249 } | 204 } |
250 } else { | 205 } else { |
251 // Modified if conditions and rate update; new ramp down mode. | 206 // Modified if conditions and rate update; new ramp down mode. |
252 if (fb.congestion_signal() == fb.est_queuing_delay_signal_ms() && | 207 if (fb.congestion_signal() == fb.est_queuing_delay_signal_ms() && |
253 fb.est_queuing_delay_signal_ms() < kQueuingDelayUpperBoundMs && | 208 fb.est_queuing_delay_signal_ms() < kQueuingDelayUpperBoundMs && |
254 fb.exp_smoothed_delay_ms() < | 209 fb.exp_smoothed_delay_ms() < |
255 kMinRefRateKbps / kProportionalityDelayBits && | 210 kMinBitrateKbps / kProportionalityDelayBits && |
256 fb.derivative() < kDerivativeUpperBound && | 211 fb.derivative() < kDerivativeUpperBound && |
257 fb.receiving_rate() > kMinRefRateKbps) { | 212 fb.receiving_rate() > kMinBitrateKbps) { |
258 AcceleratedRampUp(fb); | 213 AcceleratedRampUp(fb); |
259 } else if (fb.congestion_signal() > kMaxCongestionSignalMs || | 214 } else if (fb.congestion_signal() > kMaxCongestionSignalMs || |
260 fb.exp_smoothed_delay_ms() > kMaxCongestionSignalMs) { | 215 fb.exp_smoothed_delay_ms() > kMaxCongestionSignalMs) { |
261 AcceleratedRampDown(fb); | 216 AcceleratedRampDown(fb); |
262 } else { | 217 } else { |
263 double bitrate_reference = | 218 double bitrate_reference = |
264 (2.0 * bitrate_kbps_) / (kMaxRefRateKbps + kMinRefRateKbps); | 219 (2.0 * bitrate_kbps_) / (kMaxBitrateKbps + kMinBitrateKbps); |
265 double smoothing_factor = pow(bitrate_reference, 0.75); | 220 double smoothing_factor = pow(bitrate_reference, 0.75); |
266 GradualRateUpdate(fb, delta_s, smoothing_factor); | 221 GradualRateUpdate(fb, delta_s, smoothing_factor); |
267 } | 222 } |
268 } | 223 } |
269 | 224 |
270 bitrate_kbps_ = std::min(bitrate_kbps_, kMaxRefRateKbps); | 225 bitrate_kbps_ = std::min(bitrate_kbps_, kMaxBitrateKbps); |
271 bitrate_kbps_ = std::max(bitrate_kbps_, kMinRefRateKbps); | 226 bitrate_kbps_ = std::max(bitrate_kbps_, kMinBitrateKbps); |
272 | 227 |
273 observer_->OnNetworkChanged(1000 * bitrate_kbps_, 0, rtt_ms); | 228 observer_->OnNetworkChanged(1000 * bitrate_kbps_, 0, rtt_ms); |
274 } | 229 } |
275 | 230 |
276 int64_t NadaBweSender::TimeUntilNextProcess() { | 231 int64_t NadaBweSender::TimeUntilNextProcess() { |
277 return 100; | 232 return 100; |
278 } | 233 } |
279 | 234 |
280 int NadaBweSender::Process() { | 235 int NadaBweSender::Process() { |
281 return 0; | 236 return 0; |
(...skipping 23 matching lines...) Expand all Loading... | |
305 double smoothing_factor) { | 260 double smoothing_factor) { |
306 const float kTauOMs = 500.0f; // Referred as tau_o. | 261 const float kTauOMs = 500.0f; // Referred as tau_o. |
307 const float kEta = 2.0f; // Referred as eta. | 262 const float kEta = 2.0f; // Referred as eta. |
308 const float kKappa = 1.0f; // Referred as kappa. | 263 const float kKappa = 1.0f; // Referred as kappa. |
309 const float kReferenceDelayMs = 10.0f; // Referred as x_ref. | 264 const float kReferenceDelayMs = 10.0f; // Referred as x_ref. |
310 const float kPriorityWeight = 1.0f; // Referred as w. | 265 const float kPriorityWeight = 1.0f; // Referred as w. |
311 | 266 |
312 float x_hat = fb.congestion_signal() + kEta * kTauOMs * fb.derivative(); | 267 float x_hat = fb.congestion_signal() + kEta * kTauOMs * fb.derivative(); |
313 | 268 |
314 float kTheta = | 269 float kTheta = |
315 kPriorityWeight * (kMaxRefRateKbps - kMinRefRateKbps) * kReferenceDelayMs; | 270 kPriorityWeight * (kMaxBitrateKbps - kMinBitrateKbps) * kReferenceDelayMs; |
316 | 271 |
317 int original_increase = | 272 int original_increase = |
318 static_cast<int>((kKappa * delta_s * | 273 static_cast<int>((kKappa * delta_s * |
319 (kTheta - (bitrate_kbps_ - kMinRefRateKbps) * x_hat)) / | 274 (kTheta - (bitrate_kbps_ - kMinBitrateKbps) * x_hat)) / |
320 (kTauOMs * kTauOMs) + | 275 (kTauOMs * kTauOMs) + |
321 0.5f); | 276 0.5f); |
322 | 277 |
323 bitrate_kbps_ = bitrate_kbps_ + smoothing_factor * original_increase; | 278 bitrate_kbps_ = bitrate_kbps_ + smoothing_factor * original_increase; |
324 } | 279 } |
325 | 280 |
326 } // namespace bwe | 281 } // namespace bwe |
327 } // namespace testing | 282 } // namespace testing |
328 } // namespace webrtc | 283 } // namespace webrtc |
OLD | NEW |