1 /*
2 * Copyright 2018 The WebRTC project authors. All Rights Reserved.
3 *
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
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
10 #include "test/scenario/call_client.h"
11
12 #include <iostream>
13 #include <memory>
14 #include <utility>
15
16 #include "api/rtc_event_log/rtc_event_log.h"
17 #include "api/rtc_event_log/rtc_event_log_factory.h"
18 #include "api/transport/network_types.h"
19 #include "call/call.h"
20 #include "call/rtp_transport_controller_send_factory.h"
21 #include "modules/audio_mixer/audio_mixer_impl.h"
22 #include "modules/rtp_rtcp/source/rtp_util.h"
23
24 namespace webrtc {
25 namespace test {
26 namespace {
27 static constexpr size_t kNumSsrcs = 6;
28 const uint32_t kSendRtxSsrcs[kNumSsrcs] = {0xBADCAFD, 0xBADCAFE, 0xBADCAFF,
29 0xBADCB00, 0xBADCB01, 0xBADCB02};
30 const uint32_t kVideoSendSsrcs[kNumSsrcs] = {0xC0FFED, 0xC0FFEE, 0xC0FFEF,
31 0xC0FFF0, 0xC0FFF1, 0xC0FFF2};
32 const uint32_t kVideoRecvLocalSsrcs[kNumSsrcs] = {0xDAB001, 0xDAB002, 0xDAB003,
33 0xDAB004, 0xDAB005, 0xDAB006};
34 const uint32_t kAudioSendSsrc = 0xDEADBEEF;
35 const uint32_t kReceiverLocalAudioSsrc = 0x1234567;
36
37 constexpr int kEventLogOutputIntervalMs = 5000;
38
InitAudio(TimeController * time_controller)39 CallClientFakeAudio InitAudio(TimeController* time_controller) {
40 CallClientFakeAudio setup;
41 auto capturer = TestAudioDeviceModule::CreatePulsedNoiseCapturer(256, 48000);
42 auto renderer = TestAudioDeviceModule::CreateDiscardRenderer(48000);
43 setup.fake_audio_device = TestAudioDeviceModule::Create(
44 time_controller->GetTaskQueueFactory(), std::move(capturer),
45 std::move(renderer), 1.f);
46 setup.apm = AudioProcessingBuilder().Create();
47 setup.fake_audio_device->Init();
48 AudioState::Config audio_state_config;
49 audio_state_config.audio_mixer = AudioMixerImpl::Create();
50 audio_state_config.audio_processing = setup.apm;
51 audio_state_config.audio_device_module = setup.fake_audio_device;
52 setup.audio_state = AudioState::Create(audio_state_config);
53 setup.fake_audio_device->RegisterAudioCallback(
54 setup.audio_state->audio_transport());
55 return setup;
56 }
57
CreateCall(TimeController * time_controller,RtcEventLog * event_log,CallClientConfig config,LoggingNetworkControllerFactory * network_controller_factory,rtc::scoped_refptr<AudioState> audio_state)58 Call* CreateCall(TimeController* time_controller,
59 RtcEventLog* event_log,
60 CallClientConfig config,
61 LoggingNetworkControllerFactory* network_controller_factory,
62 rtc::scoped_refptr<AudioState> audio_state) {
63 CallConfig call_config(event_log);
64 call_config.bitrate_config.max_bitrate_bps =
65 config.transport.rates.max_rate.bps_or(-1);
66 call_config.bitrate_config.min_bitrate_bps =
67 config.transport.rates.min_rate.bps();
68 call_config.bitrate_config.start_bitrate_bps =
69 config.transport.rates.start_rate.bps();
70 call_config.task_queue_factory = time_controller->GetTaskQueueFactory();
71 call_config.network_controller_factory = network_controller_factory;
72 call_config.audio_state = audio_state;
73 call_config.trials = config.field_trials;
74 Clock* clock = time_controller->GetClock();
75 return Call::Create(call_config, clock,
76 RtpTransportControllerSendFactory().Create(
77 call_config.ExtractTransportConfig(), clock));
78 }
79
CreateEventLog(TaskQueueFactory * task_queue_factory,LogWriterFactoryInterface * log_writer_factory)80 std::unique_ptr<RtcEventLog> CreateEventLog(
81 TaskQueueFactory* task_queue_factory,
82 LogWriterFactoryInterface* log_writer_factory) {
83 if (!log_writer_factory) {
84 return std::make_unique<RtcEventLogNull>();
85 }
86 auto event_log = RtcEventLogFactory(task_queue_factory)
87 .CreateRtcEventLog(RtcEventLog::EncodingType::NewFormat);
88 bool success = event_log->StartLogging(log_writer_factory->Create(".rtc.dat"),
89 kEventLogOutputIntervalMs);
90 RTC_CHECK(success);
91 return event_log;
92 }
93 } // namespace
NetworkControleUpdateCache(std::unique_ptr<NetworkControllerInterface> controller)94 NetworkControleUpdateCache::NetworkControleUpdateCache(
95 std::unique_ptr<NetworkControllerInterface> controller)
96 : controller_(std::move(controller)) {}
OnNetworkAvailability(NetworkAvailability msg)97 NetworkControlUpdate NetworkControleUpdateCache::OnNetworkAvailability(
98 NetworkAvailability msg) {
99 return Update(controller_->OnNetworkAvailability(msg));
100 }
OnNetworkRouteChange(NetworkRouteChange msg)101 NetworkControlUpdate NetworkControleUpdateCache::OnNetworkRouteChange(
102 NetworkRouteChange msg) {
103 return Update(controller_->OnNetworkRouteChange(msg));
104 }
OnProcessInterval(ProcessInterval msg)105 NetworkControlUpdate NetworkControleUpdateCache::OnProcessInterval(
106 ProcessInterval msg) {
107 return Update(controller_->OnProcessInterval(msg));
108 }
OnRemoteBitrateReport(RemoteBitrateReport msg)109 NetworkControlUpdate NetworkControleUpdateCache::OnRemoteBitrateReport(
110 RemoteBitrateReport msg) {
111 return Update(controller_->OnRemoteBitrateReport(msg));
112 }
OnRoundTripTimeUpdate(RoundTripTimeUpdate msg)113 NetworkControlUpdate NetworkControleUpdateCache::OnRoundTripTimeUpdate(
114 RoundTripTimeUpdate msg) {
115 return Update(controller_->OnRoundTripTimeUpdate(msg));
116 }
OnSentPacket(SentPacket msg)117 NetworkControlUpdate NetworkControleUpdateCache::OnSentPacket(SentPacket msg) {
118 return Update(controller_->OnSentPacket(msg));
119 }
OnReceivedPacket(ReceivedPacket msg)120 NetworkControlUpdate NetworkControleUpdateCache::OnReceivedPacket(
121 ReceivedPacket msg) {
122 return Update(controller_->OnReceivedPacket(msg));
123 }
OnStreamsConfig(StreamsConfig msg)124 NetworkControlUpdate NetworkControleUpdateCache::OnStreamsConfig(
125 StreamsConfig msg) {
126 return Update(controller_->OnStreamsConfig(msg));
127 }
OnTargetRateConstraints(TargetRateConstraints msg)128 NetworkControlUpdate NetworkControleUpdateCache::OnTargetRateConstraints(
129 TargetRateConstraints msg) {
130 return Update(controller_->OnTargetRateConstraints(msg));
131 }
OnTransportLossReport(TransportLossReport msg)132 NetworkControlUpdate NetworkControleUpdateCache::OnTransportLossReport(
133 TransportLossReport msg) {
134 return Update(controller_->OnTransportLossReport(msg));
135 }
OnTransportPacketsFeedback(TransportPacketsFeedback msg)136 NetworkControlUpdate NetworkControleUpdateCache::OnTransportPacketsFeedback(
137 TransportPacketsFeedback msg) {
138 return Update(controller_->OnTransportPacketsFeedback(msg));
139 }
OnNetworkStateEstimate(NetworkStateEstimate msg)140 NetworkControlUpdate NetworkControleUpdateCache::OnNetworkStateEstimate(
141 NetworkStateEstimate msg) {
142 return Update(controller_->OnNetworkStateEstimate(msg));
143 }
144
update_state() const145 NetworkControlUpdate NetworkControleUpdateCache::update_state() const {
146 return update_state_;
147 }
Update(NetworkControlUpdate update)148 NetworkControlUpdate NetworkControleUpdateCache::Update(
149 NetworkControlUpdate update) {
150 if (update.target_rate)
151 update_state_.target_rate = update.target_rate;
152 if (update.pacer_config)
153 update_state_.pacer_config = update.pacer_config;
154 if (update.congestion_window)
155 update_state_.congestion_window = update.congestion_window;
156 if (!update.probe_cluster_configs.empty())
157 update_state_.probe_cluster_configs = update.probe_cluster_configs;
158 return update;
159 }
160
LoggingNetworkControllerFactory(LogWriterFactoryInterface * log_writer_factory,TransportControllerConfig config)161 LoggingNetworkControllerFactory::LoggingNetworkControllerFactory(
162 LogWriterFactoryInterface* log_writer_factory,
163 TransportControllerConfig config) {
164 if (config.cc_factory) {
165 cc_factory_ = config.cc_factory;
166 if (log_writer_factory)
167 RTC_LOG(LS_WARNING)
168 << "Can't log controller state for injected network controllers";
169 } else {
170 if (log_writer_factory) {
171 goog_cc_factory_.AttachWriter(
172 log_writer_factory->Create(".cc_state.txt"));
173 print_cc_state_ = true;
174 }
175 cc_factory_ = &goog_cc_factory_;
176 }
177 }
178
~LoggingNetworkControllerFactory()179 LoggingNetworkControllerFactory::~LoggingNetworkControllerFactory() {}
180
LogCongestionControllerStats(Timestamp at_time)181 void LoggingNetworkControllerFactory::LogCongestionControllerStats(
182 Timestamp at_time) {
183 if (print_cc_state_)
184 goog_cc_factory_.PrintState(at_time);
185 }
186
GetUpdate() const187 NetworkControlUpdate LoggingNetworkControllerFactory::GetUpdate() const {
188 if (last_controller_)
189 return last_controller_->update_state();
190 return NetworkControlUpdate();
191 }
192
193 std::unique_ptr<NetworkControllerInterface>
Create(NetworkControllerConfig config)194 LoggingNetworkControllerFactory::Create(NetworkControllerConfig config) {
195 auto controller =
196 std::make_unique<NetworkControleUpdateCache>(cc_factory_->Create(config));
197 last_controller_ = controller.get();
198 return controller;
199 }
200
GetProcessInterval() const201 TimeDelta LoggingNetworkControllerFactory::GetProcessInterval() const {
202 return cc_factory_->GetProcessInterval();
203 }
204
SetRemoteBitrateEstimate(RemoteBitrateReport msg)205 void LoggingNetworkControllerFactory::SetRemoteBitrateEstimate(
206 RemoteBitrateReport msg) {
207 if (last_controller_)
208 last_controller_->OnRemoteBitrateReport(msg);
209 }
210
CallClient(TimeController * time_controller,std::unique_ptr<LogWriterFactoryInterface> log_writer_factory,CallClientConfig config)211 CallClient::CallClient(
212 TimeController* time_controller,
213 std::unique_ptr<LogWriterFactoryInterface> log_writer_factory,
214 CallClientConfig config)
215 : time_controller_(time_controller),
216 clock_(time_controller->GetClock()),
217 log_writer_factory_(std::move(log_writer_factory)),
218 network_controller_factory_(log_writer_factory_.get(), config.transport),
219 task_queue_(time_controller->GetTaskQueueFactory()->CreateTaskQueue(
220 "CallClient",
221 TaskQueueFactory::Priority::NORMAL)) {
222 config.field_trials = &field_trials_;
223 SendTask([this, config] {
224 event_log_ = CreateEventLog(time_controller_->GetTaskQueueFactory(),
225 log_writer_factory_.get());
226 fake_audio_setup_ = InitAudio(time_controller_);
227
228 call_.reset(CreateCall(time_controller_, event_log_.get(), config,
229 &network_controller_factory_,
230 fake_audio_setup_.audio_state));
231 transport_ = std::make_unique<NetworkNodeTransport>(clock_, call_.get());
232 });
233 }
234
~CallClient()235 CallClient::~CallClient() {
236 SendTask([&] {
237 call_.reset();
238 fake_audio_setup_ = {};
239 rtc::Event done;
240 event_log_->StopLogging([&done] { done.Set(); });
241 done.Wait(rtc::Event::kForever);
242 event_log_.reset();
243 });
244 }
245
StatsPrinter()246 ColumnPrinter CallClient::StatsPrinter() {
247 return ColumnPrinter::Lambda(
248 "pacer_delay call_send_bw",
249 [this](rtc::SimpleStringBuilder& sb) {
250 Call::Stats call_stats = call_->GetStats();
251 sb.AppendFormat("%.3lf %.0lf", call_stats.pacer_delay_ms / 1000.0,
252 call_stats.send_bandwidth_bps / 8.0);
253 },
254 64);
255 }
256
GetStats()257 Call::Stats CallClient::GetStats() {
258 // This call needs to be made on the thread that `call_` was constructed on.
259 Call::Stats stats;
260 SendTask([this, &stats] { stats = call_->GetStats(); });
261 return stats;
262 }
263
target_rate() const264 DataRate CallClient::target_rate() const {
265 return network_controller_factory_.GetUpdate().target_rate->target_rate;
266 }
267
stable_target_rate() const268 DataRate CallClient::stable_target_rate() const {
269 return network_controller_factory_.GetUpdate()
270 .target_rate->stable_target_rate;
271 }
272
padding_rate() const273 DataRate CallClient::padding_rate() const {
274 return network_controller_factory_.GetUpdate().pacer_config->pad_rate();
275 }
276
SetRemoteBitrate(DataRate bitrate)277 void CallClient::SetRemoteBitrate(DataRate bitrate) {
278 RemoteBitrateReport msg;
279 msg.bandwidth = bitrate;
280 msg.receive_time = clock_->CurrentTime();
281 network_controller_factory_.SetRemoteBitrateEstimate(msg);
282 }
283
UpdateBitrateConstraints(const BitrateConstraints & constraints)284 void CallClient::UpdateBitrateConstraints(
285 const BitrateConstraints& constraints) {
286 SendTask([this, &constraints]() {
287 call_->GetTransportControllerSend()->SetSdpBitrateParameters(constraints);
288 });
289 }
290
OnPacketReceived(EmulatedIpPacket packet)291 void CallClient::OnPacketReceived(EmulatedIpPacket packet) {
292 MediaType media_type = MediaType::ANY;
293 if (IsRtpPacket(packet.data)) {
294 media_type = ssrc_media_types_[ParseRtpSsrc(packet.data)];
295 }
296 task_queue_.PostTask(
297 [call = call_.get(), media_type, packet = std::move(packet)]() mutable {
298 call->Receiver()->DeliverPacket(media_type, packet.data,
299 packet.arrival_time.us());
300 });
301 }
302
GetLogWriter(std::string name)303 std::unique_ptr<RtcEventLogOutput> CallClient::GetLogWriter(std::string name) {
304 if (!log_writer_factory_ || name.empty())
305 return nullptr;
306 return log_writer_factory_->Create(name);
307 }
308
GetNextVideoSsrc()309 uint32_t CallClient::GetNextVideoSsrc() {
310 RTC_CHECK_LT(next_video_ssrc_index_, kNumSsrcs);
311 return kVideoSendSsrcs[next_video_ssrc_index_++];
312 }
313
GetNextVideoLocalSsrc()314 uint32_t CallClient::GetNextVideoLocalSsrc() {
315 RTC_CHECK_LT(next_video_local_ssrc_index_, kNumSsrcs);
316 return kVideoRecvLocalSsrcs[next_video_local_ssrc_index_++];
317 }
318
GetNextAudioSsrc()319 uint32_t CallClient::GetNextAudioSsrc() {
320 RTC_CHECK_LT(next_audio_ssrc_index_, 1);
321 next_audio_ssrc_index_++;
322 return kAudioSendSsrc;
323 }
324
GetNextAudioLocalSsrc()325 uint32_t CallClient::GetNextAudioLocalSsrc() {
326 RTC_CHECK_LT(next_audio_local_ssrc_index_, 1);
327 next_audio_local_ssrc_index_++;
328 return kReceiverLocalAudioSsrc;
329 }
330
GetNextRtxSsrc()331 uint32_t CallClient::GetNextRtxSsrc() {
332 RTC_CHECK_LT(next_rtx_ssrc_index_, kNumSsrcs);
333 return kSendRtxSsrcs[next_rtx_ssrc_index_++];
334 }
335
SendTask(std::function<void ()> task)336 void CallClient::SendTask(std::function<void()> task) {
337 task_queue_.SendTask(std::move(task));
338 }
339
Bind(EmulatedEndpoint * endpoint)340 int16_t CallClient::Bind(EmulatedEndpoint* endpoint) {
341 uint16_t port = endpoint->BindReceiver(0, this).value();
342 endpoints_.push_back({endpoint, port});
343 return port;
344 }
345
UnBind()346 void CallClient::UnBind() {
347 for (auto ep_port : endpoints_)
348 ep_port.first->UnbindReceiver(ep_port.second);
349 }
350
351 CallClientPair::~CallClientPair() = default;
352
353 } // namespace test
354 } // namespace webrtc
355