OLD | NEW |
1 /* | 1 /* |
2 * Copyright (c) 2014 The WebRTC project authors. All Rights Reserved. | 2 * Copyright (c) 2014 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 14 matching lines...) Expand all Loading... |
25 | 25 |
26 namespace webrtc { | 26 namespace webrtc { |
27 namespace test { | 27 namespace test { |
28 | 28 |
29 namespace { | 29 namespace { |
30 const int kVideoRotationRtpExtensionId = 4; | 30 const int kVideoRotationRtpExtensionId = 4; |
31 } | 31 } |
32 | 32 |
33 CallTest::CallTest() | 33 CallTest::CallTest() |
34 : clock_(Clock::GetRealTimeClock()), | 34 : clock_(Clock::GetRealTimeClock()), |
35 event_log_(RtcEventLog::CreateNull()), | 35 event_log_(RtcEventLog::Create()), |
36 sender_call_transport_controller_(nullptr), | 36 sender_call_transport_controller_(nullptr), |
37 video_send_config_(nullptr), | 37 video_send_config_(nullptr), |
38 video_send_stream_(nullptr), | 38 video_send_stream_(nullptr), |
39 audio_send_config_(nullptr), | 39 audio_send_config_(nullptr), |
40 audio_send_stream_(nullptr), | 40 audio_send_stream_(nullptr), |
41 fake_encoder_(clock_), | 41 fake_encoder_(clock_), |
42 num_video_streams_(1), | 42 num_video_streams_(1), |
43 num_audio_streams_(0), | 43 num_audio_streams_(0), |
44 num_flexfec_streams_(0), | 44 num_flexfec_streams_(0), |
45 decoder_factory_(CreateBuiltinAudioDecoderFactory()), | 45 decoder_factory_(CreateBuiltinAudioDecoderFactory()), |
46 encoder_factory_(CreateBuiltinAudioEncoderFactory()), | 46 encoder_factory_(CreateBuiltinAudioEncoderFactory()), |
47 task_queue_("CallTestTaskQueue"), | 47 task_queue_("CallTestTaskQueue"), |
48 fake_send_audio_device_(nullptr), | 48 fake_send_audio_device_(nullptr), |
49 fake_recv_audio_device_(nullptr) {} | 49 fake_recv_audio_device_(nullptr) { |
| 50 int64_t now_ms = clock_->TimeInMilliseconds(); |
| 51 std::stringstream ss; |
| 52 ss << "/usr/local/google/home/philipel/temp/vs_stuff/event_logs/" << now_ms |
| 53 << ".log"; |
| 54 event_log_->StartLogging(ss.str(), 1000000000); |
| 55 } |
50 | 56 |
51 CallTest::~CallTest() { | 57 CallTest::~CallTest() { |
52 task_queue_.SendTask([this]() { | 58 task_queue_.SendTask([this]() { |
53 fake_send_audio_device_.reset(); | 59 fake_send_audio_device_.reset(); |
54 fake_recv_audio_device_.reset(); | 60 fake_recv_audio_device_.reset(); |
55 frame_generator_capturer_.reset(); | 61 frame_generator_capturer_.reset(); |
56 }); | 62 }); |
57 } | 63 } |
58 | 64 |
59 void CallTest::RunBaseTest(BaseTest* test) { | 65 void CallTest::RunBaseTest(BaseTest* test) { |
60 task_queue_.SendTask([this, test]() { | 66 // num_video_streams_ = test->GetNumVideoStreams(); |
61 num_video_streams_ = test->GetNumVideoStreams(); | 67 // num_audio_streams_ = test->GetNumAudioStreams(); |
62 num_audio_streams_ = test->GetNumAudioStreams(); | 68 // num_flexfec_streams_ = test->GetNumFlexfecStreams(); |
63 num_flexfec_streams_ = test->GetNumFlexfecStreams(); | 69 // RTC_DCHECK(num_video_streams_ > 0 || num_audio_streams_ > 0); |
64 RTC_DCHECK(num_video_streams_ > 0 || num_audio_streams_ > 0); | 70 // Call::Config send_config(test->GetSenderCallConfig()); |
65 Call::Config send_config(test->GetSenderCallConfig()); | 71 // if (num_audio_streams_ > 0) { |
66 if (num_audio_streams_ > 0) { | 72 // CreateFakeAudioDevices(test->CreateCapturer(), test->CreateRenderer()); |
67 CreateFakeAudioDevices(test->CreateCapturer(), test->CreateRenderer()); | 73 // test->OnFakeAudioDevicesCreated(fake_send_audio_device_.get(), |
68 test->OnFakeAudioDevicesCreated(fake_send_audio_device_.get(), | 74 // fake_recv_audio_device_.get()); |
69 fake_recv_audio_device_.get()); | 75 // apm_send_ = AudioProcessing::Create(); |
70 apm_send_ = AudioProcessing::Create(); | 76 // apm_recv_ = AudioProcessing::Create(); |
71 apm_recv_ = AudioProcessing::Create(); | 77 // CreateVoiceEngines(); |
72 CreateVoiceEngines(); | 78 // AudioState::Config audio_state_config; |
73 AudioState::Config audio_state_config; | 79 // audio_state_config.voice_engine = voe_send_.voice_engine; |
74 audio_state_config.voice_engine = voe_send_.voice_engine; | 80 // audio_state_config.audio_mixer = AudioMixerImpl::Create(); |
75 audio_state_config.audio_mixer = AudioMixerImpl::Create(); | 81 // audio_state_config.audio_processing = apm_send_; |
76 audio_state_config.audio_processing = apm_send_; | 82 // send_config.audio_state = AudioState::Create(audio_state_config); |
77 send_config.audio_state = AudioState::Create(audio_state_config); | 83 // } |
78 } | 84 // CreateSenderCall(send_config); |
79 CreateSenderCall(send_config); | 85 // if (sender_call_transport_controller_ != nullptr) { |
80 if (sender_call_transport_controller_ != nullptr) { | 86 // test->OnRtpTransportControllerSendCreated( |
81 test->OnRtpTransportControllerSendCreated( | 87 // sender_call_transport_controller_); |
82 sender_call_transport_controller_); | 88 // } |
83 } | 89 // if (test->ShouldCreateReceivers()) { |
84 if (test->ShouldCreateReceivers()) { | 90 // Call::Config recv_config(test->GetReceiverCallConfig()); |
85 Call::Config recv_config(test->GetReceiverCallConfig()); | 91 // if (num_audio_streams_ > 0) { |
86 if (num_audio_streams_ > 0) { | 92 // AudioState::Config audio_state_config; |
87 AudioState::Config audio_state_config; | 93 // audio_state_config.voice_engine = voe_recv_.voice_engine; |
88 audio_state_config.voice_engine = voe_recv_.voice_engine; | 94 // audio_state_config.audio_mixer = AudioMixerImpl::Create(); |
89 audio_state_config.audio_mixer = AudioMixerImpl::Create(); | 95 // audio_state_config.audio_processing = apm_recv_; |
90 audio_state_config.audio_processing = apm_recv_; | 96 // recv_config.audio_state = AudioState::Create(audio_state_config); |
91 recv_config.audio_state = AudioState::Create(audio_state_config); | 97 // } |
92 } | 98 // CreateReceiverCall(recv_config); |
93 CreateReceiverCall(recv_config); | 99 // } |
94 } | 100 // test->OnCallsCreated(sender_call_.get(), receiver_call_.get()); |
95 test->OnCallsCreated(sender_call_.get(), receiver_call_.get()); | 101 // receive_transport_.reset(test->CreateReceiveTransport()); |
96 receive_transport_.reset(test->CreateReceiveTransport(&task_queue_)); | 102 // send_transport_.reset(test->CreateSendTransport(sender_call_.get())); |
97 send_transport_.reset( | |
98 test->CreateSendTransport(&task_queue_, sender_call_.get())); | |
99 | 103 |
100 if (test->ShouldCreateReceivers()) { | 104 // if (test->ShouldCreateReceivers()) { |
101 send_transport_->SetReceiver(receiver_call_->Receiver()); | 105 // send_transport_->SetReceiver(receiver_call_->Receiver()); |
102 receive_transport_->SetReceiver(sender_call_->Receiver()); | 106 // receive_transport_->SetReceiver(sender_call_->Receiver()); |
103 if (num_video_streams_ > 0) | 107 // if (num_video_streams_ > 0) |
104 receiver_call_->SignalChannelNetworkState(MediaType::VIDEO, kNetworkUp); | 108 // receiver_call_->SignalChannelNetworkState(MediaType::VIDEO, |
105 if (num_audio_streams_ > 0) | 109 // kNetworkUp); |
106 receiver_call_->SignalChannelNetworkState(MediaType::AUDIO, kNetworkUp); | 110 // if (num_audio_streams_ > 0) |
107 } else { | 111 // receiver_call_->SignalChannelNetworkState(MediaType::AUDIO, |
108 // Sender-only call delivers to itself. | 112 // kNetworkUp); |
109 send_transport_->SetReceiver(sender_call_->Receiver()); | 113 // } else { |
110 receive_transport_->SetReceiver(nullptr); | 114 // // Sender-only call delivers to itself. |
111 } | 115 // send_transport_->SetReceiver(sender_call_->Receiver()); |
| 116 // receive_transport_->SetReceiver(nullptr); |
| 117 // } |
112 | 118 |
113 CreateSendConfig(num_video_streams_, num_audio_streams_, | 119 // CreateSendConfig(); |
114 num_flexfec_streams_, send_transport_.get()); | 120 // if (test->ShouldCreateReceivers()) { |
115 if (test->ShouldCreateReceivers()) { | 121 // CreateMatchingReceiveConfigs( |
116 CreateMatchingReceiveConfigs(receive_transport_.get()); | 122 // receive_transport_.get(), |
117 } | 123 // &video_receive_configs_, |
118 if (num_video_streams_ > 0) { | 124 // &allocated_decoders_, |
119 test->ModifyVideoConfigs(&video_send_config_, &video_receive_configs_, | 125 // &video_send_config_); |
120 &video_encoder_config_); | 126 // } |
121 } | 127 // if (num_video_streams_ > 0) { |
122 if (num_audio_streams_ > 0) { | 128 // test->ModifyVideoConfigs(&video_send_config_, &video_receive_configs_, |
123 test->ModifyAudioConfigs(&audio_send_config_, &audio_receive_configs_); | 129 // &video_encoder_config_); |
124 } | 130 // } |
125 if (num_flexfec_streams_ > 0) { | 131 // if (num_audio_streams_ > 0) { |
126 test->ModifyFlexfecConfigs(&flexfec_receive_configs_); | 132 // test->ModifyAudioConfigs(&audio_send_config_, &audio_receive_configs_); |
127 } | 133 // } |
| 134 // if (num_flexfec_streams_ > 0) { |
| 135 // test->ModifyFlexfecConfigs(&flexfec_receive_configs_); |
| 136 // } |
128 | 137 |
129 if (num_flexfec_streams_ > 0) { | 138 // if (num_flexfec_streams_ > 0) { |
130 CreateFlexfecStreams(); | 139 // CreateFlexfecStreams(); |
131 test->OnFlexfecStreamsCreated(flexfec_receive_streams_); | 140 // test->OnFlexfecStreamsCreated(flexfec_receive_streams_); |
132 } | 141 // } |
133 if (num_video_streams_ > 0) { | 142 // if (num_video_streams_ > 0) { |
134 CreateVideoStreams(); | 143 // video_send_stream_ = CreateVideoStreams(sender_call_.get(), |
135 test->OnVideoStreamsCreated(video_send_stream_, video_receive_streams_); | 144 // receiver_call_.get(), |
136 } | 145 // &video_send_config_, |
137 if (num_audio_streams_ > 0) { | 146 // &video_receive_configs_, |
138 CreateAudioStreams(); | 147 // &video_receive_streams_, |
139 test->OnAudioStreamsCreated(audio_send_stream_, audio_receive_streams_); | 148 // &video_encoder_config_); |
140 } | 149 // test->OnVideoStreamsCreated(video_send_stream_, video_receive_streams_); |
| 150 // } |
| 151 // if (num_audio_streams_ > 0) { |
| 152 // CreateAudioStreams(); |
| 153 // test->OnAudioStreamsCreated(audio_send_stream_, audio_receive_streams_); |
| 154 // } |
141 | 155 |
142 if (num_video_streams_ > 0) { | 156 // if (num_video_streams_ > 0) { |
143 int width = kDefaultWidth; | 157 // int width = kDefaultWidth; |
144 int height = kDefaultHeight; | 158 // int height = kDefaultHeight; |
145 int frame_rate = kDefaultFramerate; | 159 // int frame_rate = kDefaultFramerate; |
146 test->ModifyVideoCaptureStartResolution(&width, &height, &frame_rate); | 160 // test->ModifyVideoCaptureStartResolution(&width, &height, &frame_rate); |
147 CreateFrameGeneratorCapturer(frame_rate, width, height); | 161 // CreateFrameGeneratorCapturer(frame_rate, width, height); |
148 test->OnFrameGeneratorCapturerCreated(frame_generator_capturer_.get()); | 162 // test->OnFrameGeneratorCapturerCreated(frame_generator_capturer_.get()); |
149 } | 163 // } |
150 | 164 |
151 Start(); | 165 // Start(); |
152 }); | 166 // test->PerformTest(); |
| 167 // send_transport_->StopSending(); |
| 168 // receive_transport_->StopSending(); |
| 169 // Stop(); |
153 | 170 |
154 test->PerformTest(); | 171 // DestroyStreams(); |
| 172 // DestroyCalls(); |
| 173 // if (num_audio_streams_ > 0) |
| 174 // DestroyVoiceEngines(); |
155 | 175 |
156 task_queue_.SendTask([this]() { | 176 // test->OnTestFinished(); |
157 Stop(); | |
158 DestroyStreams(); | |
159 send_transport_.reset(); | |
160 receive_transport_.reset(); | |
161 DestroyCalls(); | |
162 if (num_audio_streams_ > 0) | |
163 DestroyVoiceEngines(); | |
164 }); | |
165 | |
166 test->OnTestFinished(); | |
167 } | 177 } |
168 | 178 |
169 void CallTest::CreateCalls(const Call::Config& sender_config, | 179 void CallTest::CreateCalls(const Call::Config& sender_config, |
170 const Call::Config& receiver_config) { | 180 const Call::Config& receiver_config) { |
171 CreateSenderCall(sender_config); | 181 CreateSenderCall(sender_config); |
172 CreateReceiverCall(receiver_config); | 182 CreateReceiverCall(receiver_config); |
173 } | 183 } |
174 | 184 |
175 void CallTest::CreateSenderCall(const Call::Config& config) { | 185 void CallTest::CreateSenderCall(const Call::Config& config) { |
176 sender_call_transport_controller_ = new RtpTransportControllerSend( | 186 sender_call_transport_controller_ = new RtpTransportControllerSend( |
177 Clock::GetRealTimeClock(), config.event_log); | 187 Clock::GetRealTimeClock(), config.event_log); |
178 | 188 |
179 sender_call_.reset( | 189 sender_call_.reset( |
180 Call::Create(config, std::unique_ptr<RtpTransportControllerSend>( | 190 Call::Create(config, std::unique_ptr<RtpTransportControllerSend>( |
181 sender_call_transport_controller_))); | 191 sender_call_transport_controller_))); |
| 192 sender_call_->PrintDebugStuff(); |
182 } | 193 } |
183 | 194 |
184 void CallTest::CreateReceiverCall(const Call::Config& config) { | 195 void CallTest::CreateReceiverCall(const Call::Config& config) { |
185 receiver_call_.reset(Call::Create(config)); | 196 receiver_call_.reset(Call::Create(config)); |
186 } | 197 } |
187 | 198 |
188 void CallTest::DestroyCalls() { | 199 void CallTest::DestroyCalls() { |
189 sender_call_.reset(); | 200 sender_call_.reset(); |
190 receiver_call_.reset(); | 201 receiver_call_.reset(); |
191 } | 202 } |
192 | 203 |
193 void CallTest::CreateSendConfig(size_t num_video_streams, | 204 void CallTest::CreateSendConfig(size_t num_video_streams, |
194 size_t num_audio_streams, | 205 size_t num_audio_streams, |
195 size_t num_flexfec_streams, | 206 size_t num_flexfec_streams, |
196 Transport* send_transport) { | 207 Transport* send_transport, |
| 208 VideoSendStream::Config* video_send_config, |
| 209 VideoEncoderConfig* video_encoder_config, |
| 210 std::vector<uint32_t>* send_ssrcs) { |
197 RTC_DCHECK(num_video_streams <= kNumSsrcs); | 211 RTC_DCHECK(num_video_streams <= kNumSsrcs); |
198 RTC_DCHECK_LE(num_audio_streams, 1); | 212 RTC_DCHECK_LE(num_audio_streams, 1); |
199 RTC_DCHECK_LE(num_flexfec_streams, 1); | 213 RTC_DCHECK_LE(num_flexfec_streams, 1); |
200 RTC_DCHECK(num_audio_streams == 0 || voe_send_.channel_id >= 0); | 214 RTC_DCHECK(num_audio_streams == 0); |
201 if (num_video_streams > 0) { | 215 if (num_video_streams > 0) { |
202 video_send_config_ = VideoSendStream::Config(send_transport); | 216 *video_send_config = VideoSendStream::Config(send_transport); |
203 video_send_config_.encoder_settings.encoder = &fake_encoder_; | 217 video_send_config->encoder_settings.encoder = &fake_encoder_; |
204 video_send_config_.encoder_settings.payload_name = "FAKE"; | 218 video_send_config->encoder_settings.payload_name = "FAKE"; |
205 video_send_config_.encoder_settings.payload_type = | 219 video_send_config->encoder_settings.payload_type = |
206 kFakeVideoSendPayloadType; | 220 kFakeVideoSendPayloadType; |
207 video_send_config_.rtp.extensions.push_back( | 221 video_send_config->rtp.extensions.push_back( |
208 RtpExtension(RtpExtension::kTransportSequenceNumberUri, | 222 RtpExtension(RtpExtension::kTransportSequenceNumberUri, |
209 kTransportSequenceNumberExtensionId)); | 223 kTransportSequenceNumberExtensionId)); |
210 video_send_config_.rtp.extensions.push_back(RtpExtension( | 224 video_send_config->rtp.extensions.push_back(RtpExtension( |
211 RtpExtension::kVideoContentTypeUri, kVideoContentTypeExtensionId)); | 225 RtpExtension::kVideoContentTypeUri, kVideoContentTypeExtensionId)); |
212 FillEncoderConfiguration(num_video_streams, &video_encoder_config_); | 226 FillEncoderConfiguration(num_video_streams, video_encoder_config); |
213 | 227 |
214 for (size_t i = 0; i < num_video_streams; ++i) | 228 for (size_t i = 0; i < num_video_streams; ++i) |
215 video_send_config_.rtp.ssrcs.push_back(kVideoSendSsrcs[i]); | 229 video_send_config->rtp.ssrcs.push_back(send_ssrcs->at(i)); |
216 video_send_config_.rtp.extensions.push_back(RtpExtension( | 230 video_send_config->rtp.extensions.push_back(RtpExtension( |
217 RtpExtension::kVideoRotationUri, kVideoRotationRtpExtensionId)); | 231 RtpExtension::kVideoRotationUri, kVideoRotationRtpExtensionId)); |
218 } | 232 } |
219 | 233 |
220 if (num_audio_streams > 0) { | |
221 audio_send_config_ = AudioSendStream::Config(send_transport); | |
222 audio_send_config_.voe_channel_id = voe_send_.channel_id; | |
223 audio_send_config_.rtp.ssrc = kAudioSendSsrc; | |
224 audio_send_config_.send_codec_spec = | |
225 rtc::Optional<AudioSendStream::Config::SendCodecSpec>( | |
226 {kAudioSendPayloadType, {"OPUS", 48000, 2, {{"stereo", "1"}}}}); | |
227 audio_send_config_.encoder_factory = encoder_factory_; | |
228 } | |
229 | |
230 // TODO(brandtr): Update this when we support multistream protection. | 234 // TODO(brandtr): Update this when we support multistream protection. |
231 if (num_flexfec_streams > 0) { | 235 RTC_DCHECK(num_flexfec_streams == 0); |
232 video_send_config_.rtp.flexfec.payload_type = kFlexfecPayloadType; | 236 // if (num_flexfec_streams > 0) { |
233 video_send_config_.rtp.flexfec.ssrc = kFlexfecSendSsrc; | 237 // video_send_config->rtp.flexfec.payload_type = kFlexfecPayloadType; |
234 video_send_config_.rtp.flexfec.protected_media_ssrcs = {kVideoSendSsrcs[0]}; | 238 // video_send_config->rtp.flexfec.ssrc = kFlexfecSendSsrc; |
235 } | 239 // video_send_config->rtp.flexfec.protected_media_ssrcs = |
| 240 // {kVideoSendSsrcs[0]}; |
| 241 // } |
236 } | 242 } |
237 | 243 |
238 void CallTest::CreateMatchingReceiveConfigs(Transport* rtcp_send_transport) { | 244 void CallTest::CreateMatchingReceiveConfigs( |
239 video_receive_configs_.clear(); | 245 Transport* rtcp_send_transport, |
240 allocated_decoders_.clear(); | 246 std::vector<VideoReceiveStream::Config>* video_receive_configs, |
| 247 std::vector<std::unique_ptr<VideoDecoder>>* allocated_decoders, |
| 248 VideoSendStream::Config* video_send_config) { |
| 249 video_receive_configs->clear(); |
| 250 allocated_decoders->clear(); |
241 if (num_video_streams_ > 0) { | 251 if (num_video_streams_ > 0) { |
242 RTC_DCHECK(!video_send_config_.rtp.ssrcs.empty()); | 252 RTC_DCHECK(!video_send_config->rtp.ssrcs.empty()); |
243 VideoReceiveStream::Config video_config(rtcp_send_transport); | 253 VideoReceiveStream::Config video_config(rtcp_send_transport); |
244 video_config.rtp.remb = false; | 254 video_config.rtp.remb = false; |
245 video_config.rtp.transport_cc = true; | 255 video_config.rtp.transport_cc = true; |
246 video_config.rtp.local_ssrc = kReceiverLocalVideoSsrc; | 256 video_config.rtp.local_ssrc = kReceiverLocalVideoSsrc; |
247 for (const RtpExtension& extension : video_send_config_.rtp.extensions) | 257 for (const RtpExtension& extension : video_send_config->rtp.extensions) |
248 video_config.rtp.extensions.push_back(extension); | 258 video_config.rtp.extensions.push_back(extension); |
249 video_config.renderer = &fake_renderer_; | 259 video_config.renderer = &fake_renderer_; |
250 for (size_t i = 0; i < video_send_config_.rtp.ssrcs.size(); ++i) { | 260 for (size_t i = 0; i < video_send_config->rtp.ssrcs.size(); ++i) { |
251 VideoReceiveStream::Decoder decoder = | 261 VideoReceiveStream::Decoder decoder = |
252 test::CreateMatchingDecoder(video_send_config_.encoder_settings); | 262 test::CreateMatchingDecoder(video_send_config->encoder_settings); |
253 allocated_decoders_.push_back( | 263 allocated_decoders->push_back( |
254 std::unique_ptr<VideoDecoder>(decoder.decoder)); | 264 std::unique_ptr<VideoDecoder>(decoder.decoder)); |
255 video_config.decoders.clear(); | 265 video_config.decoders.clear(); |
256 video_config.decoders.push_back(decoder); | 266 video_config.decoders.push_back(decoder); |
257 video_config.rtp.remote_ssrc = video_send_config_.rtp.ssrcs[i]; | 267 video_config.rtp.remote_ssrc = video_send_config->rtp.ssrcs[i]; |
258 video_receive_configs_.push_back(video_config.Copy()); | 268 video_receive_configs->push_back(video_config.Copy()); |
259 } | 269 } |
260 } | 270 } |
261 | 271 |
262 RTC_DCHECK_GE(1, num_audio_streams_); | 272 RTC_DCHECK_EQ(0, num_audio_streams_); |
263 if (num_audio_streams_ == 1) { | 273 RTC_DCHECK(num_flexfec_streams_ <= 0); |
264 RTC_DCHECK_LE(0, voe_send_.channel_id); | |
265 AudioReceiveStream::Config audio_config; | |
266 audio_config.rtp.local_ssrc = kReceiverLocalAudioSsrc; | |
267 audio_config.rtcp_send_transport = rtcp_send_transport; | |
268 audio_config.voe_channel_id = voe_recv_.channel_id; | |
269 audio_config.rtp.remote_ssrc = audio_send_config_.rtp.ssrc; | |
270 audio_config.decoder_factory = decoder_factory_; | |
271 audio_config.decoder_map = {{kAudioSendPayloadType, {"opus", 48000, 2}}}; | |
272 audio_receive_configs_.push_back(audio_config); | |
273 } | |
274 | |
275 // TODO(brandtr): Update this when we support multistream protection. | |
276 RTC_DCHECK(num_flexfec_streams_ <= 1); | |
277 if (num_flexfec_streams_ == 1) { | |
278 FlexfecReceiveStream::Config config(rtcp_send_transport); | |
279 config.payload_type = kFlexfecPayloadType; | |
280 config.remote_ssrc = kFlexfecSendSsrc; | |
281 config.protected_media_ssrcs = {kVideoSendSsrcs[0]}; | |
282 config.local_ssrc = kReceiverLocalVideoSsrc; | |
283 for (const RtpExtension& extension : video_send_config_.rtp.extensions) | |
284 config.rtp_header_extensions.push_back(extension); | |
285 flexfec_receive_configs_.push_back(config); | |
286 } | |
287 } | 274 } |
288 | 275 |
289 void CallTest::CreateFrameGeneratorCapturerWithDrift(Clock* clock, | 276 void CallTest::CreateFrameGeneratorCapturerWithDrift(Clock* clock, |
290 float speed, | 277 float speed, |
291 int framerate, | 278 int framerate, |
292 int width, | 279 int width, |
293 int height) { | 280 int height) { |
294 frame_generator_capturer_.reset(test::FrameGeneratorCapturer::Create( | 281 frame_generator_capturer_.reset(test::FrameGeneratorCapturer::Create( |
295 width, height, framerate * speed, clock)); | 282 width, height, framerate * speed, clock)); |
296 video_send_stream_->SetSource( | 283 video_send_stream_->SetSource( |
(...skipping 13 matching lines...) Expand all Loading... |
310 | 297 |
311 void CallTest::CreateFakeAudioDevices( | 298 void CallTest::CreateFakeAudioDevices( |
312 std::unique_ptr<FakeAudioDevice::Capturer> capturer, | 299 std::unique_ptr<FakeAudioDevice::Capturer> capturer, |
313 std::unique_ptr<FakeAudioDevice::Renderer> renderer) { | 300 std::unique_ptr<FakeAudioDevice::Renderer> renderer) { |
314 fake_send_audio_device_.reset(new FakeAudioDevice( | 301 fake_send_audio_device_.reset(new FakeAudioDevice( |
315 std::move(capturer), nullptr, 1.f)); | 302 std::move(capturer), nullptr, 1.f)); |
316 fake_recv_audio_device_.reset(new FakeAudioDevice( | 303 fake_recv_audio_device_.reset(new FakeAudioDevice( |
317 nullptr, std::move(renderer), 1.f)); | 304 nullptr, std::move(renderer), 1.f)); |
318 } | 305 } |
319 | 306 |
320 void CallTest::CreateVideoStreams() { | 307 VideoSendStream* CallTest::CreateVideoStreams( |
321 RTC_DCHECK(video_send_stream_ == nullptr); | 308 Call* sender_call, |
322 RTC_DCHECK(video_receive_streams_.empty()); | 309 Call* receiver_call, |
323 RTC_DCHECK(audio_send_stream_ == nullptr); | 310 VideoSendStream::Config* video_send_config, |
324 RTC_DCHECK(audio_receive_streams_.empty()); | 311 std::vector<VideoReceiveStream::Config>* video_receive_configs, |
325 | 312 std::vector<VideoReceiveStream*>* video_receive_streams, |
326 video_send_stream_ = sender_call_->CreateVideoSendStream( | 313 VideoEncoderConfig* video_encoder_config) { |
327 video_send_config_.Copy(), video_encoder_config_.Copy()); | 314 for (size_t i = 0; i < video_receive_configs->size(); ++i) { |
328 for (size_t i = 0; i < video_receive_configs_.size(); ++i) { | 315 video_receive_streams->push_back(receiver_call->CreateVideoReceiveStream( |
329 video_receive_streams_.push_back(receiver_call_->CreateVideoReceiveStream( | 316 video_receive_configs->at(i).Copy())); |
330 video_receive_configs_[i].Copy())); | |
331 } | 317 } |
332 | 318 |
333 AssociateFlexfecStreamsWithVideoStreams(); | 319 return sender_call->CreateVideoSendStream(video_send_config->Copy(), |
| 320 video_encoder_config->Copy()); |
334 } | 321 } |
335 | 322 |
336 void CallTest::CreateAudioStreams() { | 323 void CallTest::CreateAudioStreams() { |
337 audio_send_stream_ = sender_call_->CreateAudioSendStream(audio_send_config_); | 324 audio_send_stream_ = sender_call_->CreateAudioSendStream(audio_send_config_); |
338 for (size_t i = 0; i < audio_receive_configs_.size(); ++i) { | 325 for (size_t i = 0; i < audio_receive_configs_.size(); ++i) { |
339 audio_receive_streams_.push_back( | 326 audio_receive_streams_.push_back( |
340 receiver_call_->CreateAudioReceiveStream(audio_receive_configs_[i])); | 327 receiver_call_->CreateAudioReceiveStream(audio_receive_configs_[i])); |
341 } | 328 } |
342 } | 329 } |
343 | 330 |
(...skipping 123 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
467 const uint8_t CallTest::kFakeVideoSendPayloadType = 125; | 454 const uint8_t CallTest::kFakeVideoSendPayloadType = 125; |
468 const uint8_t CallTest::kSendRtxPayloadType = 98; | 455 const uint8_t CallTest::kSendRtxPayloadType = 98; |
469 const uint8_t CallTest::kRedPayloadType = 118; | 456 const uint8_t CallTest::kRedPayloadType = 118; |
470 const uint8_t CallTest::kRtxRedPayloadType = 99; | 457 const uint8_t CallTest::kRtxRedPayloadType = 99; |
471 const uint8_t CallTest::kUlpfecPayloadType = 119; | 458 const uint8_t CallTest::kUlpfecPayloadType = 119; |
472 const uint8_t CallTest::kFlexfecPayloadType = 120; | 459 const uint8_t CallTest::kFlexfecPayloadType = 120; |
473 const uint8_t CallTest::kAudioSendPayloadType = 103; | 460 const uint8_t CallTest::kAudioSendPayloadType = 103; |
474 const uint8_t CallTest::kPayloadTypeH264 = 122; | 461 const uint8_t CallTest::kPayloadTypeH264 = 122; |
475 const uint8_t CallTest::kPayloadTypeVP8 = 123; | 462 const uint8_t CallTest::kPayloadTypeVP8 = 123; |
476 const uint8_t CallTest::kPayloadTypeVP9 = 124; | 463 const uint8_t CallTest::kPayloadTypeVP9 = 124; |
477 const uint32_t CallTest::kSendRtxSsrcs[kNumSsrcs] = {0xBADCAFD, 0xBADCAFE, | 464 // const uint32_t CallTest::kSendRtxSsrcs[kNumSsrcs] = {0xBADCAFD, 0xBADCAFE, |
478 0xBADCAFF}; | 465 // 0xBADCAFF}; |
479 const uint32_t CallTest::kVideoSendSsrcs[kNumSsrcs] = {0xC0FFED, 0xC0FFEE, | 466 // const uint32_t CallTest::kVideoSendSsrcs[kNumSsrcs] = {0xC0FFED, 0xC0FFEE, |
480 0xC0FFEF}; | 467 // 0xC0FFEF}; |
481 const uint32_t CallTest::kAudioSendSsrc = 0xDEADBEEF; | 468 const uint32_t CallTest::kAudioSendSsrc = 0xDEADBEEF; |
482 const uint32_t CallTest::kFlexfecSendSsrc = 0xBADBEEF; | 469 const uint32_t CallTest::kFlexfecSendSsrc = 0xBADBEEF; |
483 const uint32_t CallTest::kReceiverLocalVideoSsrc = 0x123456; | 470 const uint32_t CallTest::kReceiverLocalVideoSsrc = 0x123456; |
484 const uint32_t CallTest::kReceiverLocalAudioSsrc = 0x1234567; | 471 const uint32_t CallTest::kReceiverLocalAudioSsrc = 0x1234567; |
485 const int CallTest::kNackRtpHistoryMs = 1000; | 472 const int CallTest::kNackRtpHistoryMs = 1000; |
486 | 473 |
487 const uint8_t CallTest::kDefaultKeepalivePayloadType = | 474 const uint8_t CallTest::kDefaultKeepalivePayloadType = |
488 RtpKeepAliveConfig().payload_type; | 475 RtpKeepAliveConfig().payload_type; |
489 | 476 |
490 const std::map<uint8_t, MediaType> CallTest::payload_type_map_ = { | 477 const std::map<uint8_t, MediaType> CallTest::payload_type_map_ = { |
(...skipping 113 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
604 | 591 |
605 EndToEndTest::EndToEndTest(unsigned int timeout_ms) : BaseTest(timeout_ms) { | 592 EndToEndTest::EndToEndTest(unsigned int timeout_ms) : BaseTest(timeout_ms) { |
606 } | 593 } |
607 | 594 |
608 bool EndToEndTest::ShouldCreateReceivers() const { | 595 bool EndToEndTest::ShouldCreateReceivers() const { |
609 return true; | 596 return true; |
610 } | 597 } |
611 | 598 |
612 } // namespace test | 599 } // namespace test |
613 } // namespace webrtc | 600 } // namespace webrtc |
OLD | NEW |