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