OLD | NEW |
1 /* | 1 /* |
2 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. | 2 * Copyright (c) 2012 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 #include "webrtc/video_engine/vie_channel_group.h" | 11 #include "webrtc/call/congestion_controller.h" |
12 | 12 |
13 #include "webrtc/base/checks.h" | 13 #include "webrtc/base/checks.h" |
14 #include "webrtc/base/thread_annotations.h" | 14 #include "webrtc/base/thread_annotations.h" |
15 #include "webrtc/common.h" | 15 #include "webrtc/common.h" |
16 #include "webrtc/modules/pacing/include/paced_sender.h" | 16 #include "webrtc/modules/pacing/include/paced_sender.h" |
17 #include "webrtc/modules/pacing/include/packet_router.h" | 17 #include "webrtc/modules/pacing/include/packet_router.h" |
18 #include "webrtc/modules/remote_bitrate_estimator/include/send_time_history.h" | 18 #include "webrtc/modules/remote_bitrate_estimator/include/send_time_history.h" |
19 #include "webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_abs_s
end_time.h" | 19 #include "webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_abs_s
end_time.h" |
20 #include "webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_singl
e_stream.h" | 20 #include "webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_singl
e_stream.h" |
21 #include "webrtc/modules/remote_bitrate_estimator/remote_estimator_proxy.h" | 21 #include "webrtc/modules/remote_bitrate_estimator/remote_estimator_proxy.h" |
(...skipping 114 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
136 rtc::scoped_ptr<RemoteBitrateEstimator> rbe_; | 136 rtc::scoped_ptr<RemoteBitrateEstimator> rbe_; |
137 bool using_absolute_send_time_; | 137 bool using_absolute_send_time_; |
138 uint32_t packets_since_absolute_send_time_; | 138 uint32_t packets_since_absolute_send_time_; |
139 int min_bitrate_bps_; | 139 int min_bitrate_bps_; |
140 | 140 |
141 RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(WrappingBitrateEstimator); | 141 RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(WrappingBitrateEstimator); |
142 }; | 142 }; |
143 | 143 |
144 } // namespace | 144 } // namespace |
145 | 145 |
146 ChannelGroup::ChannelGroup(ProcessThread* process_thread, | 146 CongestionController::CongestionController(ProcessThread* process_thread, |
147 CallStats* call_stats) | 147 CallStats* call_stats) |
148 : remb_(new VieRemb()), | 148 : remb_(new VieRemb()), |
149 bitrate_allocator_(new BitrateAllocator()), | 149 bitrate_allocator_(new BitrateAllocator()), |
150 packet_router_(new PacketRouter()), | 150 packet_router_(new PacketRouter()), |
151 pacer_(new PacedSender(Clock::GetRealTimeClock(), | 151 pacer_(new PacedSender(Clock::GetRealTimeClock(), |
152 packet_router_.get(), | 152 packet_router_.get(), |
153 BitrateController::kDefaultStartBitrateKbps, | 153 BitrateController::kDefaultStartBitrateKbps, |
154 PacedSender::kDefaultPaceMultiplier * | 154 PacedSender::kDefaultPaceMultiplier * |
155 BitrateController::kDefaultStartBitrateKbps, | 155 BitrateController::kDefaultStartBitrateKbps, |
156 0)), | 156 0)), |
157 remote_bitrate_estimator_( | 157 remote_bitrate_estimator_( |
(...skipping 13 matching lines...) Expand all Loading... |
171 call_stats_->RegisterStatsObserver(remote_bitrate_estimator_.get()); | 171 call_stats_->RegisterStatsObserver(remote_bitrate_estimator_.get()); |
172 | 172 |
173 pacer_thread_->RegisterModule(pacer_.get()); | 173 pacer_thread_->RegisterModule(pacer_.get()); |
174 pacer_thread_->Start(); | 174 pacer_thread_->Start(); |
175 | 175 |
176 process_thread->RegisterModule(remote_estimator_proxy_.get()); | 176 process_thread->RegisterModule(remote_estimator_proxy_.get()); |
177 process_thread->RegisterModule(remote_bitrate_estimator_.get()); | 177 process_thread->RegisterModule(remote_bitrate_estimator_.get()); |
178 process_thread->RegisterModule(bitrate_controller_.get()); | 178 process_thread->RegisterModule(bitrate_controller_.get()); |
179 } | 179 } |
180 | 180 |
181 ChannelGroup::~ChannelGroup() { | 181 CongestionController::~CongestionController() { |
182 pacer_thread_->Stop(); | 182 pacer_thread_->Stop(); |
183 pacer_thread_->DeRegisterModule(pacer_.get()); | 183 pacer_thread_->DeRegisterModule(pacer_.get()); |
184 process_thread_->DeRegisterModule(bitrate_controller_.get()); | 184 process_thread_->DeRegisterModule(bitrate_controller_.get()); |
185 process_thread_->DeRegisterModule(remote_bitrate_estimator_.get()); | 185 process_thread_->DeRegisterModule(remote_bitrate_estimator_.get()); |
186 process_thread_->DeRegisterModule(remote_estimator_proxy_.get()); | 186 process_thread_->DeRegisterModule(remote_estimator_proxy_.get()); |
187 call_stats_->DeregisterStatsObserver(remote_bitrate_estimator_.get()); | 187 call_stats_->DeregisterStatsObserver(remote_bitrate_estimator_.get()); |
188 if (transport_feedback_adapter_.get()) | 188 if (transport_feedback_adapter_.get()) |
189 call_stats_->DeregisterStatsObserver(transport_feedback_adapter_.get()); | 189 call_stats_->DeregisterStatsObserver(transport_feedback_adapter_.get()); |
190 RTC_DCHECK(!remb_->InUse()); | 190 RTC_DCHECK(!remb_->InUse()); |
191 RTC_DCHECK(encoders_.empty()); | 191 RTC_DCHECK(encoders_.empty()); |
192 } | 192 } |
193 | 193 |
194 void ChannelGroup::AddEncoder(ViEEncoder* encoder) { | 194 void CongestionController::AddEncoder(ViEEncoder* encoder) { |
195 rtc::CritScope lock(&encoder_crit_); | 195 rtc::CritScope lock(&encoder_crit_); |
196 encoders_.push_back(encoder); | 196 encoders_.push_back(encoder); |
197 } | 197 } |
198 | 198 |
199 void ChannelGroup::RemoveEncoder(ViEEncoder* encoder) { | 199 void CongestionController::RemoveEncoder(ViEEncoder* encoder) { |
200 rtc::CritScope lock(&encoder_crit_); | 200 rtc::CritScope lock(&encoder_crit_); |
201 for (auto it = encoders_.begin(); it != encoders_.end(); ++it) { | 201 for (auto it = encoders_.begin(); it != encoders_.end(); ++it) { |
202 if (*it == encoder) { | 202 if (*it == encoder) { |
203 encoders_.erase(it); | 203 encoders_.erase(it); |
204 return; | 204 return; |
205 } | 205 } |
206 } | 206 } |
207 } | 207 } |
208 | 208 |
209 void ChannelGroup::SetBweBitrates(int min_bitrate_bps, | 209 void CongestionController::SetBweBitrates(int min_bitrate_bps, |
210 int start_bitrate_bps, | 210 int start_bitrate_bps, |
211 int max_bitrate_bps) { | 211 int max_bitrate_bps) { |
212 if (start_bitrate_bps > 0) | 212 if (start_bitrate_bps > 0) |
213 bitrate_controller_->SetStartBitrate(start_bitrate_bps); | 213 bitrate_controller_->SetStartBitrate(start_bitrate_bps); |
214 bitrate_controller_->SetMinMaxBitrate(min_bitrate_bps, max_bitrate_bps); | 214 bitrate_controller_->SetMinMaxBitrate(min_bitrate_bps, max_bitrate_bps); |
215 if (remote_bitrate_estimator_.get()) | 215 if (remote_bitrate_estimator_.get()) |
216 remote_bitrate_estimator_->SetMinBitrate(min_bitrate_bps); | 216 remote_bitrate_estimator_->SetMinBitrate(min_bitrate_bps); |
217 if (transport_feedback_adapter_.get()) | 217 if (transport_feedback_adapter_.get()) |
218 transport_feedback_adapter_->GetBitrateEstimator()->SetMinBitrate( | 218 transport_feedback_adapter_->GetBitrateEstimator()->SetMinBitrate( |
219 min_bitrate_bps); | 219 min_bitrate_bps); |
220 min_bitrate_bps_ = min_bitrate_bps; | 220 min_bitrate_bps_ = min_bitrate_bps; |
221 } | 221 } |
222 | 222 |
223 BitrateController* ChannelGroup::GetBitrateController() const { | 223 BitrateController* CongestionController::GetBitrateController() const { |
224 return bitrate_controller_.get(); | 224 return bitrate_controller_.get(); |
225 } | 225 } |
226 | 226 |
227 RemoteBitrateEstimator* ChannelGroup::GetRemoteBitrateEstimator( | 227 RemoteBitrateEstimator* CongestionController::GetRemoteBitrateEstimator( |
228 bool send_side_bwe) const { | 228 bool send_side_bwe) const { |
229 | 229 |
230 if (send_side_bwe) | 230 if (send_side_bwe) |
231 return remote_estimator_proxy_.get(); | 231 return remote_estimator_proxy_.get(); |
232 else | 232 else |
233 return remote_bitrate_estimator_.get(); | 233 return remote_bitrate_estimator_.get(); |
234 } | 234 } |
235 | 235 |
236 TransportFeedbackObserver* ChannelGroup::GetTransportFeedbackObserver() { | 236 TransportFeedbackObserver* |
| 237 CongestionController::GetTransportFeedbackObserver() { |
237 if (transport_feedback_adapter_.get() == nullptr) { | 238 if (transport_feedback_adapter_.get() == nullptr) { |
238 transport_feedback_adapter_.reset(new TransportFeedbackAdapter( | 239 transport_feedback_adapter_.reset(new TransportFeedbackAdapter( |
239 bitrate_controller_->CreateRtcpBandwidthObserver(), | 240 bitrate_controller_->CreateRtcpBandwidthObserver(), |
240 Clock::GetRealTimeClock(), process_thread_)); | 241 Clock::GetRealTimeClock(), process_thread_)); |
241 transport_feedback_adapter_->SetBitrateEstimator( | 242 transport_feedback_adapter_->SetBitrateEstimator( |
242 new RemoteBitrateEstimatorAbsSendTime( | 243 new RemoteBitrateEstimatorAbsSendTime( |
243 transport_feedback_adapter_.get(), Clock::GetRealTimeClock())); | 244 transport_feedback_adapter_.get(), Clock::GetRealTimeClock())); |
244 transport_feedback_adapter_->GetBitrateEstimator()->SetMinBitrate( | 245 transport_feedback_adapter_->GetBitrateEstimator()->SetMinBitrate( |
245 min_bitrate_bps_); | 246 min_bitrate_bps_); |
246 call_stats_->RegisterStatsObserver(transport_feedback_adapter_.get()); | 247 call_stats_->RegisterStatsObserver(transport_feedback_adapter_.get()); |
247 } | 248 } |
248 return transport_feedback_adapter_.get(); | 249 return transport_feedback_adapter_.get(); |
249 } | 250 } |
250 | 251 |
251 int64_t ChannelGroup::GetPacerQueuingDelayMs() const { | 252 int64_t CongestionController::GetPacerQueuingDelayMs() const { |
252 return pacer_->QueueInMs(); | 253 return pacer_->QueueInMs(); |
253 } | 254 } |
254 | 255 |
255 // TODO(mflodman): Move out of this class. | 256 // TODO(mflodman): Move out of this class. |
256 void ChannelGroup::SetChannelRembStatus(bool sender, | 257 void CongestionController::SetChannelRembStatus(bool sender, |
257 bool receiver, | 258 bool receiver, |
258 RtpRtcp* rtp_module) { | 259 RtpRtcp* rtp_module) { |
259 rtp_module->SetREMBStatus(sender || receiver); | 260 rtp_module->SetREMBStatus(sender || receiver); |
260 if (sender) { | 261 if (sender) { |
261 remb_->AddRembSender(rtp_module); | 262 remb_->AddRembSender(rtp_module); |
262 } else { | 263 } else { |
263 remb_->RemoveRembSender(rtp_module); | 264 remb_->RemoveRembSender(rtp_module); |
264 } | 265 } |
265 if (receiver) { | 266 if (receiver) { |
266 remb_->AddReceiveChannel(rtp_module); | 267 remb_->AddReceiveChannel(rtp_module); |
267 } else { | 268 } else { |
268 remb_->RemoveReceiveChannel(rtp_module); | 269 remb_->RemoveReceiveChannel(rtp_module); |
269 } | 270 } |
270 } | 271 } |
271 | 272 |
272 void ChannelGroup::SignalNetworkState(NetworkState state) { | 273 void CongestionController::SignalNetworkState(NetworkState state) { |
273 if (state == kNetworkUp) { | 274 if (state == kNetworkUp) { |
274 pacer_->Resume(); | 275 pacer_->Resume(); |
275 } else { | 276 } else { |
276 pacer_->Pause(); | 277 pacer_->Pause(); |
277 } | 278 } |
278 } | 279 } |
279 | 280 |
280 // TODO(mflodman): Move this logic out from ChannelGroup. | 281 // TODO(mflodman): Move this logic out from CongestionController. |
281 void ChannelGroup::OnNetworkChanged(uint32_t target_bitrate_bps, | 282 void CongestionController::OnNetworkChanged(uint32_t target_bitrate_bps, |
282 uint8_t fraction_loss, | 283 uint8_t fraction_loss, |
283 int64_t rtt) { | 284 int64_t rtt) { |
284 bitrate_allocator_->OnNetworkChanged(target_bitrate_bps, fraction_loss, rtt); | 285 bitrate_allocator_->OnNetworkChanged(target_bitrate_bps, fraction_loss, rtt); |
285 int pad_up_to_bitrate_bps = 0; | 286 int pad_up_to_bitrate_bps = 0; |
286 { | 287 { |
287 rtc::CritScope lock(&encoder_crit_); | 288 rtc::CritScope lock(&encoder_crit_); |
288 for (const auto& encoder : encoders_) | 289 for (const auto& encoder : encoders_) |
289 pad_up_to_bitrate_bps += encoder->GetPaddingNeededBps(); | 290 pad_up_to_bitrate_bps += encoder->GetPaddingNeededBps(); |
290 } | 291 } |
291 pacer_->UpdateBitrate( | 292 pacer_->UpdateBitrate( |
292 target_bitrate_bps / 1000, | 293 target_bitrate_bps / 1000, |
293 PacedSender::kDefaultPaceMultiplier * target_bitrate_bps / 1000, | 294 PacedSender::kDefaultPaceMultiplier * target_bitrate_bps / 1000, |
294 pad_up_to_bitrate_bps / 1000); | 295 pad_up_to_bitrate_bps / 1000); |
295 } | 296 } |
296 | 297 |
297 void ChannelGroup::OnSentPacket(const rtc::SentPacket& sent_packet) { | 298 void CongestionController::OnSentPacket(const rtc::SentPacket& sent_packet) { |
298 if (transport_feedback_adapter_) { | 299 if (transport_feedback_adapter_) { |
299 transport_feedback_adapter_->UpdateSendTime(sent_packet.packet_id, | 300 transport_feedback_adapter_->UpdateSendTime(sent_packet.packet_id, |
300 sent_packet.send_time_ms); | 301 sent_packet.send_time_ms); |
301 } | 302 } |
302 } | 303 } |
303 } // namespace webrtc | 304 } // namespace webrtc |
OLD | NEW |