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 |
(...skipping 25 matching lines...) Expand all Loading... |
36 namespace { | 36 namespace { |
37 | 37 |
38 static const uint32_t kTimeOffsetSwitchThreshold = 30; | 38 static const uint32_t kTimeOffsetSwitchThreshold = 30; |
39 | 39 |
40 class WrappingBitrateEstimator : public RemoteBitrateEstimator { | 40 class WrappingBitrateEstimator : public RemoteBitrateEstimator { |
41 public: | 41 public: |
42 WrappingBitrateEstimator(RemoteBitrateObserver* observer, Clock* clock) | 42 WrappingBitrateEstimator(RemoteBitrateObserver* observer, Clock* clock) |
43 : observer_(observer), | 43 : observer_(observer), |
44 clock_(clock), | 44 clock_(clock), |
45 crit_sect_(CriticalSectionWrapper::CreateCriticalSection()), | 45 crit_sect_(CriticalSectionWrapper::CreateCriticalSection()), |
46 min_bitrate_bps_(RemoteBitrateEstimator::kDefaultMinBitrateBps), | 46 rbe_(new RemoteBitrateEstimatorSingleStream(observer_, clock_)), |
47 rbe_(new RemoteBitrateEstimatorSingleStream(observer_, | |
48 clock_, | |
49 min_bitrate_bps_)), | |
50 using_absolute_send_time_(false), | 47 using_absolute_send_time_(false), |
51 packets_since_absolute_send_time_(0) {} | 48 packets_since_absolute_send_time_(0), |
| 49 min_bitrate_bps_(RemoteBitrateEstimator::kDefaultMinBitrateBps) {} |
52 | 50 |
53 virtual ~WrappingBitrateEstimator() {} | 51 virtual ~WrappingBitrateEstimator() {} |
54 | 52 |
55 void IncomingPacket(int64_t arrival_time_ms, | 53 void IncomingPacket(int64_t arrival_time_ms, |
56 size_t payload_size, | 54 size_t payload_size, |
57 const RTPHeader& header, | 55 const RTPHeader& header, |
58 bool was_paced) override { | 56 bool was_paced) override { |
59 CriticalSectionScoped cs(crit_sect_.get()); | 57 CriticalSectionScoped cs(crit_sect_.get()); |
60 PickEstimatorFromHeader(header); | 58 PickEstimatorFromHeader(header); |
61 rbe_->IncomingPacket(arrival_time_ms, payload_size, header, was_paced); | 59 rbe_->IncomingPacket(arrival_time_ms, payload_size, header, was_paced); |
(...skipping 23 matching lines...) Expand all Loading... |
85 unsigned int* bitrate_bps) const override { | 83 unsigned int* bitrate_bps) const override { |
86 CriticalSectionScoped cs(crit_sect_.get()); | 84 CriticalSectionScoped cs(crit_sect_.get()); |
87 return rbe_->LatestEstimate(ssrcs, bitrate_bps); | 85 return rbe_->LatestEstimate(ssrcs, bitrate_bps); |
88 } | 86 } |
89 | 87 |
90 bool GetStats(ReceiveBandwidthEstimatorStats* output) const override { | 88 bool GetStats(ReceiveBandwidthEstimatorStats* output) const override { |
91 CriticalSectionScoped cs(crit_sect_.get()); | 89 CriticalSectionScoped cs(crit_sect_.get()); |
92 return rbe_->GetStats(output); | 90 return rbe_->GetStats(output); |
93 } | 91 } |
94 | 92 |
| 93 void SetMinBitrate(int min_bitrate_bps) { |
| 94 CriticalSectionScoped cs(crit_sect_.get()); |
| 95 rbe_->SetMinBitrate(min_bitrate_bps); |
| 96 min_bitrate_bps_ = min_bitrate_bps; |
| 97 } |
| 98 |
95 private: | 99 private: |
96 void PickEstimatorFromHeader(const RTPHeader& header) | 100 void PickEstimatorFromHeader(const RTPHeader& header) |
97 EXCLUSIVE_LOCKS_REQUIRED(crit_sect_.get()) { | 101 EXCLUSIVE_LOCKS_REQUIRED(crit_sect_.get()) { |
98 if (header.extension.hasAbsoluteSendTime) { | 102 if (header.extension.hasAbsoluteSendTime) { |
99 // If we see AST in header, switch RBE strategy immediately. | 103 // If we see AST in header, switch RBE strategy immediately. |
100 if (!using_absolute_send_time_) { | 104 if (!using_absolute_send_time_) { |
101 LOG(LS_INFO) << | 105 LOG(LS_INFO) << |
102 "WrappingBitrateEstimator: Switching to absolute send time RBE."; | 106 "WrappingBitrateEstimator: Switching to absolute send time RBE."; |
103 using_absolute_send_time_ = true; | 107 using_absolute_send_time_ = true; |
104 PickEstimator(); | 108 PickEstimator(); |
105 } | 109 } |
106 packets_since_absolute_send_time_ = 0; | 110 packets_since_absolute_send_time_ = 0; |
107 } else { | 111 } else { |
108 // When we don't see AST, wait for a few packets before going back to TOF. | 112 // When we don't see AST, wait for a few packets before going back to TOF. |
109 if (using_absolute_send_time_) { | 113 if (using_absolute_send_time_) { |
110 ++packets_since_absolute_send_time_; | 114 ++packets_since_absolute_send_time_; |
111 if (packets_since_absolute_send_time_ >= kTimeOffsetSwitchThreshold) { | 115 if (packets_since_absolute_send_time_ >= kTimeOffsetSwitchThreshold) { |
112 LOG(LS_INFO) << "WrappingBitrateEstimator: Switching to transmission " | 116 LOG(LS_INFO) << "WrappingBitrateEstimator: Switching to transmission " |
113 << "time offset RBE."; | 117 << "time offset RBE."; |
114 using_absolute_send_time_ = false; | 118 using_absolute_send_time_ = false; |
115 PickEstimator(); | 119 PickEstimator(); |
116 } | 120 } |
117 } | 121 } |
118 } | 122 } |
119 } | 123 } |
120 | 124 |
121 // Instantiate RBE for Time Offset or Absolute Send Time extensions. | 125 // Instantiate RBE for Time Offset or Absolute Send Time extensions. |
122 void PickEstimator() EXCLUSIVE_LOCKS_REQUIRED(crit_sect_.get()) { | 126 void PickEstimator() EXCLUSIVE_LOCKS_REQUIRED(crit_sect_.get()) { |
123 if (using_absolute_send_time_) { | 127 if (using_absolute_send_time_) { |
124 rbe_.reset(new RemoteBitrateEstimatorAbsSendTime(observer_, clock_, | 128 rbe_.reset(new RemoteBitrateEstimatorAbsSendTime(observer_, clock_)); |
125 min_bitrate_bps_)); | |
126 } else { | 129 } else { |
127 rbe_.reset(new RemoteBitrateEstimatorSingleStream(observer_, clock_, | 130 rbe_.reset(new RemoteBitrateEstimatorSingleStream(observer_, clock_)); |
128 min_bitrate_bps_)); | |
129 } | 131 } |
| 132 rbe_->SetMinBitrate(min_bitrate_bps_); |
130 } | 133 } |
131 | 134 |
132 RemoteBitrateObserver* observer_; | 135 RemoteBitrateObserver* observer_; |
133 Clock* clock_; | 136 Clock* clock_; |
134 rtc::scoped_ptr<CriticalSectionWrapper> crit_sect_; | 137 rtc::scoped_ptr<CriticalSectionWrapper> crit_sect_; |
135 const uint32_t min_bitrate_bps_; | |
136 rtc::scoped_ptr<RemoteBitrateEstimator> rbe_; | 138 rtc::scoped_ptr<RemoteBitrateEstimator> rbe_; |
137 bool using_absolute_send_time_; | 139 bool using_absolute_send_time_; |
138 uint32_t packets_since_absolute_send_time_; | 140 uint32_t packets_since_absolute_send_time_; |
| 141 int min_bitrate_bps_; |
139 | 142 |
140 RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(WrappingBitrateEstimator); | 143 RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(WrappingBitrateEstimator); |
141 }; | 144 }; |
142 | 145 |
143 } // namespace | 146 } // namespace |
144 | 147 |
145 ChannelGroup::ChannelGroup(ProcessThread* process_thread) | 148 ChannelGroup::ChannelGroup(ProcessThread* process_thread) |
146 : remb_(new VieRemb()), | 149 : remb_(new VieRemb()), |
147 bitrate_allocator_(new BitrateAllocator()), | 150 bitrate_allocator_(new BitrateAllocator()), |
148 call_stats_(new CallStats()), | 151 call_stats_(new CallStats()), |
149 packet_router_(new PacketRouter()), | 152 packet_router_(new PacketRouter()), |
150 pacer_(new PacedSender(Clock::GetRealTimeClock(), | 153 pacer_(new PacedSender(Clock::GetRealTimeClock(), |
151 packet_router_.get(), | 154 packet_router_.get(), |
152 BitrateController::kDefaultStartBitrateKbps, | 155 BitrateController::kDefaultStartBitrateKbps, |
153 PacedSender::kDefaultPaceMultiplier * | 156 PacedSender::kDefaultPaceMultiplier * |
154 BitrateController::kDefaultStartBitrateKbps, | 157 BitrateController::kDefaultStartBitrateKbps, |
155 0)), | 158 0)), |
156 remote_bitrate_estimator_( | 159 remote_bitrate_estimator_( |
157 new WrappingBitrateEstimator(remb_.get(), Clock::GetRealTimeClock())), | 160 new WrappingBitrateEstimator(remb_.get(), Clock::GetRealTimeClock())), |
158 remote_estimator_proxy_( | 161 remote_estimator_proxy_( |
159 new RemoteEstimatorProxy(Clock::GetRealTimeClock(), | 162 new RemoteEstimatorProxy(Clock::GetRealTimeClock(), |
160 packet_router_.get())), | 163 packet_router_.get())), |
161 encoder_state_feedback_(new EncoderStateFeedback()), | 164 encoder_state_feedback_(new EncoderStateFeedback()), |
162 process_thread_(process_thread), | 165 process_thread_(process_thread), |
163 pacer_thread_(ProcessThread::Create("PacerThread")), | 166 pacer_thread_(ProcessThread::Create("PacerThread")), |
164 // Constructed last as this object calls the provided callback on | 167 // Constructed last as this object calls the provided callback on |
165 // construction. | 168 // construction. |
166 bitrate_controller_( | 169 bitrate_controller_( |
167 BitrateController::CreateBitrateController(Clock::GetRealTimeClock(), | 170 BitrateController::CreateBitrateController(Clock::GetRealTimeClock(), |
168 this)) { | 171 this)), |
| 172 min_bitrate_bps_(RemoteBitrateEstimator::kDefaultMinBitrateBps) { |
169 call_stats_->RegisterStatsObserver(remote_bitrate_estimator_.get()); | 173 call_stats_->RegisterStatsObserver(remote_bitrate_estimator_.get()); |
170 | 174 |
171 pacer_thread_->RegisterModule(pacer_.get()); | 175 pacer_thread_->RegisterModule(pacer_.get()); |
172 pacer_thread_->Start(); | 176 pacer_thread_->Start(); |
173 | 177 |
174 process_thread->RegisterModule(remote_estimator_proxy_.get()); | 178 process_thread->RegisterModule(remote_estimator_proxy_.get()); |
175 process_thread->RegisterModule(remote_bitrate_estimator_.get()); | 179 process_thread->RegisterModule(remote_bitrate_estimator_.get()); |
176 process_thread->RegisterModule(call_stats_.get()); | 180 process_thread->RegisterModule(call_stats_.get()); |
177 process_thread->RegisterModule(bitrate_controller_.get()); | 181 process_thread->RegisterModule(bitrate_controller_.get()); |
178 } | 182 } |
(...skipping 27 matching lines...) Expand all Loading... |
206 break; | 210 break; |
207 } | 211 } |
208 } | 212 } |
209 if (transport_seq_enabled) { | 213 if (transport_seq_enabled) { |
210 if (transport_feedback_adapter_.get() == nullptr) { | 214 if (transport_feedback_adapter_.get() == nullptr) { |
211 transport_feedback_adapter_.reset(new TransportFeedbackAdapter( | 215 transport_feedback_adapter_.reset(new TransportFeedbackAdapter( |
212 bitrate_controller_->CreateRtcpBandwidthObserver(), | 216 bitrate_controller_->CreateRtcpBandwidthObserver(), |
213 Clock::GetRealTimeClock(), process_thread_)); | 217 Clock::GetRealTimeClock(), process_thread_)); |
214 transport_feedback_adapter_->SetBitrateEstimator( | 218 transport_feedback_adapter_->SetBitrateEstimator( |
215 new RemoteBitrateEstimatorAbsSendTime( | 219 new RemoteBitrateEstimatorAbsSendTime( |
216 transport_feedback_adapter_.get(), Clock::GetRealTimeClock(), | 220 transport_feedback_adapter_.get(), Clock::GetRealTimeClock())); |
217 RemoteBitrateEstimator::kDefaultMinBitrateBps)); | 221 transport_feedback_adapter_->GetBitrateEstimator()->SetMinBitrate( |
| 222 min_bitrate_bps_); |
218 call_stats_->RegisterStatsObserver(transport_feedback_adapter_.get()); | 223 call_stats_->RegisterStatsObserver(transport_feedback_adapter_.get()); |
219 } | 224 } |
220 transport_feedback_observer = transport_feedback_adapter_.get(); | 225 transport_feedback_observer = transport_feedback_adapter_.get(); |
221 } | 226 } |
222 | 227 |
223 const std::vector<uint32_t>& ssrcs = config.rtp.ssrcs; | 228 const std::vector<uint32_t>& ssrcs = config.rtp.ssrcs; |
224 RTC_DCHECK(!ssrcs.empty()); | 229 RTC_DCHECK(!ssrcs.empty()); |
225 rtc::scoped_ptr<ViEEncoder> vie_encoder(new ViEEncoder( | 230 rtc::scoped_ptr<ViEEncoder> vie_encoder(new ViEEncoder( |
226 channel_id, number_of_cores, process_thread_, stats_proxy, | 231 channel_id, number_of_cores, process_thread_, stats_proxy, |
227 pre_encode_callback, pacer_.get(), bitrate_allocator_.get())); | 232 pre_encode_callback, pacer_.get(), bitrate_allocator_.get())); |
(...skipping 129 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
357 channel_map_.erase(c_it); | 362 channel_map_.erase(c_it); |
358 | 363 |
359 return channel; | 364 return channel; |
360 } | 365 } |
361 | 366 |
362 void ChannelGroup::SetSyncInterface(VoEVideoSync* sync_interface) { | 367 void ChannelGroup::SetSyncInterface(VoEVideoSync* sync_interface) { |
363 for (auto channel : channel_map_) | 368 for (auto channel : channel_map_) |
364 channel.second->SetVoiceChannel(-1, sync_interface); | 369 channel.second->SetVoiceChannel(-1, sync_interface); |
365 } | 370 } |
366 | 371 |
| 372 void ChannelGroup::SetBweBitrates(int min_bitrate_bps, |
| 373 int start_bitrate_bps, |
| 374 int max_bitrate_bps) { |
| 375 if (start_bitrate_bps > 0) |
| 376 bitrate_controller_->SetStartBitrate(start_bitrate_bps); |
| 377 bitrate_controller_->SetMinMaxBitrate(min_bitrate_bps, max_bitrate_bps); |
| 378 if (remote_bitrate_estimator_.get()) |
| 379 remote_bitrate_estimator_->SetMinBitrate(min_bitrate_bps); |
| 380 if (transport_feedback_adapter_.get()) |
| 381 transport_feedback_adapter_->GetBitrateEstimator()->SetMinBitrate( |
| 382 min_bitrate_bps); |
| 383 min_bitrate_bps_ = min_bitrate_bps; |
| 384 } |
| 385 |
367 BitrateController* ChannelGroup::GetBitrateController() const { | 386 BitrateController* ChannelGroup::GetBitrateController() const { |
368 return bitrate_controller_.get(); | 387 return bitrate_controller_.get(); |
369 } | 388 } |
370 | 389 |
371 RemoteBitrateEstimator* ChannelGroup::GetRemoteBitrateEstimator() const { | 390 RemoteBitrateEstimator* ChannelGroup::GetRemoteBitrateEstimator() const { |
372 return remote_bitrate_estimator_.get(); | 391 return remote_bitrate_estimator_.get(); |
373 } | 392 } |
374 | 393 |
375 CallStats* ChannelGroup::GetCallStats() const { | 394 CallStats* ChannelGroup::GetCallStats() const { |
376 return call_stats_.get(); | 395 return call_stats_.get(); |
(...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
412 rtc::CritScope lock(&encoder_map_crit_); | 431 rtc::CritScope lock(&encoder_map_crit_); |
413 for (const auto& encoder : vie_encoder_map_) | 432 for (const auto& encoder : vie_encoder_map_) |
414 pad_up_to_bitrate_bps += encoder.second->GetPaddingNeededBps(); | 433 pad_up_to_bitrate_bps += encoder.second->GetPaddingNeededBps(); |
415 } | 434 } |
416 pacer_->UpdateBitrate( | 435 pacer_->UpdateBitrate( |
417 target_bitrate_bps / 1000, | 436 target_bitrate_bps / 1000, |
418 PacedSender::kDefaultPaceMultiplier * target_bitrate_bps / 1000, | 437 PacedSender::kDefaultPaceMultiplier * target_bitrate_bps / 1000, |
419 pad_up_to_bitrate_bps / 1000); | 438 pad_up_to_bitrate_bps / 1000); |
420 } | 439 } |
421 } // namespace webrtc | 440 } // namespace webrtc |
OLD | NEW |