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/video_engine/vie_channel_group.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/transport_feedback_adapter.h" | 22 #include "webrtc/modules/remote_bitrate_estimator/transport_feedback_adapter.h" |
22 #include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp.h" | 23 #include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp.h" |
23 #include "webrtc/modules/utility/interface/process_thread.h" | 24 #include "webrtc/modules/utility/interface/process_thread.h" |
24 #include "webrtc/system_wrappers/interface/critical_section_wrapper.h" | 25 #include "webrtc/system_wrappers/interface/critical_section_wrapper.h" |
25 #include "webrtc/system_wrappers/interface/logging.h" | 26 #include "webrtc/system_wrappers/interface/logging.h" |
26 #include "webrtc/video_engine/call_stats.h" | 27 #include "webrtc/video_engine/call_stats.h" |
27 #include "webrtc/video_engine/encoder_state_feedback.h" | 28 #include "webrtc/video_engine/encoder_state_feedback.h" |
28 #include "webrtc/video_engine/payload_router.h" | 29 #include "webrtc/video_engine/payload_router.h" |
29 #include "webrtc/video_engine/vie_channel.h" | 30 #include "webrtc/video_engine/vie_channel.h" |
30 #include "webrtc/video_engine/vie_encoder.h" | 31 #include "webrtc/video_engine/vie_encoder.h" |
(...skipping 107 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
138 | 139 |
139 RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(WrappingBitrateEstimator); | 140 RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(WrappingBitrateEstimator); |
140 }; | 141 }; |
141 | 142 |
142 } // namespace | 143 } // namespace |
143 | 144 |
144 ChannelGroup::ChannelGroup(ProcessThread* process_thread) | 145 ChannelGroup::ChannelGroup(ProcessThread* process_thread) |
145 : remb_(new VieRemb()), | 146 : remb_(new VieRemb()), |
146 bitrate_allocator_(new BitrateAllocator()), | 147 bitrate_allocator_(new BitrateAllocator()), |
147 call_stats_(new CallStats()), | 148 call_stats_(new CallStats()), |
148 encoder_state_feedback_(new EncoderStateFeedback()), | |
149 packet_router_(new PacketRouter()), | 149 packet_router_(new PacketRouter()), |
150 pacer_(new PacedSender(Clock::GetRealTimeClock(), | 150 pacer_(new PacedSender(Clock::GetRealTimeClock(), |
151 packet_router_.get(), | 151 packet_router_.get(), |
152 BitrateController::kDefaultStartBitrateKbps, | 152 BitrateController::kDefaultStartBitrateKbps, |
153 PacedSender::kDefaultPaceMultiplier * | 153 PacedSender::kDefaultPaceMultiplier * |
154 BitrateController::kDefaultStartBitrateKbps, | 154 BitrateController::kDefaultStartBitrateKbps, |
155 0)), | 155 0)), |
| 156 remote_bitrate_estimator_( |
| 157 new WrappingBitrateEstimator(remb_.get(), Clock::GetRealTimeClock())), |
| 158 remote_estimator_proxy_( |
| 159 new RemoteEstimatorProxy(Clock::GetRealTimeClock(), |
| 160 packet_router_.get())), |
| 161 encoder_state_feedback_(new EncoderStateFeedback()), |
156 process_thread_(process_thread), | 162 process_thread_(process_thread), |
157 pacer_thread_(ProcessThread::Create("PacerThread")), | 163 pacer_thread_(ProcessThread::Create("PacerThread")), |
158 // Constructed last as this object calls the provided callback on | 164 // Constructed last as this object calls the provided callback on |
159 // construction. | 165 // construction. |
160 bitrate_controller_( | 166 bitrate_controller_( |
161 BitrateController::CreateBitrateController(Clock::GetRealTimeClock(), | 167 BitrateController::CreateBitrateController(Clock::GetRealTimeClock(), |
162 this)) { | 168 this)) { |
163 remote_bitrate_estimator_.reset(new WrappingBitrateEstimator( | |
164 remb_.get(), Clock::GetRealTimeClock())); | |
165 | |
166 call_stats_->RegisterStatsObserver(remote_bitrate_estimator_.get()); | 169 call_stats_->RegisterStatsObserver(remote_bitrate_estimator_.get()); |
167 | 170 |
168 pacer_thread_->RegisterModule(pacer_.get()); | 171 pacer_thread_->RegisterModule(pacer_.get()); |
169 pacer_thread_->Start(); | 172 pacer_thread_->Start(); |
170 | 173 |
| 174 process_thread->RegisterModule(remote_estimator_proxy_.get()); |
171 process_thread->RegisterModule(remote_bitrate_estimator_.get()); | 175 process_thread->RegisterModule(remote_bitrate_estimator_.get()); |
172 process_thread->RegisterModule(call_stats_.get()); | 176 process_thread->RegisterModule(call_stats_.get()); |
173 process_thread->RegisterModule(bitrate_controller_.get()); | 177 process_thread->RegisterModule(bitrate_controller_.get()); |
174 } | 178 } |
175 | 179 |
176 ChannelGroup::~ChannelGroup() { | 180 ChannelGroup::~ChannelGroup() { |
177 pacer_thread_->Stop(); | 181 pacer_thread_->Stop(); |
178 pacer_thread_->DeRegisterModule(pacer_.get()); | 182 pacer_thread_->DeRegisterModule(pacer_.get()); |
179 process_thread_->DeRegisterModule(bitrate_controller_.get()); | 183 process_thread_->DeRegisterModule(bitrate_controller_.get()); |
180 process_thread_->DeRegisterModule(call_stats_.get()); | 184 process_thread_->DeRegisterModule(call_stats_.get()); |
181 process_thread_->DeRegisterModule(remote_bitrate_estimator_.get()); | 185 process_thread_->DeRegisterModule(remote_bitrate_estimator_.get()); |
| 186 process_thread_->DeRegisterModule(remote_estimator_proxy_.get()); |
182 call_stats_->DeregisterStatsObserver(remote_bitrate_estimator_.get()); | 187 call_stats_->DeregisterStatsObserver(remote_bitrate_estimator_.get()); |
| 188 if (transport_feedback_adapter_.get()) |
| 189 call_stats_->DeregisterStatsObserver(transport_feedback_adapter_.get()); |
183 RTC_DCHECK(channel_map_.empty()); | 190 RTC_DCHECK(channel_map_.empty()); |
184 RTC_DCHECK(!remb_->InUse()); | 191 RTC_DCHECK(!remb_->InUse()); |
185 RTC_DCHECK(vie_encoder_map_.empty()); | 192 RTC_DCHECK(vie_encoder_map_.empty()); |
186 } | 193 } |
187 | 194 |
188 bool ChannelGroup::CreateSendChannel(int channel_id, | 195 bool ChannelGroup::CreateSendChannel(int channel_id, |
189 Transport* transport, | 196 Transport* transport, |
190 int number_of_cores, | 197 int number_of_cores, |
191 const std::vector<uint32_t>& ssrcs) { | 198 const VideoSendStream::Config& config) { |
| 199 TransportFeedbackObserver* transport_feedback_observer = nullptr; |
| 200 bool transport_seq_enabled = false; |
| 201 for (const RtpExtension& extension : config.rtp.extensions) { |
| 202 if (extension.name == RtpExtension::kTransportSequenceNumber) { |
| 203 transport_seq_enabled = true; |
| 204 break; |
| 205 } |
| 206 } |
| 207 if (transport_seq_enabled) { |
| 208 if (transport_feedback_adapter_.get() == nullptr) { |
| 209 transport_feedback_adapter_.reset(new TransportFeedbackAdapter( |
| 210 bitrate_controller_->CreateRtcpBandwidthObserver(), |
| 211 Clock::GetRealTimeClock(), process_thread_)); |
| 212 transport_feedback_adapter_->SetBitrateEstimator( |
| 213 new RemoteBitrateEstimatorAbsSendTime( |
| 214 transport_feedback_adapter_.get(), Clock::GetRealTimeClock(), |
| 215 RemoteBitrateEstimator::kDefaultMinBitrateBps)); |
| 216 call_stats_->RegisterStatsObserver(transport_feedback_adapter_.get()); |
| 217 } |
| 218 transport_feedback_observer = transport_feedback_adapter_.get(); |
| 219 } |
| 220 |
| 221 const std::vector<uint32_t>& ssrcs = config.rtp.ssrcs; |
192 RTC_DCHECK(!ssrcs.empty()); | 222 RTC_DCHECK(!ssrcs.empty()); |
193 rtc::scoped_ptr<ViEEncoder> vie_encoder( | 223 rtc::scoped_ptr<ViEEncoder> vie_encoder( |
194 new ViEEncoder(channel_id, number_of_cores, *process_thread_, | 224 new ViEEncoder(channel_id, number_of_cores, *process_thread_, |
195 pacer_.get(), bitrate_allocator_.get())); | 225 pacer_.get(), bitrate_allocator_.get())); |
196 if (!vie_encoder->Init()) { | 226 if (!vie_encoder->Init()) { |
197 return false; | 227 return false; |
198 } | 228 } |
199 ViEEncoder* encoder = vie_encoder.get(); | 229 ViEEncoder* encoder = vie_encoder.get(); |
200 if (!CreateChannel(channel_id, transport, number_of_cores, | 230 if (!CreateChannel(channel_id, transport, number_of_cores, |
201 vie_encoder.release(), ssrcs.size(), true)) { | 231 vie_encoder.release(), ssrcs.size(), true, |
| 232 remote_bitrate_estimator_.get(), |
| 233 transport_feedback_observer)) { |
202 return false; | 234 return false; |
203 } | 235 } |
204 ViEChannel* channel = channel_map_[channel_id]; | 236 ViEChannel* channel = channel_map_[channel_id]; |
205 // Connect the encoder with the send packet router, to enable sending. | 237 // Connect the encoder with the send packet router, to enable sending. |
206 encoder->StartThreadsAndSetSharedMembers(channel->send_payload_router(), | 238 encoder->StartThreadsAndSetSharedMembers(channel->send_payload_router(), |
207 channel->vcm_protection_callback()); | 239 channel->vcm_protection_callback()); |
208 | 240 |
209 encoder_state_feedback_->AddEncoder(ssrcs, encoder); | 241 encoder_state_feedback_->AddEncoder(ssrcs, encoder); |
210 std::vector<uint32_t> first_ssrc(1, ssrcs[0]); | 242 std::vector<uint32_t> first_ssrc(1, ssrcs[0]); |
211 encoder->SetSsrcs(first_ssrc); | 243 encoder->SetSsrcs(first_ssrc); |
212 return true; | 244 return true; |
213 } | 245 } |
214 | 246 |
215 bool ChannelGroup::CreateReceiveChannel(int channel_id, | 247 bool ChannelGroup::CreateReceiveChannel( |
216 Transport* transport, | 248 int channel_id, |
217 int number_of_cores) { | 249 Transport* transport, |
218 return CreateChannel(channel_id, transport, number_of_cores, | 250 int number_of_cores, |
219 nullptr, 1, false); | 251 const VideoReceiveStream::Config& config) { |
| 252 bool send_side_bwe = false; |
| 253 for (const RtpExtension& extension : config.rtp.extensions) { |
| 254 if (extension.name == RtpExtension::kTransportSequenceNumber) { |
| 255 send_side_bwe = true; |
| 256 break; |
| 257 } |
| 258 } |
| 259 |
| 260 RemoteBitrateEstimator* bitrate_estimator; |
| 261 if (send_side_bwe) { |
| 262 bitrate_estimator = remote_estimator_proxy_.get(); |
| 263 } else { |
| 264 bitrate_estimator = remote_bitrate_estimator_.get(); |
| 265 } |
| 266 return CreateChannel(channel_id, transport, number_of_cores, nullptr, 1, |
| 267 false, bitrate_estimator, nullptr); |
220 } | 268 } |
221 | 269 |
222 bool ChannelGroup::CreateChannel(int channel_id, | 270 bool ChannelGroup::CreateChannel(int channel_id, |
223 Transport* transport, | 271 Transport* transport, |
224 int number_of_cores, | 272 int number_of_cores, |
225 ViEEncoder* vie_encoder, | 273 ViEEncoder* vie_encoder, |
226 size_t max_rtp_streams, | 274 size_t max_rtp_streams, |
227 bool sender) { | 275 bool sender, |
| 276 RemoteBitrateEstimator* bitrate_estimator, |
| 277 TransportFeedbackObserver* feedback_observer) { |
228 rtc::scoped_ptr<ViEChannel> channel(new ViEChannel( | 278 rtc::scoped_ptr<ViEChannel> channel(new ViEChannel( |
229 number_of_cores, transport, process_thread_, | 279 number_of_cores, transport, process_thread_, |
230 encoder_state_feedback_->GetRtcpIntraFrameObserver(), | 280 encoder_state_feedback_->GetRtcpIntraFrameObserver(), |
231 bitrate_controller_->CreateRtcpBandwidthObserver(), nullptr, | 281 bitrate_controller_->CreateRtcpBandwidthObserver(), feedback_observer, |
232 remote_bitrate_estimator_.get(), call_stats_->rtcp_rtt_stats(), | 282 bitrate_estimator, call_stats_->rtcp_rtt_stats(), pacer_.get(), |
233 pacer_.get(), packet_router_.get(), max_rtp_streams, sender)); | 283 packet_router_.get(), max_rtp_streams, sender)); |
234 if (channel->Init() != 0) { | 284 if (channel->Init() != 0) { |
235 return false; | 285 return false; |
236 } | 286 } |
237 | 287 |
238 // Register the channel to receive stats updates. | 288 // Register the channel to receive stats updates. |
239 call_stats_->RegisterStatsObserver(channel->GetStatsObserver()); | 289 call_stats_->RegisterStatsObserver(channel->GetStatsObserver()); |
240 | 290 |
241 // Store the channel, add it to the channel group and save the vie_encoder. | 291 // Store the channel, add it to the channel group and save the vie_encoder. |
242 channel_map_[channel_id] = channel.release(); | 292 channel_map_[channel_id] = channel.release(); |
243 if (vie_encoder) { | 293 if (vie_encoder) { |
(...skipping 116 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
360 rtc::CritScope lock(&encoder_map_crit_); | 410 rtc::CritScope lock(&encoder_map_crit_); |
361 for (const auto& encoder : vie_encoder_map_) | 411 for (const auto& encoder : vie_encoder_map_) |
362 pad_up_to_bitrate_bps += encoder.second->GetPaddingNeededBps(); | 412 pad_up_to_bitrate_bps += encoder.second->GetPaddingNeededBps(); |
363 } | 413 } |
364 pacer_->UpdateBitrate( | 414 pacer_->UpdateBitrate( |
365 target_bitrate_bps / 1000, | 415 target_bitrate_bps / 1000, |
366 PacedSender::kDefaultPaceMultiplier * target_bitrate_bps / 1000, | 416 PacedSender::kDefaultPaceMultiplier * target_bitrate_bps / 1000, |
367 pad_up_to_bitrate_bps / 1000); | 417 pad_up_to_bitrate_bps / 1000); |
368 } | 418 } |
369 } // namespace webrtc | 419 } // namespace webrtc |
OLD | NEW |