OLD | NEW |
1 /* | 1 /* |
2 * Copyright (c) 2008 The WebRTC project authors. All Rights Reserved. | 2 * Copyright (c) 2008 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 10 matching lines...) Expand all Loading... |
21 #include "webrtc/media/base/fakemediaengine.h" | 21 #include "webrtc/media/base/fakemediaengine.h" |
22 #include "webrtc/media/base/fakenetworkinterface.h" | 22 #include "webrtc/media/base/fakenetworkinterface.h" |
23 #include "webrtc/media/base/fakertp.h" | 23 #include "webrtc/media/base/fakertp.h" |
24 #include "webrtc/media/base/mediaconstants.h" | 24 #include "webrtc/media/base/mediaconstants.h" |
25 #include "webrtc/media/engine/fakewebrtccall.h" | 25 #include "webrtc/media/engine/fakewebrtccall.h" |
26 #include "webrtc/media/engine/fakewebrtcvoiceengine.h" | 26 #include "webrtc/media/engine/fakewebrtcvoiceengine.h" |
27 #include "webrtc/media/engine/webrtcvoiceengine.h" | 27 #include "webrtc/media/engine/webrtcvoiceengine.h" |
28 #include "webrtc/modules/audio_coding/codecs/builtin_audio_decoder_factory.h" | 28 #include "webrtc/modules/audio_coding/codecs/builtin_audio_decoder_factory.h" |
29 #include "webrtc/modules/audio_coding/codecs/mock/mock_audio_decoder_factory.h" | 29 #include "webrtc/modules/audio_coding/codecs/mock/mock_audio_decoder_factory.h" |
30 #include "webrtc/modules/audio_device/include/mock_audio_device.h" | 30 #include "webrtc/modules/audio_device/include/mock_audio_device.h" |
| 31 #include "webrtc/modules/audio_processing/include/mock_audio_processing.h" |
31 | 32 |
32 using testing::Return; | 33 using testing::Return; |
33 using testing::StrictMock; | 34 using testing::StrictMock; |
34 | 35 |
35 namespace { | 36 namespace { |
36 | 37 |
37 const cricket::AudioCodec kPcmuCodec(0, "PCMU", 8000, 64000, 1); | 38 const cricket::AudioCodec kPcmuCodec(0, "PCMU", 8000, 64000, 1); |
38 const cricket::AudioCodec kIsacCodec(103, "ISAC", 16000, 32000, 1); | 39 const cricket::AudioCodec kIsacCodec(103, "ISAC", 16000, 32000, 1); |
39 const cricket::AudioCodec kOpusCodec(111, "opus", 48000, 64000, 2); | 40 const cricket::AudioCodec kOpusCodec(111, "opus", 48000, 64000, 2); |
40 const cricket::AudioCodec kG722CodecVoE(9, "G722", 16000, 64000, 1); | 41 const cricket::AudioCodec kG722CodecVoE(9, "G722", 16000, 64000, 1); |
(...skipping 26 matching lines...) Expand all Loading... |
67 } // namespace | 68 } // namespace |
68 | 69 |
69 // Tests that our stub library "works". | 70 // Tests that our stub library "works". |
70 TEST(WebRtcVoiceEngineTestStubLibrary, StartupShutdown) { | 71 TEST(WebRtcVoiceEngineTestStubLibrary, StartupShutdown) { |
71 StrictMock<webrtc::test::MockAudioDeviceModule> adm; | 72 StrictMock<webrtc::test::MockAudioDeviceModule> adm; |
72 EXPECT_CALL(adm, AddRef()).WillOnce(Return(0)); | 73 EXPECT_CALL(adm, AddRef()).WillOnce(Return(0)); |
73 EXPECT_CALL(adm, Release()).WillOnce(Return(0)); | 74 EXPECT_CALL(adm, Release()).WillOnce(Return(0)); |
74 EXPECT_CALL(adm, BuiltInAECIsAvailable()).WillOnce(Return(false)); | 75 EXPECT_CALL(adm, BuiltInAECIsAvailable()).WillOnce(Return(false)); |
75 EXPECT_CALL(adm, BuiltInAGCIsAvailable()).WillOnce(Return(false)); | 76 EXPECT_CALL(adm, BuiltInAGCIsAvailable()).WillOnce(Return(false)); |
76 EXPECT_CALL(adm, BuiltInNSIsAvailable()).WillOnce(Return(false)); | 77 EXPECT_CALL(adm, BuiltInNSIsAvailable()).WillOnce(Return(false)); |
77 cricket::FakeWebRtcVoiceEngine voe; | 78 StrictMock<webrtc::test::MockAudioProcessing> apm; |
| 79 EXPECT_CALL(apm, ApplyConfig(testing::_)); |
| 80 EXPECT_CALL(apm, SetExtraOptions(testing::_)); |
| 81 EXPECT_CALL(apm, Initialize()).WillOnce(Return(0)); |
| 82 cricket::FakeWebRtcVoiceEngine voe(&apm); |
78 EXPECT_FALSE(voe.IsInited()); | 83 EXPECT_FALSE(voe.IsInited()); |
79 { | 84 { |
80 cricket::WebRtcVoiceEngine engine( | 85 cricket::WebRtcVoiceEngine engine( |
81 &adm, webrtc::MockAudioDecoderFactory::CreateUnusedFactory(), | 86 &adm, webrtc::MockAudioDecoderFactory::CreateUnusedFactory(), |
82 new FakeVoEWrapper(&voe)); | 87 new FakeVoEWrapper(&voe)); |
83 EXPECT_TRUE(voe.IsInited()); | 88 EXPECT_TRUE(voe.IsInited()); |
84 } | 89 } |
85 EXPECT_FALSE(voe.IsInited()); | 90 EXPECT_FALSE(voe.IsInited()); |
86 } | 91 } |
87 | 92 |
88 class FakeAudioSink : public webrtc::AudioSinkInterface { | 93 class FakeAudioSink : public webrtc::AudioSinkInterface { |
89 public: | 94 public: |
90 void OnData(const Data& audio) override {} | 95 void OnData(const Data& audio) override {} |
91 }; | 96 }; |
92 | 97 |
93 class FakeAudioSource : public cricket::AudioSource { | 98 class FakeAudioSource : public cricket::AudioSource { |
94 void SetSink(Sink* sink) override {} | 99 void SetSink(Sink* sink) override {} |
95 }; | 100 }; |
96 | 101 |
97 class WebRtcVoiceEngineTestFake : public testing::Test { | 102 class WebRtcVoiceEngineTestFake : public testing::Test { |
98 public: | 103 public: |
99 WebRtcVoiceEngineTestFake() : WebRtcVoiceEngineTestFake("") {} | 104 WebRtcVoiceEngineTestFake() : WebRtcVoiceEngineTestFake("") {} |
100 | 105 |
101 explicit WebRtcVoiceEngineTestFake(const char* field_trials) | 106 explicit WebRtcVoiceEngineTestFake(const char* field_trials) |
102 : call_(webrtc::Call::Config(&event_log_)), | 107 : call_(webrtc::Call::Config(&event_log_)), voe_(&apm_), |
103 override_field_trials_(field_trials) { | 108 override_field_trials_(field_trials) { |
104 auto factory = webrtc::MockAudioDecoderFactory::CreateUnusedFactory(); | 109 auto factory = webrtc::MockAudioDecoderFactory::CreateUnusedFactory(); |
105 EXPECT_CALL(adm_, AddRef()).WillOnce(Return(0)); | 110 EXPECT_CALL(adm_, AddRef()).WillOnce(Return(0)); |
106 EXPECT_CALL(adm_, Release()).WillOnce(Return(0)); | 111 EXPECT_CALL(adm_, Release()).WillOnce(Return(0)); |
107 EXPECT_CALL(adm_, BuiltInAECIsAvailable()).WillOnce(Return(false)); | 112 EXPECT_CALL(adm_, BuiltInAECIsAvailable()).WillOnce(Return(false)); |
108 EXPECT_CALL(adm_, BuiltInAGCIsAvailable()).WillOnce(Return(false)); | 113 EXPECT_CALL(adm_, BuiltInAGCIsAvailable()).WillOnce(Return(false)); |
109 EXPECT_CALL(adm_, BuiltInNSIsAvailable()).WillOnce(Return(false)); | 114 EXPECT_CALL(adm_, BuiltInNSIsAvailable()).WillOnce(Return(false)); |
| 115 EXPECT_CALL(apm_, ApplyConfig(testing::_)); |
| 116 EXPECT_CALL(apm_, SetExtraOptions(testing::_)); |
| 117 EXPECT_CALL(apm_, Initialize()).WillOnce(Return(0)); |
110 engine_.reset(new cricket::WebRtcVoiceEngine(&adm_, factory, | 118 engine_.reset(new cricket::WebRtcVoiceEngine(&adm_, factory, |
111 new FakeVoEWrapper(&voe_))); | 119 new FakeVoEWrapper(&voe_))); |
112 send_parameters_.codecs.push_back(kPcmuCodec); | 120 send_parameters_.codecs.push_back(kPcmuCodec); |
113 recv_parameters_.codecs.push_back(kPcmuCodec); | 121 recv_parameters_.codecs.push_back(kPcmuCodec); |
114 } | 122 } |
115 | 123 |
116 bool SetupChannel() { | 124 bool SetupChannel() { |
| 125 EXPECT_CALL(apm_, ApplyConfig(testing::_)); |
| 126 EXPECT_CALL(apm_, SetExtraOptions(testing::_)); |
117 channel_ = engine_->CreateChannel(&call_, cricket::MediaConfig(), | 127 channel_ = engine_->CreateChannel(&call_, cricket::MediaConfig(), |
118 cricket::AudioOptions()); | 128 cricket::AudioOptions()); |
119 return (channel_ != nullptr); | 129 return (channel_ != nullptr); |
120 } | 130 } |
121 | 131 |
122 bool SetupRecvStream() { | 132 bool SetupRecvStream() { |
123 if (!SetupChannel()) { | 133 if (!SetupChannel()) { |
124 return false; | 134 return false; |
125 } | 135 } |
126 return AddRecvStream(kSsrc1); | 136 return AddRecvStream(kSsrc1); |
127 } | 137 } |
128 | 138 |
129 bool SetupSendStream() { | 139 bool SetupSendStream() { |
130 if (!SetupChannel()) { | 140 if (!SetupChannel()) { |
131 return false; | 141 return false; |
132 } | 142 } |
133 if (!channel_->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc1))) { | 143 if (!channel_->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc1))) { |
134 return false; | 144 return false; |
135 } | 145 } |
| 146 EXPECT_CALL(apm_, set_output_will_be_muted(false)); |
136 return channel_->SetAudioSend(kSsrc1, true, nullptr, &fake_source_); | 147 return channel_->SetAudioSend(kSsrc1, true, nullptr, &fake_source_); |
137 } | 148 } |
138 | 149 |
139 bool AddRecvStream(uint32_t ssrc) { | 150 bool AddRecvStream(uint32_t ssrc) { |
140 EXPECT_TRUE(channel_); | 151 EXPECT_TRUE(channel_); |
141 return channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(ssrc)); | 152 return channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(ssrc)); |
142 } | 153 } |
143 | 154 |
144 void SetupForMultiSendStream() { | 155 void SetupForMultiSendStream() { |
145 EXPECT_TRUE(SetupSendStream()); | 156 EXPECT_TRUE(SetupSendStream()); |
(...skipping 26 matching lines...) Expand all Loading... |
172 } | 183 } |
173 | 184 |
174 const webrtc::AudioSendStream::Config& GetSendStreamConfig(uint32_t ssrc) { | 185 const webrtc::AudioSendStream::Config& GetSendStreamConfig(uint32_t ssrc) { |
175 return GetSendStream(ssrc).GetConfig(); | 186 return GetSendStream(ssrc).GetConfig(); |
176 } | 187 } |
177 | 188 |
178 const webrtc::AudioReceiveStream::Config& GetRecvStreamConfig(uint32_t ssrc) { | 189 const webrtc::AudioReceiveStream::Config& GetRecvStreamConfig(uint32_t ssrc) { |
179 return GetRecvStream(ssrc).GetConfig(); | 190 return GetRecvStream(ssrc).GetConfig(); |
180 } | 191 } |
181 | 192 |
182 void SetSend(cricket::VoiceMediaChannel* channel, bool enable) { | 193 void SetSend(bool enable) { |
183 ASSERT_TRUE(channel); | 194 ASSERT_TRUE(channel_); |
184 if (enable) { | 195 if (enable) { |
185 EXPECT_CALL(adm_, RecordingIsInitialized()).WillOnce(Return(false)); | 196 EXPECT_CALL(adm_, RecordingIsInitialized()).WillOnce(Return(false)); |
186 EXPECT_CALL(adm_, Recording()).WillOnce(Return(false)); | 197 EXPECT_CALL(adm_, Recording()).WillOnce(Return(false)); |
187 EXPECT_CALL(adm_, InitRecording()).WillOnce(Return(0)); | 198 EXPECT_CALL(adm_, InitRecording()).WillOnce(Return(0)); |
| 199 EXPECT_CALL(apm_, ApplyConfig(testing::_)); |
| 200 EXPECT_CALL(apm_, SetExtraOptions(testing::_)); |
188 } | 201 } |
189 channel->SetSend(enable); | 202 channel_->SetSend(enable); |
| 203 } |
| 204 |
| 205 void SetSendParameters(const cricket::AudioSendParameters& params) { |
| 206 EXPECT_CALL(apm_, ApplyConfig(testing::_)); |
| 207 EXPECT_CALL(apm_, SetExtraOptions(testing::_)); |
| 208 ASSERT_TRUE(channel_); |
| 209 EXPECT_TRUE(channel_->SetSendParameters(params)); |
| 210 } |
| 211 |
| 212 void SetAudioSend(uint32_t ssrc, bool enable, cricket::AudioSource* source) { |
| 213 EXPECT_CALL(apm_, set_output_will_be_muted(!enable)); |
| 214 ASSERT_TRUE(channel_); |
| 215 EXPECT_TRUE(channel_->SetAudioSend(ssrc, enable, nullptr, source)); |
190 } | 216 } |
191 | 217 |
192 void TestInsertDtmf(uint32_t ssrc, bool caller) { | 218 void TestInsertDtmf(uint32_t ssrc, bool caller) { |
193 EXPECT_TRUE(SetupChannel()); | 219 EXPECT_TRUE(SetupChannel()); |
194 if (caller) { | 220 if (caller) { |
195 // If this is a caller, local description will be applied and add the | 221 // If this is a caller, local description will be applied and add the |
196 // send stream. | 222 // send stream. |
197 EXPECT_TRUE(channel_->AddSendStream( | 223 EXPECT_TRUE(channel_->AddSendStream( |
198 cricket::StreamParams::CreateLegacy(kSsrc1))); | 224 cricket::StreamParams::CreateLegacy(kSsrc1))); |
199 } | 225 } |
200 | 226 |
201 // Test we can only InsertDtmf when the other side supports telephone-event. | 227 // Test we can only InsertDtmf when the other side supports telephone-event. |
202 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); | 228 SetSendParameters(send_parameters_); |
203 SetSend(channel_, true); | 229 SetSend(true); |
204 EXPECT_FALSE(channel_->CanInsertDtmf()); | 230 EXPECT_FALSE(channel_->CanInsertDtmf()); |
205 EXPECT_FALSE(channel_->InsertDtmf(ssrc, 1, 111)); | 231 EXPECT_FALSE(channel_->InsertDtmf(ssrc, 1, 111)); |
206 send_parameters_.codecs.push_back(kTelephoneEventCodec); | 232 send_parameters_.codecs.push_back(kTelephoneEventCodec); |
207 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); | 233 SetSendParameters(send_parameters_); |
208 EXPECT_TRUE(channel_->CanInsertDtmf()); | 234 EXPECT_TRUE(channel_->CanInsertDtmf()); |
209 | 235 |
210 if (!caller) { | 236 if (!caller) { |
211 // If this is callee, there's no active send channel yet. | 237 // If this is callee, there's no active send channel yet. |
212 EXPECT_FALSE(channel_->InsertDtmf(ssrc, 2, 123)); | 238 EXPECT_FALSE(channel_->InsertDtmf(ssrc, 2, 123)); |
213 EXPECT_TRUE(channel_->AddSendStream( | 239 EXPECT_TRUE(channel_->AddSendStream( |
214 cricket::StreamParams::CreateLegacy(kSsrc1))); | 240 cricket::StreamParams::CreateLegacy(kSsrc1))); |
215 } | 241 } |
216 | 242 |
217 // Check we fail if the ssrc is invalid. | 243 // Check we fail if the ssrc is invalid. |
(...skipping 15 matching lines...) Expand all Loading... |
233 // |max_bitrate| is a parameter to set to SetMaxSendBandwidth(). | 259 // |max_bitrate| is a parameter to set to SetMaxSendBandwidth(). |
234 // |expected_result| is the expected result from SetMaxSendBandwidth(). | 260 // |expected_result| is the expected result from SetMaxSendBandwidth(). |
235 // |expected_bitrate| is the expected audio bitrate afterward. | 261 // |expected_bitrate| is the expected audio bitrate afterward. |
236 void TestMaxSendBandwidth(const cricket::AudioCodec& codec, | 262 void TestMaxSendBandwidth(const cricket::AudioCodec& codec, |
237 int max_bitrate, | 263 int max_bitrate, |
238 bool expected_result, | 264 bool expected_result, |
239 int expected_bitrate) { | 265 int expected_bitrate) { |
240 cricket::AudioSendParameters parameters; | 266 cricket::AudioSendParameters parameters; |
241 parameters.codecs.push_back(codec); | 267 parameters.codecs.push_back(codec); |
242 parameters.max_bandwidth_bps = max_bitrate; | 268 parameters.max_bandwidth_bps = max_bitrate; |
243 EXPECT_EQ(expected_result, channel_->SetSendParameters(parameters)); | 269 if (expected_result) { |
| 270 SetSendParameters(parameters); |
| 271 } else { |
| 272 EXPECT_FALSE(channel_->SetSendParameters(parameters)); |
| 273 } |
244 EXPECT_EQ(expected_bitrate, GetCodecBitrate(kSsrc1)); | 274 EXPECT_EQ(expected_bitrate, GetCodecBitrate(kSsrc1)); |
245 } | 275 } |
246 | 276 |
247 // Sets the per-stream maximum bitrate limit for the specified SSRC. | 277 // Sets the per-stream maximum bitrate limit for the specified SSRC. |
248 bool SetMaxBitrateForStream(int32_t ssrc, int bitrate) { | 278 bool SetMaxBitrateForStream(int32_t ssrc, int bitrate) { |
249 webrtc::RtpParameters parameters = channel_->GetRtpSendParameters(ssrc); | 279 webrtc::RtpParameters parameters = channel_->GetRtpSendParameters(ssrc); |
250 EXPECT_EQ(1UL, parameters.encodings.size()); | 280 EXPECT_EQ(1UL, parameters.encodings.size()); |
251 | 281 |
252 parameters.encodings[0].max_bitrate_bps = bitrate; | 282 parameters.encodings[0].max_bitrate_bps = bitrate; |
253 return channel_->SetRtpSendParameters(ssrc, parameters); | 283 return channel_->SetRtpSendParameters(ssrc, parameters); |
254 } | 284 } |
255 | 285 |
256 bool SetGlobalMaxBitrate(const cricket::AudioCodec& codec, int bitrate) { | 286 void SetGlobalMaxBitrate(const cricket::AudioCodec& codec, int bitrate) { |
257 cricket::AudioSendParameters send_parameters; | 287 cricket::AudioSendParameters send_parameters; |
258 send_parameters.codecs.push_back(codec); | 288 send_parameters.codecs.push_back(codec); |
259 send_parameters.max_bandwidth_bps = bitrate; | 289 send_parameters.max_bandwidth_bps = bitrate; |
260 return channel_->SetSendParameters(send_parameters); | 290 SetSendParameters(send_parameters); |
261 } | 291 } |
262 | 292 |
263 void CheckSendCodec(int32_t ssrc, | 293 void CheckSendCodec(int32_t ssrc, |
264 const char expected_name[], | 294 const char expected_name[], |
265 int expected_channels, | 295 int expected_channels, |
266 int expected_bitrate) { | 296 int expected_bitrate) { |
267 const auto& codec = GetSendStreamConfig(ssrc).send_codec_spec.codec_inst; | 297 const auto& codec = GetSendStreamConfig(ssrc).send_codec_spec.codec_inst; |
268 EXPECT_STREQ(expected_name, codec.plname); | 298 EXPECT_STREQ(expected_name, codec.plname); |
269 EXPECT_EQ(expected_channels, codec.channels); | 299 EXPECT_EQ(expected_channels, codec.channels); |
270 EXPECT_EQ(expected_bitrate, codec.rate); | 300 EXPECT_EQ(expected_bitrate, codec.rate); |
(...skipping 21 matching lines...) Expand all Loading... |
292 | 322 |
293 void SetAndExpectMaxBitrate(const cricket::AudioCodec& codec, | 323 void SetAndExpectMaxBitrate(const cricket::AudioCodec& codec, |
294 int global_max, | 324 int global_max, |
295 int stream_max, | 325 int stream_max, |
296 bool expected_result, | 326 bool expected_result, |
297 int expected_codec_bitrate) { | 327 int expected_codec_bitrate) { |
298 // Clear the bitrate limit from the previous test case. | 328 // Clear the bitrate limit from the previous test case. |
299 EXPECT_TRUE(SetMaxBitrateForStream(kSsrc1, -1)); | 329 EXPECT_TRUE(SetMaxBitrateForStream(kSsrc1, -1)); |
300 | 330 |
301 // Attempt to set the requested bitrate limits. | 331 // Attempt to set the requested bitrate limits. |
302 EXPECT_TRUE(SetGlobalMaxBitrate(codec, global_max)); | 332 SetGlobalMaxBitrate(codec, global_max); |
303 EXPECT_EQ(expected_result, SetMaxBitrateForStream(kSsrc1, stream_max)); | 333 EXPECT_EQ(expected_result, SetMaxBitrateForStream(kSsrc1, stream_max)); |
304 | 334 |
305 // Verify that reading back the parameters gives results | 335 // Verify that reading back the parameters gives results |
306 // consistent with the Set() result. | 336 // consistent with the Set() result. |
307 webrtc::RtpParameters resulting_parameters = | 337 webrtc::RtpParameters resulting_parameters = |
308 channel_->GetRtpSendParameters(kSsrc1); | 338 channel_->GetRtpSendParameters(kSsrc1); |
309 EXPECT_EQ(1UL, resulting_parameters.encodings.size()); | 339 EXPECT_EQ(1UL, resulting_parameters.encodings.size()); |
310 EXPECT_EQ(expected_result ? stream_max : -1, | 340 EXPECT_EQ(expected_result ? stream_max : -1, |
311 resulting_parameters.encodings[0].max_bitrate_bps); | 341 resulting_parameters.encodings[0].max_bitrate_bps); |
312 | 342 |
313 // Verify that the codec settings have the expected bitrate. | 343 // Verify that the codec settings have the expected bitrate. |
314 EXPECT_EQ(expected_codec_bitrate, GetCodecBitrate(kSsrc1)); | 344 EXPECT_EQ(expected_codec_bitrate, GetCodecBitrate(kSsrc1)); |
315 } | 345 } |
316 | 346 |
317 void TestSetSendRtpHeaderExtensions(const std::string& ext) { | 347 void TestSetSendRtpHeaderExtensions(const std::string& ext) { |
318 EXPECT_TRUE(SetupSendStream()); | 348 EXPECT_TRUE(SetupSendStream()); |
319 | 349 |
320 // Ensure extensions are off by default. | 350 // Ensure extensions are off by default. |
321 EXPECT_EQ(0u, GetSendStreamConfig(kSsrc1).rtp.extensions.size()); | 351 EXPECT_EQ(0u, GetSendStreamConfig(kSsrc1).rtp.extensions.size()); |
322 | 352 |
323 // Ensure unknown extensions won't cause an error. | 353 // Ensure unknown extensions won't cause an error. |
324 send_parameters_.extensions.push_back( | 354 send_parameters_.extensions.push_back( |
325 webrtc::RtpExtension("urn:ietf:params:unknownextention", 1)); | 355 webrtc::RtpExtension("urn:ietf:params:unknownextention", 1)); |
326 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); | 356 SetSendParameters(send_parameters_); |
327 EXPECT_EQ(0u, GetSendStreamConfig(kSsrc1).rtp.extensions.size()); | 357 EXPECT_EQ(0u, GetSendStreamConfig(kSsrc1).rtp.extensions.size()); |
328 | 358 |
329 // Ensure extensions stay off with an empty list of headers. | 359 // Ensure extensions stay off with an empty list of headers. |
330 send_parameters_.extensions.clear(); | 360 send_parameters_.extensions.clear(); |
331 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); | 361 SetSendParameters(send_parameters_); |
332 EXPECT_EQ(0u, GetSendStreamConfig(kSsrc1).rtp.extensions.size()); | 362 EXPECT_EQ(0u, GetSendStreamConfig(kSsrc1).rtp.extensions.size()); |
333 | 363 |
334 // Ensure extension is set properly. | 364 // Ensure extension is set properly. |
335 const int id = 1; | 365 const int id = 1; |
336 send_parameters_.extensions.push_back(webrtc::RtpExtension(ext, id)); | 366 send_parameters_.extensions.push_back(webrtc::RtpExtension(ext, id)); |
337 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); | 367 SetSendParameters(send_parameters_); |
338 EXPECT_EQ(1u, GetSendStreamConfig(kSsrc1).rtp.extensions.size()); | 368 EXPECT_EQ(1u, GetSendStreamConfig(kSsrc1).rtp.extensions.size()); |
339 EXPECT_EQ(ext, GetSendStreamConfig(kSsrc1).rtp.extensions[0].uri); | 369 EXPECT_EQ(ext, GetSendStreamConfig(kSsrc1).rtp.extensions[0].uri); |
340 EXPECT_EQ(id, GetSendStreamConfig(kSsrc1).rtp.extensions[0].id); | 370 EXPECT_EQ(id, GetSendStreamConfig(kSsrc1).rtp.extensions[0].id); |
341 | 371 |
342 // Ensure extension is set properly on new stream. | 372 // Ensure extension is set properly on new stream. |
343 EXPECT_TRUE(channel_->AddSendStream( | 373 EXPECT_TRUE(channel_->AddSendStream( |
344 cricket::StreamParams::CreateLegacy(kSsrc2))); | 374 cricket::StreamParams::CreateLegacy(kSsrc2))); |
345 EXPECT_NE(call_.GetAudioSendStream(kSsrc1), | 375 EXPECT_NE(call_.GetAudioSendStream(kSsrc1), |
346 call_.GetAudioSendStream(kSsrc2)); | 376 call_.GetAudioSendStream(kSsrc2)); |
347 EXPECT_EQ(1u, GetSendStreamConfig(kSsrc2).rtp.extensions.size()); | 377 EXPECT_EQ(1u, GetSendStreamConfig(kSsrc2).rtp.extensions.size()); |
348 EXPECT_EQ(ext, GetSendStreamConfig(kSsrc2).rtp.extensions[0].uri); | 378 EXPECT_EQ(ext, GetSendStreamConfig(kSsrc2).rtp.extensions[0].uri); |
349 EXPECT_EQ(id, GetSendStreamConfig(kSsrc2).rtp.extensions[0].id); | 379 EXPECT_EQ(id, GetSendStreamConfig(kSsrc2).rtp.extensions[0].id); |
350 | 380 |
351 // Ensure all extensions go back off with an empty list. | 381 // Ensure all extensions go back off with an empty list. |
352 send_parameters_.codecs.push_back(kPcmuCodec); | 382 send_parameters_.codecs.push_back(kPcmuCodec); |
353 send_parameters_.extensions.clear(); | 383 send_parameters_.extensions.clear(); |
354 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); | 384 SetSendParameters(send_parameters_); |
355 EXPECT_EQ(0u, GetSendStreamConfig(kSsrc1).rtp.extensions.size()); | 385 EXPECT_EQ(0u, GetSendStreamConfig(kSsrc1).rtp.extensions.size()); |
356 EXPECT_EQ(0u, GetSendStreamConfig(kSsrc2).rtp.extensions.size()); | 386 EXPECT_EQ(0u, GetSendStreamConfig(kSsrc2).rtp.extensions.size()); |
357 } | 387 } |
358 | 388 |
359 void TestSetRecvRtpHeaderExtensions(const std::string& ext) { | 389 void TestSetRecvRtpHeaderExtensions(const std::string& ext) { |
360 EXPECT_TRUE(SetupRecvStream()); | 390 EXPECT_TRUE(SetupRecvStream()); |
361 | 391 |
362 // Ensure extensions are off by default. | 392 // Ensure extensions are off by default. |
363 EXPECT_EQ(0u, GetRecvStreamConfig(kSsrc1).rtp.extensions.size()); | 393 EXPECT_EQ(0u, GetRecvStreamConfig(kSsrc1).rtp.extensions.size()); |
364 | 394 |
(...skipping 141 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
506 EXPECT_EQ(info.decoding_normal, stats.decoding_normal); | 536 EXPECT_EQ(info.decoding_normal, stats.decoding_normal); |
507 EXPECT_EQ(info.decoding_plc, stats.decoding_plc); | 537 EXPECT_EQ(info.decoding_plc, stats.decoding_plc); |
508 EXPECT_EQ(info.decoding_cng, stats.decoding_cng); | 538 EXPECT_EQ(info.decoding_cng, stats.decoding_cng); |
509 EXPECT_EQ(info.decoding_plc_cng, stats.decoding_plc_cng); | 539 EXPECT_EQ(info.decoding_plc_cng, stats.decoding_plc_cng); |
510 EXPECT_EQ(info.decoding_muted_output, stats.decoding_muted_output); | 540 EXPECT_EQ(info.decoding_muted_output, stats.decoding_muted_output); |
511 EXPECT_EQ(info.capture_start_ntp_time_ms, stats.capture_start_ntp_time_ms); | 541 EXPECT_EQ(info.capture_start_ntp_time_ms, stats.capture_start_ntp_time_ms); |
512 } | 542 } |
513 | 543 |
514 protected: | 544 protected: |
515 StrictMock<webrtc::test::MockAudioDeviceModule> adm_; | 545 StrictMock<webrtc::test::MockAudioDeviceModule> adm_; |
| 546 StrictMock<webrtc::test::MockAudioProcessing> apm_; |
516 webrtc::RtcEventLogNullImpl event_log_; | 547 webrtc::RtcEventLogNullImpl event_log_; |
517 cricket::FakeCall call_; | 548 cricket::FakeCall call_; |
518 cricket::FakeWebRtcVoiceEngine voe_; | 549 cricket::FakeWebRtcVoiceEngine voe_; |
519 std::unique_ptr<cricket::WebRtcVoiceEngine> engine_; | 550 std::unique_ptr<cricket::WebRtcVoiceEngine> engine_; |
520 cricket::VoiceMediaChannel* channel_ = nullptr; | 551 cricket::VoiceMediaChannel* channel_ = nullptr; |
521 cricket::AudioSendParameters send_parameters_; | 552 cricket::AudioSendParameters send_parameters_; |
522 cricket::AudioRecvParameters recv_parameters_; | 553 cricket::AudioRecvParameters recv_parameters_; |
523 FakeAudioSource fake_source_; | 554 FakeAudioSource fake_source_; |
524 private: | 555 private: |
525 webrtc::test::ScopedFieldTrials override_field_trials_; | 556 webrtc::test::ScopedFieldTrials override_field_trials_; |
(...skipping 330 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
856 TestMaxSendBandwidth(kPcmuCodec, 63999, false, 64000); | 887 TestMaxSendBandwidth(kPcmuCodec, 63999, false, 64000); |
857 TestMaxSendBandwidth(kPcmuCodec, 64001, true, 64000); | 888 TestMaxSendBandwidth(kPcmuCodec, 64001, true, 64000); |
858 } | 889 } |
859 | 890 |
860 TEST_F(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthMultiRateAsCallee) { | 891 TEST_F(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthMultiRateAsCallee) { |
861 EXPECT_TRUE(SetupChannel()); | 892 EXPECT_TRUE(SetupChannel()); |
862 const int kDesiredBitrate = 128000; | 893 const int kDesiredBitrate = 128000; |
863 cricket::AudioSendParameters parameters; | 894 cricket::AudioSendParameters parameters; |
864 parameters.codecs = engine_->send_codecs(); | 895 parameters.codecs = engine_->send_codecs(); |
865 parameters.max_bandwidth_bps = kDesiredBitrate; | 896 parameters.max_bandwidth_bps = kDesiredBitrate; |
866 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 897 SetSendParameters(parameters); |
867 | 898 |
868 EXPECT_TRUE(channel_->AddSendStream( | 899 EXPECT_TRUE(channel_->AddSendStream( |
869 cricket::StreamParams::CreateLegacy(kSsrc1))); | 900 cricket::StreamParams::CreateLegacy(kSsrc1))); |
870 | 901 |
871 EXPECT_EQ(kDesiredBitrate, GetCodecBitrate(kSsrc1)); | 902 EXPECT_EQ(kDesiredBitrate, GetCodecBitrate(kSsrc1)); |
872 } | 903 } |
873 | 904 |
874 // Test that bitrate cannot be set for CBR codecs. | 905 // Test that bitrate cannot be set for CBR codecs. |
875 // Bitrate is ignored if it is higher than the fixed bitrate. | 906 // Bitrate is ignored if it is higher than the fixed bitrate. |
876 // Bitrate less then the fixed bitrate is an error. | 907 // Bitrate less then the fixed bitrate is an error. |
877 TEST_F(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthCbr) { | 908 TEST_F(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthCbr) { |
878 EXPECT_TRUE(SetupSendStream()); | 909 EXPECT_TRUE(SetupSendStream()); |
879 | 910 |
880 // PCMU, default bitrate == 64000. | 911 // PCMU, default bitrate == 64000. |
881 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); | 912 SetSendParameters(send_parameters_); |
882 EXPECT_EQ(64000, GetCodecBitrate(kSsrc1)); | 913 EXPECT_EQ(64000, GetCodecBitrate(kSsrc1)); |
883 | 914 |
884 send_parameters_.max_bandwidth_bps = 128000; | 915 send_parameters_.max_bandwidth_bps = 128000; |
885 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); | 916 SetSendParameters(send_parameters_); |
886 EXPECT_EQ(64000, GetCodecBitrate(kSsrc1)); | 917 EXPECT_EQ(64000, GetCodecBitrate(kSsrc1)); |
887 | 918 |
888 send_parameters_.max_bandwidth_bps = 128; | 919 send_parameters_.max_bandwidth_bps = 128; |
889 EXPECT_FALSE(channel_->SetSendParameters(send_parameters_)); | 920 EXPECT_FALSE(channel_->SetSendParameters(send_parameters_)); |
890 EXPECT_EQ(64000, GetCodecBitrate(kSsrc1)); | 921 EXPECT_EQ(64000, GetCodecBitrate(kSsrc1)); |
891 } | 922 } |
892 | 923 |
893 // Test that the per-stream bitrate limit and the global | 924 // Test that the per-stream bitrate limit and the global |
894 // bitrate limit both apply. | 925 // bitrate limit both apply. |
895 TEST_F(WebRtcVoiceEngineTestFake, SetMaxBitratePerStream) { | 926 TEST_F(WebRtcVoiceEngineTestFake, SetMaxBitratePerStream) { |
(...skipping 44 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
940 EXPECT_TRUE(channel_->SetRtpSendParameters(kSsrc1, parameters)); | 971 EXPECT_TRUE(channel_->SetRtpSendParameters(kSsrc1, parameters)); |
941 // Two or more encodings should result in failure. | 972 // Two or more encodings should result in failure. |
942 parameters.encodings.push_back(webrtc::RtpEncodingParameters()); | 973 parameters.encodings.push_back(webrtc::RtpEncodingParameters()); |
943 EXPECT_FALSE(channel_->SetRtpSendParameters(kSsrc1, parameters)); | 974 EXPECT_FALSE(channel_->SetRtpSendParameters(kSsrc1, parameters)); |
944 } | 975 } |
945 | 976 |
946 // Test that a stream will not be sending if its encoding is made | 977 // Test that a stream will not be sending if its encoding is made |
947 // inactive through SetRtpSendParameters. | 978 // inactive through SetRtpSendParameters. |
948 TEST_F(WebRtcVoiceEngineTestFake, SetRtpParametersEncodingsActive) { | 979 TEST_F(WebRtcVoiceEngineTestFake, SetRtpParametersEncodingsActive) { |
949 EXPECT_TRUE(SetupSendStream()); | 980 EXPECT_TRUE(SetupSendStream()); |
950 SetSend(channel_, true); | 981 SetSend(true); |
951 EXPECT_TRUE(GetSendStream(kSsrc1).IsSending()); | 982 EXPECT_TRUE(GetSendStream(kSsrc1).IsSending()); |
952 // Get current parameters and change "active" to false. | 983 // Get current parameters and change "active" to false. |
953 webrtc::RtpParameters parameters = channel_->GetRtpSendParameters(kSsrc1); | 984 webrtc::RtpParameters parameters = channel_->GetRtpSendParameters(kSsrc1); |
954 ASSERT_EQ(1u, parameters.encodings.size()); | 985 ASSERT_EQ(1u, parameters.encodings.size()); |
955 ASSERT_TRUE(parameters.encodings[0].active); | 986 ASSERT_TRUE(parameters.encodings[0].active); |
956 parameters.encodings[0].active = false; | 987 parameters.encodings[0].active = false; |
957 EXPECT_TRUE(channel_->SetRtpSendParameters(kSsrc1, parameters)); | 988 EXPECT_TRUE(channel_->SetRtpSendParameters(kSsrc1, parameters)); |
958 EXPECT_FALSE(GetSendStream(kSsrc1).IsSending()); | 989 EXPECT_FALSE(GetSendStream(kSsrc1).IsSending()); |
959 | 990 |
960 // Now change it back to active and verify we resume sending. | 991 // Now change it back to active and verify we resume sending. |
961 parameters.encodings[0].active = true; | 992 parameters.encodings[0].active = true; |
962 EXPECT_TRUE(channel_->SetRtpSendParameters(kSsrc1, parameters)); | 993 EXPECT_TRUE(channel_->SetRtpSendParameters(kSsrc1, parameters)); |
963 EXPECT_TRUE(GetSendStream(kSsrc1).IsSending()); | 994 EXPECT_TRUE(GetSendStream(kSsrc1).IsSending()); |
964 } | 995 } |
965 | 996 |
966 // Test that SetRtpSendParameters configures the correct encoding channel for | 997 // Test that SetRtpSendParameters configures the correct encoding channel for |
967 // each SSRC. | 998 // each SSRC. |
968 TEST_F(WebRtcVoiceEngineTestFake, RtpParametersArePerStream) { | 999 TEST_F(WebRtcVoiceEngineTestFake, RtpParametersArePerStream) { |
969 SetupForMultiSendStream(); | 1000 SetupForMultiSendStream(); |
970 // Create send streams. | 1001 // Create send streams. |
971 for (uint32_t ssrc : kSsrcs4) { | 1002 for (uint32_t ssrc : kSsrcs4) { |
972 EXPECT_TRUE( | 1003 EXPECT_TRUE( |
973 channel_->AddSendStream(cricket::StreamParams::CreateLegacy(ssrc))); | 1004 channel_->AddSendStream(cricket::StreamParams::CreateLegacy(ssrc))); |
974 } | 1005 } |
975 // Configure one stream to be limited by the stream config, another to be | 1006 // Configure one stream to be limited by the stream config, another to be |
976 // limited by the global max, and the third one with no per-stream limit | 1007 // limited by the global max, and the third one with no per-stream limit |
977 // (still subject to the global limit). | 1008 // (still subject to the global limit). |
978 EXPECT_TRUE(SetGlobalMaxBitrate(kOpusCodec, 64000)); | 1009 SetGlobalMaxBitrate(kOpusCodec, 64000); |
979 EXPECT_TRUE(SetMaxBitrateForStream(kSsrcs4[0], 48000)); | 1010 EXPECT_TRUE(SetMaxBitrateForStream(kSsrcs4[0], 48000)); |
980 EXPECT_TRUE(SetMaxBitrateForStream(kSsrcs4[1], 96000)); | 1011 EXPECT_TRUE(SetMaxBitrateForStream(kSsrcs4[1], 96000)); |
981 EXPECT_TRUE(SetMaxBitrateForStream(kSsrcs4[2], -1)); | 1012 EXPECT_TRUE(SetMaxBitrateForStream(kSsrcs4[2], -1)); |
982 | 1013 |
983 EXPECT_EQ(48000, GetCodecBitrate(kSsrcs4[0])); | 1014 EXPECT_EQ(48000, GetCodecBitrate(kSsrcs4[0])); |
984 EXPECT_EQ(64000, GetCodecBitrate(kSsrcs4[1])); | 1015 EXPECT_EQ(64000, GetCodecBitrate(kSsrcs4[1])); |
985 EXPECT_EQ(64000, GetCodecBitrate(kSsrcs4[2])); | 1016 EXPECT_EQ(64000, GetCodecBitrate(kSsrcs4[2])); |
986 | 1017 |
987 // Remove the global cap; the streams should switch to their respective | 1018 // Remove the global cap; the streams should switch to their respective |
988 // maximums (or remain unchanged if there was no other limit on them.) | 1019 // maximums (or remain unchanged if there was no other limit on them.) |
989 EXPECT_TRUE(SetGlobalMaxBitrate(kOpusCodec, -1)); | 1020 SetGlobalMaxBitrate(kOpusCodec, -1); |
990 EXPECT_EQ(48000, GetCodecBitrate(kSsrcs4[0])); | 1021 EXPECT_EQ(48000, GetCodecBitrate(kSsrcs4[0])); |
991 EXPECT_EQ(96000, GetCodecBitrate(kSsrcs4[1])); | 1022 EXPECT_EQ(96000, GetCodecBitrate(kSsrcs4[1])); |
992 EXPECT_EQ(64000, GetCodecBitrate(kSsrcs4[2])); | 1023 EXPECT_EQ(64000, GetCodecBitrate(kSsrcs4[2])); |
993 } | 1024 } |
994 | 1025 |
995 // Test that GetRtpSendParameters returns the currently configured codecs. | 1026 // Test that GetRtpSendParameters returns the currently configured codecs. |
996 TEST_F(WebRtcVoiceEngineTestFake, GetRtpSendParametersCodecs) { | 1027 TEST_F(WebRtcVoiceEngineTestFake, GetRtpSendParametersCodecs) { |
997 EXPECT_TRUE(SetupSendStream()); | 1028 EXPECT_TRUE(SetupSendStream()); |
998 cricket::AudioSendParameters parameters; | 1029 cricket::AudioSendParameters parameters; |
999 parameters.codecs.push_back(kIsacCodec); | 1030 parameters.codecs.push_back(kIsacCodec); |
1000 parameters.codecs.push_back(kPcmuCodec); | 1031 parameters.codecs.push_back(kPcmuCodec); |
1001 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1032 SetSendParameters(parameters); |
1002 | 1033 |
1003 webrtc::RtpParameters rtp_parameters = channel_->GetRtpSendParameters(kSsrc1); | 1034 webrtc::RtpParameters rtp_parameters = channel_->GetRtpSendParameters(kSsrc1); |
1004 ASSERT_EQ(2u, rtp_parameters.codecs.size()); | 1035 ASSERT_EQ(2u, rtp_parameters.codecs.size()); |
1005 EXPECT_EQ(kIsacCodec.ToCodecParameters(), rtp_parameters.codecs[0]); | 1036 EXPECT_EQ(kIsacCodec.ToCodecParameters(), rtp_parameters.codecs[0]); |
1006 EXPECT_EQ(kPcmuCodec.ToCodecParameters(), rtp_parameters.codecs[1]); | 1037 EXPECT_EQ(kPcmuCodec.ToCodecParameters(), rtp_parameters.codecs[1]); |
1007 } | 1038 } |
1008 | 1039 |
1009 // Test that if we set/get parameters multiple times, we get the same results. | 1040 // Test that if we set/get parameters multiple times, we get the same results. |
1010 TEST_F(WebRtcVoiceEngineTestFake, SetAndGetRtpSendParameters) { | 1041 TEST_F(WebRtcVoiceEngineTestFake, SetAndGetRtpSendParameters) { |
1011 EXPECT_TRUE(SetupSendStream()); | 1042 EXPECT_TRUE(SetupSendStream()); |
1012 cricket::AudioSendParameters parameters; | 1043 cricket::AudioSendParameters parameters; |
1013 parameters.codecs.push_back(kIsacCodec); | 1044 parameters.codecs.push_back(kIsacCodec); |
1014 parameters.codecs.push_back(kPcmuCodec); | 1045 parameters.codecs.push_back(kPcmuCodec); |
1015 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1046 SetSendParameters(parameters); |
1016 | 1047 |
1017 webrtc::RtpParameters initial_params = channel_->GetRtpSendParameters(kSsrc1); | 1048 webrtc::RtpParameters initial_params = channel_->GetRtpSendParameters(kSsrc1); |
1018 | 1049 |
1019 // We should be able to set the params we just got. | 1050 // We should be able to set the params we just got. |
1020 EXPECT_TRUE(channel_->SetRtpSendParameters(kSsrc1, initial_params)); | 1051 EXPECT_TRUE(channel_->SetRtpSendParameters(kSsrc1, initial_params)); |
1021 | 1052 |
1022 // ... And this shouldn't change the params returned by GetRtpSendParameters. | 1053 // ... And this shouldn't change the params returned by GetRtpSendParameters. |
1023 webrtc::RtpParameters new_params = channel_->GetRtpSendParameters(kSsrc1); | 1054 webrtc::RtpParameters new_params = channel_->GetRtpSendParameters(kSsrc1); |
1024 EXPECT_EQ(initial_params, channel_->GetRtpSendParameters(kSsrc1)); | 1055 EXPECT_EQ(initial_params, channel_->GetRtpSendParameters(kSsrc1)); |
1025 } | 1056 } |
(...skipping 36 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1062 // Test that we apply codecs properly. | 1093 // Test that we apply codecs properly. |
1063 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecs) { | 1094 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecs) { |
1064 EXPECT_TRUE(SetupSendStream()); | 1095 EXPECT_TRUE(SetupSendStream()); |
1065 cricket::AudioSendParameters parameters; | 1096 cricket::AudioSendParameters parameters; |
1066 parameters.codecs.push_back(kIsacCodec); | 1097 parameters.codecs.push_back(kIsacCodec); |
1067 parameters.codecs.push_back(kPcmuCodec); | 1098 parameters.codecs.push_back(kPcmuCodec); |
1068 parameters.codecs.push_back(kCn8000Codec); | 1099 parameters.codecs.push_back(kCn8000Codec); |
1069 parameters.codecs[0].id = 96; | 1100 parameters.codecs[0].id = 96; |
1070 parameters.codecs[0].bitrate = 48000; | 1101 parameters.codecs[0].bitrate = 48000; |
1071 const int initial_num = call_.GetNumCreatedSendStreams(); | 1102 const int initial_num = call_.GetNumCreatedSendStreams(); |
1072 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1103 SetSendParameters(parameters); |
1073 EXPECT_EQ(initial_num + 1, call_.GetNumCreatedSendStreams()); | 1104 EXPECT_EQ(initial_num + 1, call_.GetNumCreatedSendStreams()); |
1074 const auto& send_codec_spec = GetSendStreamConfig(kSsrc1).send_codec_spec; | 1105 const auto& send_codec_spec = GetSendStreamConfig(kSsrc1).send_codec_spec; |
1075 EXPECT_EQ(96, send_codec_spec.codec_inst.pltype); | 1106 EXPECT_EQ(96, send_codec_spec.codec_inst.pltype); |
1076 EXPECT_EQ(48000, send_codec_spec.codec_inst.rate); | 1107 EXPECT_EQ(48000, send_codec_spec.codec_inst.rate); |
1077 EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname); | 1108 EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname); |
1078 EXPECT_NE(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq); | 1109 EXPECT_NE(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq); |
1079 EXPECT_EQ(13, send_codec_spec.cng_payload_type); | 1110 EXPECT_EQ(13, send_codec_spec.cng_payload_type); |
1080 EXPECT_EQ(webrtc::kFreq8000Hz, send_codec_spec.cng_plfreq); | 1111 EXPECT_EQ(webrtc::kFreq8000Hz, send_codec_spec.cng_plfreq); |
1081 EXPECT_FALSE(channel_->CanInsertDtmf()); | 1112 EXPECT_FALSE(channel_->CanInsertDtmf()); |
1082 } | 1113 } |
1083 | 1114 |
1084 // Test that VoE Channel doesn't call SetSendCodec again if same codec is tried | 1115 // Test that VoE Channel doesn't call SetSendCodec again if same codec is tried |
1085 // to apply. | 1116 // to apply. |
1086 TEST_F(WebRtcVoiceEngineTestFake, DontResetSetSendCodec) { | 1117 TEST_F(WebRtcVoiceEngineTestFake, DontResetSetSendCodec) { |
1087 EXPECT_TRUE(SetupSendStream()); | 1118 EXPECT_TRUE(SetupSendStream()); |
1088 cricket::AudioSendParameters parameters; | 1119 cricket::AudioSendParameters parameters; |
1089 parameters.codecs.push_back(kIsacCodec); | 1120 parameters.codecs.push_back(kIsacCodec); |
1090 parameters.codecs.push_back(kPcmuCodec); | 1121 parameters.codecs.push_back(kPcmuCodec); |
1091 parameters.codecs.push_back(kCn8000Codec); | 1122 parameters.codecs.push_back(kCn8000Codec); |
1092 parameters.codecs[0].id = 96; | 1123 parameters.codecs[0].id = 96; |
1093 parameters.codecs[0].bitrate = 48000; | 1124 parameters.codecs[0].bitrate = 48000; |
1094 const int initial_num = call_.GetNumCreatedSendStreams(); | 1125 const int initial_num = call_.GetNumCreatedSendStreams(); |
1095 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1126 SetSendParameters(parameters); |
1096 EXPECT_EQ(initial_num + 1, call_.GetNumCreatedSendStreams()); | 1127 EXPECT_EQ(initial_num + 1, call_.GetNumCreatedSendStreams()); |
1097 // Calling SetSendCodec again with same codec which is already set. | 1128 // Calling SetSendCodec again with same codec which is already set. |
1098 // In this case media channel shouldn't send codec to VoE. | 1129 // In this case media channel shouldn't send codec to VoE. |
1099 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1130 SetSendParameters(parameters); |
1100 EXPECT_EQ(initial_num + 1, call_.GetNumCreatedSendStreams()); | 1131 EXPECT_EQ(initial_num + 1, call_.GetNumCreatedSendStreams()); |
1101 } | 1132 } |
1102 | 1133 |
1103 // Verify that G722 is set with 16000 samples per second to WebRTC. | 1134 // Verify that G722 is set with 16000 samples per second to WebRTC. |
1104 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecG722) { | 1135 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecG722) { |
1105 EXPECT_TRUE(SetupSendStream()); | 1136 EXPECT_TRUE(SetupSendStream()); |
1106 cricket::AudioSendParameters parameters; | 1137 cricket::AudioSendParameters parameters; |
1107 parameters.codecs.push_back(kG722CodecSdp); | 1138 parameters.codecs.push_back(kG722CodecSdp); |
1108 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1139 SetSendParameters(parameters); |
1109 const auto& gcodec = GetSendStreamConfig(kSsrc1).send_codec_spec.codec_inst; | 1140 const auto& gcodec = GetSendStreamConfig(kSsrc1).send_codec_spec.codec_inst; |
1110 EXPECT_STREQ("G722", gcodec.plname); | 1141 EXPECT_STREQ("G722", gcodec.plname); |
1111 EXPECT_EQ(1, gcodec.channels); | 1142 EXPECT_EQ(1, gcodec.channels); |
1112 EXPECT_EQ(16000, gcodec.plfreq); | 1143 EXPECT_EQ(16000, gcodec.plfreq); |
1113 } | 1144 } |
1114 | 1145 |
1115 // Test that if clockrate is not 48000 for opus, we fail. | 1146 // Test that if clockrate is not 48000 for opus, we fail. |
1116 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusBadClockrate) { | 1147 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusBadClockrate) { |
1117 EXPECT_TRUE(SetupSendStream()); | 1148 EXPECT_TRUE(SetupSendStream()); |
1118 cricket::AudioSendParameters parameters; | 1149 cricket::AudioSendParameters parameters; |
(...skipping 56 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1175 EXPECT_FALSE(channel_->SetSendParameters(parameters)); | 1206 EXPECT_FALSE(channel_->SetSendParameters(parameters)); |
1176 } | 1207 } |
1177 | 1208 |
1178 // Test that with bitrate=0 and no stereo, | 1209 // Test that with bitrate=0 and no stereo, |
1179 // channels and bitrate are 1 and 32000. | 1210 // channels and bitrate are 1 and 32000. |
1180 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGood0BitrateNoStereo) { | 1211 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGood0BitrateNoStereo) { |
1181 EXPECT_TRUE(SetupSendStream()); | 1212 EXPECT_TRUE(SetupSendStream()); |
1182 cricket::AudioSendParameters parameters; | 1213 cricket::AudioSendParameters parameters; |
1183 parameters.codecs.push_back(kOpusCodec); | 1214 parameters.codecs.push_back(kOpusCodec); |
1184 parameters.codecs[0].bitrate = 0; | 1215 parameters.codecs[0].bitrate = 0; |
1185 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1216 SetSendParameters(parameters); |
1186 CheckSendCodec(kSsrc1, "opus", 1, 32000); | 1217 CheckSendCodec(kSsrc1, "opus", 1, 32000); |
1187 } | 1218 } |
1188 | 1219 |
1189 // Test that with bitrate=0 and stereo=0, | 1220 // Test that with bitrate=0 and stereo=0, |
1190 // channels and bitrate are 1 and 32000. | 1221 // channels and bitrate are 1 and 32000. |
1191 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGood0Bitrate0Stereo) { | 1222 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGood0Bitrate0Stereo) { |
1192 EXPECT_TRUE(SetupSendStream()); | 1223 EXPECT_TRUE(SetupSendStream()); |
1193 cricket::AudioSendParameters parameters; | 1224 cricket::AudioSendParameters parameters; |
1194 parameters.codecs.push_back(kOpusCodec); | 1225 parameters.codecs.push_back(kOpusCodec); |
1195 parameters.codecs[0].bitrate = 0; | 1226 parameters.codecs[0].bitrate = 0; |
1196 parameters.codecs[0].params["stereo"] = "0"; | 1227 parameters.codecs[0].params["stereo"] = "0"; |
1197 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1228 SetSendParameters(parameters); |
1198 CheckSendCodec(kSsrc1, "opus", 1, 32000); | 1229 CheckSendCodec(kSsrc1, "opus", 1, 32000); |
1199 } | 1230 } |
1200 | 1231 |
1201 // Test that with bitrate=invalid and stereo=0, | 1232 // Test that with bitrate=invalid and stereo=0, |
1202 // channels and bitrate are 1 and 32000. | 1233 // channels and bitrate are 1 and 32000. |
1203 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodXBitrate0Stereo) { | 1234 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodXBitrate0Stereo) { |
1204 EXPECT_TRUE(SetupSendStream()); | 1235 EXPECT_TRUE(SetupSendStream()); |
1205 cricket::AudioSendParameters parameters; | 1236 cricket::AudioSendParameters parameters; |
1206 parameters.codecs.push_back(kOpusCodec); | 1237 parameters.codecs.push_back(kOpusCodec); |
1207 parameters.codecs[0].params["stereo"] = "0"; | 1238 parameters.codecs[0].params["stereo"] = "0"; |
1208 // bitrate that's out of the range between 6000 and 510000 will be clamped. | 1239 // bitrate that's out of the range between 6000 and 510000 will be clamped. |
1209 parameters.codecs[0].bitrate = 5999; | 1240 parameters.codecs[0].bitrate = 5999; |
1210 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1241 SetSendParameters(parameters); |
1211 CheckSendCodec(kSsrc1, "opus", 1, 6000); | 1242 CheckSendCodec(kSsrc1, "opus", 1, 6000); |
1212 | 1243 |
1213 parameters.codecs[0].bitrate = 510001; | 1244 parameters.codecs[0].bitrate = 510001; |
1214 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1245 SetSendParameters(parameters); |
1215 CheckSendCodec(kSsrc1, "opus", 1, 510000); | 1246 CheckSendCodec(kSsrc1, "opus", 1, 510000); |
1216 } | 1247 } |
1217 | 1248 |
1218 // Test that with bitrate=0 and stereo=1, | 1249 // Test that with bitrate=0 and stereo=1, |
1219 // channels and bitrate are 2 and 64000. | 1250 // channels and bitrate are 2 and 64000. |
1220 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGood0Bitrate1Stereo) { | 1251 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGood0Bitrate1Stereo) { |
1221 EXPECT_TRUE(SetupSendStream()); | 1252 EXPECT_TRUE(SetupSendStream()); |
1222 cricket::AudioSendParameters parameters; | 1253 cricket::AudioSendParameters parameters; |
1223 parameters.codecs.push_back(kOpusCodec); | 1254 parameters.codecs.push_back(kOpusCodec); |
1224 parameters.codecs[0].bitrate = 0; | 1255 parameters.codecs[0].bitrate = 0; |
1225 parameters.codecs[0].params["stereo"] = "1"; | 1256 parameters.codecs[0].params["stereo"] = "1"; |
1226 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1257 SetSendParameters(parameters); |
1227 CheckSendCodec(kSsrc1, "opus", 2, 64000); | 1258 CheckSendCodec(kSsrc1, "opus", 2, 64000); |
1228 } | 1259 } |
1229 | 1260 |
1230 // Test that with bitrate=invalid and stereo=1, | 1261 // Test that with bitrate=invalid and stereo=1, |
1231 // channels and bitrate are 2 and 64000. | 1262 // channels and bitrate are 2 and 64000. |
1232 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodXBitrate1Stereo) { | 1263 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodXBitrate1Stereo) { |
1233 EXPECT_TRUE(SetupSendStream()); | 1264 EXPECT_TRUE(SetupSendStream()); |
1234 cricket::AudioSendParameters parameters; | 1265 cricket::AudioSendParameters parameters; |
1235 parameters.codecs.push_back(kOpusCodec); | 1266 parameters.codecs.push_back(kOpusCodec); |
1236 parameters.codecs[0].params["stereo"] = "1"; | 1267 parameters.codecs[0].params["stereo"] = "1"; |
1237 // bitrate that's out of the range between 6000 and 510000 will be clamped. | 1268 // bitrate that's out of the range between 6000 and 510000 will be clamped. |
1238 parameters.codecs[0].bitrate = 5999; | 1269 parameters.codecs[0].bitrate = 5999; |
1239 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1270 SetSendParameters(parameters); |
1240 CheckSendCodec(kSsrc1, "opus", 2, 6000); | 1271 CheckSendCodec(kSsrc1, "opus", 2, 6000); |
1241 | 1272 |
1242 parameters.codecs[0].bitrate = 510001; | 1273 parameters.codecs[0].bitrate = 510001; |
1243 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1274 SetSendParameters(parameters); |
1244 CheckSendCodec(kSsrc1, "opus", 2, 510000); | 1275 CheckSendCodec(kSsrc1, "opus", 2, 510000); |
1245 } | 1276 } |
1246 | 1277 |
1247 // Test that with bitrate=N and stereo unset, | 1278 // Test that with bitrate=N and stereo unset, |
1248 // channels and bitrate are 1 and N. | 1279 // channels and bitrate are 1 and N. |
1249 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrateNoStereo) { | 1280 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrateNoStereo) { |
1250 EXPECT_TRUE(SetupSendStream()); | 1281 EXPECT_TRUE(SetupSendStream()); |
1251 cricket::AudioSendParameters parameters; | 1282 cricket::AudioSendParameters parameters; |
1252 parameters.codecs.push_back(kOpusCodec); | 1283 parameters.codecs.push_back(kOpusCodec); |
1253 parameters.codecs[0].bitrate = 96000; | 1284 parameters.codecs[0].bitrate = 96000; |
1254 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1285 SetSendParameters(parameters); |
1255 const auto& gcodec = GetSendStreamConfig(kSsrc1).send_codec_spec.codec_inst; | 1286 const auto& gcodec = GetSendStreamConfig(kSsrc1).send_codec_spec.codec_inst; |
1256 EXPECT_EQ(111, gcodec.pltype); | 1287 EXPECT_EQ(111, gcodec.pltype); |
1257 EXPECT_EQ(96000, gcodec.rate); | 1288 EXPECT_EQ(96000, gcodec.rate); |
1258 EXPECT_STREQ("opus", gcodec.plname); | 1289 EXPECT_STREQ("opus", gcodec.plname); |
1259 EXPECT_EQ(1, gcodec.channels); | 1290 EXPECT_EQ(1, gcodec.channels); |
1260 EXPECT_EQ(48000, gcodec.plfreq); | 1291 EXPECT_EQ(48000, gcodec.plfreq); |
1261 } | 1292 } |
1262 | 1293 |
1263 // Test that with bitrate=N and stereo=0, | 1294 // Test that with bitrate=N and stereo=0, |
1264 // channels and bitrate are 1 and N. | 1295 // channels and bitrate are 1 and N. |
1265 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrate0Stereo) { | 1296 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrate0Stereo) { |
1266 EXPECT_TRUE(SetupSendStream()); | 1297 EXPECT_TRUE(SetupSendStream()); |
1267 cricket::AudioSendParameters parameters; | 1298 cricket::AudioSendParameters parameters; |
1268 parameters.codecs.push_back(kOpusCodec); | 1299 parameters.codecs.push_back(kOpusCodec); |
1269 parameters.codecs[0].bitrate = 30000; | 1300 parameters.codecs[0].bitrate = 30000; |
1270 parameters.codecs[0].params["stereo"] = "0"; | 1301 parameters.codecs[0].params["stereo"] = "0"; |
1271 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1302 SetSendParameters(parameters); |
1272 CheckSendCodec(kSsrc1, "opus", 1, 30000); | 1303 CheckSendCodec(kSsrc1, "opus", 1, 30000); |
1273 } | 1304 } |
1274 | 1305 |
1275 // Test that with bitrate=N and without any parameters, | 1306 // Test that with bitrate=N and without any parameters, |
1276 // channels and bitrate are 1 and N. | 1307 // channels and bitrate are 1 and N. |
1277 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrateNoParameters) { | 1308 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrateNoParameters) { |
1278 EXPECT_TRUE(SetupSendStream()); | 1309 EXPECT_TRUE(SetupSendStream()); |
1279 cricket::AudioSendParameters parameters; | 1310 cricket::AudioSendParameters parameters; |
1280 parameters.codecs.push_back(kOpusCodec); | 1311 parameters.codecs.push_back(kOpusCodec); |
1281 parameters.codecs[0].bitrate = 30000; | 1312 parameters.codecs[0].bitrate = 30000; |
1282 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1313 SetSendParameters(parameters); |
1283 CheckSendCodec(kSsrc1, "opus", 1, 30000); | 1314 CheckSendCodec(kSsrc1, "opus", 1, 30000); |
1284 } | 1315 } |
1285 | 1316 |
1286 // Test that with bitrate=N and stereo=1, | 1317 // Test that with bitrate=N and stereo=1, |
1287 // channels and bitrate are 2 and N. | 1318 // channels and bitrate are 2 and N. |
1288 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrate1Stereo) { | 1319 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrate1Stereo) { |
1289 EXPECT_TRUE(SetupSendStream()); | 1320 EXPECT_TRUE(SetupSendStream()); |
1290 cricket::AudioSendParameters parameters; | 1321 cricket::AudioSendParameters parameters; |
1291 parameters.codecs.push_back(kOpusCodec); | 1322 parameters.codecs.push_back(kOpusCodec); |
1292 parameters.codecs[0].bitrate = 30000; | 1323 parameters.codecs[0].bitrate = 30000; |
1293 parameters.codecs[0].params["stereo"] = "1"; | 1324 parameters.codecs[0].params["stereo"] = "1"; |
1294 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1325 SetSendParameters(parameters); |
1295 CheckSendCodec(kSsrc1, "opus", 2, 30000); | 1326 CheckSendCodec(kSsrc1, "opus", 2, 30000); |
1296 } | 1327 } |
1297 | 1328 |
1298 // Test that bitrate will be overridden by the "maxaveragebitrate" parameter. | 1329 // Test that bitrate will be overridden by the "maxaveragebitrate" parameter. |
1299 // Also test that the "maxaveragebitrate" can't be set to values outside the | 1330 // Also test that the "maxaveragebitrate" can't be set to values outside the |
1300 // range of 6000 and 510000 | 1331 // range of 6000 and 510000 |
1301 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusMaxAverageBitrate) { | 1332 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusMaxAverageBitrate) { |
1302 EXPECT_TRUE(SetupSendStream()); | 1333 EXPECT_TRUE(SetupSendStream()); |
1303 cricket::AudioSendParameters parameters; | 1334 cricket::AudioSendParameters parameters; |
1304 parameters.codecs.push_back(kOpusCodec); | 1335 parameters.codecs.push_back(kOpusCodec); |
1305 parameters.codecs[0].bitrate = 30000; | 1336 parameters.codecs[0].bitrate = 30000; |
1306 // Ignore if less than 6000. | 1337 // Ignore if less than 6000. |
1307 parameters.codecs[0].params["maxaveragebitrate"] = "5999"; | 1338 parameters.codecs[0].params["maxaveragebitrate"] = "5999"; |
1308 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1339 SetSendParameters(parameters); |
1309 EXPECT_EQ(6000, GetCodecBitrate(kSsrc1)); | 1340 EXPECT_EQ(6000, GetCodecBitrate(kSsrc1)); |
1310 | 1341 |
1311 // Ignore if larger than 510000. | 1342 // Ignore if larger than 510000. |
1312 parameters.codecs[0].params["maxaveragebitrate"] = "510001"; | 1343 parameters.codecs[0].params["maxaveragebitrate"] = "510001"; |
1313 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1344 SetSendParameters(parameters); |
1314 EXPECT_EQ(510000, GetCodecBitrate(kSsrc1)); | 1345 EXPECT_EQ(510000, GetCodecBitrate(kSsrc1)); |
1315 | 1346 |
1316 parameters.codecs[0].params["maxaveragebitrate"] = "200000"; | 1347 parameters.codecs[0].params["maxaveragebitrate"] = "200000"; |
1317 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1348 SetSendParameters(parameters); |
1318 EXPECT_EQ(200000, GetCodecBitrate(kSsrc1)); | 1349 EXPECT_EQ(200000, GetCodecBitrate(kSsrc1)); |
1319 } | 1350 } |
1320 | 1351 |
1321 // Test that we can enable NACK with opus as caller. | 1352 // Test that we can enable NACK with opus as caller. |
1322 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecEnableNackAsCaller) { | 1353 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecEnableNackAsCaller) { |
1323 EXPECT_TRUE(SetupSendStream()); | 1354 EXPECT_TRUE(SetupSendStream()); |
1324 cricket::AudioSendParameters parameters; | 1355 cricket::AudioSendParameters parameters; |
1325 parameters.codecs.push_back(kOpusCodec); | 1356 parameters.codecs.push_back(kOpusCodec); |
1326 parameters.codecs[0].AddFeedbackParam( | 1357 parameters.codecs[0].AddFeedbackParam( |
1327 cricket::FeedbackParam(cricket::kRtcpFbParamNack, | 1358 cricket::FeedbackParam(cricket::kRtcpFbParamNack, |
1328 cricket::kParamValueEmpty)); | 1359 cricket::kParamValueEmpty)); |
1329 EXPECT_EQ(0, GetSendStreamConfig(kSsrc1).rtp.nack.rtp_history_ms); | 1360 EXPECT_EQ(0, GetSendStreamConfig(kSsrc1).rtp.nack.rtp_history_ms); |
1330 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1361 SetSendParameters(parameters); |
1331 EXPECT_EQ(kRtpHistoryMs, GetSendStreamConfig(kSsrc1).rtp.nack.rtp_history_ms); | 1362 EXPECT_EQ(kRtpHistoryMs, GetSendStreamConfig(kSsrc1).rtp.nack.rtp_history_ms); |
1332 } | 1363 } |
1333 | 1364 |
1334 // Test that we can enable NACK with opus as callee. | 1365 // Test that we can enable NACK with opus as callee. |
1335 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecEnableNackAsCallee) { | 1366 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecEnableNackAsCallee) { |
1336 EXPECT_TRUE(SetupRecvStream()); | 1367 EXPECT_TRUE(SetupRecvStream()); |
1337 cricket::AudioSendParameters parameters; | 1368 cricket::AudioSendParameters parameters; |
1338 parameters.codecs.push_back(kOpusCodec); | 1369 parameters.codecs.push_back(kOpusCodec); |
1339 parameters.codecs[0].AddFeedbackParam( | 1370 parameters.codecs[0].AddFeedbackParam( |
1340 cricket::FeedbackParam(cricket::kRtcpFbParamNack, | 1371 cricket::FeedbackParam(cricket::kRtcpFbParamNack, |
1341 cricket::kParamValueEmpty)); | 1372 cricket::kParamValueEmpty)); |
1342 EXPECT_EQ(0, GetRecvStreamConfig(kSsrc1).rtp.nack.rtp_history_ms); | 1373 EXPECT_EQ(0, GetRecvStreamConfig(kSsrc1).rtp.nack.rtp_history_ms); |
1343 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1374 SetSendParameters(parameters); |
1344 // NACK should be enabled even with no send stream. | 1375 // NACK should be enabled even with no send stream. |
1345 EXPECT_EQ(kRtpHistoryMs, GetRecvStreamConfig(kSsrc1).rtp.nack.rtp_history_ms); | 1376 EXPECT_EQ(kRtpHistoryMs, GetRecvStreamConfig(kSsrc1).rtp.nack.rtp_history_ms); |
1346 | 1377 |
1347 EXPECT_TRUE(channel_->AddSendStream( | 1378 EXPECT_TRUE(channel_->AddSendStream( |
1348 cricket::StreamParams::CreateLegacy(kSsrc1))); | 1379 cricket::StreamParams::CreateLegacy(kSsrc1))); |
1349 EXPECT_EQ(kRtpHistoryMs, GetSendStreamConfig(kSsrc1).rtp.nack.rtp_history_ms); | 1380 EXPECT_EQ(kRtpHistoryMs, GetSendStreamConfig(kSsrc1).rtp.nack.rtp_history_ms); |
1350 } | 1381 } |
1351 | 1382 |
1352 // Test that we can enable NACK on receive streams. | 1383 // Test that we can enable NACK on receive streams. |
1353 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecEnableNackRecvStreams) { | 1384 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecEnableNackRecvStreams) { |
1354 EXPECT_TRUE(SetupSendStream()); | 1385 EXPECT_TRUE(SetupSendStream()); |
1355 EXPECT_TRUE(AddRecvStream(kSsrc2)); | 1386 EXPECT_TRUE(AddRecvStream(kSsrc2)); |
1356 cricket::AudioSendParameters parameters; | 1387 cricket::AudioSendParameters parameters; |
1357 parameters.codecs.push_back(kOpusCodec); | 1388 parameters.codecs.push_back(kOpusCodec); |
1358 parameters.codecs[0].AddFeedbackParam( | 1389 parameters.codecs[0].AddFeedbackParam( |
1359 cricket::FeedbackParam(cricket::kRtcpFbParamNack, | 1390 cricket::FeedbackParam(cricket::kRtcpFbParamNack, |
1360 cricket::kParamValueEmpty)); | 1391 cricket::kParamValueEmpty)); |
1361 EXPECT_EQ(0, GetSendStreamConfig(kSsrc1).rtp.nack.rtp_history_ms); | 1392 EXPECT_EQ(0, GetSendStreamConfig(kSsrc1).rtp.nack.rtp_history_ms); |
1362 EXPECT_EQ(0, GetRecvStreamConfig(kSsrc2).rtp.nack.rtp_history_ms); | 1393 EXPECT_EQ(0, GetRecvStreamConfig(kSsrc2).rtp.nack.rtp_history_ms); |
1363 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1394 SetSendParameters(parameters); |
1364 EXPECT_EQ(kRtpHistoryMs, GetSendStreamConfig(kSsrc1).rtp.nack.rtp_history_ms); | 1395 EXPECT_EQ(kRtpHistoryMs, GetSendStreamConfig(kSsrc1).rtp.nack.rtp_history_ms); |
1365 EXPECT_EQ(kRtpHistoryMs, GetRecvStreamConfig(kSsrc2).rtp.nack.rtp_history_ms); | 1396 EXPECT_EQ(kRtpHistoryMs, GetRecvStreamConfig(kSsrc2).rtp.nack.rtp_history_ms); |
1366 } | 1397 } |
1367 | 1398 |
1368 // Test that we can disable NACK. | 1399 // Test that we can disable NACK. |
1369 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecDisableNack) { | 1400 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecDisableNack) { |
1370 EXPECT_TRUE(SetupSendStream()); | 1401 EXPECT_TRUE(SetupSendStream()); |
1371 cricket::AudioSendParameters parameters; | 1402 cricket::AudioSendParameters parameters; |
1372 parameters.codecs.push_back(kOpusCodec); | 1403 parameters.codecs.push_back(kOpusCodec); |
1373 parameters.codecs[0].AddFeedbackParam( | 1404 parameters.codecs[0].AddFeedbackParam( |
1374 cricket::FeedbackParam(cricket::kRtcpFbParamNack, | 1405 cricket::FeedbackParam(cricket::kRtcpFbParamNack, |
1375 cricket::kParamValueEmpty)); | 1406 cricket::kParamValueEmpty)); |
1376 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1407 SetSendParameters(parameters); |
1377 EXPECT_EQ(kRtpHistoryMs, GetSendStreamConfig(kSsrc1).rtp.nack.rtp_history_ms); | 1408 EXPECT_EQ(kRtpHistoryMs, GetSendStreamConfig(kSsrc1).rtp.nack.rtp_history_ms); |
1378 | 1409 |
1379 parameters.codecs.clear(); | 1410 parameters.codecs.clear(); |
1380 parameters.codecs.push_back(kOpusCodec); | 1411 parameters.codecs.push_back(kOpusCodec); |
1381 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1412 SetSendParameters(parameters); |
1382 EXPECT_EQ(0, GetSendStreamConfig(kSsrc1).rtp.nack.rtp_history_ms); | 1413 EXPECT_EQ(0, GetSendStreamConfig(kSsrc1).rtp.nack.rtp_history_ms); |
1383 } | 1414 } |
1384 | 1415 |
1385 // Test that we can disable NACK on receive streams. | 1416 // Test that we can disable NACK on receive streams. |
1386 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecDisableNackRecvStreams) { | 1417 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecDisableNackRecvStreams) { |
1387 EXPECT_TRUE(SetupSendStream()); | 1418 EXPECT_TRUE(SetupSendStream()); |
1388 EXPECT_TRUE(AddRecvStream(kSsrc2)); | 1419 EXPECT_TRUE(AddRecvStream(kSsrc2)); |
1389 cricket::AudioSendParameters parameters; | 1420 cricket::AudioSendParameters parameters; |
1390 parameters.codecs.push_back(kOpusCodec); | 1421 parameters.codecs.push_back(kOpusCodec); |
1391 parameters.codecs[0].AddFeedbackParam( | 1422 parameters.codecs[0].AddFeedbackParam( |
1392 cricket::FeedbackParam(cricket::kRtcpFbParamNack, | 1423 cricket::FeedbackParam(cricket::kRtcpFbParamNack, |
1393 cricket::kParamValueEmpty)); | 1424 cricket::kParamValueEmpty)); |
1394 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1425 SetSendParameters(parameters); |
1395 EXPECT_EQ(kRtpHistoryMs, GetSendStreamConfig(kSsrc1).rtp.nack.rtp_history_ms); | 1426 EXPECT_EQ(kRtpHistoryMs, GetSendStreamConfig(kSsrc1).rtp.nack.rtp_history_ms); |
1396 EXPECT_EQ(kRtpHistoryMs, GetRecvStreamConfig(kSsrc2).rtp.nack.rtp_history_ms); | 1427 EXPECT_EQ(kRtpHistoryMs, GetRecvStreamConfig(kSsrc2).rtp.nack.rtp_history_ms); |
1397 | 1428 |
1398 parameters.codecs.clear(); | 1429 parameters.codecs.clear(); |
1399 parameters.codecs.push_back(kOpusCodec); | 1430 parameters.codecs.push_back(kOpusCodec); |
1400 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1431 SetSendParameters(parameters); |
1401 EXPECT_EQ(0, GetSendStreamConfig(kSsrc1).rtp.nack.rtp_history_ms); | 1432 EXPECT_EQ(0, GetSendStreamConfig(kSsrc1).rtp.nack.rtp_history_ms); |
1402 EXPECT_EQ(0, GetRecvStreamConfig(kSsrc2).rtp.nack.rtp_history_ms); | 1433 EXPECT_EQ(0, GetRecvStreamConfig(kSsrc2).rtp.nack.rtp_history_ms); |
1403 } | 1434 } |
1404 | 1435 |
1405 // Test that NACK is enabled on a new receive stream. | 1436 // Test that NACK is enabled on a new receive stream. |
1406 TEST_F(WebRtcVoiceEngineTestFake, AddRecvStreamEnableNack) { | 1437 TEST_F(WebRtcVoiceEngineTestFake, AddRecvStreamEnableNack) { |
1407 EXPECT_TRUE(SetupSendStream()); | 1438 EXPECT_TRUE(SetupSendStream()); |
1408 cricket::AudioSendParameters parameters; | 1439 cricket::AudioSendParameters parameters; |
1409 parameters.codecs.push_back(kIsacCodec); | 1440 parameters.codecs.push_back(kIsacCodec); |
1410 parameters.codecs.push_back(kCn16000Codec); | 1441 parameters.codecs.push_back(kCn16000Codec); |
1411 parameters.codecs[0].AddFeedbackParam( | 1442 parameters.codecs[0].AddFeedbackParam( |
1412 cricket::FeedbackParam(cricket::kRtcpFbParamNack, | 1443 cricket::FeedbackParam(cricket::kRtcpFbParamNack, |
1413 cricket::kParamValueEmpty)); | 1444 cricket::kParamValueEmpty)); |
1414 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1445 SetSendParameters(parameters); |
1415 EXPECT_EQ(kRtpHistoryMs, GetSendStreamConfig(kSsrc1).rtp.nack.rtp_history_ms); | 1446 EXPECT_EQ(kRtpHistoryMs, GetSendStreamConfig(kSsrc1).rtp.nack.rtp_history_ms); |
1416 | 1447 |
1417 EXPECT_TRUE(AddRecvStream(kSsrc2)); | 1448 EXPECT_TRUE(AddRecvStream(kSsrc2)); |
1418 EXPECT_EQ(kRtpHistoryMs, GetRecvStreamConfig(kSsrc2).rtp.nack.rtp_history_ms); | 1449 EXPECT_EQ(kRtpHistoryMs, GetRecvStreamConfig(kSsrc2).rtp.nack.rtp_history_ms); |
1419 EXPECT_TRUE(AddRecvStream(kSsrc3)); | 1450 EXPECT_TRUE(AddRecvStream(kSsrc3)); |
1420 EXPECT_EQ(kRtpHistoryMs, GetRecvStreamConfig(kSsrc3).rtp.nack.rtp_history_ms); | 1451 EXPECT_EQ(kRtpHistoryMs, GetRecvStreamConfig(kSsrc3).rtp.nack.rtp_history_ms); |
1421 } | 1452 } |
1422 | 1453 |
1423 // Test that without useinbandfec, Opus FEC is off. | 1454 // Test that without useinbandfec, Opus FEC is off. |
1424 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecNoOpusFec) { | 1455 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecNoOpusFec) { |
1425 EXPECT_TRUE(SetupSendStream()); | 1456 EXPECT_TRUE(SetupSendStream()); |
1426 cricket::AudioSendParameters parameters; | 1457 cricket::AudioSendParameters parameters; |
1427 parameters.codecs.push_back(kOpusCodec); | 1458 parameters.codecs.push_back(kOpusCodec); |
1428 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1459 SetSendParameters(parameters); |
1429 EXPECT_FALSE(GetCodecFec(kSsrc1)); | 1460 EXPECT_FALSE(GetCodecFec(kSsrc1)); |
1430 } | 1461 } |
1431 | 1462 |
1432 // Test that with useinbandfec=0, Opus FEC is off. | 1463 // Test that with useinbandfec=0, Opus FEC is off. |
1433 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusDisableFec) { | 1464 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusDisableFec) { |
1434 EXPECT_TRUE(SetupSendStream()); | 1465 EXPECT_TRUE(SetupSendStream()); |
1435 cricket::AudioSendParameters parameters; | 1466 cricket::AudioSendParameters parameters; |
1436 parameters.codecs.push_back(kOpusCodec); | 1467 parameters.codecs.push_back(kOpusCodec); |
1437 parameters.codecs[0].bitrate = 0; | 1468 parameters.codecs[0].bitrate = 0; |
1438 parameters.codecs[0].params["useinbandfec"] = "0"; | 1469 parameters.codecs[0].params["useinbandfec"] = "0"; |
1439 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1470 SetSendParameters(parameters); |
1440 CheckSendCodec(kSsrc1, "opus", 1, 32000); | 1471 CheckSendCodec(kSsrc1, "opus", 1, 32000); |
1441 } | 1472 } |
1442 | 1473 |
1443 // Test that with useinbandfec=1, Opus FEC is on. | 1474 // Test that with useinbandfec=1, Opus FEC is on. |
1444 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusEnableFec) { | 1475 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusEnableFec) { |
1445 EXPECT_TRUE(SetupSendStream()); | 1476 EXPECT_TRUE(SetupSendStream()); |
1446 cricket::AudioSendParameters parameters; | 1477 cricket::AudioSendParameters parameters; |
1447 parameters.codecs.push_back(kOpusCodec); | 1478 parameters.codecs.push_back(kOpusCodec); |
1448 parameters.codecs[0].bitrate = 0; | 1479 parameters.codecs[0].bitrate = 0; |
1449 parameters.codecs[0].params["useinbandfec"] = "1"; | 1480 parameters.codecs[0].params["useinbandfec"] = "1"; |
1450 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1481 SetSendParameters(parameters); |
1451 EXPECT_TRUE(GetCodecFec(kSsrc1)); | 1482 EXPECT_TRUE(GetCodecFec(kSsrc1)); |
1452 CheckSendCodec(kSsrc1, "opus", 1, 32000); | 1483 CheckSendCodec(kSsrc1, "opus", 1, 32000); |
1453 } | 1484 } |
1454 | 1485 |
1455 // Test that with useinbandfec=1, stereo=1, Opus FEC is on. | 1486 // Test that with useinbandfec=1, stereo=1, Opus FEC is on. |
1456 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusEnableFecStereo) { | 1487 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusEnableFecStereo) { |
1457 EXPECT_TRUE(SetupSendStream()); | 1488 EXPECT_TRUE(SetupSendStream()); |
1458 cricket::AudioSendParameters parameters; | 1489 cricket::AudioSendParameters parameters; |
1459 parameters.codecs.push_back(kOpusCodec); | 1490 parameters.codecs.push_back(kOpusCodec); |
1460 parameters.codecs[0].bitrate = 0; | 1491 parameters.codecs[0].bitrate = 0; |
1461 parameters.codecs[0].params["stereo"] = "1"; | 1492 parameters.codecs[0].params["stereo"] = "1"; |
1462 parameters.codecs[0].params["useinbandfec"] = "1"; | 1493 parameters.codecs[0].params["useinbandfec"] = "1"; |
1463 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1494 SetSendParameters(parameters); |
1464 EXPECT_TRUE(GetCodecFec(kSsrc1)); | 1495 EXPECT_TRUE(GetCodecFec(kSsrc1)); |
1465 CheckSendCodec(kSsrc1, "opus", 2, 64000); | 1496 CheckSendCodec(kSsrc1, "opus", 2, 64000); |
1466 } | 1497 } |
1467 | 1498 |
1468 // Test that with non-Opus, codec FEC is off. | 1499 // Test that with non-Opus, codec FEC is off. |
1469 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecIsacNoFec) { | 1500 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecIsacNoFec) { |
1470 EXPECT_TRUE(SetupSendStream()); | 1501 EXPECT_TRUE(SetupSendStream()); |
1471 cricket::AudioSendParameters parameters; | 1502 cricket::AudioSendParameters parameters; |
1472 parameters.codecs.push_back(kIsacCodec); | 1503 parameters.codecs.push_back(kIsacCodec); |
1473 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1504 SetSendParameters(parameters); |
1474 EXPECT_FALSE(GetCodecFec(kSsrc1)); | 1505 EXPECT_FALSE(GetCodecFec(kSsrc1)); |
1475 } | 1506 } |
1476 | 1507 |
1477 // Test the with non-Opus, even if useinbandfec=1, FEC is off. | 1508 // Test the with non-Opus, even if useinbandfec=1, FEC is off. |
1478 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecIsacWithParamNoFec) { | 1509 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecIsacWithParamNoFec) { |
1479 EXPECT_TRUE(SetupSendStream()); | 1510 EXPECT_TRUE(SetupSendStream()); |
1480 cricket::AudioSendParameters parameters; | 1511 cricket::AudioSendParameters parameters; |
1481 parameters.codecs.push_back(kIsacCodec); | 1512 parameters.codecs.push_back(kIsacCodec); |
1482 parameters.codecs[0].params["useinbandfec"] = "1"; | 1513 parameters.codecs[0].params["useinbandfec"] = "1"; |
1483 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1514 SetSendParameters(parameters); |
1484 EXPECT_FALSE(GetCodecFec(kSsrc1)); | 1515 EXPECT_FALSE(GetCodecFec(kSsrc1)); |
1485 } | 1516 } |
1486 | 1517 |
1487 // Test that Opus FEC status can be changed. | 1518 // Test that Opus FEC status can be changed. |
1488 TEST_F(WebRtcVoiceEngineTestFake, ChangeOpusFecStatus) { | 1519 TEST_F(WebRtcVoiceEngineTestFake, ChangeOpusFecStatus) { |
1489 EXPECT_TRUE(SetupSendStream()); | 1520 EXPECT_TRUE(SetupSendStream()); |
1490 cricket::AudioSendParameters parameters; | 1521 cricket::AudioSendParameters parameters; |
1491 parameters.codecs.push_back(kOpusCodec); | 1522 parameters.codecs.push_back(kOpusCodec); |
1492 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1523 SetSendParameters(parameters); |
1493 EXPECT_FALSE(GetCodecFec(kSsrc1)); | 1524 EXPECT_FALSE(GetCodecFec(kSsrc1)); |
1494 | 1525 |
1495 parameters.codecs[0].params["useinbandfec"] = "1"; | 1526 parameters.codecs[0].params["useinbandfec"] = "1"; |
1496 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1527 SetSendParameters(parameters); |
1497 EXPECT_TRUE(GetCodecFec(kSsrc1)); | 1528 EXPECT_TRUE(GetCodecFec(kSsrc1)); |
1498 } | 1529 } |
1499 | 1530 |
1500 TEST_F(WebRtcVoiceEngineTestFake, TransportCcCanBeEnabledAndDisabled) { | 1531 TEST_F(WebRtcVoiceEngineTestFake, TransportCcCanBeEnabledAndDisabled) { |
1501 EXPECT_TRUE(SetupChannel()); | 1532 EXPECT_TRUE(SetupChannel()); |
1502 cricket::AudioSendParameters send_parameters; | 1533 cricket::AudioSendParameters send_parameters; |
1503 send_parameters.codecs.push_back(kOpusCodec); | 1534 send_parameters.codecs.push_back(kOpusCodec); |
1504 EXPECT_TRUE(send_parameters.codecs[0].feedback_params.params().empty()); | 1535 EXPECT_TRUE(send_parameters.codecs[0].feedback_params.params().empty()); |
1505 EXPECT_TRUE(channel_->SetSendParameters(send_parameters)); | 1536 SetSendParameters(send_parameters); |
1506 | 1537 |
1507 cricket::AudioRecvParameters recv_parameters; | 1538 cricket::AudioRecvParameters recv_parameters; |
1508 recv_parameters.codecs.push_back(kIsacCodec); | 1539 recv_parameters.codecs.push_back(kIsacCodec); |
1509 EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters)); | 1540 EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters)); |
1510 EXPECT_TRUE(AddRecvStream(kSsrc1)); | 1541 EXPECT_TRUE(AddRecvStream(kSsrc1)); |
1511 ASSERT_TRUE(call_.GetAudioReceiveStream(kSsrc1) != nullptr); | 1542 ASSERT_TRUE(call_.GetAudioReceiveStream(kSsrc1) != nullptr); |
1512 EXPECT_FALSE( | 1543 EXPECT_FALSE( |
1513 call_.GetAudioReceiveStream(kSsrc1)->GetConfig().rtp.transport_cc); | 1544 call_.GetAudioReceiveStream(kSsrc1)->GetConfig().rtp.transport_cc); |
1514 | 1545 |
1515 send_parameters.codecs = engine_->send_codecs(); | 1546 send_parameters.codecs = engine_->send_codecs(); |
1516 EXPECT_TRUE(channel_->SetSendParameters(send_parameters)); | 1547 SetSendParameters(send_parameters); |
1517 ASSERT_TRUE(call_.GetAudioReceiveStream(kSsrc1) != nullptr); | 1548 ASSERT_TRUE(call_.GetAudioReceiveStream(kSsrc1) != nullptr); |
1518 EXPECT_TRUE( | 1549 EXPECT_TRUE( |
1519 call_.GetAudioReceiveStream(kSsrc1)->GetConfig().rtp.transport_cc); | 1550 call_.GetAudioReceiveStream(kSsrc1)->GetConfig().rtp.transport_cc); |
1520 } | 1551 } |
1521 | 1552 |
1522 // Test maxplaybackrate <= 8000 triggers Opus narrow band mode. | 1553 // Test maxplaybackrate <= 8000 triggers Opus narrow band mode. |
1523 TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateNb) { | 1554 TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateNb) { |
1524 EXPECT_TRUE(SetupSendStream()); | 1555 EXPECT_TRUE(SetupSendStream()); |
1525 cricket::AudioSendParameters parameters; | 1556 cricket::AudioSendParameters parameters; |
1526 parameters.codecs.push_back(kOpusCodec); | 1557 parameters.codecs.push_back(kOpusCodec); |
1527 parameters.codecs[0].bitrate = 0; | 1558 parameters.codecs[0].bitrate = 0; |
1528 parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 8000); | 1559 parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 8000); |
1529 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1560 SetSendParameters(parameters); |
1530 EXPECT_EQ(8000, GetOpusMaxPlaybackRate(kSsrc1)); | 1561 EXPECT_EQ(8000, GetOpusMaxPlaybackRate(kSsrc1)); |
1531 EXPECT_EQ(12000, GetCodecBitrate(kSsrc1)); | 1562 EXPECT_EQ(12000, GetCodecBitrate(kSsrc1)); |
1532 | 1563 |
1533 parameters.codecs[0].SetParam(cricket::kCodecParamStereo, "1"); | 1564 parameters.codecs[0].SetParam(cricket::kCodecParamStereo, "1"); |
1534 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1565 SetSendParameters(parameters); |
1535 EXPECT_EQ(24000, GetCodecBitrate(kSsrc1)); | 1566 EXPECT_EQ(24000, GetCodecBitrate(kSsrc1)); |
1536 } | 1567 } |
1537 | 1568 |
1538 // Test 8000 < maxplaybackrate <= 12000 triggers Opus medium band mode. | 1569 // Test 8000 < maxplaybackrate <= 12000 triggers Opus medium band mode. |
1539 TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateMb) { | 1570 TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateMb) { |
1540 EXPECT_TRUE(SetupSendStream()); | 1571 EXPECT_TRUE(SetupSendStream()); |
1541 cricket::AudioSendParameters parameters; | 1572 cricket::AudioSendParameters parameters; |
1542 parameters.codecs.push_back(kOpusCodec); | 1573 parameters.codecs.push_back(kOpusCodec); |
1543 parameters.codecs[0].bitrate = 0; | 1574 parameters.codecs[0].bitrate = 0; |
1544 parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 8001); | 1575 parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 8001); |
1545 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1576 SetSendParameters(parameters); |
1546 EXPECT_EQ(8001, GetOpusMaxPlaybackRate(kSsrc1)); | 1577 EXPECT_EQ(8001, GetOpusMaxPlaybackRate(kSsrc1)); |
1547 EXPECT_EQ(20000, GetCodecBitrate(kSsrc1)); | 1578 EXPECT_EQ(20000, GetCodecBitrate(kSsrc1)); |
1548 | 1579 |
1549 parameters.codecs[0].SetParam(cricket::kCodecParamStereo, "1"); | 1580 parameters.codecs[0].SetParam(cricket::kCodecParamStereo, "1"); |
1550 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1581 SetSendParameters(parameters); |
1551 EXPECT_EQ(40000, GetCodecBitrate(kSsrc1)); | 1582 EXPECT_EQ(40000, GetCodecBitrate(kSsrc1)); |
1552 } | 1583 } |
1553 | 1584 |
1554 // Test 12000 < maxplaybackrate <= 16000 triggers Opus wide band mode. | 1585 // Test 12000 < maxplaybackrate <= 16000 triggers Opus wide band mode. |
1555 TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateWb) { | 1586 TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateWb) { |
1556 EXPECT_TRUE(SetupSendStream()); | 1587 EXPECT_TRUE(SetupSendStream()); |
1557 cricket::AudioSendParameters parameters; | 1588 cricket::AudioSendParameters parameters; |
1558 parameters.codecs.push_back(kOpusCodec); | 1589 parameters.codecs.push_back(kOpusCodec); |
1559 parameters.codecs[0].bitrate = 0; | 1590 parameters.codecs[0].bitrate = 0; |
1560 parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 12001); | 1591 parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 12001); |
1561 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1592 SetSendParameters(parameters); |
1562 EXPECT_EQ(12001, GetOpusMaxPlaybackRate(kSsrc1)); | 1593 EXPECT_EQ(12001, GetOpusMaxPlaybackRate(kSsrc1)); |
1563 EXPECT_EQ(20000, GetCodecBitrate(kSsrc1)); | 1594 EXPECT_EQ(20000, GetCodecBitrate(kSsrc1)); |
1564 | 1595 |
1565 parameters.codecs[0].SetParam(cricket::kCodecParamStereo, "1"); | 1596 parameters.codecs[0].SetParam(cricket::kCodecParamStereo, "1"); |
1566 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1597 SetSendParameters(parameters); |
1567 EXPECT_EQ(40000, GetCodecBitrate(kSsrc1)); | 1598 EXPECT_EQ(40000, GetCodecBitrate(kSsrc1)); |
1568 } | 1599 } |
1569 | 1600 |
1570 // Test 16000 < maxplaybackrate <= 24000 triggers Opus super wide band mode. | 1601 // Test 16000 < maxplaybackrate <= 24000 triggers Opus super wide band mode. |
1571 TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateSwb) { | 1602 TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateSwb) { |
1572 EXPECT_TRUE(SetupSendStream()); | 1603 EXPECT_TRUE(SetupSendStream()); |
1573 cricket::AudioSendParameters parameters; | 1604 cricket::AudioSendParameters parameters; |
1574 parameters.codecs.push_back(kOpusCodec); | 1605 parameters.codecs.push_back(kOpusCodec); |
1575 parameters.codecs[0].bitrate = 0; | 1606 parameters.codecs[0].bitrate = 0; |
1576 parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 16001); | 1607 parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 16001); |
1577 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1608 SetSendParameters(parameters); |
1578 EXPECT_EQ(16001, GetOpusMaxPlaybackRate(kSsrc1)); | 1609 EXPECT_EQ(16001, GetOpusMaxPlaybackRate(kSsrc1)); |
1579 EXPECT_EQ(32000, GetCodecBitrate(kSsrc1)); | 1610 EXPECT_EQ(32000, GetCodecBitrate(kSsrc1)); |
1580 | 1611 |
1581 parameters.codecs[0].SetParam(cricket::kCodecParamStereo, "1"); | 1612 parameters.codecs[0].SetParam(cricket::kCodecParamStereo, "1"); |
1582 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1613 SetSendParameters(parameters); |
1583 EXPECT_EQ(64000, GetCodecBitrate(kSsrc1)); | 1614 EXPECT_EQ(64000, GetCodecBitrate(kSsrc1)); |
1584 } | 1615 } |
1585 | 1616 |
1586 // Test 24000 < maxplaybackrate triggers Opus full band mode. | 1617 // Test 24000 < maxplaybackrate triggers Opus full band mode. |
1587 TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateFb) { | 1618 TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateFb) { |
1588 EXPECT_TRUE(SetupSendStream()); | 1619 EXPECT_TRUE(SetupSendStream()); |
1589 cricket::AudioSendParameters parameters; | 1620 cricket::AudioSendParameters parameters; |
1590 parameters.codecs.push_back(kOpusCodec); | 1621 parameters.codecs.push_back(kOpusCodec); |
1591 parameters.codecs[0].bitrate = 0; | 1622 parameters.codecs[0].bitrate = 0; |
1592 parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 24001); | 1623 parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 24001); |
1593 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1624 SetSendParameters(parameters); |
1594 EXPECT_EQ(24001, GetOpusMaxPlaybackRate(kSsrc1)); | 1625 EXPECT_EQ(24001, GetOpusMaxPlaybackRate(kSsrc1)); |
1595 EXPECT_EQ(32000, GetCodecBitrate(kSsrc1)); | 1626 EXPECT_EQ(32000, GetCodecBitrate(kSsrc1)); |
1596 | 1627 |
1597 parameters.codecs[0].SetParam(cricket::kCodecParamStereo, "1"); | 1628 parameters.codecs[0].SetParam(cricket::kCodecParamStereo, "1"); |
1598 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1629 SetSendParameters(parameters); |
1599 EXPECT_EQ(64000, GetCodecBitrate(kSsrc1)); | 1630 EXPECT_EQ(64000, GetCodecBitrate(kSsrc1)); |
1600 } | 1631 } |
1601 | 1632 |
1602 // Test Opus that without maxplaybackrate, default playback rate is used. | 1633 // Test Opus that without maxplaybackrate, default playback rate is used. |
1603 TEST_F(WebRtcVoiceEngineTestFake, DefaultOpusMaxPlaybackRate) { | 1634 TEST_F(WebRtcVoiceEngineTestFake, DefaultOpusMaxPlaybackRate) { |
1604 EXPECT_TRUE(SetupSendStream()); | 1635 EXPECT_TRUE(SetupSendStream()); |
1605 cricket::AudioSendParameters parameters; | 1636 cricket::AudioSendParameters parameters; |
1606 parameters.codecs.push_back(kOpusCodec); | 1637 parameters.codecs.push_back(kOpusCodec); |
1607 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1638 SetSendParameters(parameters); |
1608 EXPECT_EQ(48000, GetOpusMaxPlaybackRate(kSsrc1)); | 1639 EXPECT_EQ(48000, GetOpusMaxPlaybackRate(kSsrc1)); |
1609 } | 1640 } |
1610 | 1641 |
1611 // Test the with non-Opus, maxplaybackrate has no effect. | 1642 // Test the with non-Opus, maxplaybackrate has no effect. |
1612 TEST_F(WebRtcVoiceEngineTestFake, SetNonOpusMaxPlaybackRate) { | 1643 TEST_F(WebRtcVoiceEngineTestFake, SetNonOpusMaxPlaybackRate) { |
1613 EXPECT_TRUE(SetupSendStream()); | 1644 EXPECT_TRUE(SetupSendStream()); |
1614 cricket::AudioSendParameters parameters; | 1645 cricket::AudioSendParameters parameters; |
1615 parameters.codecs.push_back(kIsacCodec); | 1646 parameters.codecs.push_back(kIsacCodec); |
1616 parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 32000); | 1647 parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 32000); |
1617 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1648 SetSendParameters(parameters); |
1618 EXPECT_EQ(0, GetOpusMaxPlaybackRate(kSsrc1)); | 1649 EXPECT_EQ(0, GetOpusMaxPlaybackRate(kSsrc1)); |
1619 } | 1650 } |
1620 | 1651 |
1621 // Test maxplaybackrate can be set on two streams. | 1652 // Test maxplaybackrate can be set on two streams. |
1622 TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateOnTwoStreams) { | 1653 TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateOnTwoStreams) { |
1623 EXPECT_TRUE(SetupSendStream()); | 1654 EXPECT_TRUE(SetupSendStream()); |
1624 cricket::AudioSendParameters parameters; | 1655 cricket::AudioSendParameters parameters; |
1625 parameters.codecs.push_back(kOpusCodec); | 1656 parameters.codecs.push_back(kOpusCodec); |
1626 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1657 SetSendParameters(parameters); |
1627 EXPECT_EQ(48000, GetOpusMaxPlaybackRate(kSsrc1)); | 1658 EXPECT_EQ(48000, GetOpusMaxPlaybackRate(kSsrc1)); |
1628 | 1659 |
1629 parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 8000); | 1660 parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 8000); |
1630 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1661 SetSendParameters(parameters); |
1631 EXPECT_EQ(8000, GetOpusMaxPlaybackRate(kSsrc1)); | 1662 EXPECT_EQ(8000, GetOpusMaxPlaybackRate(kSsrc1)); |
1632 | 1663 |
1633 channel_->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc2)); | 1664 channel_->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc2)); |
1634 EXPECT_EQ(8000, GetOpusMaxPlaybackRate(kSsrc2)); | 1665 EXPECT_EQ(8000, GetOpusMaxPlaybackRate(kSsrc2)); |
1635 } | 1666 } |
1636 | 1667 |
1637 // Test that with usedtx=0, Opus DTX is off. | 1668 // Test that with usedtx=0, Opus DTX is off. |
1638 TEST_F(WebRtcVoiceEngineTestFake, DisableOpusDtxOnOpus) { | 1669 TEST_F(WebRtcVoiceEngineTestFake, DisableOpusDtxOnOpus) { |
1639 EXPECT_TRUE(SetupSendStream()); | 1670 EXPECT_TRUE(SetupSendStream()); |
1640 cricket::AudioSendParameters parameters; | 1671 cricket::AudioSendParameters parameters; |
1641 parameters.codecs.push_back(kOpusCodec); | 1672 parameters.codecs.push_back(kOpusCodec); |
1642 parameters.codecs[0].params["usedtx"] = "0"; | 1673 parameters.codecs[0].params["usedtx"] = "0"; |
1643 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1674 SetSendParameters(parameters); |
1644 EXPECT_FALSE(GetOpusDtx(kSsrc1)); | 1675 EXPECT_FALSE(GetOpusDtx(kSsrc1)); |
1645 } | 1676 } |
1646 | 1677 |
1647 // Test that with usedtx=1, Opus DTX is on. | 1678 // Test that with usedtx=1, Opus DTX is on. |
1648 TEST_F(WebRtcVoiceEngineTestFake, EnableOpusDtxOnOpus) { | 1679 TEST_F(WebRtcVoiceEngineTestFake, EnableOpusDtxOnOpus) { |
1649 EXPECT_TRUE(SetupSendStream()); | 1680 EXPECT_TRUE(SetupSendStream()); |
1650 cricket::AudioSendParameters parameters; | 1681 cricket::AudioSendParameters parameters; |
1651 parameters.codecs.push_back(kOpusCodec); | 1682 parameters.codecs.push_back(kOpusCodec); |
1652 parameters.codecs[0].params["usedtx"] = "1"; | 1683 parameters.codecs[0].params["usedtx"] = "1"; |
1653 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1684 SetSendParameters(parameters); |
1654 EXPECT_TRUE(GetOpusDtx(kSsrc1)); | 1685 EXPECT_TRUE(GetOpusDtx(kSsrc1)); |
1655 } | 1686 } |
1656 | 1687 |
1657 // Test that usedtx=1 works with stereo Opus. | 1688 // Test that usedtx=1 works with stereo Opus. |
1658 TEST_F(WebRtcVoiceEngineTestFake, EnableOpusDtxOnOpusStereo) { | 1689 TEST_F(WebRtcVoiceEngineTestFake, EnableOpusDtxOnOpusStereo) { |
1659 EXPECT_TRUE(SetupSendStream()); | 1690 EXPECT_TRUE(SetupSendStream()); |
1660 cricket::AudioSendParameters parameters; | 1691 cricket::AudioSendParameters parameters; |
1661 parameters.codecs.push_back(kOpusCodec); | 1692 parameters.codecs.push_back(kOpusCodec); |
1662 parameters.codecs[0].params["usedtx"] = "1"; | 1693 parameters.codecs[0].params["usedtx"] = "1"; |
1663 parameters.codecs[0].params["stereo"] = "1"; | 1694 parameters.codecs[0].params["stereo"] = "1"; |
1664 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1695 SetSendParameters(parameters); |
1665 EXPECT_TRUE(GetOpusDtx(kSsrc1)); | 1696 EXPECT_TRUE(GetOpusDtx(kSsrc1)); |
1666 } | 1697 } |
1667 | 1698 |
1668 // Test that usedtx=1 does not work with non Opus. | 1699 // Test that usedtx=1 does not work with non Opus. |
1669 TEST_F(WebRtcVoiceEngineTestFake, CannotEnableOpusDtxOnNonOpus) { | 1700 TEST_F(WebRtcVoiceEngineTestFake, CannotEnableOpusDtxOnNonOpus) { |
1670 EXPECT_TRUE(SetupSendStream()); | 1701 EXPECT_TRUE(SetupSendStream()); |
1671 cricket::AudioSendParameters parameters; | 1702 cricket::AudioSendParameters parameters; |
1672 parameters.codecs.push_back(kIsacCodec); | 1703 parameters.codecs.push_back(kIsacCodec); |
1673 parameters.codecs[0].params["usedtx"] = "1"; | 1704 parameters.codecs[0].params["usedtx"] = "1"; |
1674 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1705 SetSendParameters(parameters); |
1675 EXPECT_FALSE(GetOpusDtx(kSsrc1)); | 1706 EXPECT_FALSE(GetOpusDtx(kSsrc1)); |
1676 } | 1707 } |
1677 | 1708 |
1678 // Test that we can switch back and forth between Opus and ISAC with CN. | 1709 // Test that we can switch back and forth between Opus and ISAC with CN. |
1679 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsIsacOpusSwitching) { | 1710 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsIsacOpusSwitching) { |
1680 EXPECT_TRUE(SetupSendStream()); | 1711 EXPECT_TRUE(SetupSendStream()); |
1681 | 1712 |
1682 cricket::AudioSendParameters opus_parameters; | 1713 cricket::AudioSendParameters opus_parameters; |
1683 opus_parameters.codecs.push_back(kOpusCodec); | 1714 opus_parameters.codecs.push_back(kOpusCodec); |
1684 EXPECT_TRUE(channel_->SetSendParameters(opus_parameters)); | 1715 SetSendParameters(opus_parameters); |
1685 { | 1716 { |
1686 const auto& gcodec = GetSendStreamConfig(kSsrc1).send_codec_spec.codec_inst; | 1717 const auto& gcodec = GetSendStreamConfig(kSsrc1).send_codec_spec.codec_inst; |
1687 EXPECT_EQ(111, gcodec.pltype); | 1718 EXPECT_EQ(111, gcodec.pltype); |
1688 EXPECT_STREQ("opus", gcodec.plname); | 1719 EXPECT_STREQ("opus", gcodec.plname); |
1689 } | 1720 } |
1690 | 1721 |
1691 cricket::AudioSendParameters isac_parameters; | 1722 cricket::AudioSendParameters isac_parameters; |
1692 isac_parameters.codecs.push_back(kIsacCodec); | 1723 isac_parameters.codecs.push_back(kIsacCodec); |
1693 isac_parameters.codecs.push_back(kCn16000Codec); | 1724 isac_parameters.codecs.push_back(kCn16000Codec); |
1694 isac_parameters.codecs.push_back(kOpusCodec); | 1725 isac_parameters.codecs.push_back(kOpusCodec); |
1695 EXPECT_TRUE(channel_->SetSendParameters(isac_parameters)); | 1726 SetSendParameters(isac_parameters); |
1696 { | 1727 { |
1697 const auto& gcodec = GetSendStreamConfig(kSsrc1).send_codec_spec.codec_inst; | 1728 const auto& gcodec = GetSendStreamConfig(kSsrc1).send_codec_spec.codec_inst; |
1698 EXPECT_EQ(103, gcodec.pltype); | 1729 EXPECT_EQ(103, gcodec.pltype); |
1699 EXPECT_STREQ("ISAC", gcodec.plname); | 1730 EXPECT_STREQ("ISAC", gcodec.plname); |
1700 } | 1731 } |
1701 | 1732 |
1702 EXPECT_TRUE(channel_->SetSendParameters(opus_parameters)); | 1733 SetSendParameters(opus_parameters); |
1703 { | 1734 { |
1704 const auto& gcodec = GetSendStreamConfig(kSsrc1).send_codec_spec.codec_inst; | 1735 const auto& gcodec = GetSendStreamConfig(kSsrc1).send_codec_spec.codec_inst; |
1705 EXPECT_EQ(111, gcodec.pltype); | 1736 EXPECT_EQ(111, gcodec.pltype); |
1706 EXPECT_STREQ("opus", gcodec.plname); | 1737 EXPECT_STREQ("opus", gcodec.plname); |
1707 } | 1738 } |
1708 } | 1739 } |
1709 | 1740 |
1710 // Test that we handle various ways of specifying bitrate. | 1741 // Test that we handle various ways of specifying bitrate. |
1711 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsBitrate) { | 1742 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsBitrate) { |
1712 EXPECT_TRUE(SetupSendStream()); | 1743 EXPECT_TRUE(SetupSendStream()); |
1713 cricket::AudioSendParameters parameters; | 1744 cricket::AudioSendParameters parameters; |
1714 parameters.codecs.push_back(kIsacCodec); // bitrate == 32000 | 1745 parameters.codecs.push_back(kIsacCodec); // bitrate == 32000 |
1715 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1746 SetSendParameters(parameters); |
1716 { | 1747 { |
1717 const auto& gcodec = GetSendStreamConfig(kSsrc1).send_codec_spec.codec_inst; | 1748 const auto& gcodec = GetSendStreamConfig(kSsrc1).send_codec_spec.codec_inst; |
1718 EXPECT_EQ(103, gcodec.pltype); | 1749 EXPECT_EQ(103, gcodec.pltype); |
1719 EXPECT_STREQ("ISAC", gcodec.plname); | 1750 EXPECT_STREQ("ISAC", gcodec.plname); |
1720 EXPECT_EQ(32000, gcodec.rate); | 1751 EXPECT_EQ(32000, gcodec.rate); |
1721 } | 1752 } |
1722 | 1753 |
1723 parameters.codecs[0].bitrate = 0; // bitrate == default | 1754 parameters.codecs[0].bitrate = 0; // bitrate == default |
1724 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1755 SetSendParameters(parameters); |
1725 { | 1756 { |
1726 const auto& gcodec = GetSendStreamConfig(kSsrc1).send_codec_spec.codec_inst; | 1757 const auto& gcodec = GetSendStreamConfig(kSsrc1).send_codec_spec.codec_inst; |
1727 EXPECT_EQ(103, gcodec.pltype); | 1758 EXPECT_EQ(103, gcodec.pltype); |
1728 EXPECT_STREQ("ISAC", gcodec.plname); | 1759 EXPECT_STREQ("ISAC", gcodec.plname); |
1729 EXPECT_EQ(-1, gcodec.rate); | 1760 EXPECT_EQ(-1, gcodec.rate); |
1730 } | 1761 } |
1731 parameters.codecs[0].bitrate = 28000; // bitrate == 28000 | 1762 parameters.codecs[0].bitrate = 28000; // bitrate == 28000 |
1732 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1763 SetSendParameters(parameters); |
1733 { | 1764 { |
1734 const auto& gcodec = GetSendStreamConfig(kSsrc1).send_codec_spec.codec_inst; | 1765 const auto& gcodec = GetSendStreamConfig(kSsrc1).send_codec_spec.codec_inst; |
1735 EXPECT_EQ(103, gcodec.pltype); | 1766 EXPECT_EQ(103, gcodec.pltype); |
1736 EXPECT_STREQ("ISAC", gcodec.plname); | 1767 EXPECT_STREQ("ISAC", gcodec.plname); |
1737 EXPECT_EQ(28000, gcodec.rate); | 1768 EXPECT_EQ(28000, gcodec.rate); |
1738 } | 1769 } |
1739 | 1770 |
1740 parameters.codecs[0] = kPcmuCodec; // bitrate == 64000 | 1771 parameters.codecs[0] = kPcmuCodec; // bitrate == 64000 |
1741 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1772 SetSendParameters(parameters); |
1742 { | 1773 { |
1743 const auto& gcodec = GetSendStreamConfig(kSsrc1).send_codec_spec.codec_inst; | 1774 const auto& gcodec = GetSendStreamConfig(kSsrc1).send_codec_spec.codec_inst; |
1744 EXPECT_EQ(0, gcodec.pltype); | 1775 EXPECT_EQ(0, gcodec.pltype); |
1745 EXPECT_STREQ("PCMU", gcodec.plname); | 1776 EXPECT_STREQ("PCMU", gcodec.plname); |
1746 EXPECT_EQ(64000, gcodec.rate); | 1777 EXPECT_EQ(64000, gcodec.rate); |
1747 } | 1778 } |
1748 | 1779 |
1749 parameters.codecs[0].bitrate = 0; // bitrate == default | 1780 parameters.codecs[0].bitrate = 0; // bitrate == default |
1750 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1781 SetSendParameters(parameters); |
1751 { | 1782 { |
1752 const auto& gcodec = GetSendStreamConfig(kSsrc1).send_codec_spec.codec_inst; | 1783 const auto& gcodec = GetSendStreamConfig(kSsrc1).send_codec_spec.codec_inst; |
1753 EXPECT_EQ(0, gcodec.pltype); | 1784 EXPECT_EQ(0, gcodec.pltype); |
1754 EXPECT_STREQ("PCMU", gcodec.plname); | 1785 EXPECT_STREQ("PCMU", gcodec.plname); |
1755 EXPECT_EQ(64000, gcodec.rate); | 1786 EXPECT_EQ(64000, gcodec.rate); |
1756 } | 1787 } |
1757 | 1788 |
1758 parameters.codecs[0] = kOpusCodec; | 1789 parameters.codecs[0] = kOpusCodec; |
1759 parameters.codecs[0].bitrate = 0; // bitrate == default | 1790 parameters.codecs[0].bitrate = 0; // bitrate == default |
1760 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1791 SetSendParameters(parameters); |
1761 { | 1792 { |
1762 const auto& gcodec = GetSendStreamConfig(kSsrc1).send_codec_spec.codec_inst; | 1793 const auto& gcodec = GetSendStreamConfig(kSsrc1).send_codec_spec.codec_inst; |
1763 EXPECT_EQ(111, gcodec.pltype); | 1794 EXPECT_EQ(111, gcodec.pltype); |
1764 EXPECT_STREQ("opus", gcodec.plname); | 1795 EXPECT_STREQ("opus", gcodec.plname); |
1765 EXPECT_EQ(32000, gcodec.rate); | 1796 EXPECT_EQ(32000, gcodec.rate); |
1766 } | 1797 } |
1767 } | 1798 } |
1768 | 1799 |
1769 // Test that we could set packet size specified in kCodecParamPTime. | 1800 // Test that we could set packet size specified in kCodecParamPTime. |
1770 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsPTimeAsPacketSize) { | 1801 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsPTimeAsPacketSize) { |
1771 EXPECT_TRUE(SetupSendStream()); | 1802 EXPECT_TRUE(SetupSendStream()); |
1772 cricket::AudioSendParameters parameters; | 1803 cricket::AudioSendParameters parameters; |
1773 parameters.codecs.push_back(kOpusCodec); | 1804 parameters.codecs.push_back(kOpusCodec); |
1774 parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 40); // Within range. | 1805 parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 40); // Within range. |
1775 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1806 SetSendParameters(parameters); |
1776 EXPECT_EQ(1920, GetCodecPacSize(kSsrc1)); // Opus gets 40ms. | 1807 EXPECT_EQ(1920, GetCodecPacSize(kSsrc1)); // Opus gets 40ms. |
1777 | 1808 |
1778 parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 5); // Below range. | 1809 parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 5); // Below range. |
1779 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1810 SetSendParameters(parameters); |
1780 EXPECT_EQ(480, GetCodecPacSize(kSsrc1)); // Opus gets 10ms. | 1811 EXPECT_EQ(480, GetCodecPacSize(kSsrc1)); // Opus gets 10ms. |
1781 | 1812 |
1782 parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 80); // Beyond range. | 1813 parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 80); // Beyond range. |
1783 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1814 SetSendParameters(parameters); |
1784 EXPECT_EQ(2880, GetCodecPacSize(kSsrc1)); // Opus gets 60ms. | 1815 EXPECT_EQ(2880, GetCodecPacSize(kSsrc1)); // Opus gets 60ms. |
1785 | 1816 |
1786 parameters.codecs[0] = kIsacCodec; // Also try Isac, with unsupported size. | 1817 parameters.codecs[0] = kIsacCodec; // Also try Isac, with unsupported size. |
1787 parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 40); // Within range. | 1818 parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 40); // Within range. |
1788 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1819 SetSendParameters(parameters); |
1789 EXPECT_EQ(480, GetCodecPacSize( | 1820 EXPECT_EQ(480, GetCodecPacSize( |
1790 kSsrc1)); // Isac gets 30ms as the next smallest value. | 1821 kSsrc1)); // Isac gets 30ms as the next smallest value. |
1791 | 1822 |
1792 parameters.codecs[0] = kG722CodecSdp; // Try G722 @8kHz as negotiated in SDP. | 1823 parameters.codecs[0] = kG722CodecSdp; // Try G722 @8kHz as negotiated in SDP. |
1793 parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 40); | 1824 parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 40); |
1794 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1825 SetSendParameters(parameters); |
1795 EXPECT_EQ(640, GetCodecPacSize( | 1826 EXPECT_EQ(640, GetCodecPacSize( |
1796 kSsrc1)); // G722 gets 40ms @16kHz as defined in VoE. | 1827 kSsrc1)); // G722 gets 40ms @16kHz as defined in VoE. |
1797 } | 1828 } |
1798 | 1829 |
1799 // Test that we fail if no codecs are specified. | 1830 // Test that we fail if no codecs are specified. |
1800 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsNoCodecs) { | 1831 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsNoCodecs) { |
1801 EXPECT_TRUE(SetupSendStream()); | 1832 EXPECT_TRUE(SetupSendStream()); |
1802 cricket::AudioSendParameters parameters; | 1833 cricket::AudioSendParameters parameters; |
1803 EXPECT_FALSE(channel_->SetSendParameters(parameters)); | 1834 EXPECT_FALSE(channel_->SetSendParameters(parameters)); |
1804 } | 1835 } |
1805 | 1836 |
1806 // Test that we can set send codecs even with telephone-event codec as the first | 1837 // Test that we can set send codecs even with telephone-event codec as the first |
1807 // one on the list. | 1838 // one on the list. |
1808 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsDTMFOnTop) { | 1839 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsDTMFOnTop) { |
1809 EXPECT_TRUE(SetupSendStream()); | 1840 EXPECT_TRUE(SetupSendStream()); |
1810 cricket::AudioSendParameters parameters; | 1841 cricket::AudioSendParameters parameters; |
1811 parameters.codecs.push_back(kTelephoneEventCodec); | 1842 parameters.codecs.push_back(kTelephoneEventCodec); |
1812 parameters.codecs.push_back(kIsacCodec); | 1843 parameters.codecs.push_back(kIsacCodec); |
1813 parameters.codecs.push_back(kPcmuCodec); | 1844 parameters.codecs.push_back(kPcmuCodec); |
1814 parameters.codecs[0].id = 98; // DTMF | 1845 parameters.codecs[0].id = 98; // DTMF |
1815 parameters.codecs[1].id = 96; | 1846 parameters.codecs[1].id = 96; |
1816 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1847 SetSendParameters(parameters); |
1817 const auto& gcodec = GetSendStreamConfig(kSsrc1).send_codec_spec.codec_inst; | 1848 const auto& gcodec = GetSendStreamConfig(kSsrc1).send_codec_spec.codec_inst; |
1818 EXPECT_EQ(96, gcodec.pltype); | 1849 EXPECT_EQ(96, gcodec.pltype); |
1819 EXPECT_STREQ("ISAC", gcodec.plname); | 1850 EXPECT_STREQ("ISAC", gcodec.plname); |
1820 EXPECT_TRUE(channel_->CanInsertDtmf()); | 1851 EXPECT_TRUE(channel_->CanInsertDtmf()); |
1821 } | 1852 } |
1822 | 1853 |
1823 // Test that payload type range is limited for telephone-event codec. | 1854 // Test that payload type range is limited for telephone-event codec. |
1824 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsDTMFPayloadTypeOutOfRange) { | 1855 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsDTMFPayloadTypeOutOfRange) { |
1825 EXPECT_TRUE(SetupSendStream()); | 1856 EXPECT_TRUE(SetupSendStream()); |
1826 cricket::AudioSendParameters parameters; | 1857 cricket::AudioSendParameters parameters; |
1827 parameters.codecs.push_back(kTelephoneEventCodec); | 1858 parameters.codecs.push_back(kTelephoneEventCodec); |
1828 parameters.codecs.push_back(kIsacCodec); | 1859 parameters.codecs.push_back(kIsacCodec); |
1829 parameters.codecs[0].id = 0; // DTMF | 1860 parameters.codecs[0].id = 0; // DTMF |
1830 parameters.codecs[1].id = 96; | 1861 parameters.codecs[1].id = 96; |
1831 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1862 SetSendParameters(parameters); |
1832 EXPECT_TRUE(channel_->CanInsertDtmf()); | 1863 EXPECT_TRUE(channel_->CanInsertDtmf()); |
1833 parameters.codecs[0].id = 128; // DTMF | 1864 parameters.codecs[0].id = 128; // DTMF |
1834 EXPECT_FALSE(channel_->SetSendParameters(parameters)); | 1865 EXPECT_FALSE(channel_->SetSendParameters(parameters)); |
1835 EXPECT_FALSE(channel_->CanInsertDtmf()); | 1866 EXPECT_FALSE(channel_->CanInsertDtmf()); |
1836 parameters.codecs[0].id = 127; | 1867 parameters.codecs[0].id = 127; |
1837 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1868 SetSendParameters(parameters); |
1838 EXPECT_TRUE(channel_->CanInsertDtmf()); | 1869 EXPECT_TRUE(channel_->CanInsertDtmf()); |
1839 parameters.codecs[0].id = -1; // DTMF | 1870 parameters.codecs[0].id = -1; // DTMF |
1840 EXPECT_FALSE(channel_->SetSendParameters(parameters)); | 1871 EXPECT_FALSE(channel_->SetSendParameters(parameters)); |
1841 EXPECT_FALSE(channel_->CanInsertDtmf()); | 1872 EXPECT_FALSE(channel_->CanInsertDtmf()); |
1842 } | 1873 } |
1843 | 1874 |
1844 // Test that we can set send codecs even with CN codec as the first | 1875 // Test that we can set send codecs even with CN codec as the first |
1845 // one on the list. | 1876 // one on the list. |
1846 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNOnTop) { | 1877 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNOnTop) { |
1847 EXPECT_TRUE(SetupSendStream()); | 1878 EXPECT_TRUE(SetupSendStream()); |
1848 cricket::AudioSendParameters parameters; | 1879 cricket::AudioSendParameters parameters; |
1849 parameters.codecs.push_back(kCn16000Codec); | 1880 parameters.codecs.push_back(kCn16000Codec); |
1850 parameters.codecs.push_back(kIsacCodec); | 1881 parameters.codecs.push_back(kIsacCodec); |
1851 parameters.codecs.push_back(kPcmuCodec); | 1882 parameters.codecs.push_back(kPcmuCodec); |
1852 parameters.codecs[0].id = 98; // wideband CN | 1883 parameters.codecs[0].id = 98; // wideband CN |
1853 parameters.codecs[1].id = 96; | 1884 parameters.codecs[1].id = 96; |
1854 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1885 SetSendParameters(parameters); |
1855 const auto& send_codec_spec = GetSendStreamConfig(kSsrc1).send_codec_spec; | 1886 const auto& send_codec_spec = GetSendStreamConfig(kSsrc1).send_codec_spec; |
1856 EXPECT_EQ(96, send_codec_spec.codec_inst.pltype); | 1887 EXPECT_EQ(96, send_codec_spec.codec_inst.pltype); |
1857 EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname); | 1888 EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname); |
1858 EXPECT_EQ(98, send_codec_spec.cng_payload_type); | 1889 EXPECT_EQ(98, send_codec_spec.cng_payload_type); |
1859 EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq); | 1890 EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq); |
1860 } | 1891 } |
1861 | 1892 |
1862 // Test that we set VAD and DTMF types correctly as caller. | 1893 // Test that we set VAD and DTMF types correctly as caller. |
1863 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNandDTMFAsCaller) { | 1894 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNandDTMFAsCaller) { |
1864 EXPECT_TRUE(SetupSendStream()); | 1895 EXPECT_TRUE(SetupSendStream()); |
1865 cricket::AudioSendParameters parameters; | 1896 cricket::AudioSendParameters parameters; |
1866 parameters.codecs.push_back(kIsacCodec); | 1897 parameters.codecs.push_back(kIsacCodec); |
1867 parameters.codecs.push_back(kPcmuCodec); | 1898 parameters.codecs.push_back(kPcmuCodec); |
1868 // TODO(juberti): cn 32000 | 1899 // TODO(juberti): cn 32000 |
1869 parameters.codecs.push_back(kCn16000Codec); | 1900 parameters.codecs.push_back(kCn16000Codec); |
1870 parameters.codecs.push_back(kCn8000Codec); | 1901 parameters.codecs.push_back(kCn8000Codec); |
1871 parameters.codecs.push_back(kTelephoneEventCodec); | 1902 parameters.codecs.push_back(kTelephoneEventCodec); |
1872 parameters.codecs[0].id = 96; | 1903 parameters.codecs[0].id = 96; |
1873 parameters.codecs[2].id = 97; // wideband CN | 1904 parameters.codecs[2].id = 97; // wideband CN |
1874 parameters.codecs[4].id = 98; // DTMF | 1905 parameters.codecs[4].id = 98; // DTMF |
1875 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1906 SetSendParameters(parameters); |
1876 const auto& send_codec_spec = GetSendStreamConfig(kSsrc1).send_codec_spec; | 1907 const auto& send_codec_spec = GetSendStreamConfig(kSsrc1).send_codec_spec; |
1877 EXPECT_EQ(96, send_codec_spec.codec_inst.pltype); | 1908 EXPECT_EQ(96, send_codec_spec.codec_inst.pltype); |
1878 EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname); | 1909 EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname); |
1879 EXPECT_EQ(1, send_codec_spec.codec_inst.channels); | 1910 EXPECT_EQ(1, send_codec_spec.codec_inst.channels); |
1880 EXPECT_EQ(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq); | 1911 EXPECT_EQ(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq); |
1881 EXPECT_EQ(97, send_codec_spec.cng_payload_type); | 1912 EXPECT_EQ(97, send_codec_spec.cng_payload_type); |
1882 EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq); | 1913 EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq); |
1883 EXPECT_TRUE(channel_->CanInsertDtmf()); | 1914 EXPECT_TRUE(channel_->CanInsertDtmf()); |
1884 } | 1915 } |
1885 | 1916 |
1886 // Test that we set VAD and DTMF types correctly as callee. | 1917 // Test that we set VAD and DTMF types correctly as callee. |
1887 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNandDTMFAsCallee) { | 1918 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNandDTMFAsCallee) { |
1888 EXPECT_TRUE(SetupChannel()); | 1919 EXPECT_TRUE(SetupChannel()); |
1889 cricket::AudioSendParameters parameters; | 1920 cricket::AudioSendParameters parameters; |
1890 parameters.codecs.push_back(kIsacCodec); | 1921 parameters.codecs.push_back(kIsacCodec); |
1891 parameters.codecs.push_back(kPcmuCodec); | 1922 parameters.codecs.push_back(kPcmuCodec); |
1892 // TODO(juberti): cn 32000 | 1923 // TODO(juberti): cn 32000 |
1893 parameters.codecs.push_back(kCn16000Codec); | 1924 parameters.codecs.push_back(kCn16000Codec); |
1894 parameters.codecs.push_back(kCn8000Codec); | 1925 parameters.codecs.push_back(kCn8000Codec); |
1895 parameters.codecs.push_back(kTelephoneEventCodec); | 1926 parameters.codecs.push_back(kTelephoneEventCodec); |
1896 parameters.codecs[0].id = 96; | 1927 parameters.codecs[0].id = 96; |
1897 parameters.codecs[2].id = 97; // wideband CN | 1928 parameters.codecs[2].id = 97; // wideband CN |
1898 parameters.codecs[4].id = 98; // DTMF | 1929 parameters.codecs[4].id = 98; // DTMF |
1899 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1930 SetSendParameters(parameters); |
1900 EXPECT_TRUE(channel_->AddSendStream( | 1931 EXPECT_TRUE(channel_->AddSendStream( |
1901 cricket::StreamParams::CreateLegacy(kSsrc1))); | 1932 cricket::StreamParams::CreateLegacy(kSsrc1))); |
1902 | 1933 |
1903 const auto& send_codec_spec = GetSendStreamConfig(kSsrc1).send_codec_spec; | 1934 const auto& send_codec_spec = GetSendStreamConfig(kSsrc1).send_codec_spec; |
1904 EXPECT_EQ(96, send_codec_spec.codec_inst.pltype); | 1935 EXPECT_EQ(96, send_codec_spec.codec_inst.pltype); |
1905 EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname); | 1936 EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname); |
1906 EXPECT_EQ(1, send_codec_spec.codec_inst.channels); | 1937 EXPECT_EQ(1, send_codec_spec.codec_inst.channels); |
1907 EXPECT_EQ(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq); | 1938 EXPECT_EQ(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq); |
1908 EXPECT_EQ(97, send_codec_spec.cng_payload_type); | 1939 EXPECT_EQ(97, send_codec_spec.cng_payload_type); |
1909 EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq); | 1940 EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq); |
1910 EXPECT_TRUE(channel_->CanInsertDtmf()); | 1941 EXPECT_TRUE(channel_->CanInsertDtmf()); |
1911 } | 1942 } |
1912 | 1943 |
1913 // Test that we only apply VAD if we have a CN codec that matches the | 1944 // Test that we only apply VAD if we have a CN codec that matches the |
1914 // send codec clockrate. | 1945 // send codec clockrate. |
1915 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNNoMatch) { | 1946 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNNoMatch) { |
1916 EXPECT_TRUE(SetupSendStream()); | 1947 EXPECT_TRUE(SetupSendStream()); |
1917 cricket::AudioSendParameters parameters; | 1948 cricket::AudioSendParameters parameters; |
1918 // Set ISAC(16K) and CN(16K). VAD should be activated. | 1949 // Set ISAC(16K) and CN(16K). VAD should be activated. |
1919 parameters.codecs.push_back(kIsacCodec); | 1950 parameters.codecs.push_back(kIsacCodec); |
1920 parameters.codecs.push_back(kCn16000Codec); | 1951 parameters.codecs.push_back(kCn16000Codec); |
1921 parameters.codecs[1].id = 97; | 1952 parameters.codecs[1].id = 97; |
1922 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1953 SetSendParameters(parameters); |
1923 { | 1954 { |
1924 const auto& send_codec_spec = GetSendStreamConfig(kSsrc1).send_codec_spec; | 1955 const auto& send_codec_spec = GetSendStreamConfig(kSsrc1).send_codec_spec; |
1925 EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname); | 1956 EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname); |
1926 EXPECT_EQ(1, send_codec_spec.codec_inst.channels); | 1957 EXPECT_EQ(1, send_codec_spec.codec_inst.channels); |
1927 EXPECT_EQ(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq); | 1958 EXPECT_EQ(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq); |
1928 EXPECT_EQ(97, send_codec_spec.cng_payload_type); | 1959 EXPECT_EQ(97, send_codec_spec.cng_payload_type); |
1929 EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq); | 1960 EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq); |
1930 } | 1961 } |
1931 // Set PCMU(8K) and CN(16K). VAD should not be activated. | 1962 // Set PCMU(8K) and CN(16K). VAD should not be activated. |
1932 parameters.codecs[0] = kPcmuCodec; | 1963 parameters.codecs[0] = kPcmuCodec; |
1933 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1964 SetSendParameters(parameters); |
1934 { | 1965 { |
1935 const auto& send_codec_spec = GetSendStreamConfig(kSsrc1).send_codec_spec; | 1966 const auto& send_codec_spec = GetSendStreamConfig(kSsrc1).send_codec_spec; |
1936 EXPECT_STREQ("PCMU", send_codec_spec.codec_inst.plname); | 1967 EXPECT_STREQ("PCMU", send_codec_spec.codec_inst.plname); |
1937 EXPECT_NE(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq); | 1968 EXPECT_NE(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq); |
1938 } | 1969 } |
1939 // Set PCMU(8K) and CN(8K). VAD should be activated. | 1970 // Set PCMU(8K) and CN(8K). VAD should be activated. |
1940 parameters.codecs[1] = kCn8000Codec; | 1971 parameters.codecs[1] = kCn8000Codec; |
1941 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1972 SetSendParameters(parameters); |
1942 { | 1973 { |
1943 const auto& send_codec_spec = GetSendStreamConfig(kSsrc1).send_codec_spec; | 1974 const auto& send_codec_spec = GetSendStreamConfig(kSsrc1).send_codec_spec; |
1944 EXPECT_STREQ("PCMU", send_codec_spec.codec_inst.plname); | 1975 EXPECT_STREQ("PCMU", send_codec_spec.codec_inst.plname); |
1945 EXPECT_EQ(1, send_codec_spec.codec_inst.channels); | 1976 EXPECT_EQ(1, send_codec_spec.codec_inst.channels); |
1946 EXPECT_EQ(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq); | 1977 EXPECT_EQ(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq); |
1947 EXPECT_EQ(13, send_codec_spec.cng_payload_type); | 1978 EXPECT_EQ(13, send_codec_spec.cng_payload_type); |
1948 EXPECT_EQ(webrtc::kFreq8000Hz, send_codec_spec.cng_plfreq); | 1979 EXPECT_EQ(webrtc::kFreq8000Hz, send_codec_spec.cng_plfreq); |
1949 } | 1980 } |
1950 // Set ISAC(16K) and CN(8K). VAD should not be activated. | 1981 // Set ISAC(16K) and CN(8K). VAD should not be activated. |
1951 parameters.codecs[0] = kIsacCodec; | 1982 parameters.codecs[0] = kIsacCodec; |
1952 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1983 SetSendParameters(parameters); |
1953 { | 1984 { |
1954 const auto& send_codec_spec = GetSendStreamConfig(kSsrc1).send_codec_spec; | 1985 const auto& send_codec_spec = GetSendStreamConfig(kSsrc1).send_codec_spec; |
1955 EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname); | 1986 EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname); |
1956 EXPECT_NE(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq); | 1987 EXPECT_NE(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq); |
1957 } | 1988 } |
1958 } | 1989 } |
1959 | 1990 |
1960 // Test that we perform case-insensitive matching of codec names. | 1991 // Test that we perform case-insensitive matching of codec names. |
1961 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCaseInsensitive) { | 1992 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCaseInsensitive) { |
1962 EXPECT_TRUE(SetupSendStream()); | 1993 EXPECT_TRUE(SetupSendStream()); |
1963 cricket::AudioSendParameters parameters; | 1994 cricket::AudioSendParameters parameters; |
1964 parameters.codecs.push_back(kIsacCodec); | 1995 parameters.codecs.push_back(kIsacCodec); |
1965 parameters.codecs.push_back(kPcmuCodec); | 1996 parameters.codecs.push_back(kPcmuCodec); |
1966 parameters.codecs.push_back(kCn16000Codec); | 1997 parameters.codecs.push_back(kCn16000Codec); |
1967 parameters.codecs.push_back(kCn8000Codec); | 1998 parameters.codecs.push_back(kCn8000Codec); |
1968 parameters.codecs.push_back(kTelephoneEventCodec); | 1999 parameters.codecs.push_back(kTelephoneEventCodec); |
1969 parameters.codecs[0].name = "iSaC"; | 2000 parameters.codecs[0].name = "iSaC"; |
1970 parameters.codecs[0].id = 96; | 2001 parameters.codecs[0].id = 96; |
1971 parameters.codecs[2].id = 97; // wideband CN | 2002 parameters.codecs[2].id = 97; // wideband CN |
1972 parameters.codecs[4].id = 98; // DTMF | 2003 parameters.codecs[4].id = 98; // DTMF |
1973 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 2004 SetSendParameters(parameters); |
1974 const auto& send_codec_spec = GetSendStreamConfig(kSsrc1).send_codec_spec; | 2005 const auto& send_codec_spec = GetSendStreamConfig(kSsrc1).send_codec_spec; |
1975 EXPECT_EQ(96, send_codec_spec.codec_inst.pltype); | 2006 EXPECT_EQ(96, send_codec_spec.codec_inst.pltype); |
1976 EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname); | 2007 EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname); |
1977 EXPECT_EQ(1, send_codec_spec.codec_inst.channels); | 2008 EXPECT_EQ(1, send_codec_spec.codec_inst.channels); |
1978 EXPECT_EQ(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq); | 2009 EXPECT_EQ(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq); |
1979 EXPECT_EQ(97, send_codec_spec.cng_payload_type); | 2010 EXPECT_EQ(97, send_codec_spec.cng_payload_type); |
1980 EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq); | 2011 EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq); |
1981 EXPECT_TRUE(channel_->CanInsertDtmf()); | 2012 EXPECT_TRUE(channel_->CanInsertDtmf()); |
1982 } | 2013 } |
1983 | 2014 |
(...skipping 29 matching lines...) Expand all Loading... |
2013 TEST_F(WebRtcVoiceEngineTestFake, SendAbsoluteSendTimeHeaderExtensions) { | 2044 TEST_F(WebRtcVoiceEngineTestFake, SendAbsoluteSendTimeHeaderExtensions) { |
2014 TestSetSendRtpHeaderExtensions(webrtc::RtpExtension::kAbsSendTimeUri); | 2045 TestSetSendRtpHeaderExtensions(webrtc::RtpExtension::kAbsSendTimeUri); |
2015 } | 2046 } |
2016 TEST_F(WebRtcVoiceEngineTestFake, RecvAbsoluteSendTimeHeaderExtensions) { | 2047 TEST_F(WebRtcVoiceEngineTestFake, RecvAbsoluteSendTimeHeaderExtensions) { |
2017 TestSetRecvRtpHeaderExtensions(webrtc::RtpExtension::kAbsSendTimeUri); | 2048 TestSetRecvRtpHeaderExtensions(webrtc::RtpExtension::kAbsSendTimeUri); |
2018 } | 2049 } |
2019 | 2050 |
2020 // Test that we can create a channel and start sending on it. | 2051 // Test that we can create a channel and start sending on it. |
2021 TEST_F(WebRtcVoiceEngineTestFake, Send) { | 2052 TEST_F(WebRtcVoiceEngineTestFake, Send) { |
2022 EXPECT_TRUE(SetupSendStream()); | 2053 EXPECT_TRUE(SetupSendStream()); |
2023 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); | 2054 SetSendParameters(send_parameters_); |
2024 SetSend(channel_, true); | 2055 SetSend(true); |
2025 EXPECT_TRUE(GetSendStream(kSsrc1).IsSending()); | 2056 EXPECT_TRUE(GetSendStream(kSsrc1).IsSending()); |
2026 SetSend(channel_, false); | 2057 SetSend(false); |
2027 EXPECT_FALSE(GetSendStream(kSsrc1).IsSending()); | 2058 EXPECT_FALSE(GetSendStream(kSsrc1).IsSending()); |
2028 } | 2059 } |
2029 | 2060 |
2030 // Test that a channel will send if and only if it has a source and is enabled | 2061 // Test that a channel will send if and only if it has a source and is enabled |
2031 // for sending. | 2062 // for sending. |
2032 TEST_F(WebRtcVoiceEngineTestFake, SendStateWithAndWithoutSource) { | 2063 TEST_F(WebRtcVoiceEngineTestFake, SendStateWithAndWithoutSource) { |
2033 EXPECT_TRUE(SetupSendStream()); | 2064 EXPECT_TRUE(SetupSendStream()); |
2034 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); | 2065 SetSendParameters(send_parameters_); |
2035 EXPECT_TRUE(channel_->SetAudioSend(kSsrc1, true, nullptr, nullptr)); | 2066 SetAudioSend(kSsrc1, true, nullptr); |
2036 SetSend(channel_, true); | 2067 SetSend(true); |
2037 EXPECT_FALSE(GetSendStream(kSsrc1).IsSending()); | 2068 EXPECT_FALSE(GetSendStream(kSsrc1).IsSending()); |
2038 EXPECT_TRUE(channel_->SetAudioSend(kSsrc1, true, nullptr, &fake_source_)); | 2069 SetAudioSend(kSsrc1, true, &fake_source_); |
2039 EXPECT_TRUE(GetSendStream(kSsrc1).IsSending()); | 2070 EXPECT_TRUE(GetSendStream(kSsrc1).IsSending()); |
2040 EXPECT_TRUE(channel_->SetAudioSend(kSsrc1, true, nullptr, nullptr)); | 2071 SetAudioSend(kSsrc1, true, nullptr); |
2041 EXPECT_FALSE(GetSendStream(kSsrc1).IsSending()); | 2072 EXPECT_FALSE(GetSendStream(kSsrc1).IsSending()); |
2042 } | 2073 } |
2043 | 2074 |
2044 // Test that a channel is muted/unmuted. | 2075 // Test that a channel is muted/unmuted. |
2045 TEST_F(WebRtcVoiceEngineTestFake, SendStateMuteUnmute) { | 2076 TEST_F(WebRtcVoiceEngineTestFake, SendStateMuteUnmute) { |
2046 EXPECT_TRUE(SetupSendStream()); | 2077 EXPECT_TRUE(SetupSendStream()); |
2047 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); | 2078 SetSendParameters(send_parameters_); |
2048 EXPECT_FALSE(GetSendStream(kSsrc1).muted()); | 2079 EXPECT_FALSE(GetSendStream(kSsrc1).muted()); |
2049 EXPECT_TRUE(channel_->SetAudioSend(kSsrc1, true, nullptr, nullptr)); | 2080 SetAudioSend(kSsrc1, true, nullptr); |
2050 EXPECT_FALSE(GetSendStream(kSsrc1).muted()); | 2081 EXPECT_FALSE(GetSendStream(kSsrc1).muted()); |
2051 EXPECT_TRUE(channel_->SetAudioSend(kSsrc1, false, nullptr, nullptr)); | 2082 SetAudioSend(kSsrc1, false, nullptr); |
2052 EXPECT_TRUE(GetSendStream(kSsrc1).muted()); | 2083 EXPECT_TRUE(GetSendStream(kSsrc1).muted()); |
2053 } | 2084 } |
2054 | 2085 |
2055 // Test that SetSendParameters() does not alter a stream's send state. | 2086 // Test that SetSendParameters() does not alter a stream's send state. |
2056 TEST_F(WebRtcVoiceEngineTestFake, SendStateWhenStreamsAreRecreated) { | 2087 TEST_F(WebRtcVoiceEngineTestFake, SendStateWhenStreamsAreRecreated) { |
2057 EXPECT_TRUE(SetupSendStream()); | 2088 EXPECT_TRUE(SetupSendStream()); |
2058 EXPECT_FALSE(GetSendStream(kSsrc1).IsSending()); | 2089 EXPECT_FALSE(GetSendStream(kSsrc1).IsSending()); |
2059 | 2090 |
2060 // Turn on sending. | 2091 // Turn on sending. |
2061 SetSend(channel_, true); | 2092 SetSend(true); |
2062 EXPECT_TRUE(GetSendStream(kSsrc1).IsSending()); | 2093 EXPECT_TRUE(GetSendStream(kSsrc1).IsSending()); |
2063 | 2094 |
2064 // Changing RTP header extensions will recreate the AudioSendStream. | 2095 // Changing RTP header extensions will recreate the AudioSendStream. |
2065 send_parameters_.extensions.push_back( | 2096 send_parameters_.extensions.push_back( |
2066 webrtc::RtpExtension(webrtc::RtpExtension::kAudioLevelUri, 12)); | 2097 webrtc::RtpExtension(webrtc::RtpExtension::kAudioLevelUri, 12)); |
2067 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); | 2098 SetSendParameters(send_parameters_); |
2068 EXPECT_TRUE(GetSendStream(kSsrc1).IsSending()); | 2099 EXPECT_TRUE(GetSendStream(kSsrc1).IsSending()); |
2069 | 2100 |
2070 // Turn off sending. | 2101 // Turn off sending. |
2071 SetSend(channel_, false); | 2102 SetSend(false); |
2072 EXPECT_FALSE(GetSendStream(kSsrc1).IsSending()); | 2103 EXPECT_FALSE(GetSendStream(kSsrc1).IsSending()); |
2073 | 2104 |
2074 // Changing RTP header extensions will recreate the AudioSendStream. | 2105 // Changing RTP header extensions will recreate the AudioSendStream. |
2075 send_parameters_.extensions.clear(); | 2106 send_parameters_.extensions.clear(); |
2076 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); | 2107 SetSendParameters(send_parameters_); |
2077 EXPECT_FALSE(GetSendStream(kSsrc1).IsSending()); | 2108 EXPECT_FALSE(GetSendStream(kSsrc1).IsSending()); |
2078 } | 2109 } |
2079 | 2110 |
2080 // Test that we can create a channel and start playing out on it. | 2111 // Test that we can create a channel and start playing out on it. |
2081 TEST_F(WebRtcVoiceEngineTestFake, Playout) { | 2112 TEST_F(WebRtcVoiceEngineTestFake, Playout) { |
2082 EXPECT_TRUE(SetupRecvStream()); | 2113 EXPECT_TRUE(SetupRecvStream()); |
2083 EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_)); | 2114 EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_)); |
2084 channel_->SetPlayout(true); | 2115 channel_->SetPlayout(true); |
2085 EXPECT_TRUE(GetRecvStream(kSsrc1).started()); | 2116 EXPECT_TRUE(GetRecvStream(kSsrc1).started()); |
2086 channel_->SetPlayout(false); | 2117 channel_->SetPlayout(false); |
2087 EXPECT_FALSE(GetRecvStream(kSsrc1).started()); | 2118 EXPECT_FALSE(GetRecvStream(kSsrc1).started()); |
2088 } | 2119 } |
2089 | 2120 |
2090 // Test that we can add and remove send streams. | 2121 // Test that we can add and remove send streams. |
2091 TEST_F(WebRtcVoiceEngineTestFake, CreateAndDeleteMultipleSendStreams) { | 2122 TEST_F(WebRtcVoiceEngineTestFake, CreateAndDeleteMultipleSendStreams) { |
2092 SetupForMultiSendStream(); | 2123 SetupForMultiSendStream(); |
2093 | 2124 |
2094 // Set the global state for sending. | 2125 // Set the global state for sending. |
2095 SetSend(channel_, true); | 2126 SetSend(true); |
2096 | 2127 |
2097 for (uint32_t ssrc : kSsrcs4) { | 2128 for (uint32_t ssrc : kSsrcs4) { |
2098 EXPECT_TRUE(channel_->AddSendStream( | 2129 EXPECT_TRUE(channel_->AddSendStream( |
2099 cricket::StreamParams::CreateLegacy(ssrc))); | 2130 cricket::StreamParams::CreateLegacy(ssrc))); |
2100 EXPECT_TRUE(channel_->SetAudioSend(ssrc, true, nullptr, &fake_source_)); | 2131 SetAudioSend(ssrc, true, &fake_source_); |
2101 // Verify that we are in a sending state for all the created streams. | 2132 // Verify that we are in a sending state for all the created streams. |
2102 EXPECT_TRUE(GetSendStream(ssrc).IsSending()); | 2133 EXPECT_TRUE(GetSendStream(ssrc).IsSending()); |
2103 } | 2134 } |
2104 EXPECT_EQ(arraysize(kSsrcs4), call_.GetAudioSendStreams().size()); | 2135 EXPECT_EQ(arraysize(kSsrcs4), call_.GetAudioSendStreams().size()); |
2105 | 2136 |
2106 // Delete the send streams. | 2137 // Delete the send streams. |
2107 for (uint32_t ssrc : kSsrcs4) { | 2138 for (uint32_t ssrc : kSsrcs4) { |
2108 EXPECT_TRUE(channel_->RemoveSendStream(ssrc)); | 2139 EXPECT_TRUE(channel_->RemoveSendStream(ssrc)); |
2109 EXPECT_FALSE(call_.GetAudioSendStream(ssrc)); | 2140 EXPECT_FALSE(call_.GetAudioSendStream(ssrc)); |
2110 EXPECT_FALSE(channel_->RemoveSendStream(ssrc)); | 2141 EXPECT_FALSE(channel_->RemoveSendStream(ssrc)); |
2111 } | 2142 } |
2112 EXPECT_EQ(0u, call_.GetAudioSendStreams().size()); | 2143 EXPECT_EQ(0u, call_.GetAudioSendStreams().size()); |
2113 } | 2144 } |
2114 | 2145 |
2115 // Test SetSendCodecs correctly configure the codecs in all send streams. | 2146 // Test SetSendCodecs correctly configure the codecs in all send streams. |
2116 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsWithMultipleSendStreams) { | 2147 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsWithMultipleSendStreams) { |
2117 SetupForMultiSendStream(); | 2148 SetupForMultiSendStream(); |
2118 | 2149 |
2119 // Create send streams. | 2150 // Create send streams. |
2120 for (uint32_t ssrc : kSsrcs4) { | 2151 for (uint32_t ssrc : kSsrcs4) { |
2121 EXPECT_TRUE(channel_->AddSendStream( | 2152 EXPECT_TRUE(channel_->AddSendStream( |
2122 cricket::StreamParams::CreateLegacy(ssrc))); | 2153 cricket::StreamParams::CreateLegacy(ssrc))); |
2123 } | 2154 } |
2124 | 2155 |
2125 cricket::AudioSendParameters parameters; | 2156 cricket::AudioSendParameters parameters; |
2126 // Set ISAC(16K) and CN(16K). VAD should be activated. | 2157 // Set ISAC(16K) and CN(16K). VAD should be activated. |
2127 parameters.codecs.push_back(kIsacCodec); | 2158 parameters.codecs.push_back(kIsacCodec); |
2128 parameters.codecs.push_back(kCn16000Codec); | 2159 parameters.codecs.push_back(kCn16000Codec); |
2129 parameters.codecs[1].id = 97; | 2160 parameters.codecs[1].id = 97; |
2130 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 2161 SetSendParameters(parameters); |
2131 | 2162 |
2132 // Verify ISAC and VAD are corrected configured on all send channels. | 2163 // Verify ISAC and VAD are corrected configured on all send channels. |
2133 for (uint32_t ssrc : kSsrcs4) { | 2164 for (uint32_t ssrc : kSsrcs4) { |
2134 ASSERT_TRUE(call_.GetAudioSendStream(ssrc) != nullptr); | 2165 ASSERT_TRUE(call_.GetAudioSendStream(ssrc) != nullptr); |
2135 const auto& send_codec_spec = | 2166 const auto& send_codec_spec = |
2136 call_.GetAudioSendStream(ssrc)->GetConfig().send_codec_spec; | 2167 call_.GetAudioSendStream(ssrc)->GetConfig().send_codec_spec; |
2137 EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname); | 2168 EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname); |
2138 EXPECT_EQ(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq); | 2169 EXPECT_EQ(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq); |
2139 EXPECT_EQ(1, send_codec_spec.codec_inst.channels); | 2170 EXPECT_EQ(1, send_codec_spec.codec_inst.channels); |
2140 EXPECT_EQ(97, send_codec_spec.cng_payload_type); | 2171 EXPECT_EQ(97, send_codec_spec.cng_payload_type); |
2141 EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq); | 2172 EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq); |
2142 } | 2173 } |
2143 | 2174 |
2144 // Change to PCMU(8K) and CN(16K). | 2175 // Change to PCMU(8K) and CN(16K). |
2145 parameters.codecs[0] = kPcmuCodec; | 2176 parameters.codecs[0] = kPcmuCodec; |
2146 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 2177 SetSendParameters(parameters); |
2147 for (uint32_t ssrc : kSsrcs4) { | 2178 for (uint32_t ssrc : kSsrcs4) { |
2148 ASSERT_TRUE(call_.GetAudioSendStream(ssrc) != nullptr); | 2179 ASSERT_TRUE(call_.GetAudioSendStream(ssrc) != nullptr); |
2149 const auto& send_codec_spec = | 2180 const auto& send_codec_spec = |
2150 call_.GetAudioSendStream(ssrc)->GetConfig().send_codec_spec; | 2181 call_.GetAudioSendStream(ssrc)->GetConfig().send_codec_spec; |
2151 EXPECT_STREQ("PCMU", send_codec_spec.codec_inst.plname); | 2182 EXPECT_STREQ("PCMU", send_codec_spec.codec_inst.plname); |
2152 EXPECT_NE(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq); | 2183 EXPECT_NE(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq); |
2153 EXPECT_EQ(97, send_codec_spec.cng_payload_type); | 2184 EXPECT_EQ(97, send_codec_spec.cng_payload_type); |
2154 EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq); | 2185 EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq); |
2155 } | 2186 } |
2156 } | 2187 } |
2157 | 2188 |
2158 // Test we can SetSend on all send streams correctly. | 2189 // Test we can SetSend on all send streams correctly. |
2159 TEST_F(WebRtcVoiceEngineTestFake, SetSendWithMultipleSendStreams) { | 2190 TEST_F(WebRtcVoiceEngineTestFake, SetSendWithMultipleSendStreams) { |
2160 SetupForMultiSendStream(); | 2191 SetupForMultiSendStream(); |
2161 | 2192 |
2162 // Create the send channels and they should be a "not sending" date. | 2193 // Create the send channels and they should be a "not sending" date. |
2163 for (uint32_t ssrc : kSsrcs4) { | 2194 for (uint32_t ssrc : kSsrcs4) { |
2164 EXPECT_TRUE(channel_->AddSendStream( | 2195 EXPECT_TRUE(channel_->AddSendStream( |
2165 cricket::StreamParams::CreateLegacy(ssrc))); | 2196 cricket::StreamParams::CreateLegacy(ssrc))); |
2166 EXPECT_TRUE(channel_->SetAudioSend(ssrc, true, nullptr, &fake_source_)); | 2197 SetAudioSend(ssrc, true, &fake_source_); |
2167 EXPECT_FALSE(GetSendStream(ssrc).IsSending()); | 2198 EXPECT_FALSE(GetSendStream(ssrc).IsSending()); |
2168 } | 2199 } |
2169 | 2200 |
2170 // Set the global state for starting sending. | 2201 // Set the global state for starting sending. |
2171 SetSend(channel_, true); | 2202 SetSend(true); |
2172 for (uint32_t ssrc : kSsrcs4) { | 2203 for (uint32_t ssrc : kSsrcs4) { |
2173 // Verify that we are in a sending state for all the send streams. | 2204 // Verify that we are in a sending state for all the send streams. |
2174 EXPECT_TRUE(GetSendStream(ssrc).IsSending()); | 2205 EXPECT_TRUE(GetSendStream(ssrc).IsSending()); |
2175 } | 2206 } |
2176 | 2207 |
2177 // Set the global state for stopping sending. | 2208 // Set the global state for stopping sending. |
2178 SetSend(channel_, false); | 2209 SetSend(false); |
2179 for (uint32_t ssrc : kSsrcs4) { | 2210 for (uint32_t ssrc : kSsrcs4) { |
2180 // Verify that we are in a stop state for all the send streams. | 2211 // Verify that we are in a stop state for all the send streams. |
2181 EXPECT_FALSE(GetSendStream(ssrc).IsSending()); | 2212 EXPECT_FALSE(GetSendStream(ssrc).IsSending()); |
2182 } | 2213 } |
2183 } | 2214 } |
2184 | 2215 |
2185 // Test we can set the correct statistics on all send streams. | 2216 // Test we can set the correct statistics on all send streams. |
2186 TEST_F(WebRtcVoiceEngineTestFake, GetStatsWithMultipleSendStreams) { | 2217 TEST_F(WebRtcVoiceEngineTestFake, GetStatsWithMultipleSendStreams) { |
2187 SetupForMultiSendStream(); | 2218 SetupForMultiSendStream(); |
2188 | 2219 |
2189 // Create send streams. | 2220 // Create send streams. |
2190 for (uint32_t ssrc : kSsrcs4) { | 2221 for (uint32_t ssrc : kSsrcs4) { |
2191 EXPECT_TRUE(channel_->AddSendStream( | 2222 EXPECT_TRUE(channel_->AddSendStream( |
2192 cricket::StreamParams::CreateLegacy(ssrc))); | 2223 cricket::StreamParams::CreateLegacy(ssrc))); |
2193 } | 2224 } |
2194 | 2225 |
2195 // Create a receive stream to check that none of the send streams end up in | 2226 // Create a receive stream to check that none of the send streams end up in |
2196 // the receive stream stats. | 2227 // the receive stream stats. |
2197 EXPECT_TRUE(AddRecvStream(kSsrc2)); | 2228 EXPECT_TRUE(AddRecvStream(kSsrc2)); |
2198 | 2229 |
2199 // We need send codec to be set to get all stats. | 2230 // We need send codec to be set to get all stats. |
2200 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); | 2231 SetSendParameters(send_parameters_); |
2201 EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_)); | 2232 EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_)); |
2202 SetAudioSendStreamStats(); | 2233 SetAudioSendStreamStats(); |
2203 | 2234 |
2204 // Check stats for the added streams. | 2235 // Check stats for the added streams. |
2205 { | 2236 { |
2206 cricket::VoiceMediaInfo info; | 2237 cricket::VoiceMediaInfo info; |
2207 EXPECT_EQ(true, channel_->GetStats(&info)); | 2238 EXPECT_EQ(true, channel_->GetStats(&info)); |
2208 | 2239 |
2209 // We have added 4 send streams. We should see empty stats for all. | 2240 // We have added 4 send streams. We should see empty stats for all. |
2210 EXPECT_EQ(static_cast<size_t>(arraysize(kSsrcs4)), info.senders.size()); | 2241 EXPECT_EQ(static_cast<size_t>(arraysize(kSsrcs4)), info.senders.size()); |
(...skipping 27 matching lines...) Expand all Loading... |
2238 VerifyVoiceReceiverInfo(info.receivers[0]); | 2269 VerifyVoiceReceiverInfo(info.receivers[0]); |
2239 } | 2270 } |
2240 } | 2271 } |
2241 | 2272 |
2242 // Test that we can add and remove receive streams, and do proper send/playout. | 2273 // Test that we can add and remove receive streams, and do proper send/playout. |
2243 // We can receive on multiple streams while sending one stream. | 2274 // We can receive on multiple streams while sending one stream. |
2244 TEST_F(WebRtcVoiceEngineTestFake, PlayoutWithMultipleStreams) { | 2275 TEST_F(WebRtcVoiceEngineTestFake, PlayoutWithMultipleStreams) { |
2245 EXPECT_TRUE(SetupSendStream()); | 2276 EXPECT_TRUE(SetupSendStream()); |
2246 | 2277 |
2247 // Start playout without a receive stream. | 2278 // Start playout without a receive stream. |
2248 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); | 2279 SetSendParameters(send_parameters_); |
2249 channel_->SetPlayout(true); | 2280 channel_->SetPlayout(true); |
2250 | 2281 |
2251 // Adding another stream should enable playout on the new stream only. | 2282 // Adding another stream should enable playout on the new stream only. |
2252 EXPECT_TRUE(AddRecvStream(kSsrc2)); | 2283 EXPECT_TRUE(AddRecvStream(kSsrc2)); |
2253 SetSend(channel_, true); | 2284 SetSend(true); |
2254 EXPECT_TRUE(GetSendStream(kSsrc1).IsSending()); | 2285 EXPECT_TRUE(GetSendStream(kSsrc1).IsSending()); |
2255 | 2286 |
2256 // Make sure only the new stream is played out. | 2287 // Make sure only the new stream is played out. |
2257 EXPECT_TRUE(GetRecvStream(kSsrc2).started()); | 2288 EXPECT_TRUE(GetRecvStream(kSsrc2).started()); |
2258 | 2289 |
2259 // Adding yet another stream should have stream 2 and 3 enabled for playout. | 2290 // Adding yet another stream should have stream 2 and 3 enabled for playout. |
2260 EXPECT_TRUE(AddRecvStream(kSsrc3)); | 2291 EXPECT_TRUE(AddRecvStream(kSsrc3)); |
2261 EXPECT_TRUE(GetRecvStream(kSsrc2).started()); | 2292 EXPECT_TRUE(GetRecvStream(kSsrc2).started()); |
2262 EXPECT_TRUE(GetRecvStream(kSsrc3).started()); | 2293 EXPECT_TRUE(GetRecvStream(kSsrc3).started()); |
2263 | 2294 |
2264 // Stop sending. | 2295 // Stop sending. |
2265 SetSend(channel_, false); | 2296 SetSend(false); |
2266 EXPECT_FALSE(GetSendStream(kSsrc1).IsSending()); | 2297 EXPECT_FALSE(GetSendStream(kSsrc1).IsSending()); |
2267 | 2298 |
2268 // Stop playout. | 2299 // Stop playout. |
2269 channel_->SetPlayout(false); | 2300 channel_->SetPlayout(false); |
2270 EXPECT_FALSE(GetRecvStream(kSsrc2).started()); | 2301 EXPECT_FALSE(GetRecvStream(kSsrc2).started()); |
2271 EXPECT_FALSE(GetRecvStream(kSsrc3).started()); | 2302 EXPECT_FALSE(GetRecvStream(kSsrc3).started()); |
2272 | 2303 |
2273 // Restart playout and make sure recv streams are played out. | 2304 // Restart playout and make sure recv streams are played out. |
2274 channel_->SetPlayout(true); | 2305 channel_->SetPlayout(true); |
2275 EXPECT_TRUE(GetRecvStream(kSsrc2).started()); | 2306 EXPECT_TRUE(GetRecvStream(kSsrc2).started()); |
2276 EXPECT_TRUE(GetRecvStream(kSsrc3).started()); | 2307 EXPECT_TRUE(GetRecvStream(kSsrc3).started()); |
2277 | 2308 |
2278 // Now remove the recv streams. | 2309 // Now remove the recv streams. |
2279 EXPECT_TRUE(channel_->RemoveRecvStream(3)); | 2310 EXPECT_TRUE(channel_->RemoveRecvStream(3)); |
2280 EXPECT_TRUE(channel_->RemoveRecvStream(2)); | 2311 EXPECT_TRUE(channel_->RemoveRecvStream(2)); |
2281 } | 2312 } |
2282 | 2313 |
2283 // Test that we can create a channel configured for Codian bridges, | 2314 // Test that we can create a channel configured for Codian bridges, |
2284 // and start sending on it. | 2315 // and start sending on it. |
2285 TEST_F(WebRtcVoiceEngineTestFake, CodianSend) { | 2316 TEST_F(WebRtcVoiceEngineTestFake, CodianSend) { |
2286 EXPECT_TRUE(SetupSendStream()); | 2317 EXPECT_TRUE(SetupSendStream()); |
2287 cricket::AudioOptions options_adjust_agc; | 2318 cricket::AudioOptions options_adjust_agc; |
2288 options_adjust_agc.adjust_agc_delta = rtc::Optional<int>(-10); | 2319 options_adjust_agc.adjust_agc_delta = rtc::Optional<int>(-10); |
2289 webrtc::AgcConfig agc_config; | 2320 webrtc::AgcConfig agc_config; |
2290 EXPECT_EQ(0, voe_.GetAgcConfig(agc_config)); | 2321 EXPECT_EQ(0, voe_.GetAgcConfig(agc_config)); |
2291 EXPECT_EQ(0, agc_config.targetLeveldBOv); | 2322 EXPECT_EQ(0, agc_config.targetLeveldBOv); |
2292 send_parameters_.options = options_adjust_agc; | 2323 send_parameters_.options = options_adjust_agc; |
2293 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); | 2324 SetSendParameters(send_parameters_); |
2294 SetSend(channel_, true); | 2325 SetSend(true); |
2295 EXPECT_TRUE(GetSendStream(kSsrc1).IsSending()); | 2326 EXPECT_TRUE(GetSendStream(kSsrc1).IsSending()); |
2296 EXPECT_EQ(0, voe_.GetAgcConfig(agc_config)); | 2327 EXPECT_EQ(0, voe_.GetAgcConfig(agc_config)); |
2297 EXPECT_EQ(agc_config.targetLeveldBOv, 10); // level was attenuated | 2328 EXPECT_EQ(agc_config.targetLeveldBOv, 10); // level was attenuated |
2298 SetSend(channel_, false); | 2329 SetSend(false); |
2299 EXPECT_FALSE(GetSendStream(kSsrc1).IsSending()); | 2330 EXPECT_FALSE(GetSendStream(kSsrc1).IsSending()); |
2300 EXPECT_EQ(0, voe_.GetAgcConfig(agc_config)); | 2331 EXPECT_EQ(0, voe_.GetAgcConfig(agc_config)); |
2301 } | 2332 } |
2302 | 2333 |
2303 TEST_F(WebRtcVoiceEngineTestFake, TxAgcConfigViaOptions) { | 2334 TEST_F(WebRtcVoiceEngineTestFake, TxAgcConfigViaOptions) { |
2304 EXPECT_TRUE(SetupSendStream()); | 2335 EXPECT_TRUE(SetupSendStream()); |
2305 EXPECT_CALL(adm_, | 2336 EXPECT_CALL(adm_, |
2306 BuiltInAGCIsAvailable()).Times(2).WillRepeatedly(Return(false)); | 2337 BuiltInAGCIsAvailable()).Times(2).WillRepeatedly(Return(false)); |
2307 webrtc::AgcConfig agc_config; | 2338 webrtc::AgcConfig agc_config; |
2308 EXPECT_EQ(0, voe_.GetAgcConfig(agc_config)); | 2339 EXPECT_EQ(0, voe_.GetAgcConfig(agc_config)); |
2309 EXPECT_EQ(0, agc_config.targetLeveldBOv); | 2340 EXPECT_EQ(0, agc_config.targetLeveldBOv); |
2310 send_parameters_.options.tx_agc_target_dbov = rtc::Optional<uint16_t>(3); | 2341 send_parameters_.options.tx_agc_target_dbov = rtc::Optional<uint16_t>(3); |
2311 send_parameters_.options.tx_agc_digital_compression_gain = | 2342 send_parameters_.options.tx_agc_digital_compression_gain = |
2312 rtc::Optional<uint16_t>(9); | 2343 rtc::Optional<uint16_t>(9); |
2313 send_parameters_.options.tx_agc_limiter = rtc::Optional<bool>(true); | 2344 send_parameters_.options.tx_agc_limiter = rtc::Optional<bool>(true); |
2314 send_parameters_.options.auto_gain_control = rtc::Optional<bool>(true); | 2345 send_parameters_.options.auto_gain_control = rtc::Optional<bool>(true); |
2315 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); | 2346 SetSendParameters(send_parameters_); |
2316 EXPECT_EQ(0, voe_.GetAgcConfig(agc_config)); | 2347 EXPECT_EQ(0, voe_.GetAgcConfig(agc_config)); |
2317 EXPECT_EQ(3, agc_config.targetLeveldBOv); | 2348 EXPECT_EQ(3, agc_config.targetLeveldBOv); |
2318 EXPECT_EQ(9, agc_config.digitalCompressionGaindB); | 2349 EXPECT_EQ(9, agc_config.digitalCompressionGaindB); |
2319 EXPECT_TRUE(agc_config.limiterEnable); | 2350 EXPECT_TRUE(agc_config.limiterEnable); |
2320 | 2351 |
2321 // Check interaction with adjust_agc_delta. Both should be respected, for | 2352 // Check interaction with adjust_agc_delta. Both should be respected, for |
2322 // backwards compatibility. | 2353 // backwards compatibility. |
2323 send_parameters_.options.adjust_agc_delta = rtc::Optional<int>(-10); | 2354 send_parameters_.options.adjust_agc_delta = rtc::Optional<int>(-10); |
2324 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); | 2355 SetSendParameters(send_parameters_); |
2325 EXPECT_EQ(0, voe_.GetAgcConfig(agc_config)); | 2356 EXPECT_EQ(0, voe_.GetAgcConfig(agc_config)); |
2326 EXPECT_EQ(13, agc_config.targetLeveldBOv); | 2357 EXPECT_EQ(13, agc_config.targetLeveldBOv); |
2327 } | 2358 } |
2328 | 2359 |
2329 TEST_F(WebRtcVoiceEngineTestFake, SampleRatesViaOptions) { | 2360 TEST_F(WebRtcVoiceEngineTestFake, SampleRatesViaOptions) { |
2330 EXPECT_TRUE(SetupSendStream()); | 2361 EXPECT_TRUE(SetupSendStream()); |
2331 EXPECT_CALL(adm_, SetRecordingSampleRate(48000)).WillOnce(Return(0)); | 2362 EXPECT_CALL(adm_, SetRecordingSampleRate(48000)).WillOnce(Return(0)); |
2332 EXPECT_CALL(adm_, SetPlayoutSampleRate(44100)).WillOnce(Return(0)); | 2363 EXPECT_CALL(adm_, SetPlayoutSampleRate(44100)).WillOnce(Return(0)); |
2333 send_parameters_.options.recording_sample_rate = | 2364 send_parameters_.options.recording_sample_rate = |
2334 rtc::Optional<uint32_t>(48000); | 2365 rtc::Optional<uint32_t>(48000); |
2335 send_parameters_.options.playout_sample_rate = rtc::Optional<uint32_t>(44100); | 2366 send_parameters_.options.playout_sample_rate = rtc::Optional<uint32_t>(44100); |
2336 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); | 2367 SetSendParameters(send_parameters_); |
2337 } | 2368 } |
2338 | 2369 |
2339 // Test that we can set the outgoing SSRC properly. | 2370 // Test that we can set the outgoing SSRC properly. |
2340 // SSRC is set in SetupSendStream() by calling AddSendStream. | 2371 // SSRC is set in SetupSendStream() by calling AddSendStream. |
2341 TEST_F(WebRtcVoiceEngineTestFake, SetSendSsrc) { | 2372 TEST_F(WebRtcVoiceEngineTestFake, SetSendSsrc) { |
2342 EXPECT_TRUE(SetupSendStream()); | 2373 EXPECT_TRUE(SetupSendStream()); |
2343 EXPECT_TRUE(call_.GetAudioSendStream(kSsrc1)); | 2374 EXPECT_TRUE(call_.GetAudioSendStream(kSsrc1)); |
2344 } | 2375 } |
2345 | 2376 |
2346 TEST_F(WebRtcVoiceEngineTestFake, GetStats) { | 2377 TEST_F(WebRtcVoiceEngineTestFake, GetStats) { |
2347 // Setup. We need send codec to be set to get all stats. | 2378 // Setup. We need send codec to be set to get all stats. |
2348 EXPECT_TRUE(SetupSendStream()); | 2379 EXPECT_TRUE(SetupSendStream()); |
2349 // SetupSendStream adds a send stream with kSsrc1, so the receive | 2380 // SetupSendStream adds a send stream with kSsrc1, so the receive |
2350 // stream has to use a different SSRC. | 2381 // stream has to use a different SSRC. |
2351 EXPECT_TRUE(AddRecvStream(kSsrc2)); | 2382 EXPECT_TRUE(AddRecvStream(kSsrc2)); |
2352 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); | 2383 SetSendParameters(send_parameters_); |
2353 EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_)); | 2384 EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_)); |
2354 SetAudioSendStreamStats(); | 2385 SetAudioSendStreamStats(); |
2355 | 2386 |
2356 // Check stats for the added streams. | 2387 // Check stats for the added streams. |
2357 { | 2388 { |
2358 cricket::VoiceMediaInfo info; | 2389 cricket::VoiceMediaInfo info; |
2359 EXPECT_EQ(true, channel_->GetStats(&info)); | 2390 EXPECT_EQ(true, channel_->GetStats(&info)); |
2360 | 2391 |
2361 // We have added one send stream. We should see the stats we've set. | 2392 // We have added one send stream. We should see the stats we've set. |
2362 EXPECT_EQ(1u, info.senders.size()); | 2393 EXPECT_EQ(1u, info.senders.size()); |
2363 VerifyVoiceSenderInfo(info.senders[0], false); | 2394 VerifyVoiceSenderInfo(info.senders[0], false); |
2364 // We have added one receive stream. We should see empty stats. | 2395 // We have added one receive stream. We should see empty stats. |
2365 EXPECT_EQ(info.receivers.size(), 1u); | 2396 EXPECT_EQ(info.receivers.size(), 1u); |
2366 EXPECT_EQ(info.receivers[0].ssrc(), 0); | 2397 EXPECT_EQ(info.receivers[0].ssrc(), 0); |
2367 } | 2398 } |
2368 | 2399 |
2369 // Start sending - this affects some reported stats. | 2400 // Start sending - this affects some reported stats. |
2370 { | 2401 { |
2371 cricket::VoiceMediaInfo info; | 2402 cricket::VoiceMediaInfo info; |
2372 SetSend(channel_, true); | 2403 SetSend(true); |
2373 EXPECT_EQ(true, channel_->GetStats(&info)); | 2404 EXPECT_EQ(true, channel_->GetStats(&info)); |
2374 VerifyVoiceSenderInfo(info.senders[0], true); | 2405 VerifyVoiceSenderInfo(info.senders[0], true); |
2375 } | 2406 } |
2376 | 2407 |
2377 // Remove the kSsrc2 stream. No receiver stats. | 2408 // Remove the kSsrc2 stream. No receiver stats. |
2378 { | 2409 { |
2379 cricket::VoiceMediaInfo info; | 2410 cricket::VoiceMediaInfo info; |
2380 EXPECT_TRUE(channel_->RemoveRecvStream(kSsrc2)); | 2411 EXPECT_TRUE(channel_->RemoveRecvStream(kSsrc2)); |
2381 EXPECT_EQ(true, channel_->GetStats(&info)); | 2412 EXPECT_EQ(true, channel_->GetStats(&info)); |
2382 EXPECT_EQ(1u, info.senders.size()); | 2413 EXPECT_EQ(1u, info.senders.size()); |
(...skipping 205 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2588 rtc::strcpyn(gcodec.plname, arraysize(gcodec.plname), "opus"); | 2619 rtc::strcpyn(gcodec.plname, arraysize(gcodec.plname), "opus"); |
2589 gcodec.plfreq = 48000; | 2620 gcodec.plfreq = 48000; |
2590 gcodec.channels = 2; | 2621 gcodec.channels = 2; |
2591 EXPECT_EQ(-1, voe_.GetRecPayloadType(channel_num2, gcodec)); | 2622 EXPECT_EQ(-1, voe_.GetRecPayloadType(channel_num2, gcodec)); |
2592 } | 2623 } |
2593 | 2624 |
2594 // Test that we properly clean up any streams that were added, even if | 2625 // Test that we properly clean up any streams that were added, even if |
2595 // not explicitly removed. | 2626 // not explicitly removed. |
2596 TEST_F(WebRtcVoiceEngineTestFake, StreamCleanup) { | 2627 TEST_F(WebRtcVoiceEngineTestFake, StreamCleanup) { |
2597 EXPECT_TRUE(SetupSendStream()); | 2628 EXPECT_TRUE(SetupSendStream()); |
2598 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); | 2629 SetSendParameters(send_parameters_); |
2599 EXPECT_TRUE(AddRecvStream(1)); | 2630 EXPECT_TRUE(AddRecvStream(1)); |
2600 EXPECT_TRUE(AddRecvStream(2)); | 2631 EXPECT_TRUE(AddRecvStream(2)); |
2601 EXPECT_EQ(3, voe_.GetNumChannels()); // default channel + 2 added | 2632 EXPECT_EQ(3, voe_.GetNumChannels()); // default channel + 2 added |
2602 delete channel_; | 2633 delete channel_; |
2603 channel_ = NULL; | 2634 channel_ = NULL; |
2604 EXPECT_EQ(0, voe_.GetNumChannels()); | 2635 EXPECT_EQ(0, voe_.GetNumChannels()); |
2605 } | 2636 } |
2606 | 2637 |
2607 TEST_F(WebRtcVoiceEngineTestFake, TestAddRecvStreamFailWithZeroSsrc) { | 2638 TEST_F(WebRtcVoiceEngineTestFake, TestAddRecvStreamFailWithZeroSsrc) { |
2608 EXPECT_TRUE(SetupSendStream()); | 2639 EXPECT_TRUE(SetupSendStream()); |
(...skipping 71 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2680 EXPECT_TRUE(highpass_filter_enabled); | 2711 EXPECT_TRUE(highpass_filter_enabled); |
2681 EXPECT_FALSE(stereo_swapping_enabled); | 2712 EXPECT_FALSE(stereo_swapping_enabled); |
2682 EXPECT_TRUE(typing_detection_enabled); | 2713 EXPECT_TRUE(typing_detection_enabled); |
2683 EXPECT_EQ(ec_mode, webrtc::kEcConference); | 2714 EXPECT_EQ(ec_mode, webrtc::kEcConference); |
2684 EXPECT_EQ(ns_mode, webrtc::kNsHighSuppression); | 2715 EXPECT_EQ(ns_mode, webrtc::kNsHighSuppression); |
2685 EXPECT_EQ(50, voe_.GetNetEqCapacity()); | 2716 EXPECT_EQ(50, voe_.GetNetEqCapacity()); |
2686 EXPECT_FALSE(voe_.GetNetEqFastAccelerate()); | 2717 EXPECT_FALSE(voe_.GetNetEqFastAccelerate()); |
2687 | 2718 |
2688 // Nothing set in AudioOptions, so everything should be as default. | 2719 // Nothing set in AudioOptions, so everything should be as default. |
2689 send_parameters_.options = cricket::AudioOptions(); | 2720 send_parameters_.options = cricket::AudioOptions(); |
2690 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); | 2721 SetSendParameters(send_parameters_); |
2691 voe_.GetEcStatus(ec_enabled, ec_mode); | 2722 voe_.GetEcStatus(ec_enabled, ec_mode); |
2692 voe_.GetAecmMode(aecm_mode, cng_enabled); | 2723 voe_.GetAecmMode(aecm_mode, cng_enabled); |
2693 voe_.GetAgcStatus(agc_enabled, agc_mode); | 2724 voe_.GetAgcStatus(agc_enabled, agc_mode); |
2694 voe_.GetAgcConfig(agc_config); | 2725 voe_.GetAgcConfig(agc_config); |
2695 voe_.GetNsStatus(ns_enabled, ns_mode); | 2726 voe_.GetNsStatus(ns_enabled, ns_mode); |
2696 highpass_filter_enabled = voe_.IsHighPassFilterEnabled(); | 2727 highpass_filter_enabled = voe_.IsHighPassFilterEnabled(); |
2697 stereo_swapping_enabled = voe_.IsStereoChannelSwappingEnabled(); | 2728 stereo_swapping_enabled = voe_.IsStereoChannelSwappingEnabled(); |
2698 voe_.GetTypingDetectionStatus(typing_detection_enabled); | 2729 voe_.GetTypingDetectionStatus(typing_detection_enabled); |
2699 EXPECT_TRUE(ec_enabled); | 2730 EXPECT_TRUE(ec_enabled); |
2700 EXPECT_TRUE(voe_.ec_metrics_enabled()); | 2731 EXPECT_TRUE(voe_.ec_metrics_enabled()); |
2701 EXPECT_FALSE(cng_enabled); | 2732 EXPECT_FALSE(cng_enabled); |
2702 EXPECT_TRUE(agc_enabled); | 2733 EXPECT_TRUE(agc_enabled); |
2703 EXPECT_EQ(0, agc_config.targetLeveldBOv); | 2734 EXPECT_EQ(0, agc_config.targetLeveldBOv); |
2704 EXPECT_TRUE(ns_enabled); | 2735 EXPECT_TRUE(ns_enabled); |
2705 EXPECT_TRUE(highpass_filter_enabled); | 2736 EXPECT_TRUE(highpass_filter_enabled); |
2706 EXPECT_FALSE(stereo_swapping_enabled); | 2737 EXPECT_FALSE(stereo_swapping_enabled); |
2707 EXPECT_TRUE(typing_detection_enabled); | 2738 EXPECT_TRUE(typing_detection_enabled); |
2708 EXPECT_EQ(ec_mode, webrtc::kEcConference); | 2739 EXPECT_EQ(ec_mode, webrtc::kEcConference); |
2709 EXPECT_EQ(ns_mode, webrtc::kNsHighSuppression); | 2740 EXPECT_EQ(ns_mode, webrtc::kNsHighSuppression); |
2710 EXPECT_EQ(50, voe_.GetNetEqCapacity()); | 2741 EXPECT_EQ(50, voe_.GetNetEqCapacity()); |
2711 EXPECT_FALSE(voe_.GetNetEqFastAccelerate()); | 2742 EXPECT_FALSE(voe_.GetNetEqFastAccelerate()); |
2712 | 2743 |
2713 // Turn echo cancellation off | 2744 // Turn echo cancellation off |
2714 send_parameters_.options.echo_cancellation = rtc::Optional<bool>(false); | 2745 send_parameters_.options.echo_cancellation = rtc::Optional<bool>(false); |
2715 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); | 2746 SetSendParameters(send_parameters_); |
2716 voe_.GetEcStatus(ec_enabled, ec_mode); | 2747 voe_.GetEcStatus(ec_enabled, ec_mode); |
2717 EXPECT_FALSE(ec_enabled); | 2748 EXPECT_FALSE(ec_enabled); |
2718 | 2749 |
2719 // Turn echo cancellation back on, with settings, and make sure | 2750 // Turn echo cancellation back on, with settings, and make sure |
2720 // nothing else changed. | 2751 // nothing else changed. |
2721 send_parameters_.options.echo_cancellation = rtc::Optional<bool>(true); | 2752 send_parameters_.options.echo_cancellation = rtc::Optional<bool>(true); |
2722 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); | 2753 SetSendParameters(send_parameters_); |
2723 voe_.GetEcStatus(ec_enabled, ec_mode); | 2754 voe_.GetEcStatus(ec_enabled, ec_mode); |
2724 voe_.GetAecmMode(aecm_mode, cng_enabled); | 2755 voe_.GetAecmMode(aecm_mode, cng_enabled); |
2725 voe_.GetAgcStatus(agc_enabled, agc_mode); | 2756 voe_.GetAgcStatus(agc_enabled, agc_mode); |
2726 voe_.GetAgcConfig(agc_config); | 2757 voe_.GetAgcConfig(agc_config); |
2727 voe_.GetNsStatus(ns_enabled, ns_mode); | 2758 voe_.GetNsStatus(ns_enabled, ns_mode); |
2728 highpass_filter_enabled = voe_.IsHighPassFilterEnabled(); | 2759 highpass_filter_enabled = voe_.IsHighPassFilterEnabled(); |
2729 stereo_swapping_enabled = voe_.IsStereoChannelSwappingEnabled(); | 2760 stereo_swapping_enabled = voe_.IsStereoChannelSwappingEnabled(); |
2730 voe_.GetTypingDetectionStatus(typing_detection_enabled); | 2761 voe_.GetTypingDetectionStatus(typing_detection_enabled); |
2731 EXPECT_TRUE(ec_enabled); | 2762 EXPECT_TRUE(ec_enabled); |
2732 EXPECT_TRUE(voe_.ec_metrics_enabled()); | 2763 EXPECT_TRUE(voe_.ec_metrics_enabled()); |
2733 EXPECT_TRUE(agc_enabled); | 2764 EXPECT_TRUE(agc_enabled); |
2734 EXPECT_EQ(0, agc_config.targetLeveldBOv); | 2765 EXPECT_EQ(0, agc_config.targetLeveldBOv); |
2735 EXPECT_TRUE(ns_enabled); | 2766 EXPECT_TRUE(ns_enabled); |
2736 EXPECT_TRUE(highpass_filter_enabled); | 2767 EXPECT_TRUE(highpass_filter_enabled); |
2737 EXPECT_FALSE(stereo_swapping_enabled); | 2768 EXPECT_FALSE(stereo_swapping_enabled); |
2738 EXPECT_TRUE(typing_detection_enabled); | 2769 EXPECT_TRUE(typing_detection_enabled); |
2739 EXPECT_EQ(ec_mode, webrtc::kEcConference); | 2770 EXPECT_EQ(ec_mode, webrtc::kEcConference); |
2740 EXPECT_EQ(ns_mode, webrtc::kNsHighSuppression); | 2771 EXPECT_EQ(ns_mode, webrtc::kNsHighSuppression); |
2741 | 2772 |
2742 // Turn on delay agnostic aec and make sure nothing change w.r.t. echo | 2773 // Turn on delay agnostic aec and make sure nothing change w.r.t. echo |
2743 // control. | 2774 // control. |
2744 send_parameters_.options.delay_agnostic_aec = rtc::Optional<bool>(true); | 2775 send_parameters_.options.delay_agnostic_aec = rtc::Optional<bool>(true); |
2745 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); | 2776 SetSendParameters(send_parameters_); |
2746 voe_.GetEcStatus(ec_enabled, ec_mode); | 2777 voe_.GetEcStatus(ec_enabled, ec_mode); |
2747 voe_.GetAecmMode(aecm_mode, cng_enabled); | 2778 voe_.GetAecmMode(aecm_mode, cng_enabled); |
2748 EXPECT_TRUE(ec_enabled); | 2779 EXPECT_TRUE(ec_enabled); |
2749 EXPECT_TRUE(voe_.ec_metrics_enabled()); | 2780 EXPECT_TRUE(voe_.ec_metrics_enabled()); |
2750 EXPECT_EQ(ec_mode, webrtc::kEcConference); | 2781 EXPECT_EQ(ec_mode, webrtc::kEcConference); |
2751 | 2782 |
2752 // Turn off echo cancellation and delay agnostic aec. | 2783 // Turn off echo cancellation and delay agnostic aec. |
2753 send_parameters_.options.delay_agnostic_aec = rtc::Optional<bool>(false); | 2784 send_parameters_.options.delay_agnostic_aec = rtc::Optional<bool>(false); |
2754 send_parameters_.options.extended_filter_aec = rtc::Optional<bool>(false); | 2785 send_parameters_.options.extended_filter_aec = rtc::Optional<bool>(false); |
2755 send_parameters_.options.echo_cancellation = rtc::Optional<bool>(false); | 2786 send_parameters_.options.echo_cancellation = rtc::Optional<bool>(false); |
2756 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); | 2787 SetSendParameters(send_parameters_); |
2757 voe_.GetEcStatus(ec_enabled, ec_mode); | 2788 voe_.GetEcStatus(ec_enabled, ec_mode); |
2758 EXPECT_FALSE(ec_enabled); | 2789 EXPECT_FALSE(ec_enabled); |
2759 // Turning delay agnostic aec back on should also turn on echo cancellation. | 2790 // Turning delay agnostic aec back on should also turn on echo cancellation. |
2760 send_parameters_.options.delay_agnostic_aec = rtc::Optional<bool>(true); | 2791 send_parameters_.options.delay_agnostic_aec = rtc::Optional<bool>(true); |
2761 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); | 2792 SetSendParameters(send_parameters_); |
2762 voe_.GetEcStatus(ec_enabled, ec_mode); | 2793 voe_.GetEcStatus(ec_enabled, ec_mode); |
2763 EXPECT_TRUE(ec_enabled); | 2794 EXPECT_TRUE(ec_enabled); |
2764 EXPECT_TRUE(voe_.ec_metrics_enabled()); | 2795 EXPECT_TRUE(voe_.ec_metrics_enabled()); |
2765 EXPECT_EQ(ec_mode, webrtc::kEcConference); | 2796 EXPECT_EQ(ec_mode, webrtc::kEcConference); |
2766 | 2797 |
2767 // Turn off AGC | 2798 // Turn off AGC |
2768 send_parameters_.options.auto_gain_control = rtc::Optional<bool>(false); | 2799 send_parameters_.options.auto_gain_control = rtc::Optional<bool>(false); |
2769 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); | 2800 SetSendParameters(send_parameters_); |
2770 voe_.GetAgcStatus(agc_enabled, agc_mode); | 2801 voe_.GetAgcStatus(agc_enabled, agc_mode); |
2771 EXPECT_FALSE(agc_enabled); | 2802 EXPECT_FALSE(agc_enabled); |
2772 | 2803 |
2773 // Turn AGC back on | 2804 // Turn AGC back on |
2774 send_parameters_.options.auto_gain_control = rtc::Optional<bool>(true); | 2805 send_parameters_.options.auto_gain_control = rtc::Optional<bool>(true); |
2775 send_parameters_.options.adjust_agc_delta = rtc::Optional<int>(); | 2806 send_parameters_.options.adjust_agc_delta = rtc::Optional<int>(); |
2776 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); | 2807 SetSendParameters(send_parameters_); |
2777 voe_.GetAgcStatus(agc_enabled, agc_mode); | 2808 voe_.GetAgcStatus(agc_enabled, agc_mode); |
2778 EXPECT_TRUE(agc_enabled); | 2809 EXPECT_TRUE(agc_enabled); |
2779 voe_.GetAgcConfig(agc_config); | 2810 voe_.GetAgcConfig(agc_config); |
2780 EXPECT_EQ(0, agc_config.targetLeveldBOv); | 2811 EXPECT_EQ(0, agc_config.targetLeveldBOv); |
2781 | 2812 |
2782 // Turn off other options (and stereo swapping on). | 2813 // Turn off other options (and stereo swapping on). |
2783 send_parameters_.options.noise_suppression = rtc::Optional<bool>(false); | 2814 send_parameters_.options.noise_suppression = rtc::Optional<bool>(false); |
2784 send_parameters_.options.highpass_filter = rtc::Optional<bool>(false); | 2815 send_parameters_.options.highpass_filter = rtc::Optional<bool>(false); |
2785 send_parameters_.options.typing_detection = rtc::Optional<bool>(false); | 2816 send_parameters_.options.typing_detection = rtc::Optional<bool>(false); |
2786 send_parameters_.options.stereo_swapping = rtc::Optional<bool>(true); | 2817 send_parameters_.options.stereo_swapping = rtc::Optional<bool>(true); |
2787 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); | 2818 SetSendParameters(send_parameters_); |
2788 voe_.GetNsStatus(ns_enabled, ns_mode); | 2819 voe_.GetNsStatus(ns_enabled, ns_mode); |
2789 highpass_filter_enabled = voe_.IsHighPassFilterEnabled(); | 2820 highpass_filter_enabled = voe_.IsHighPassFilterEnabled(); |
2790 stereo_swapping_enabled = voe_.IsStereoChannelSwappingEnabled(); | 2821 stereo_swapping_enabled = voe_.IsStereoChannelSwappingEnabled(); |
2791 voe_.GetTypingDetectionStatus(typing_detection_enabled); | 2822 voe_.GetTypingDetectionStatus(typing_detection_enabled); |
2792 EXPECT_FALSE(ns_enabled); | 2823 EXPECT_FALSE(ns_enabled); |
2793 EXPECT_FALSE(highpass_filter_enabled); | 2824 EXPECT_FALSE(highpass_filter_enabled); |
2794 EXPECT_FALSE(typing_detection_enabled); | 2825 EXPECT_FALSE(typing_detection_enabled); |
2795 EXPECT_TRUE(stereo_swapping_enabled); | 2826 EXPECT_TRUE(stereo_swapping_enabled); |
2796 | 2827 |
2797 // Set options again to ensure it has no impact. | 2828 // Set options again to ensure it has no impact. |
2798 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); | 2829 SetSendParameters(send_parameters_); |
2799 voe_.GetEcStatus(ec_enabled, ec_mode); | 2830 voe_.GetEcStatus(ec_enabled, ec_mode); |
2800 voe_.GetNsStatus(ns_enabled, ns_mode); | 2831 voe_.GetNsStatus(ns_enabled, ns_mode); |
2801 EXPECT_TRUE(ec_enabled); | 2832 EXPECT_TRUE(ec_enabled); |
2802 EXPECT_EQ(webrtc::kEcConference, ec_mode); | 2833 EXPECT_EQ(webrtc::kEcConference, ec_mode); |
2803 EXPECT_FALSE(ns_enabled); | 2834 EXPECT_FALSE(ns_enabled); |
2804 EXPECT_EQ(webrtc::kNsHighSuppression, ns_mode); | 2835 EXPECT_EQ(webrtc::kNsHighSuppression, ns_mode); |
2805 } | 2836 } |
2806 | 2837 |
2807 TEST_F(WebRtcVoiceEngineTestFake, DefaultOptions) { | 2838 TEST_F(WebRtcVoiceEngineTestFake, DefaultOptions) { |
2808 EXPECT_TRUE(SetupSendStream()); | 2839 EXPECT_TRUE(SetupSendStream()); |
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2847 } | 2878 } |
2848 | 2879 |
2849 TEST_F(WebRtcVoiceEngineTestFake, SetOptionOverridesViaChannels) { | 2880 TEST_F(WebRtcVoiceEngineTestFake, SetOptionOverridesViaChannels) { |
2850 EXPECT_TRUE(SetupSendStream()); | 2881 EXPECT_TRUE(SetupSendStream()); |
2851 EXPECT_CALL(adm_, | 2882 EXPECT_CALL(adm_, |
2852 BuiltInAECIsAvailable()).Times(9).WillRepeatedly(Return(false)); | 2883 BuiltInAECIsAvailable()).Times(9).WillRepeatedly(Return(false)); |
2853 EXPECT_CALL(adm_, | 2884 EXPECT_CALL(adm_, |
2854 BuiltInAGCIsAvailable()).Times(9).WillRepeatedly(Return(false)); | 2885 BuiltInAGCIsAvailable()).Times(9).WillRepeatedly(Return(false)); |
2855 EXPECT_CALL(adm_, | 2886 EXPECT_CALL(adm_, |
2856 BuiltInNSIsAvailable()).Times(9).WillRepeatedly(Return(false)); | 2887 BuiltInNSIsAvailable()).Times(9).WillRepeatedly(Return(false)); |
| 2888 EXPECT_CALL(adm_, |
| 2889 RecordingIsInitialized()).Times(2).WillRepeatedly(Return(false)); |
| 2890 EXPECT_CALL(adm_, Recording()).Times(2).WillRepeatedly(Return(false)); |
| 2891 EXPECT_CALL(adm_, InitRecording()).Times(2).WillRepeatedly(Return(0)); |
| 2892 EXPECT_CALL(apm_, ApplyConfig(testing::_)).Times(10); |
| 2893 EXPECT_CALL(apm_, SetExtraOptions(testing::_)).Times(10); |
2857 | 2894 |
2858 std::unique_ptr<cricket::WebRtcVoiceMediaChannel> channel1( | 2895 std::unique_ptr<cricket::WebRtcVoiceMediaChannel> channel1( |
2859 static_cast<cricket::WebRtcVoiceMediaChannel*>(engine_->CreateChannel( | 2896 static_cast<cricket::WebRtcVoiceMediaChannel*>(engine_->CreateChannel( |
2860 &call_, cricket::MediaConfig(), cricket::AudioOptions()))); | 2897 &call_, cricket::MediaConfig(), cricket::AudioOptions()))); |
2861 std::unique_ptr<cricket::WebRtcVoiceMediaChannel> channel2( | 2898 std::unique_ptr<cricket::WebRtcVoiceMediaChannel> channel2( |
2862 static_cast<cricket::WebRtcVoiceMediaChannel*>(engine_->CreateChannel( | 2899 static_cast<cricket::WebRtcVoiceMediaChannel*>(engine_->CreateChannel( |
2863 &call_, cricket::MediaConfig(), cricket::AudioOptions()))); | 2900 &call_, cricket::MediaConfig(), cricket::AudioOptions()))); |
2864 | 2901 |
2865 // Have to add a stream to make SetSend work. | 2902 // Have to add a stream to make SetSend work. |
2866 cricket::StreamParams stream1; | 2903 cricket::StreamParams stream1; |
2867 stream1.ssrcs.push_back(1); | 2904 stream1.ssrcs.push_back(1); |
2868 channel1->AddSendStream(stream1); | 2905 channel1->AddSendStream(stream1); |
2869 cricket::StreamParams stream2; | 2906 cricket::StreamParams stream2; |
2870 stream2.ssrcs.push_back(2); | 2907 stream2.ssrcs.push_back(2); |
2871 channel2->AddSendStream(stream2); | 2908 channel2->AddSendStream(stream2); |
2872 | 2909 |
2873 // AEC and AGC and NS | 2910 // AEC and AGC and NS |
2874 cricket::AudioSendParameters parameters_options_all = send_parameters_; | 2911 cricket::AudioSendParameters parameters_options_all = send_parameters_; |
2875 parameters_options_all.options.echo_cancellation = rtc::Optional<bool>(true); | 2912 parameters_options_all.options.echo_cancellation = rtc::Optional<bool>(true); |
2876 parameters_options_all.options.auto_gain_control = rtc::Optional<bool>(true); | 2913 parameters_options_all.options.auto_gain_control = rtc::Optional<bool>(true); |
2877 parameters_options_all.options.noise_suppression = rtc::Optional<bool>(true); | 2914 parameters_options_all.options.noise_suppression = rtc::Optional<bool>(true); |
2878 ASSERT_TRUE(channel1->SetSendParameters(parameters_options_all)); | 2915 EXPECT_TRUE(channel1->SetSendParameters(parameters_options_all)); |
2879 EXPECT_EQ(parameters_options_all.options, channel1->options()); | 2916 EXPECT_EQ(parameters_options_all.options, channel1->options()); |
2880 ASSERT_TRUE(channel2->SetSendParameters(parameters_options_all)); | 2917 EXPECT_TRUE(channel2->SetSendParameters(parameters_options_all)); |
2881 EXPECT_EQ(parameters_options_all.options, channel2->options()); | 2918 EXPECT_EQ(parameters_options_all.options, channel2->options()); |
2882 | 2919 |
2883 // unset NS | 2920 // unset NS |
2884 cricket::AudioSendParameters parameters_options_no_ns = send_parameters_; | 2921 cricket::AudioSendParameters parameters_options_no_ns = send_parameters_; |
2885 parameters_options_no_ns.options.noise_suppression = | 2922 parameters_options_no_ns.options.noise_suppression = |
2886 rtc::Optional<bool>(false); | 2923 rtc::Optional<bool>(false); |
2887 ASSERT_TRUE(channel1->SetSendParameters(parameters_options_no_ns)); | 2924 EXPECT_TRUE(channel1->SetSendParameters(parameters_options_no_ns)); |
2888 cricket::AudioOptions expected_options = parameters_options_all.options; | 2925 cricket::AudioOptions expected_options = parameters_options_all.options; |
2889 expected_options.echo_cancellation = rtc::Optional<bool>(true); | 2926 expected_options.echo_cancellation = rtc::Optional<bool>(true); |
2890 expected_options.auto_gain_control = rtc::Optional<bool>(true); | 2927 expected_options.auto_gain_control = rtc::Optional<bool>(true); |
2891 expected_options.noise_suppression = rtc::Optional<bool>(false); | 2928 expected_options.noise_suppression = rtc::Optional<bool>(false); |
2892 EXPECT_EQ(expected_options, channel1->options()); | 2929 EXPECT_EQ(expected_options, channel1->options()); |
2893 | 2930 |
2894 // unset AGC | 2931 // unset AGC |
2895 cricket::AudioSendParameters parameters_options_no_agc = send_parameters_; | 2932 cricket::AudioSendParameters parameters_options_no_agc = send_parameters_; |
2896 parameters_options_no_agc.options.auto_gain_control = | 2933 parameters_options_no_agc.options.auto_gain_control = |
2897 rtc::Optional<bool>(false); | 2934 rtc::Optional<bool>(false); |
2898 ASSERT_TRUE(channel2->SetSendParameters(parameters_options_no_agc)); | 2935 EXPECT_TRUE(channel2->SetSendParameters(parameters_options_no_agc)); |
2899 expected_options.echo_cancellation = rtc::Optional<bool>(true); | 2936 expected_options.echo_cancellation = rtc::Optional<bool>(true); |
2900 expected_options.auto_gain_control = rtc::Optional<bool>(false); | 2937 expected_options.auto_gain_control = rtc::Optional<bool>(false); |
2901 expected_options.noise_suppression = rtc::Optional<bool>(true); | 2938 expected_options.noise_suppression = rtc::Optional<bool>(true); |
2902 EXPECT_EQ(expected_options, channel2->options()); | 2939 EXPECT_EQ(expected_options, channel2->options()); |
2903 | 2940 |
2904 ASSERT_TRUE(channel_->SetSendParameters(parameters_options_all)); | 2941 EXPECT_TRUE(channel_->SetSendParameters(parameters_options_all)); |
2905 bool ec_enabled; | 2942 bool ec_enabled; |
2906 webrtc::EcModes ec_mode; | 2943 webrtc::EcModes ec_mode; |
2907 bool agc_enabled; | 2944 bool agc_enabled; |
2908 webrtc::AgcModes agc_mode; | 2945 webrtc::AgcModes agc_mode; |
2909 bool ns_enabled; | 2946 bool ns_enabled; |
2910 webrtc::NsModes ns_mode; | 2947 webrtc::NsModes ns_mode; |
2911 voe_.GetEcStatus(ec_enabled, ec_mode); | 2948 voe_.GetEcStatus(ec_enabled, ec_mode); |
2912 voe_.GetAgcStatus(agc_enabled, agc_mode); | 2949 voe_.GetAgcStatus(agc_enabled, agc_mode); |
2913 voe_.GetNsStatus(ns_enabled, ns_mode); | 2950 voe_.GetNsStatus(ns_enabled, ns_mode); |
2914 EXPECT_TRUE(ec_enabled); | 2951 EXPECT_TRUE(ec_enabled); |
2915 EXPECT_TRUE(agc_enabled); | 2952 EXPECT_TRUE(agc_enabled); |
2916 EXPECT_TRUE(ns_enabled); | 2953 EXPECT_TRUE(ns_enabled); |
2917 | 2954 |
2918 SetSend(channel1.get(), true); | 2955 channel1->SetSend(true); |
2919 voe_.GetEcStatus(ec_enabled, ec_mode); | 2956 voe_.GetEcStatus(ec_enabled, ec_mode); |
2920 voe_.GetAgcStatus(agc_enabled, agc_mode); | 2957 voe_.GetAgcStatus(agc_enabled, agc_mode); |
2921 voe_.GetNsStatus(ns_enabled, ns_mode); | 2958 voe_.GetNsStatus(ns_enabled, ns_mode); |
2922 EXPECT_TRUE(ec_enabled); | 2959 EXPECT_TRUE(ec_enabled); |
2923 EXPECT_TRUE(agc_enabled); | 2960 EXPECT_TRUE(agc_enabled); |
2924 EXPECT_FALSE(ns_enabled); | 2961 EXPECT_FALSE(ns_enabled); |
2925 | 2962 |
2926 SetSend(channel2.get(), true); | 2963 channel2->SetSend(true); |
2927 voe_.GetEcStatus(ec_enabled, ec_mode); | 2964 voe_.GetEcStatus(ec_enabled, ec_mode); |
2928 voe_.GetAgcStatus(agc_enabled, agc_mode); | 2965 voe_.GetAgcStatus(agc_enabled, agc_mode); |
2929 voe_.GetNsStatus(ns_enabled, ns_mode); | 2966 voe_.GetNsStatus(ns_enabled, ns_mode); |
2930 EXPECT_TRUE(ec_enabled); | 2967 EXPECT_TRUE(ec_enabled); |
2931 EXPECT_FALSE(agc_enabled); | 2968 EXPECT_FALSE(agc_enabled); |
2932 EXPECT_TRUE(ns_enabled); | 2969 EXPECT_TRUE(ns_enabled); |
2933 | 2970 |
2934 // Make sure settings take effect while we are sending. | 2971 // Make sure settings take effect while we are sending. |
2935 ASSERT_TRUE(channel_->SetSendParameters(parameters_options_all)); | 2972 EXPECT_TRUE(channel_->SetSendParameters(parameters_options_all)); |
| 2973 EXPECT_CALL(apm_, ApplyConfig(testing::_)); |
| 2974 EXPECT_CALL(apm_, SetExtraOptions(testing::_)); |
2936 cricket::AudioSendParameters parameters_options_no_agc_nor_ns = | 2975 cricket::AudioSendParameters parameters_options_no_agc_nor_ns = |
2937 send_parameters_; | 2976 send_parameters_; |
2938 parameters_options_no_agc_nor_ns.options.auto_gain_control = | 2977 parameters_options_no_agc_nor_ns.options.auto_gain_control = |
2939 rtc::Optional<bool>(false); | 2978 rtc::Optional<bool>(false); |
2940 parameters_options_no_agc_nor_ns.options.noise_suppression = | 2979 parameters_options_no_agc_nor_ns.options.noise_suppression = |
2941 rtc::Optional<bool>(false); | 2980 rtc::Optional<bool>(false); |
2942 channel2->SetSend(true); | 2981 channel2->SetSend(true); |
2943 channel2->SetSendParameters(parameters_options_no_agc_nor_ns); | 2982 EXPECT_TRUE(channel2->SetSendParameters(parameters_options_no_agc_nor_ns)); |
2944 expected_options.echo_cancellation = rtc::Optional<bool>(true); | 2983 expected_options.echo_cancellation = rtc::Optional<bool>(true); |
2945 expected_options.auto_gain_control = rtc::Optional<bool>(false); | 2984 expected_options.auto_gain_control = rtc::Optional<bool>(false); |
2946 expected_options.noise_suppression = rtc::Optional<bool>(false); | 2985 expected_options.noise_suppression = rtc::Optional<bool>(false); |
2947 EXPECT_EQ(expected_options, channel2->options()); | 2986 EXPECT_EQ(expected_options, channel2->options()); |
2948 voe_.GetEcStatus(ec_enabled, ec_mode); | 2987 voe_.GetEcStatus(ec_enabled, ec_mode); |
2949 voe_.GetAgcStatus(agc_enabled, agc_mode); | 2988 voe_.GetAgcStatus(agc_enabled, agc_mode); |
2950 voe_.GetNsStatus(ns_enabled, ns_mode); | 2989 voe_.GetNsStatus(ns_enabled, ns_mode); |
2951 EXPECT_TRUE(ec_enabled); | 2990 EXPECT_TRUE(ec_enabled); |
2952 EXPECT_FALSE(agc_enabled); | 2991 EXPECT_FALSE(agc_enabled); |
2953 EXPECT_FALSE(ns_enabled); | 2992 EXPECT_FALSE(ns_enabled); |
2954 } | 2993 } |
2955 | 2994 |
2956 // This test verifies DSCP settings are properly applied on voice media channel. | 2995 // This test verifies DSCP settings are properly applied on voice media channel. |
2957 TEST_F(WebRtcVoiceEngineTestFake, TestSetDscpOptions) { | 2996 TEST_F(WebRtcVoiceEngineTestFake, TestSetDscpOptions) { |
2958 EXPECT_TRUE(SetupSendStream()); | 2997 EXPECT_TRUE(SetupSendStream()); |
2959 cricket::FakeNetworkInterface network_interface; | 2998 cricket::FakeNetworkInterface network_interface; |
2960 cricket::MediaConfig config; | 2999 cricket::MediaConfig config; |
2961 std::unique_ptr<cricket::VoiceMediaChannel> channel; | 3000 std::unique_ptr<cricket::VoiceMediaChannel> channel; |
2962 | 3001 |
| 3002 EXPECT_CALL(apm_, ApplyConfig(testing::_)).Times(3); |
| 3003 EXPECT_CALL(apm_, SetExtraOptions(testing::_)).Times(3); |
| 3004 |
2963 channel.reset( | 3005 channel.reset( |
2964 engine_->CreateChannel(&call_, config, cricket::AudioOptions())); | 3006 engine_->CreateChannel(&call_, config, cricket::AudioOptions())); |
2965 channel->SetInterface(&network_interface); | 3007 channel->SetInterface(&network_interface); |
2966 // Default value when DSCP is disabled should be DSCP_DEFAULT. | 3008 // Default value when DSCP is disabled should be DSCP_DEFAULT. |
2967 EXPECT_EQ(rtc::DSCP_DEFAULT, network_interface.dscp()); | 3009 EXPECT_EQ(rtc::DSCP_DEFAULT, network_interface.dscp()); |
2968 | 3010 |
2969 config.enable_dscp = true; | 3011 config.enable_dscp = true; |
2970 channel.reset( | 3012 channel.reset( |
2971 engine_->CreateChannel(&call_, config, cricket::AudioOptions())); | 3013 engine_->CreateChannel(&call_, config, cricket::AudioOptions())); |
2972 channel->SetInterface(&network_interface); | 3014 channel->SetInterface(&network_interface); |
(...skipping 88 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3061 // TODO(solenberg): Remove, once recv streams are configured through Call. | 3103 // TODO(solenberg): Remove, once recv streams are configured through Call. |
3062 // (This is then covered by TestSetRecvRtpHeaderExtensions.) | 3104 // (This is then covered by TestSetRecvRtpHeaderExtensions.) |
3063 TEST_F(WebRtcVoiceEngineTestFake, ConfiguresAudioReceiveStreamRtpExtensions) { | 3105 TEST_F(WebRtcVoiceEngineTestFake, ConfiguresAudioReceiveStreamRtpExtensions) { |
3064 // Test that setting the header extensions results in the expected state | 3106 // Test that setting the header extensions results in the expected state |
3065 // changes on an associated Call. | 3107 // changes on an associated Call. |
3066 std::vector<uint32_t> ssrcs; | 3108 std::vector<uint32_t> ssrcs; |
3067 ssrcs.push_back(223); | 3109 ssrcs.push_back(223); |
3068 ssrcs.push_back(224); | 3110 ssrcs.push_back(224); |
3069 | 3111 |
3070 EXPECT_TRUE(SetupSendStream()); | 3112 EXPECT_TRUE(SetupSendStream()); |
3071 cricket::WebRtcVoiceMediaChannel* media_channel = | 3113 SetSendParameters(send_parameters_); |
3072 static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_); | |
3073 EXPECT_TRUE(media_channel->SetSendParameters(send_parameters_)); | |
3074 for (uint32_t ssrc : ssrcs) { | 3114 for (uint32_t ssrc : ssrcs) { |
3075 EXPECT_TRUE(media_channel->AddRecvStream( | 3115 EXPECT_TRUE(channel_->AddRecvStream( |
3076 cricket::StreamParams::CreateLegacy(ssrc))); | 3116 cricket::StreamParams::CreateLegacy(ssrc))); |
3077 } | 3117 } |
3078 | 3118 |
3079 EXPECT_EQ(2, call_.GetAudioReceiveStreams().size()); | 3119 EXPECT_EQ(2, call_.GetAudioReceiveStreams().size()); |
3080 for (uint32_t ssrc : ssrcs) { | 3120 for (uint32_t ssrc : ssrcs) { |
3081 const auto* s = call_.GetAudioReceiveStream(ssrc); | 3121 const auto* s = call_.GetAudioReceiveStream(ssrc); |
3082 EXPECT_NE(nullptr, s); | 3122 EXPECT_NE(nullptr, s); |
3083 EXPECT_EQ(0, s->GetConfig().rtp.extensions.size()); | 3123 EXPECT_EQ(0, s->GetConfig().rtp.extensions.size()); |
3084 } | 3124 } |
3085 | 3125 |
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3120 0x80, 0xc9, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, | 3160 0x80, 0xc9, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, |
3121 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, | 3161 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, |
3122 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, | 3162 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
3123 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 | 3163 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 |
3124 }; | 3164 }; |
3125 rtc::CopyOnWriteBuffer kRtcpPacket(kRtcp, sizeof(kRtcp)); | 3165 rtc::CopyOnWriteBuffer kRtcpPacket(kRtcp, sizeof(kRtcp)); |
3126 | 3166 |
3127 EXPECT_TRUE(SetupSendStream()); | 3167 EXPECT_TRUE(SetupSendStream()); |
3128 cricket::WebRtcVoiceMediaChannel* media_channel = | 3168 cricket::WebRtcVoiceMediaChannel* media_channel = |
3129 static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_); | 3169 static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_); |
3130 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); | 3170 SetSendParameters(send_parameters_); |
3131 EXPECT_TRUE(media_channel->AddRecvStream( | 3171 EXPECT_TRUE(media_channel->AddRecvStream( |
3132 cricket::StreamParams::CreateLegacy(kAudioSsrc))); | 3172 cricket::StreamParams::CreateLegacy(kAudioSsrc))); |
3133 | 3173 |
3134 EXPECT_EQ(1, call_.GetAudioReceiveStreams().size()); | 3174 EXPECT_EQ(1, call_.GetAudioReceiveStreams().size()); |
3135 const cricket::FakeAudioReceiveStream* s = | 3175 const cricket::FakeAudioReceiveStream* s = |
3136 call_.GetAudioReceiveStream(kAudioSsrc); | 3176 call_.GetAudioReceiveStream(kAudioSsrc); |
3137 EXPECT_EQ(0, s->received_packets()); | 3177 EXPECT_EQ(0, s->received_packets()); |
3138 channel_->OnPacketReceived(&kPcmuPacket, rtc::PacketTime()); | 3178 channel_->OnPacketReceived(&kPcmuPacket, rtc::PacketTime()); |
3139 EXPECT_EQ(1, s->received_packets()); | 3179 EXPECT_EQ(1, s->received_packets()); |
3140 channel_->OnRtcpReceived(&kRtcpPacket, rtc::PacketTime()); | 3180 channel_->OnRtcpReceived(&kRtcpPacket, rtc::PacketTime()); |
3141 EXPECT_EQ(2, s->received_packets()); | 3181 EXPECT_EQ(2, s->received_packets()); |
3142 } | 3182 } |
3143 | 3183 |
3144 // All receive channels should be associated with the first send channel, | 3184 // All receive channels should be associated with the first send channel, |
3145 // since they do not send RTCP SR. | 3185 // since they do not send RTCP SR. |
3146 TEST_F(WebRtcVoiceEngineTestFake, AssociateFirstSendChannel) { | 3186 TEST_F(WebRtcVoiceEngineTestFake, AssociateFirstSendChannel) { |
3147 EXPECT_TRUE(SetupSendStream()); | 3187 EXPECT_TRUE(SetupSendStream()); |
3148 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); | 3188 SetSendParameters(send_parameters_); |
3149 int default_channel = voe_.GetLastChannel(); | 3189 int default_channel = voe_.GetLastChannel(); |
3150 EXPECT_TRUE(AddRecvStream(1)); | 3190 EXPECT_TRUE(AddRecvStream(1)); |
3151 int recv_ch = voe_.GetLastChannel(); | 3191 int recv_ch = voe_.GetLastChannel(); |
3152 EXPECT_NE(recv_ch, default_channel); | 3192 EXPECT_NE(recv_ch, default_channel); |
3153 EXPECT_EQ(voe_.GetAssociateSendChannel(recv_ch), default_channel); | 3193 EXPECT_EQ(voe_.GetAssociateSendChannel(recv_ch), default_channel); |
3154 EXPECT_TRUE(channel_->AddSendStream(cricket::StreamParams::CreateLegacy(2))); | 3194 EXPECT_TRUE(channel_->AddSendStream(cricket::StreamParams::CreateLegacy(2))); |
3155 EXPECT_EQ(voe_.GetAssociateSendChannel(recv_ch), default_channel); | 3195 EXPECT_EQ(voe_.GetAssociateSendChannel(recv_ch), default_channel); |
3156 EXPECT_TRUE(AddRecvStream(3)); | 3196 EXPECT_TRUE(AddRecvStream(3)); |
3157 recv_ch = voe_.GetLastChannel(); | 3197 recv_ch = voe_.GetLastChannel(); |
3158 EXPECT_NE(recv_ch, default_channel); | 3198 EXPECT_NE(recv_ch, default_channel); |
3159 EXPECT_EQ(voe_.GetAssociateSendChannel(recv_ch), default_channel); | 3199 EXPECT_EQ(voe_.GetAssociateSendChannel(recv_ch), default_channel); |
3160 } | 3200 } |
3161 | 3201 |
3162 TEST_F(WebRtcVoiceEngineTestFake, AssociateChannelResetUponDeleteChannnel) { | 3202 TEST_F(WebRtcVoiceEngineTestFake, AssociateChannelResetUponDeleteChannnel) { |
3163 EXPECT_TRUE(SetupSendStream()); | 3203 EXPECT_TRUE(SetupSendStream()); |
3164 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); | 3204 SetSendParameters(send_parameters_); |
3165 | 3205 |
3166 EXPECT_TRUE(AddRecvStream(1)); | 3206 EXPECT_TRUE(AddRecvStream(1)); |
3167 int recv_ch = voe_.GetLastChannel(); | 3207 int recv_ch = voe_.GetLastChannel(); |
3168 | 3208 |
3169 EXPECT_TRUE(channel_->AddSendStream(cricket::StreamParams::CreateLegacy(2))); | 3209 EXPECT_TRUE(channel_->AddSendStream(cricket::StreamParams::CreateLegacy(2))); |
3170 int send_ch = voe_.GetLastChannel(); | 3210 int send_ch = voe_.GetLastChannel(); |
3171 | 3211 |
3172 // Manually associate |recv_ch| to |send_ch|. This test is to verify a | 3212 // Manually associate |recv_ch| to |send_ch|. This test is to verify a |
3173 // deleting logic, i.e., deleting |send_ch| will reset the associate send | 3213 // deleting logic, i.e., deleting |send_ch| will reset the associate send |
3174 // channel of |recv_ch|.This is not a common case, since, normally, only the | 3214 // channel of |recv_ch|.This is not a common case, since, normally, only the |
(...skipping 246 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3421 nullptr, webrtc::CreateBuiltinAudioDecoderFactory()); | 3461 nullptr, webrtc::CreateBuiltinAudioDecoderFactory()); |
3422 webrtc::RtcEventLogNullImpl event_log; | 3462 webrtc::RtcEventLogNullImpl event_log; |
3423 std::unique_ptr<webrtc::Call> call( | 3463 std::unique_ptr<webrtc::Call> call( |
3424 webrtc::Call::Create(webrtc::Call::Config(&event_log))); | 3464 webrtc::Call::Create(webrtc::Call::Config(&event_log))); |
3425 cricket::WebRtcVoiceMediaChannel channel(&engine, cricket::MediaConfig(), | 3465 cricket::WebRtcVoiceMediaChannel channel(&engine, cricket::MediaConfig(), |
3426 cricket::AudioOptions(), call.get()); | 3466 cricket::AudioOptions(), call.get()); |
3427 cricket::AudioRecvParameters parameters; | 3467 cricket::AudioRecvParameters parameters; |
3428 parameters.codecs = engine.recv_codecs(); | 3468 parameters.codecs = engine.recv_codecs(); |
3429 EXPECT_TRUE(channel.SetRecvParameters(parameters)); | 3469 EXPECT_TRUE(channel.SetRecvParameters(parameters)); |
3430 } | 3470 } |
OLD | NEW |