blob: 7c2536716478b01326db29332c723c0efcd05279 [file] [log] [blame]
henrike@webrtc.org79047f92014-03-06 23:46:59 +00001/*
kjellander1afca732016-02-07 20:46:45 -08002 * Copyright (c) 2008 The WebRTC project authors. All Rights Reserved.
henrike@webrtc.org79047f92014-03-06 23:46:59 +00003 *
kjellander1afca732016-02-07 20:46:45 -08004 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
henrike@webrtc.org79047f92014-03-06 23:46:59 +00009 */
henrike@webrtc.org28e20752013-07-10 00:45:36 +000010
kwiberg686a8ef2016-02-26 03:00:35 -080011#include <memory>
12
kjellander@webrtc.org9b8df252016-02-12 06:47:59 +010013#include "webrtc/pc/channel.h"
tfarina5237aaf2015-11-10 23:44:30 -080014#include "webrtc/base/arraysize.h"
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +000015#include "webrtc/base/byteorder.h"
16#include "webrtc/base/gunit.h"
Fredrik Solenberg709ed672015-09-15 12:26:33 +020017#include "webrtc/call.h"
stefanba4c0e42016-02-04 04:12:24 -080018#include "webrtc/p2p/base/faketransportcontroller.h"
19#include "webrtc/test/field_trial.h"
kjellandera96e2d72016-02-04 23:52:28 -080020#include "webrtc/media/base/fakemediaengine.h"
21#include "webrtc/media/base/fakenetworkinterface.h"
22#include "webrtc/media/base/fakertp.h"
kjellanderf4752772016-03-02 05:42:30 -080023#include "webrtc/media/base/mediaconstants.h"
kjellander@webrtc.org5ad12972016-02-12 06:39:40 +010024#include "webrtc/media/engine/fakewebrtccall.h"
25#include "webrtc/media/engine/fakewebrtcvoiceengine.h"
26#include "webrtc/media/engine/webrtcvoiceengine.h"
ossu29b1a8d2016-06-13 07:34:51 -070027#include "webrtc/modules/audio_coding/codecs/builtin_audio_decoder_factory.h"
28#include "webrtc/modules/audio_coding/codecs/mock/mock_audio_decoder_factory.h"
solenbergbc37fc82016-04-04 09:54:44 -070029#include "webrtc/modules/audio_device/include/mock_audio_device.h"
henrike@webrtc.org28e20752013-07-10 00:45:36 +000030
solenbergbc37fc82016-04-04 09:54:44 -070031using testing::Return;
32using testing::StrictMock;
buildbot@webrtc.org150835e2014-05-06 15:54:38 +000033
Fredrik Solenberg4f4ec0a2015-10-22 10:49:27 +020034namespace {
35
deadbeef67cf2c12016-04-13 10:07:16 -070036const cricket::AudioCodec kPcmuCodec(0, "PCMU", 8000, 64000, 1);
37const cricket::AudioCodec kIsacCodec(103, "ISAC", 16000, 32000, 1);
38const cricket::AudioCodec kOpusCodec(111, "opus", 48000, 64000, 2);
39const cricket::AudioCodec kG722CodecVoE(9, "G722", 16000, 64000, 1);
40const cricket::AudioCodec kG722CodecSdp(9, "G722", 8000, 64000, 1);
deadbeef67cf2c12016-04-13 10:07:16 -070041const cricket::AudioCodec kCn8000Codec(13, "CN", 8000, 0, 1);
42const cricket::AudioCodec kCn16000Codec(105, "CN", 16000, 0, 1);
43const cricket::AudioCodec kTelephoneEventCodec(106,
44 "telephone-event",
45 8000,
46 0,
47 1);
solenberg85a04962015-10-27 03:35:21 -070048const uint32_t kSsrc1 = 0x99;
Taylor Brandstetter1a018dc2016-03-08 12:37:39 -080049const uint32_t kSsrc2 = 2;
50const uint32_t kSsrc3 = 3;
solenberg85a04962015-10-27 03:35:21 -070051const uint32_t kSsrcs4[] = { 1, 2, 3, 4 };
henrike@webrtc.org28e20752013-07-10 00:45:36 +000052
solenberg971cab02016-06-14 10:02:41 -070053constexpr int kRtpHistoryMs = 5000;
54
henrike@webrtc.org28e20752013-07-10 00:45:36 +000055class FakeVoEWrapper : public cricket::VoEWrapper {
56 public:
57 explicit FakeVoEWrapper(cricket::FakeWebRtcVoiceEngine* engine)
58 : cricket::VoEWrapper(engine, // processing
59 engine, // base
60 engine, // codec
henrike@webrtc.org28e20752013-07-10 00:45:36 +000061 engine, // hw
henrike@webrtc.org28e20752013-07-10 00:45:36 +000062 engine, // rtp
henrike@webrtc.org28e20752013-07-10 00:45:36 +000063 engine) { // volume
64 }
65};
Fredrik Solenberg4f4ec0a2015-10-22 10:49:27 +020066} // namespace
henrike@webrtc.org28e20752013-07-10 00:45:36 +000067
solenbergff976312016-03-30 23:28:51 -070068// Tests that our stub library "works".
69TEST(WebRtcVoiceEngineTestStubLibrary, StartupShutdown) {
solenbergbc37fc82016-04-04 09:54:44 -070070 StrictMock<webrtc::test::MockAudioDeviceModule> adm;
71 EXPECT_CALL(adm, AddRef()).WillOnce(Return(0));
72 EXPECT_CALL(adm, Release()).WillOnce(Return(0));
solenberg5b5129a2016-04-08 05:35:48 -070073 EXPECT_CALL(adm, BuiltInAECIsAvailable()).WillOnce(Return(false));
74 EXPECT_CALL(adm, BuiltInAGCIsAvailable()).WillOnce(Return(false));
75 EXPECT_CALL(adm, BuiltInNSIsAvailable()).WillOnce(Return(false));
solenbergff976312016-03-30 23:28:51 -070076 cricket::FakeWebRtcVoiceEngine voe;
77 EXPECT_FALSE(voe.IsInited());
78 {
ossu29b1a8d2016-06-13 07:34:51 -070079 cricket::WebRtcVoiceEngine engine(&adm, nullptr, new FakeVoEWrapper(&voe));
solenbergff976312016-03-30 23:28:51 -070080 EXPECT_TRUE(voe.IsInited());
81 }
82 EXPECT_FALSE(voe.IsInited());
83}
84
deadbeef884f5852016-01-15 09:20:04 -080085class FakeAudioSink : public webrtc::AudioSinkInterface {
86 public:
87 void OnData(const Data& audio) override {}
88};
89
Taylor Brandstetter1a018dc2016-03-08 12:37:39 -080090class FakeAudioSource : public cricket::AudioSource {
91 void SetSink(Sink* sink) override {}
92};
93
henrike@webrtc.org28e20752013-07-10 00:45:36 +000094class WebRtcVoiceEngineTestFake : public testing::Test {
95 public:
stefanba4c0e42016-02-04 04:12:24 -080096 WebRtcVoiceEngineTestFake() : WebRtcVoiceEngineTestFake("") {}
97
98 explicit WebRtcVoiceEngineTestFake(const char* field_trials)
solenbergbc37fc82016-04-04 09:54:44 -070099 : call_(webrtc::Call::Config()), override_field_trials_(field_trials) {
100 EXPECT_CALL(adm_, AddRef()).WillOnce(Return(0));
101 EXPECT_CALL(adm_, Release()).WillOnce(Return(0));
solenberg5b5129a2016-04-08 05:35:48 -0700102 EXPECT_CALL(adm_, BuiltInAECIsAvailable()).WillOnce(Return(false));
103 EXPECT_CALL(adm_, BuiltInAGCIsAvailable()).WillOnce(Return(false));
104 EXPECT_CALL(adm_, BuiltInNSIsAvailable()).WillOnce(Return(false));
ossu29b1a8d2016-06-13 07:34:51 -0700105 engine_.reset(new cricket::WebRtcVoiceEngine(&adm_, nullptr,
solenbergbc37fc82016-04-04 09:54:44 -0700106 new FakeVoEWrapper(&voe_)));
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200107 send_parameters_.codecs.push_back(kPcmuCodec);
108 recv_parameters_.codecs.push_back(kPcmuCodec);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000109 }
solenberg8189b022016-06-14 12:13:00 -0700110
solenbergff976312016-03-30 23:28:51 -0700111 bool SetupChannel() {
solenbergbc37fc82016-04-04 09:54:44 -0700112 channel_ = engine_->CreateChannel(&call_, cricket::MediaConfig(),
113 cricket::AudioOptions());
Jelena Marusicc28a8962015-05-29 15:05:44 +0200114 return (channel_ != nullptr);
buildbot@webrtc.org150835e2014-05-06 15:54:38 +0000115 }
solenberg8189b022016-06-14 12:13:00 -0700116
solenbergff976312016-03-30 23:28:51 -0700117 bool SetupRecvStream() {
118 if (!SetupChannel()) {
solenberg1ac56142015-10-13 03:58:19 -0700119 return false;
120 }
solenberg8189b022016-06-14 12:13:00 -0700121 return AddRecvStream(kSsrc1);
solenberg1ac56142015-10-13 03:58:19 -0700122 }
solenberg8189b022016-06-14 12:13:00 -0700123
solenbergff976312016-03-30 23:28:51 -0700124 bool SetupSendStream() {
125 if (!SetupChannel()) {
buildbot@webrtc.org150835e2014-05-06 15:54:38 +0000126 return false;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000127 }
Taylor Brandstetter1a018dc2016-03-08 12:37:39 -0800128 if (!channel_->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc1))) {
129 return false;
130 }
131 return channel_->SetAudioSend(kSsrc1, true, nullptr, &fake_source_);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000132 }
solenberg8189b022016-06-14 12:13:00 -0700133
134 bool AddRecvStream(uint32_t ssrc) {
135 EXPECT_TRUE(channel_);
136 return channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(ssrc));
137 }
138
wu@webrtc.org9dba5252013-08-05 20:36:57 +0000139 void SetupForMultiSendStream() {
solenbergff976312016-03-30 23:28:51 -0700140 EXPECT_TRUE(SetupSendStream());
solenberg0a617e22015-10-20 15:49:38 -0700141 // Remove stream added in Setup.
solenberg3a941542015-11-16 07:34:50 -0800142 EXPECT_TRUE(call_.GetAudioSendStream(kSsrc1));
solenberg85a04962015-10-27 03:35:21 -0700143 EXPECT_TRUE(channel_->RemoveSendStream(kSsrc1));
solenberg0a617e22015-10-20 15:49:38 -0700144 // Verify the channel does not exist.
solenberg3a941542015-11-16 07:34:50 -0800145 EXPECT_FALSE(call_.GetAudioSendStream(kSsrc1));
wu@webrtc.org9dba5252013-08-05 20:36:57 +0000146 }
solenberg8189b022016-06-14 12:13:00 -0700147
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000148 void DeliverPacket(const void* data, int len) {
jbaucheec21bd2016-03-20 06:15:43 -0700149 rtc::CopyOnWriteBuffer packet(reinterpret_cast<const uint8_t*>(data), len);
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000150 channel_->OnPacketReceived(&packet, rtc::PacketTime());
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000151 }
solenberg8189b022016-06-14 12:13:00 -0700152
Fredrik Solenbergaaf8ff22015-05-07 16:05:53 +0200153 void TearDown() override {
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000154 delete channel_;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000155 }
156
Fredrik Solenbergb5727682015-12-04 15:22:19 +0100157 const cricket::FakeAudioSendStream& GetSendStream(uint32_t ssrc) {
158 const auto* send_stream = call_.GetAudioSendStream(ssrc);
159 EXPECT_TRUE(send_stream);
160 return *send_stream;
161 }
162
deadbeef884f5852016-01-15 09:20:04 -0800163 const cricket::FakeAudioReceiveStream& GetRecvStream(uint32_t ssrc) {
164 const auto* recv_stream = call_.GetAudioReceiveStream(ssrc);
165 EXPECT_TRUE(recv_stream);
166 return *recv_stream;
167 }
168
solenberg3a941542015-11-16 07:34:50 -0800169 const webrtc::AudioSendStream::Config& GetSendStreamConfig(uint32_t ssrc) {
Taylor Brandstetter1a018dc2016-03-08 12:37:39 -0800170 return GetSendStream(ssrc).GetConfig();
solenberg3a941542015-11-16 07:34:50 -0800171 }
172
solenberg7add0582015-11-20 09:59:34 -0800173 const webrtc::AudioReceiveStream::Config& GetRecvStreamConfig(uint32_t ssrc) {
Taylor Brandstetter1a018dc2016-03-08 12:37:39 -0800174 return GetRecvStream(ssrc).GetConfig();
solenberg7add0582015-11-20 09:59:34 -0800175 }
176
solenbergd53a3f92016-04-14 13:56:37 -0700177 void SetSend(cricket::VoiceMediaChannel* channel, bool enable) {
178 ASSERT_TRUE(channel);
179 if (enable) {
180 EXPECT_CALL(adm_, RecordingIsInitialized()).WillOnce(Return(false));
181 EXPECT_CALL(adm_, Recording()).WillOnce(Return(false));
182 EXPECT_CALL(adm_, InitRecording()).WillOnce(Return(0));
183 }
184 channel->SetSend(enable);
185 }
186
Peter Boström0c4e06b2015-10-07 12:23:21 +0200187 void TestInsertDtmf(uint32_t ssrc, bool caller) {
solenbergff976312016-03-30 23:28:51 -0700188 EXPECT_TRUE(SetupChannel());
wu@webrtc.orgcadf9042013-08-30 21:24:16 +0000189 if (caller) {
solenberg0a617e22015-10-20 15:49:38 -0700190 // If this is a caller, local description will be applied and add the
wu@webrtc.orgcadf9042013-08-30 21:24:16 +0000191 // send stream.
192 EXPECT_TRUE(channel_->AddSendStream(
193 cricket::StreamParams::CreateLegacy(kSsrc1)));
194 }
wu@webrtc.orgcadf9042013-08-30 21:24:16 +0000195
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000196 // Test we can only InsertDtmf when the other side supports telephone-event.
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200197 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
solenbergd53a3f92016-04-14 13:56:37 -0700198 SetSend(channel_, true);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000199 EXPECT_FALSE(channel_->CanInsertDtmf());
solenberg1d63dd02015-12-02 12:35:09 -0800200 EXPECT_FALSE(channel_->InsertDtmf(ssrc, 1, 111));
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200201 send_parameters_.codecs.push_back(kTelephoneEventCodec);
202 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000203 EXPECT_TRUE(channel_->CanInsertDtmf());
wu@webrtc.orgcadf9042013-08-30 21:24:16 +0000204
205 if (!caller) {
solenberg0a617e22015-10-20 15:49:38 -0700206 // If this is callee, there's no active send channel yet.
solenberg1d63dd02015-12-02 12:35:09 -0800207 EXPECT_FALSE(channel_->InsertDtmf(ssrc, 2, 123));
wu@webrtc.orgcadf9042013-08-30 21:24:16 +0000208 EXPECT_TRUE(channel_->AddSendStream(
209 cricket::StreamParams::CreateLegacy(kSsrc1)));
210 }
211
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000212 // Check we fail if the ssrc is invalid.
solenberg1d63dd02015-12-02 12:35:09 -0800213 EXPECT_FALSE(channel_->InsertDtmf(-1, 1, 111));
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000214
Fredrik Solenbergb5727682015-12-04 15:22:19 +0100215 // Test send.
216 cricket::FakeAudioSendStream::TelephoneEvent telephone_event =
217 GetSendStream(kSsrc1).GetLatestTelephoneEvent();
218 EXPECT_EQ(-1, telephone_event.payload_type);
solenberg1d63dd02015-12-02 12:35:09 -0800219 EXPECT_TRUE(channel_->InsertDtmf(ssrc, 2, 123));
Fredrik Solenbergb5727682015-12-04 15:22:19 +0100220 telephone_event = GetSendStream(kSsrc1).GetLatestTelephoneEvent();
221 EXPECT_EQ(kTelephoneEventCodec.id, telephone_event.payload_type);
222 EXPECT_EQ(2, telephone_event.event_code);
223 EXPECT_EQ(123, telephone_event.duration_ms);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000224 }
225
226 // Test that send bandwidth is set correctly.
227 // |codec| is the codec under test.
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +0000228 // |max_bitrate| is a parameter to set to SetMaxSendBandwidth().
229 // |expected_result| is the expected result from SetMaxSendBandwidth().
230 // |expected_bitrate| is the expected audio bitrate afterward.
deadbeef80346142016-04-27 14:17:10 -0700231 void TestMaxSendBandwidth(const cricket::AudioCodec& codec,
232 int max_bitrate,
233 bool expected_result,
234 int expected_bitrate) {
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200235 cricket::AudioSendParameters parameters;
236 parameters.codecs.push_back(codec);
237 parameters.max_bandwidth_bps = max_bitrate;
238 EXPECT_EQ(expected_result, channel_->SetSendParameters(parameters));
239
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000240 int channel_num = voe_.GetLastChannel();
wu@webrtc.org1d1ffc92013-10-16 18:12:02 +0000241 webrtc::CodecInst temp_codec;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000242 EXPECT_FALSE(voe_.GetSendCodec(channel_num, temp_codec));
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +0000243 EXPECT_EQ(expected_bitrate, temp_codec.rate);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000244 }
245
skvlade0d46372016-04-07 22:59:22 -0700246 // Sets the per-stream maximum bitrate limit for the specified SSRC.
247 bool SetMaxBitrateForStream(int32_t ssrc, int bitrate) {
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -0700248 webrtc::RtpParameters parameters = channel_->GetRtpSendParameters(ssrc);
skvlade0d46372016-04-07 22:59:22 -0700249 EXPECT_EQ(1UL, parameters.encodings.size());
250
251 parameters.encodings[0].max_bitrate_bps = bitrate;
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -0700252 return channel_->SetRtpSendParameters(ssrc, parameters);
skvlade0d46372016-04-07 22:59:22 -0700253 }
254
255 bool SetGlobalMaxBitrate(const cricket::AudioCodec& codec, int bitrate) {
256 cricket::AudioSendParameters send_parameters;
257 send_parameters.codecs.push_back(codec);
258 send_parameters.max_bandwidth_bps = bitrate;
259 return channel_->SetSendParameters(send_parameters);
260 }
261
262 int GetCodecBitrate(int32_t ssrc) {
263 cricket::WebRtcVoiceMediaChannel* media_channel =
264 static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_);
265 int channel = media_channel->GetSendChannelId(ssrc);
266 EXPECT_NE(-1, channel);
267 webrtc::CodecInst codec;
268 EXPECT_FALSE(voe_.GetSendCodec(channel, codec));
269 return codec.rate;
270 }
271
272 void SetAndExpectMaxBitrate(const cricket::AudioCodec& codec,
273 int global_max,
274 int stream_max,
275 bool expected_result,
276 int expected_codec_bitrate) {
277 // Clear the bitrate limit from the previous test case.
278 EXPECT_TRUE(SetMaxBitrateForStream(kSsrc1, -1));
279
280 // Attempt to set the requested bitrate limits.
281 EXPECT_TRUE(SetGlobalMaxBitrate(codec, global_max));
282 EXPECT_EQ(expected_result, SetMaxBitrateForStream(kSsrc1, stream_max));
283
284 // Verify that reading back the parameters gives results
285 // consistent with the Set() result.
286 webrtc::RtpParameters resulting_parameters =
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -0700287 channel_->GetRtpSendParameters(kSsrc1);
skvlade0d46372016-04-07 22:59:22 -0700288 EXPECT_EQ(1UL, resulting_parameters.encodings.size());
289 EXPECT_EQ(expected_result ? stream_max : -1,
290 resulting_parameters.encodings[0].max_bitrate_bps);
291
292 // Verify that the codec settings have the expected bitrate.
293 EXPECT_EQ(expected_codec_bitrate, GetCodecBitrate(kSsrc1));
294 }
295
buildbot@webrtc.org150835e2014-05-06 15:54:38 +0000296 void TestSetSendRtpHeaderExtensions(const std::string& ext) {
solenbergff976312016-03-30 23:28:51 -0700297 EXPECT_TRUE(SetupSendStream());
wu@webrtc.org9dba5252013-08-05 20:36:57 +0000298
henrike@webrtc.org79047f92014-03-06 23:46:59 +0000299 // Ensure extensions are off by default.
solenberg3a941542015-11-16 07:34:50 -0800300 EXPECT_EQ(0u, GetSendStreamConfig(kSsrc1).rtp.extensions.size());
wu@webrtc.org9dba5252013-08-05 20:36:57 +0000301
302 // Ensure unknown extensions won't cause an error.
isheriff6f8d6862016-05-26 11:24:55 -0700303 send_parameters_.extensions.push_back(
304 webrtc::RtpExtension("urn:ietf:params:unknownextention", 1));
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200305 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
solenberg3a941542015-11-16 07:34:50 -0800306 EXPECT_EQ(0u, GetSendStreamConfig(kSsrc1).rtp.extensions.size());
wu@webrtc.org9dba5252013-08-05 20:36:57 +0000307
henrike@webrtc.org79047f92014-03-06 23:46:59 +0000308 // Ensure extensions stay off with an empty list of headers.
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200309 send_parameters_.extensions.clear();
310 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
solenberg3a941542015-11-16 07:34:50 -0800311 EXPECT_EQ(0u, GetSendStreamConfig(kSsrc1).rtp.extensions.size());
wu@webrtc.org9dba5252013-08-05 20:36:57 +0000312
buildbot@webrtc.org150835e2014-05-06 15:54:38 +0000313 // Ensure extension is set properly.
314 const int id = 1;
isheriff6f8d6862016-05-26 11:24:55 -0700315 send_parameters_.extensions.push_back(webrtc::RtpExtension(ext, id));
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200316 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
solenberg3a941542015-11-16 07:34:50 -0800317 EXPECT_EQ(1u, GetSendStreamConfig(kSsrc1).rtp.extensions.size());
isheriff6f8d6862016-05-26 11:24:55 -0700318 EXPECT_EQ(ext, GetSendStreamConfig(kSsrc1).rtp.extensions[0].uri);
solenberg3a941542015-11-16 07:34:50 -0800319 EXPECT_EQ(id, GetSendStreamConfig(kSsrc1).rtp.extensions[0].id);
wu@webrtc.org9dba5252013-08-05 20:36:57 +0000320
solenberg7add0582015-11-20 09:59:34 -0800321 // Ensure extension is set properly on new stream.
buildbot@webrtc.org150835e2014-05-06 15:54:38 +0000322 EXPECT_TRUE(channel_->AddSendStream(
solenberg0a617e22015-10-20 15:49:38 -0700323 cricket::StreamParams::CreateLegacy(kSsrc2)));
solenberg3a941542015-11-16 07:34:50 -0800324 EXPECT_NE(call_.GetAudioSendStream(kSsrc1),
325 call_.GetAudioSendStream(kSsrc2));
326 EXPECT_EQ(1u, GetSendStreamConfig(kSsrc2).rtp.extensions.size());
isheriff6f8d6862016-05-26 11:24:55 -0700327 EXPECT_EQ(ext, GetSendStreamConfig(kSsrc2).rtp.extensions[0].uri);
solenberg3a941542015-11-16 07:34:50 -0800328 EXPECT_EQ(id, GetSendStreamConfig(kSsrc2).rtp.extensions[0].id);
henrike@webrtc.org79047f92014-03-06 23:46:59 +0000329
330 // Ensure all extensions go back off with an empty list.
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200331 send_parameters_.codecs.push_back(kPcmuCodec);
332 send_parameters_.extensions.clear();
333 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
solenberg3a941542015-11-16 07:34:50 -0800334 EXPECT_EQ(0u, GetSendStreamConfig(kSsrc1).rtp.extensions.size());
335 EXPECT_EQ(0u, GetSendStreamConfig(kSsrc2).rtp.extensions.size());
henrike@webrtc.org79047f92014-03-06 23:46:59 +0000336 }
337
buildbot@webrtc.org150835e2014-05-06 15:54:38 +0000338 void TestSetRecvRtpHeaderExtensions(const std::string& ext) {
solenbergff976312016-03-30 23:28:51 -0700339 EXPECT_TRUE(SetupRecvStream());
henrike@webrtc.org79047f92014-03-06 23:46:59 +0000340
henrike@webrtc.org79047f92014-03-06 23:46:59 +0000341 // Ensure extensions are off by default.
solenberg7add0582015-11-20 09:59:34 -0800342 EXPECT_EQ(0u, GetRecvStreamConfig(kSsrc1).rtp.extensions.size());
henrike@webrtc.org79047f92014-03-06 23:46:59 +0000343
344 // Ensure unknown extensions won't cause an error.
isheriff6f8d6862016-05-26 11:24:55 -0700345 recv_parameters_.extensions.push_back(
346 webrtc::RtpExtension("urn:ietf:params:unknownextention", 1));
solenberg7add0582015-11-20 09:59:34 -0800347 EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
348 EXPECT_EQ(0u, GetRecvStreamConfig(kSsrc1).rtp.extensions.size());
henrike@webrtc.org79047f92014-03-06 23:46:59 +0000349
buildbot@webrtc.org150835e2014-05-06 15:54:38 +0000350 // Ensure extensions stay off with an empty list of headers.
solenberg7add0582015-11-20 09:59:34 -0800351 recv_parameters_.extensions.clear();
352 EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
353 EXPECT_EQ(0u, GetRecvStreamConfig(kSsrc1).rtp.extensions.size());
henrike@webrtc.org79047f92014-03-06 23:46:59 +0000354
buildbot@webrtc.org150835e2014-05-06 15:54:38 +0000355 // Ensure extension is set properly.
356 const int id = 2;
isheriff6f8d6862016-05-26 11:24:55 -0700357 recv_parameters_.extensions.push_back(webrtc::RtpExtension(ext, id));
solenberg7add0582015-11-20 09:59:34 -0800358 EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
359 EXPECT_EQ(1u, GetRecvStreamConfig(kSsrc1).rtp.extensions.size());
isheriff6f8d6862016-05-26 11:24:55 -0700360 EXPECT_EQ(ext, GetRecvStreamConfig(kSsrc1).rtp.extensions[0].uri);
solenberg7add0582015-11-20 09:59:34 -0800361 EXPECT_EQ(id, GetRecvStreamConfig(kSsrc1).rtp.extensions[0].id);
henrike@webrtc.org79047f92014-03-06 23:46:59 +0000362
solenberg7add0582015-11-20 09:59:34 -0800363 // Ensure extension is set properly on new stream.
solenberg8189b022016-06-14 12:13:00 -0700364 EXPECT_TRUE(AddRecvStream(kSsrc2));
solenberg7add0582015-11-20 09:59:34 -0800365 EXPECT_NE(call_.GetAudioReceiveStream(kSsrc1),
366 call_.GetAudioReceiveStream(kSsrc2));
367 EXPECT_EQ(1u, GetRecvStreamConfig(kSsrc2).rtp.extensions.size());
isheriff6f8d6862016-05-26 11:24:55 -0700368 EXPECT_EQ(ext, GetRecvStreamConfig(kSsrc2).rtp.extensions[0].uri);
solenberg7add0582015-11-20 09:59:34 -0800369 EXPECT_EQ(id, GetRecvStreamConfig(kSsrc2).rtp.extensions[0].id);
buildbot@webrtc.org150835e2014-05-06 15:54:38 +0000370
371 // Ensure all extensions go back off with an empty list.
solenberg7add0582015-11-20 09:59:34 -0800372 recv_parameters_.extensions.clear();
373 EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
374 EXPECT_EQ(0u, GetRecvStreamConfig(kSsrc1).rtp.extensions.size());
375 EXPECT_EQ(0u, GetRecvStreamConfig(kSsrc2).rtp.extensions.size());
wu@webrtc.org9dba5252013-08-05 20:36:57 +0000376 }
377
solenberg85a04962015-10-27 03:35:21 -0700378 webrtc::AudioSendStream::Stats GetAudioSendStreamStats() const {
379 webrtc::AudioSendStream::Stats stats;
380 stats.local_ssrc = 12;
381 stats.bytes_sent = 345;
382 stats.packets_sent = 678;
383 stats.packets_lost = 9012;
384 stats.fraction_lost = 34.56f;
385 stats.codec_name = "codec_name_send";
386 stats.ext_seqnum = 789;
387 stats.jitter_ms = 12;
388 stats.rtt_ms = 345;
389 stats.audio_level = 678;
390 stats.aec_quality_min = 9.01f;
391 stats.echo_delay_median_ms = 234;
392 stats.echo_delay_std_ms = 567;
393 stats.echo_return_loss = 890;
394 stats.echo_return_loss_enhancement = 1234;
395 stats.typing_noise_detected = true;
396 return stats;
397 }
398 void SetAudioSendStreamStats() {
399 for (auto* s : call_.GetAudioSendStreams()) {
400 s->SetStats(GetAudioSendStreamStats());
Fredrik Solenberg4f4ec0a2015-10-22 10:49:27 +0200401 }
solenberg85a04962015-10-27 03:35:21 -0700402 }
solenberg566ef242015-11-06 15:34:49 -0800403 void VerifyVoiceSenderInfo(const cricket::VoiceSenderInfo& info,
404 bool is_sending) {
solenberg85a04962015-10-27 03:35:21 -0700405 const auto stats = GetAudioSendStreamStats();
406 EXPECT_EQ(info.ssrc(), stats.local_ssrc);
407 EXPECT_EQ(info.bytes_sent, stats.bytes_sent);
408 EXPECT_EQ(info.packets_sent, stats.packets_sent);
409 EXPECT_EQ(info.packets_lost, stats.packets_lost);
410 EXPECT_EQ(info.fraction_lost, stats.fraction_lost);
411 EXPECT_EQ(info.codec_name, stats.codec_name);
412 EXPECT_EQ(info.ext_seqnum, stats.ext_seqnum);
413 EXPECT_EQ(info.jitter_ms, stats.jitter_ms);
414 EXPECT_EQ(info.rtt_ms, stats.rtt_ms);
415 EXPECT_EQ(info.audio_level, stats.audio_level);
416 EXPECT_EQ(info.aec_quality_min, stats.aec_quality_min);
417 EXPECT_EQ(info.echo_delay_median_ms, stats.echo_delay_median_ms);
418 EXPECT_EQ(info.echo_delay_std_ms, stats.echo_delay_std_ms);
419 EXPECT_EQ(info.echo_return_loss, stats.echo_return_loss);
420 EXPECT_EQ(info.echo_return_loss_enhancement,
421 stats.echo_return_loss_enhancement);
solenberg566ef242015-11-06 15:34:49 -0800422 EXPECT_EQ(info.typing_noise_detected,
423 stats.typing_noise_detected && is_sending);
solenberg85a04962015-10-27 03:35:21 -0700424 }
425
426 webrtc::AudioReceiveStream::Stats GetAudioReceiveStreamStats() const {
427 webrtc::AudioReceiveStream::Stats stats;
428 stats.remote_ssrc = 123;
429 stats.bytes_rcvd = 456;
430 stats.packets_rcvd = 768;
431 stats.packets_lost = 101;
432 stats.fraction_lost = 23.45f;
433 stats.codec_name = "codec_name_recv";
434 stats.ext_seqnum = 678;
435 stats.jitter_ms = 901;
436 stats.jitter_buffer_ms = 234;
437 stats.jitter_buffer_preferred_ms = 567;
438 stats.delay_estimate_ms = 890;
439 stats.audio_level = 1234;
440 stats.expand_rate = 5.67f;
441 stats.speech_expand_rate = 8.90f;
442 stats.secondary_decoded_rate = 1.23f;
443 stats.accelerate_rate = 4.56f;
444 stats.preemptive_expand_rate = 7.89f;
445 stats.decoding_calls_to_silence_generator = 12;
446 stats.decoding_calls_to_neteq = 345;
447 stats.decoding_normal = 67890;
448 stats.decoding_plc = 1234;
449 stats.decoding_cng = 5678;
450 stats.decoding_plc_cng = 9012;
451 stats.capture_start_ntp_time_ms = 3456;
Fredrik Solenberg4f4ec0a2015-10-22 10:49:27 +0200452 return stats;
453 }
454 void SetAudioReceiveStreamStats() {
455 for (auto* s : call_.GetAudioReceiveStreams()) {
456 s->SetStats(GetAudioReceiveStreamStats());
457 }
458 }
459 void VerifyVoiceReceiverInfo(const cricket::VoiceReceiverInfo& info) {
solenberg85a04962015-10-27 03:35:21 -0700460 const auto stats = GetAudioReceiveStreamStats();
461 EXPECT_EQ(info.ssrc(), stats.remote_ssrc);
462 EXPECT_EQ(info.bytes_rcvd, stats.bytes_rcvd);
463 EXPECT_EQ(info.packets_rcvd, stats.packets_rcvd);
464 EXPECT_EQ(info.packets_lost, stats.packets_lost);
465 EXPECT_EQ(info.fraction_lost, stats.fraction_lost);
466 EXPECT_EQ(info.codec_name, stats.codec_name);
467 EXPECT_EQ(info.ext_seqnum, stats.ext_seqnum);
468 EXPECT_EQ(info.jitter_ms, stats.jitter_ms);
469 EXPECT_EQ(info.jitter_buffer_ms, stats.jitter_buffer_ms);
Fredrik Solenberg4f4ec0a2015-10-22 10:49:27 +0200470 EXPECT_EQ(info.jitter_buffer_preferred_ms,
solenberg85a04962015-10-27 03:35:21 -0700471 stats.jitter_buffer_preferred_ms);
472 EXPECT_EQ(info.delay_estimate_ms, stats.delay_estimate_ms);
473 EXPECT_EQ(info.audio_level, stats.audio_level);
474 EXPECT_EQ(info.expand_rate, stats.expand_rate);
475 EXPECT_EQ(info.speech_expand_rate, stats.speech_expand_rate);
476 EXPECT_EQ(info.secondary_decoded_rate, stats.secondary_decoded_rate);
477 EXPECT_EQ(info.accelerate_rate, stats.accelerate_rate);
478 EXPECT_EQ(info.preemptive_expand_rate, stats.preemptive_expand_rate);
Fredrik Solenberg4f4ec0a2015-10-22 10:49:27 +0200479 EXPECT_EQ(info.decoding_calls_to_silence_generator,
solenberg85a04962015-10-27 03:35:21 -0700480 stats.decoding_calls_to_silence_generator);
481 EXPECT_EQ(info.decoding_calls_to_neteq, stats.decoding_calls_to_neteq);
482 EXPECT_EQ(info.decoding_normal, stats.decoding_normal);
483 EXPECT_EQ(info.decoding_plc, stats.decoding_plc);
484 EXPECT_EQ(info.decoding_cng, stats.decoding_cng);
485 EXPECT_EQ(info.decoding_plc_cng, stats.decoding_plc_cng);
486 EXPECT_EQ(info.capture_start_ntp_time_ms, stats.capture_start_ntp_time_ms);
Fredrik Solenberg4f4ec0a2015-10-22 10:49:27 +0200487 }
488
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000489 protected:
solenbergbc37fc82016-04-04 09:54:44 -0700490 StrictMock<webrtc::test::MockAudioDeviceModule> adm_;
Fredrik Solenberg709ed672015-09-15 12:26:33 +0200491 cricket::FakeCall call_;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000492 cricket::FakeWebRtcVoiceEngine voe_;
solenbergbc37fc82016-04-04 09:54:44 -0700493 std::unique_ptr<cricket::WebRtcVoiceEngine> engine_;
solenbergff976312016-03-30 23:28:51 -0700494 cricket::VoiceMediaChannel* channel_ = nullptr;
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200495 cricket::AudioSendParameters send_parameters_;
496 cricket::AudioRecvParameters recv_parameters_;
Taylor Brandstetter1a018dc2016-03-08 12:37:39 -0800497 FakeAudioSource fake_source_;
stefanba4c0e42016-02-04 04:12:24 -0800498 private:
499 webrtc::test::ScopedFieldTrials override_field_trials_;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000500};
501
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000502// Tests that we can create and destroy a channel.
503TEST_F(WebRtcVoiceEngineTestFake, CreateChannel) {
solenbergff976312016-03-30 23:28:51 -0700504 EXPECT_TRUE(SetupChannel());
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000505}
506
solenberg31fec402016-05-06 02:13:12 -0700507// Test that we can add a send stream and that it has the correct defaults.
508TEST_F(WebRtcVoiceEngineTestFake, CreateSendStream) {
509 EXPECT_TRUE(SetupChannel());
510 EXPECT_TRUE(
511 channel_->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc1)));
512 const webrtc::AudioSendStream::Config& config = GetSendStreamConfig(kSsrc1);
513 EXPECT_EQ(kSsrc1, config.rtp.ssrc);
514 EXPECT_EQ("", config.rtp.c_name);
515 EXPECT_EQ(0u, config.rtp.extensions.size());
516 EXPECT_EQ(static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_),
517 config.send_transport);
518}
519
520// Test that we can add a receive stream and that it has the correct defaults.
521TEST_F(WebRtcVoiceEngineTestFake, CreateRecvStream) {
522 EXPECT_TRUE(SetupChannel());
solenberg8189b022016-06-14 12:13:00 -0700523 EXPECT_TRUE(AddRecvStream(kSsrc1));
solenberg31fec402016-05-06 02:13:12 -0700524 const webrtc::AudioReceiveStream::Config& config =
525 GetRecvStreamConfig(kSsrc1);
526 EXPECT_EQ(kSsrc1, config.rtp.remote_ssrc);
527 EXPECT_EQ(0xFA17FA17, config.rtp.local_ssrc);
528 EXPECT_FALSE(config.rtp.transport_cc);
529 EXPECT_EQ(0u, config.rtp.extensions.size());
530 EXPECT_EQ(static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_),
531 config.rtcp_send_transport);
532 EXPECT_EQ("", config.sync_group);
533}
534
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000535// Tests that the list of supported codecs is created properly and ordered
deadbeef67cf2c12016-04-13 10:07:16 -0700536// correctly (such that opus appears first).
ossudedfd282016-06-14 07:12:39 -0700537// TODO(ossu): This test should move into a separate builtin audio codecs
538// module.
deadbeef67cf2c12016-04-13 10:07:16 -0700539TEST_F(WebRtcVoiceEngineTestFake, CodecOrder) {
ossudedfd282016-06-14 07:12:39 -0700540 const std::vector<cricket::AudioCodec>& codecs = engine_->send_codecs();
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000541 ASSERT_FALSE(codecs.empty());
542 EXPECT_STRCASEEQ("opus", codecs[0].name.c_str());
543 EXPECT_EQ(48000, codecs[0].clockrate);
544 EXPECT_EQ(2, codecs[0].channels);
545 EXPECT_EQ(64000, codecs[0].bitrate);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000546}
547
stefanba4c0e42016-02-04 04:12:24 -0800548TEST_F(WebRtcVoiceEngineTestFake, OpusSupportsTransportCc) {
ossudedfd282016-06-14 07:12:39 -0700549 const std::vector<cricket::AudioCodec>& codecs = engine_->send_codecs();
stefanba4c0e42016-02-04 04:12:24 -0800550 bool opus_found = false;
551 for (cricket::AudioCodec codec : codecs) {
552 if (codec.name == "opus") {
553 EXPECT_TRUE(HasTransportCc(codec));
554 opus_found = true;
555 }
556 }
557 EXPECT_TRUE(opus_found);
558}
559
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000560// Tests that we can find codecs by name or id, and that we interpret the
561// clockrate and bitrate fields properly.
562TEST_F(WebRtcVoiceEngineTestFake, FindCodec) {
563 cricket::AudioCodec codec;
564 webrtc::CodecInst codec_inst;
565 // Find PCMU with explicit clockrate and bitrate.
solenberg26c8c912015-11-27 04:00:25 -0800566 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(kPcmuCodec, &codec_inst));
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000567 // Find ISAC with explicit clockrate and 0 bitrate.
solenberg26c8c912015-11-27 04:00:25 -0800568 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(kIsacCodec, &codec_inst));
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000569 // Find telephone-event with explicit clockrate and 0 bitrate.
solenberg26c8c912015-11-27 04:00:25 -0800570 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(kTelephoneEventCodec,
571 &codec_inst));
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000572 // Find ISAC with a different payload id.
573 codec = kIsacCodec;
574 codec.id = 127;
solenberg26c8c912015-11-27 04:00:25 -0800575 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(codec, &codec_inst));
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000576 EXPECT_EQ(codec.id, codec_inst.pltype);
577 // Find PCMU with a 0 clockrate.
578 codec = kPcmuCodec;
579 codec.clockrate = 0;
solenberg26c8c912015-11-27 04:00:25 -0800580 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(codec, &codec_inst));
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000581 EXPECT_EQ(codec.id, codec_inst.pltype);
582 EXPECT_EQ(8000, codec_inst.plfreq);
583 // Find PCMU with a 0 bitrate.
584 codec = kPcmuCodec;
585 codec.bitrate = 0;
solenberg26c8c912015-11-27 04:00:25 -0800586 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(codec, &codec_inst));
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000587 EXPECT_EQ(codec.id, codec_inst.pltype);
588 EXPECT_EQ(64000, codec_inst.rate);
589 // Find ISAC with an explicit bitrate.
590 codec = kIsacCodec;
591 codec.bitrate = 32000;
solenberg26c8c912015-11-27 04:00:25 -0800592 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(codec, &codec_inst));
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000593 EXPECT_EQ(codec.id, codec_inst.pltype);
594 EXPECT_EQ(32000, codec_inst.rate);
595}
596
597// Test that we set our inbound codecs properly, including changing PT.
598TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecs) {
solenbergff976312016-03-30 23:28:51 -0700599 EXPECT_TRUE(SetupChannel());
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200600 cricket::AudioRecvParameters parameters;
601 parameters.codecs.push_back(kIsacCodec);
602 parameters.codecs.push_back(kPcmuCodec);
603 parameters.codecs.push_back(kTelephoneEventCodec);
604 parameters.codecs[0].id = 106; // collide with existing telephone-event
605 parameters.codecs[2].id = 126;
606 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
solenberg8189b022016-06-14 12:13:00 -0700607 EXPECT_TRUE(AddRecvStream(kSsrc1));
solenberg1ac56142015-10-13 03:58:19 -0700608 int channel_num = voe_.GetLastChannel();
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000609 webrtc::CodecInst gcodec;
tfarina5237aaf2015-11-10 23:44:30 -0800610 rtc::strcpyn(gcodec.plname, arraysize(gcodec.plname), "ISAC");
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000611 gcodec.plfreq = 16000;
612 gcodec.channels = 1;
613 EXPECT_EQ(0, voe_.GetRecPayloadType(channel_num, gcodec));
614 EXPECT_EQ(106, gcodec.pltype);
615 EXPECT_STREQ("ISAC", gcodec.plname);
tfarina5237aaf2015-11-10 23:44:30 -0800616 rtc::strcpyn(gcodec.plname, arraysize(gcodec.plname), "telephone-event");
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000617 gcodec.plfreq = 8000;
618 EXPECT_EQ(0, voe_.GetRecPayloadType(channel_num, gcodec));
619 EXPECT_EQ(126, gcodec.pltype);
620 EXPECT_STREQ("telephone-event", gcodec.plname);
621}
622
623// Test that we fail to set an unknown inbound codec.
624TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecsUnsupportedCodec) {
solenbergff976312016-03-30 23:28:51 -0700625 EXPECT_TRUE(SetupChannel());
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200626 cricket::AudioRecvParameters parameters;
627 parameters.codecs.push_back(kIsacCodec);
deadbeef67cf2c12016-04-13 10:07:16 -0700628 parameters.codecs.push_back(cricket::AudioCodec(127, "XYZ", 32000, 0, 1));
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200629 EXPECT_FALSE(channel_->SetRecvParameters(parameters));
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000630}
631
632// Test that we fail if we have duplicate types in the inbound list.
633TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecsDuplicatePayloadType) {
solenbergff976312016-03-30 23:28:51 -0700634 EXPECT_TRUE(SetupChannel());
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200635 cricket::AudioRecvParameters parameters;
636 parameters.codecs.push_back(kIsacCodec);
637 parameters.codecs.push_back(kCn16000Codec);
638 parameters.codecs[1].id = kIsacCodec.id;
639 EXPECT_FALSE(channel_->SetRecvParameters(parameters));
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000640}
641
642// Test that we can decode OPUS without stereo parameters.
643TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecsWithOpusNoStereo) {
solenbergff976312016-03-30 23:28:51 -0700644 EXPECT_TRUE(SetupChannel());
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200645 cricket::AudioRecvParameters parameters;
646 parameters.codecs.push_back(kIsacCodec);
647 parameters.codecs.push_back(kPcmuCodec);
648 parameters.codecs.push_back(kOpusCodec);
649 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
solenberg8189b022016-06-14 12:13:00 -0700650 EXPECT_TRUE(AddRecvStream(kSsrc1));
solenberg1ac56142015-10-13 03:58:19 -0700651 int channel_num = voe_.GetLastChannel();
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000652 webrtc::CodecInst opus;
solenberg26c8c912015-11-27 04:00:25 -0800653 cricket::WebRtcVoiceEngine::ToCodecInst(kOpusCodec, &opus);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000654 // Even without stereo parameters, recv codecs still specify channels = 2.
655 EXPECT_EQ(2, opus.channels);
656 EXPECT_EQ(111, opus.pltype);
657 EXPECT_STREQ("opus", opus.plname);
658 opus.pltype = 0;
solenberg1ac56142015-10-13 03:58:19 -0700659 EXPECT_EQ(0, voe_.GetRecPayloadType(channel_num, opus));
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000660 EXPECT_EQ(111, opus.pltype);
661}
662
663// Test that we can decode OPUS with stereo = 0.
664TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecsWithOpus0Stereo) {
solenbergff976312016-03-30 23:28:51 -0700665 EXPECT_TRUE(SetupChannel());
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200666 cricket::AudioRecvParameters parameters;
667 parameters.codecs.push_back(kIsacCodec);
668 parameters.codecs.push_back(kPcmuCodec);
669 parameters.codecs.push_back(kOpusCodec);
670 parameters.codecs[2].params["stereo"] = "0";
671 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
solenberg8189b022016-06-14 12:13:00 -0700672 EXPECT_TRUE(AddRecvStream(kSsrc1));
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000673 int channel_num2 = voe_.GetLastChannel();
674 webrtc::CodecInst opus;
solenberg26c8c912015-11-27 04:00:25 -0800675 cricket::WebRtcVoiceEngine::ToCodecInst(kOpusCodec, &opus);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000676 // Even when stereo is off, recv codecs still specify channels = 2.
677 EXPECT_EQ(2, opus.channels);
678 EXPECT_EQ(111, opus.pltype);
679 EXPECT_STREQ("opus", opus.plname);
680 opus.pltype = 0;
681 EXPECT_EQ(0, voe_.GetRecPayloadType(channel_num2, opus));
682 EXPECT_EQ(111, opus.pltype);
683}
684
685// Test that we can decode OPUS with stereo = 1.
686TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecsWithOpus1Stereo) {
solenbergff976312016-03-30 23:28:51 -0700687 EXPECT_TRUE(SetupChannel());
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200688 cricket::AudioRecvParameters parameters;
689 parameters.codecs.push_back(kIsacCodec);
690 parameters.codecs.push_back(kPcmuCodec);
691 parameters.codecs.push_back(kOpusCodec);
692 parameters.codecs[2].params["stereo"] = "1";
693 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
solenberg8189b022016-06-14 12:13:00 -0700694 EXPECT_TRUE(AddRecvStream(kSsrc1));
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000695 int channel_num2 = voe_.GetLastChannel();
696 webrtc::CodecInst opus;
solenberg26c8c912015-11-27 04:00:25 -0800697 cricket::WebRtcVoiceEngine::ToCodecInst(kOpusCodec, &opus);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000698 EXPECT_EQ(2, opus.channels);
699 EXPECT_EQ(111, opus.pltype);
700 EXPECT_STREQ("opus", opus.plname);
701 opus.pltype = 0;
702 EXPECT_EQ(0, voe_.GetRecPayloadType(channel_num2, opus));
703 EXPECT_EQ(111, opus.pltype);
704}
705
706// Test that changes to recv codecs are applied to all streams.
707TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecsWithMultipleStreams) {
solenbergff976312016-03-30 23:28:51 -0700708 EXPECT_TRUE(SetupChannel());
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200709 cricket::AudioRecvParameters parameters;
710 parameters.codecs.push_back(kIsacCodec);
711 parameters.codecs.push_back(kPcmuCodec);
712 parameters.codecs.push_back(kTelephoneEventCodec);
713 parameters.codecs[0].id = 106; // collide with existing telephone-event
714 parameters.codecs[2].id = 126;
715 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
solenberg8189b022016-06-14 12:13:00 -0700716 EXPECT_TRUE(AddRecvStream(kSsrc1));
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000717 int channel_num2 = voe_.GetLastChannel();
718 webrtc::CodecInst gcodec;
tfarina5237aaf2015-11-10 23:44:30 -0800719 rtc::strcpyn(gcodec.plname, arraysize(gcodec.plname), "ISAC");
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000720 gcodec.plfreq = 16000;
721 gcodec.channels = 1;
722 EXPECT_EQ(0, voe_.GetRecPayloadType(channel_num2, gcodec));
723 EXPECT_EQ(106, gcodec.pltype);
724 EXPECT_STREQ("ISAC", gcodec.plname);
tfarina5237aaf2015-11-10 23:44:30 -0800725 rtc::strcpyn(gcodec.plname, arraysize(gcodec.plname), "telephone-event");
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000726 gcodec.plfreq = 8000;
727 gcodec.channels = 1;
728 EXPECT_EQ(0, voe_.GetRecPayloadType(channel_num2, gcodec));
729 EXPECT_EQ(126, gcodec.pltype);
730 EXPECT_STREQ("telephone-event", gcodec.plname);
731}
732
733TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecsAfterAddingStreams) {
solenbergff976312016-03-30 23:28:51 -0700734 EXPECT_TRUE(SetupRecvStream());
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200735 cricket::AudioRecvParameters parameters;
736 parameters.codecs.push_back(kIsacCodec);
737 parameters.codecs[0].id = 106; // collide with existing telephone-event
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200738 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000739
740 int channel_num2 = voe_.GetLastChannel();
741 webrtc::CodecInst gcodec;
tfarina5237aaf2015-11-10 23:44:30 -0800742 rtc::strcpyn(gcodec.plname, arraysize(gcodec.plname), "ISAC");
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000743 gcodec.plfreq = 16000;
744 gcodec.channels = 1;
745 EXPECT_EQ(0, voe_.GetRecPayloadType(channel_num2, gcodec));
746 EXPECT_EQ(106, gcodec.pltype);
747 EXPECT_STREQ("ISAC", gcodec.plname);
748}
749
750// Test that we can apply the same set of codecs again while playing.
751TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecsWhilePlaying) {
solenbergff976312016-03-30 23:28:51 -0700752 EXPECT_TRUE(SetupRecvStream());
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200753 cricket::AudioRecvParameters parameters;
754 parameters.codecs.push_back(kIsacCodec);
755 parameters.codecs.push_back(kCn16000Codec);
756 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000757 EXPECT_TRUE(channel_->SetPlayout(true));
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200758 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000759
760 // Changing the payload type of a codec should fail.
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200761 parameters.codecs[0].id = 127;
762 EXPECT_FALSE(channel_->SetRecvParameters(parameters));
763 int channel_num = voe_.GetLastChannel();
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000764 EXPECT_TRUE(voe_.GetPlayout(channel_num));
765}
766
767// Test that we can add a codec while playing.
768TEST_F(WebRtcVoiceEngineTestFake, AddRecvCodecsWhilePlaying) {
solenbergff976312016-03-30 23:28:51 -0700769 EXPECT_TRUE(SetupRecvStream());
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200770 cricket::AudioRecvParameters parameters;
771 parameters.codecs.push_back(kIsacCodec);
772 parameters.codecs.push_back(kCn16000Codec);
773 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000774 EXPECT_TRUE(channel_->SetPlayout(true));
775
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200776 parameters.codecs.push_back(kOpusCodec);
777 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
778 int channel_num = voe_.GetLastChannel();
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000779 EXPECT_TRUE(voe_.GetPlayout(channel_num));
780 webrtc::CodecInst gcodec;
solenberg26c8c912015-11-27 04:00:25 -0800781 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(kOpusCodec, &gcodec));
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000782 EXPECT_EQ(kOpusCodec.id, gcodec.pltype);
783}
784
785TEST_F(WebRtcVoiceEngineTestFake, SetSendBandwidthAuto) {
solenbergff976312016-03-30 23:28:51 -0700786 EXPECT_TRUE(SetupSendStream());
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000787
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +0000788 // Test that when autobw is enabled, bitrate is kept as the default
789 // value. autobw is enabled for the following tests because the target
790 // bitrate is <= 0.
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000791
792 // ISAC, default bitrate == 32000.
deadbeef80346142016-04-27 14:17:10 -0700793 TestMaxSendBandwidth(kIsacCodec, 0, true, 32000);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000794
795 // PCMU, default bitrate == 64000.
deadbeef80346142016-04-27 14:17:10 -0700796 TestMaxSendBandwidth(kPcmuCodec, -1, true, 64000);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000797
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000798 // opus, default bitrate == 64000.
deadbeef80346142016-04-27 14:17:10 -0700799 TestMaxSendBandwidth(kOpusCodec, -1, true, 64000);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000800}
801
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +0000802TEST_F(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthMultiRateAsCaller) {
solenbergff976312016-03-30 23:28:51 -0700803 EXPECT_TRUE(SetupSendStream());
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000804
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +0000805 // Test that the bitrate of a multi-rate codec is always the maximum.
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000806
807 // ISAC, default bitrate == 32000.
deadbeef80346142016-04-27 14:17:10 -0700808 TestMaxSendBandwidth(kIsacCodec, 40000, true, 40000);
809 TestMaxSendBandwidth(kIsacCodec, 16000, true, 16000);
810 // Rates above the max (56000) should be capped.
811 TestMaxSendBandwidth(kIsacCodec, 100000, true, 56000);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000812
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000813 // opus, default bitrate == 64000.
deadbeef80346142016-04-27 14:17:10 -0700814 TestMaxSendBandwidth(kOpusCodec, 96000, true, 96000);
815 TestMaxSendBandwidth(kOpusCodec, 48000, true, 48000);
816 // Rates above the max (510000) should be capped.
817 TestMaxSendBandwidth(kOpusCodec, 600000, true, 510000);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000818}
819
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +0000820TEST_F(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthFixedRateAsCaller) {
solenbergff976312016-03-30 23:28:51 -0700821 EXPECT_TRUE(SetupSendStream());
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +0000822
823 // Test that we can only set a maximum bitrate for a fixed-rate codec
824 // if it's bigger than the fixed rate.
825
826 // PCMU, fixed bitrate == 64000.
deadbeef80346142016-04-27 14:17:10 -0700827 TestMaxSendBandwidth(kPcmuCodec, 0, true, 64000);
828 TestMaxSendBandwidth(kPcmuCodec, 1, false, 64000);
829 TestMaxSendBandwidth(kPcmuCodec, 128000, true, 64000);
830 TestMaxSendBandwidth(kPcmuCodec, 32000, false, 64000);
831 TestMaxSendBandwidth(kPcmuCodec, 64000, true, 64000);
832 TestMaxSendBandwidth(kPcmuCodec, 63999, false, 64000);
833 TestMaxSendBandwidth(kPcmuCodec, 64001, true, 64000);
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +0000834}
835
836TEST_F(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthMultiRateAsCallee) {
solenbergff976312016-03-30 23:28:51 -0700837 EXPECT_TRUE(SetupChannel());
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200838 const int kDesiredBitrate = 128000;
839 cricket::AudioSendParameters parameters;
ossudedfd282016-06-14 07:12:39 -0700840 parameters.codecs = engine_->send_codecs();
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200841 parameters.max_bandwidth_bps = kDesiredBitrate;
842 EXPECT_TRUE(channel_->SetSendParameters(parameters));
wu@webrtc.org1d1ffc92013-10-16 18:12:02 +0000843
844 EXPECT_TRUE(channel_->AddSendStream(
845 cricket::StreamParams::CreateLegacy(kSsrc1)));
846
847 int channel_num = voe_.GetLastChannel();
848 webrtc::CodecInst codec;
849 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, codec));
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200850 EXPECT_EQ(kDesiredBitrate, codec.rate);
wu@webrtc.org1d1ffc92013-10-16 18:12:02 +0000851}
852
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000853// Test that bitrate cannot be set for CBR codecs.
854// Bitrate is ignored if it is higher than the fixed bitrate.
855// Bitrate less then the fixed bitrate is an error.
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +0000856TEST_F(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthCbr) {
solenbergff976312016-03-30 23:28:51 -0700857 EXPECT_TRUE(SetupSendStream());
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000858
859 // PCMU, default bitrate == 64000.
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200860 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
861 int channel_num = voe_.GetLastChannel();
862 webrtc::CodecInst codec;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000863 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, codec));
864 EXPECT_EQ(64000, codec.rate);
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200865
866 send_parameters_.max_bandwidth_bps = 128000;
867 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000868 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, codec));
869 EXPECT_EQ(64000, codec.rate);
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200870
871 send_parameters_.max_bandwidth_bps = 128;
872 EXPECT_FALSE(channel_->SetSendParameters(send_parameters_));
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000873 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, codec));
874 EXPECT_EQ(64000, codec.rate);
875}
876
skvlade0d46372016-04-07 22:59:22 -0700877// Test that the per-stream bitrate limit and the global
878// bitrate limit both apply.
879TEST_F(WebRtcVoiceEngineTestFake, SetMaxBitratePerStream) {
880 EXPECT_TRUE(SetupSendStream());
881
882 // opus, default bitrate == 64000.
883 SetAndExpectMaxBitrate(kOpusCodec, 0, 0, true, 64000);
884 SetAndExpectMaxBitrate(kOpusCodec, 48000, 0, true, 48000);
885 SetAndExpectMaxBitrate(kOpusCodec, 48000, 64000, true, 48000);
886 SetAndExpectMaxBitrate(kOpusCodec, 64000, 48000, true, 48000);
887
888 // CBR codecs allow both maximums to exceed the bitrate.
889 SetAndExpectMaxBitrate(kPcmuCodec, 0, 0, true, 64000);
890 SetAndExpectMaxBitrate(kPcmuCodec, 64001, 0, true, 64000);
891 SetAndExpectMaxBitrate(kPcmuCodec, 0, 64001, true, 64000);
892 SetAndExpectMaxBitrate(kPcmuCodec, 64001, 64001, true, 64000);
893
894 // CBR codecs don't allow per stream maximums to be too low.
895 SetAndExpectMaxBitrate(kPcmuCodec, 0, 63999, false, 64000);
896 SetAndExpectMaxBitrate(kPcmuCodec, 64001, 63999, false, 64000);
897}
898
899// Test that an attempt to set RtpParameters for a stream that does not exist
900// fails.
901TEST_F(WebRtcVoiceEngineTestFake, CannotSetMaxBitrateForNonexistentStream) {
902 EXPECT_TRUE(SetupChannel());
903 webrtc::RtpParameters nonexistent_parameters =
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -0700904 channel_->GetRtpSendParameters(kSsrc1);
skvlade0d46372016-04-07 22:59:22 -0700905 EXPECT_EQ(0, nonexistent_parameters.encodings.size());
906
907 nonexistent_parameters.encodings.push_back(webrtc::RtpEncodingParameters());
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -0700908 EXPECT_FALSE(channel_->SetRtpSendParameters(kSsrc1, nonexistent_parameters));
skvlade0d46372016-04-07 22:59:22 -0700909}
910
911TEST_F(WebRtcVoiceEngineTestFake,
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -0700912 CannotSetRtpSendParametersWithIncorrectNumberOfEncodings) {
skvlade0d46372016-04-07 22:59:22 -0700913 // This test verifies that setting RtpParameters succeeds only if
914 // the structure contains exactly one encoding.
915 // TODO(skvlad): Update this test when we start supporting setting parameters
916 // for each encoding individually.
917
918 EXPECT_TRUE(SetupSendStream());
919 // Setting RtpParameters with no encoding is expected to fail.
920 webrtc::RtpParameters parameters;
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -0700921 EXPECT_FALSE(channel_->SetRtpSendParameters(kSsrc1, parameters));
skvlade0d46372016-04-07 22:59:22 -0700922 // Setting RtpParameters with exactly one encoding should succeed.
923 parameters.encodings.push_back(webrtc::RtpEncodingParameters());
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -0700924 EXPECT_TRUE(channel_->SetRtpSendParameters(kSsrc1, parameters));
skvlade0d46372016-04-07 22:59:22 -0700925 // Two or more encodings should result in failure.
926 parameters.encodings.push_back(webrtc::RtpEncodingParameters());
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -0700927 EXPECT_FALSE(channel_->SetRtpSendParameters(kSsrc1, parameters));
skvlade0d46372016-04-07 22:59:22 -0700928}
929
Taylor Brandstetter55dd7082016-05-03 13:50:11 -0700930// Test that a stream will not be sending if its encoding is made
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -0700931// inactive through SetRtpSendParameters.
Taylor Brandstetter55dd7082016-05-03 13:50:11 -0700932TEST_F(WebRtcVoiceEngineTestFake, SetRtpParametersEncodingsActive) {
933 EXPECT_TRUE(SetupSendStream());
934 SetSend(channel_, true);
935 EXPECT_TRUE(GetSendStream(kSsrc1).IsSending());
936 // Get current parameters and change "active" to false.
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -0700937 webrtc::RtpParameters parameters = channel_->GetRtpSendParameters(kSsrc1);
Taylor Brandstetter55dd7082016-05-03 13:50:11 -0700938 ASSERT_EQ(1u, parameters.encodings.size());
939 ASSERT_TRUE(parameters.encodings[0].active);
940 parameters.encodings[0].active = false;
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -0700941 EXPECT_TRUE(channel_->SetRtpSendParameters(kSsrc1, parameters));
Taylor Brandstetter55dd7082016-05-03 13:50:11 -0700942 EXPECT_FALSE(GetSendStream(kSsrc1).IsSending());
943
944 // Now change it back to active and verify we resume sending.
945 parameters.encodings[0].active = true;
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -0700946 EXPECT_TRUE(channel_->SetRtpSendParameters(kSsrc1, parameters));
Taylor Brandstetter55dd7082016-05-03 13:50:11 -0700947 EXPECT_TRUE(GetSendStream(kSsrc1).IsSending());
948}
949
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -0700950// Test that SetRtpSendParameters configures the correct encoding channel for
951// each SSRC.
skvlade0d46372016-04-07 22:59:22 -0700952TEST_F(WebRtcVoiceEngineTestFake, RtpParametersArePerStream) {
953 SetupForMultiSendStream();
954 // Create send streams.
955 for (uint32_t ssrc : kSsrcs4) {
956 EXPECT_TRUE(
957 channel_->AddSendStream(cricket::StreamParams::CreateLegacy(ssrc)));
958 }
959 // Configure one stream to be limited by the stream config, another to be
960 // limited by the global max, and the third one with no per-stream limit
961 // (still subject to the global limit).
962 EXPECT_TRUE(SetGlobalMaxBitrate(kOpusCodec, 64000));
963 EXPECT_TRUE(SetMaxBitrateForStream(kSsrcs4[0], 48000));
964 EXPECT_TRUE(SetMaxBitrateForStream(kSsrcs4[1], 96000));
965 EXPECT_TRUE(SetMaxBitrateForStream(kSsrcs4[2], -1));
966
967 EXPECT_EQ(48000, GetCodecBitrate(kSsrcs4[0]));
968 EXPECT_EQ(64000, GetCodecBitrate(kSsrcs4[1]));
969 EXPECT_EQ(64000, GetCodecBitrate(kSsrcs4[2]));
970
971 // Remove the global cap; the streams should switch to their respective
972 // maximums (or remain unchanged if there was no other limit on them.)
973 EXPECT_TRUE(SetGlobalMaxBitrate(kOpusCodec, -1));
974 EXPECT_EQ(48000, GetCodecBitrate(kSsrcs4[0]));
975 EXPECT_EQ(96000, GetCodecBitrate(kSsrcs4[1]));
976 EXPECT_EQ(64000, GetCodecBitrate(kSsrcs4[2]));
977}
978
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -0700979// Test that GetRtpSendParameters returns the currently configured codecs.
980TEST_F(WebRtcVoiceEngineTestFake, GetRtpSendParametersCodecs) {
Taylor Brandstetter0cd086b2016-04-20 16:23:10 -0700981 EXPECT_TRUE(SetupSendStream());
982 cricket::AudioSendParameters parameters;
983 parameters.codecs.push_back(kIsacCodec);
984 parameters.codecs.push_back(kPcmuCodec);
985 EXPECT_TRUE(channel_->SetSendParameters(parameters));
986
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -0700987 webrtc::RtpParameters rtp_parameters = channel_->GetRtpSendParameters(kSsrc1);
Taylor Brandstetter0cd086b2016-04-20 16:23:10 -0700988 ASSERT_EQ(2u, rtp_parameters.codecs.size());
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -0700989 EXPECT_EQ(kIsacCodec.ToCodecParameters(), rtp_parameters.codecs[0]);
990 EXPECT_EQ(kPcmuCodec.ToCodecParameters(), rtp_parameters.codecs[1]);
Taylor Brandstetter0cd086b2016-04-20 16:23:10 -0700991}
992
993// Test that if we set/get parameters multiple times, we get the same results.
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -0700994TEST_F(WebRtcVoiceEngineTestFake, SetAndGetRtpSendParameters) {
Taylor Brandstetter0cd086b2016-04-20 16:23:10 -0700995 EXPECT_TRUE(SetupSendStream());
996 cricket::AudioSendParameters parameters;
997 parameters.codecs.push_back(kIsacCodec);
998 parameters.codecs.push_back(kPcmuCodec);
999 EXPECT_TRUE(channel_->SetSendParameters(parameters));
1000
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07001001 webrtc::RtpParameters initial_params = channel_->GetRtpSendParameters(kSsrc1);
Taylor Brandstetter0cd086b2016-04-20 16:23:10 -07001002
1003 // We should be able to set the params we just got.
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07001004 EXPECT_TRUE(channel_->SetRtpSendParameters(kSsrc1, initial_params));
Taylor Brandstetter0cd086b2016-04-20 16:23:10 -07001005
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07001006 // ... And this shouldn't change the params returned by GetRtpSendParameters.
1007 webrtc::RtpParameters new_params = channel_->GetRtpSendParameters(kSsrc1);
1008 EXPECT_EQ(initial_params, channel_->GetRtpSendParameters(kSsrc1));
1009}
1010
1011// Test that GetRtpReceiveParameters returns the currently configured codecs.
1012TEST_F(WebRtcVoiceEngineTestFake, GetRtpReceiveParametersCodecs) {
1013 EXPECT_TRUE(SetupRecvStream());
1014 cricket::AudioRecvParameters parameters;
1015 parameters.codecs.push_back(kIsacCodec);
1016 parameters.codecs.push_back(kPcmuCodec);
1017 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
1018
1019 webrtc::RtpParameters rtp_parameters =
1020 channel_->GetRtpReceiveParameters(kSsrc1);
1021 ASSERT_EQ(2u, rtp_parameters.codecs.size());
1022 EXPECT_EQ(kIsacCodec.ToCodecParameters(), rtp_parameters.codecs[0]);
1023 EXPECT_EQ(kPcmuCodec.ToCodecParameters(), rtp_parameters.codecs[1]);
1024}
1025
1026// Test that if we set/get parameters multiple times, we get the same results.
1027TEST_F(WebRtcVoiceEngineTestFake, SetAndGetRtpReceiveParameters) {
1028 EXPECT_TRUE(SetupRecvStream());
1029 cricket::AudioRecvParameters parameters;
1030 parameters.codecs.push_back(kIsacCodec);
1031 parameters.codecs.push_back(kPcmuCodec);
1032 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
1033
1034 webrtc::RtpParameters initial_params =
1035 channel_->GetRtpReceiveParameters(kSsrc1);
1036
1037 // We should be able to set the params we just got.
1038 EXPECT_TRUE(channel_->SetRtpReceiveParameters(kSsrc1, initial_params));
1039
1040 // ... And this shouldn't change the params returned by
1041 // GetRtpReceiveParameters.
1042 webrtc::RtpParameters new_params = channel_->GetRtpReceiveParameters(kSsrc1);
1043 EXPECT_EQ(initial_params, channel_->GetRtpReceiveParameters(kSsrc1));
Taylor Brandstetter0cd086b2016-04-20 16:23:10 -07001044}
1045
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001046// Test that we apply codecs properly.
1047TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecs) {
solenbergff976312016-03-30 23:28:51 -07001048 EXPECT_TRUE(SetupSendStream());
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001049 cricket::AudioSendParameters parameters;
1050 parameters.codecs.push_back(kIsacCodec);
1051 parameters.codecs.push_back(kPcmuCodec);
kwiberg68061362016-06-14 08:04:47 -07001052 parameters.codecs.push_back(kCn8000Codec);
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001053 parameters.codecs[0].id = 96;
1054 parameters.codecs[0].bitrate = 48000;
1055 EXPECT_TRUE(channel_->SetSendParameters(parameters));
wu@webrtc.org05e7b442014-04-01 17:44:24 +00001056 EXPECT_EQ(1, voe_.GetNumSetSendCodecs());
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001057 int channel_num = voe_.GetLastChannel();
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001058 webrtc::CodecInst gcodec;
1059 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
1060 EXPECT_EQ(96, gcodec.pltype);
1061 EXPECT_EQ(48000, gcodec.rate);
1062 EXPECT_STREQ("ISAC", gcodec.plname);
1063 EXPECT_FALSE(voe_.GetVAD(channel_num));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001064 EXPECT_EQ(13, voe_.GetSendCNPayloadType(channel_num, false));
1065 EXPECT_EQ(105, voe_.GetSendCNPayloadType(channel_num, true));
Fredrik Solenbergb5727682015-12-04 15:22:19 +01001066 EXPECT_FALSE(channel_->CanInsertDtmf());
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001067}
1068
wu@webrtc.org05e7b442014-04-01 17:44:24 +00001069// Test that VoE Channel doesn't call SetSendCodec again if same codec is tried
1070// to apply.
1071TEST_F(WebRtcVoiceEngineTestFake, DontResetSetSendCodec) {
solenbergff976312016-03-30 23:28:51 -07001072 EXPECT_TRUE(SetupSendStream());
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001073 cricket::AudioSendParameters parameters;
1074 parameters.codecs.push_back(kIsacCodec);
1075 parameters.codecs.push_back(kPcmuCodec);
kwiberg68061362016-06-14 08:04:47 -07001076 parameters.codecs.push_back(kCn8000Codec);
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001077 parameters.codecs[0].id = 96;
1078 parameters.codecs[0].bitrate = 48000;
1079 EXPECT_TRUE(channel_->SetSendParameters(parameters));
wu@webrtc.org05e7b442014-04-01 17:44:24 +00001080 EXPECT_EQ(1, voe_.GetNumSetSendCodecs());
1081 // Calling SetSendCodec again with same codec which is already set.
1082 // In this case media channel shouldn't send codec to VoE.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001083 EXPECT_TRUE(channel_->SetSendParameters(parameters));
wu@webrtc.org05e7b442014-04-01 17:44:24 +00001084 EXPECT_EQ(1, voe_.GetNumSetSendCodecs());
1085}
1086
henrik.lundin@webrtc.orgf85dbce2014-11-07 12:25:00 +00001087// Verify that G722 is set with 16000 samples per second to WebRTC.
1088TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecG722) {
solenbergff976312016-03-30 23:28:51 -07001089 EXPECT_TRUE(SetupSendStream());
henrik.lundin@webrtc.orgf85dbce2014-11-07 12:25:00 +00001090 int channel_num = voe_.GetLastChannel();
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001091 cricket::AudioSendParameters parameters;
1092 parameters.codecs.push_back(kG722CodecSdp);
1093 EXPECT_TRUE(channel_->SetSendParameters(parameters));
henrik.lundin@webrtc.orgf85dbce2014-11-07 12:25:00 +00001094 webrtc::CodecInst gcodec;
1095 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
1096 EXPECT_STREQ("G722", gcodec.plname);
1097 EXPECT_EQ(1, gcodec.channels);
1098 EXPECT_EQ(16000, gcodec.plfreq);
1099}
1100
henrike@webrtc.org704bf9e2014-02-27 17:52:04 +00001101// Test that if clockrate is not 48000 for opus, we fail.
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001102TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusBadClockrate) {
solenbergff976312016-03-30 23:28:51 -07001103 EXPECT_TRUE(SetupSendStream());
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001104 cricket::AudioSendParameters parameters;
1105 parameters.codecs.push_back(kOpusCodec);
1106 parameters.codecs[0].bitrate = 0;
1107 parameters.codecs[0].clockrate = 50000;
1108 EXPECT_FALSE(channel_->SetSendParameters(parameters));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001109}
1110
henrike@webrtc.org704bf9e2014-02-27 17:52:04 +00001111// Test that if channels=0 for opus, we fail.
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001112TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusBad0ChannelsNoStereo) {
solenbergff976312016-03-30 23:28:51 -07001113 EXPECT_TRUE(SetupSendStream());
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001114 cricket::AudioSendParameters parameters;
1115 parameters.codecs.push_back(kOpusCodec);
1116 parameters.codecs[0].bitrate = 0;
1117 parameters.codecs[0].channels = 0;
1118 EXPECT_FALSE(channel_->SetSendParameters(parameters));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001119}
1120
henrike@webrtc.org704bf9e2014-02-27 17:52:04 +00001121// Test that if channels=0 for opus, we fail.
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001122TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusBad0Channels1Stereo) {
solenbergff976312016-03-30 23:28:51 -07001123 EXPECT_TRUE(SetupSendStream());
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001124 cricket::AudioSendParameters parameters;
1125 parameters.codecs.push_back(kOpusCodec);
1126 parameters.codecs[0].bitrate = 0;
1127 parameters.codecs[0].channels = 0;
1128 parameters.codecs[0].params["stereo"] = "1";
1129 EXPECT_FALSE(channel_->SetSendParameters(parameters));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001130}
1131
1132// Test that if channel is 1 for opus and there's no stereo, we fail.
1133TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpus1ChannelNoStereo) {
solenbergff976312016-03-30 23:28:51 -07001134 EXPECT_TRUE(SetupSendStream());
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001135 cricket::AudioSendParameters parameters;
1136 parameters.codecs.push_back(kOpusCodec);
1137 parameters.codecs[0].bitrate = 0;
1138 parameters.codecs[0].channels = 1;
1139 EXPECT_FALSE(channel_->SetSendParameters(parameters));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001140}
1141
1142// Test that if channel is 1 for opus and stereo=0, we fail.
1143TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusBad1Channel0Stereo) {
solenbergff976312016-03-30 23:28:51 -07001144 EXPECT_TRUE(SetupSendStream());
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001145 cricket::AudioSendParameters parameters;
1146 parameters.codecs.push_back(kOpusCodec);
1147 parameters.codecs[0].bitrate = 0;
1148 parameters.codecs[0].channels = 1;
1149 parameters.codecs[0].params["stereo"] = "0";
1150 EXPECT_FALSE(channel_->SetSendParameters(parameters));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001151}
1152
1153// Test that if channel is 1 for opus and stereo=1, we fail.
1154TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusBad1Channel1Stereo) {
solenbergff976312016-03-30 23:28:51 -07001155 EXPECT_TRUE(SetupSendStream());
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001156 cricket::AudioSendParameters parameters;
1157 parameters.codecs.push_back(kOpusCodec);
1158 parameters.codecs[0].bitrate = 0;
1159 parameters.codecs[0].channels = 1;
1160 parameters.codecs[0].params["stereo"] = "1";
1161 EXPECT_FALSE(channel_->SetSendParameters(parameters));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001162}
1163
1164// Test that with bitrate=0 and no stereo,
1165// channels and bitrate are 1 and 32000.
1166TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGood0BitrateNoStereo) {
solenbergff976312016-03-30 23:28:51 -07001167 EXPECT_TRUE(SetupSendStream());
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001168 int channel_num = voe_.GetLastChannel();
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001169 cricket::AudioSendParameters parameters;
1170 parameters.codecs.push_back(kOpusCodec);
1171 parameters.codecs[0].bitrate = 0;
1172 EXPECT_TRUE(channel_->SetSendParameters(parameters));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001173 webrtc::CodecInst gcodec;
1174 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
1175 EXPECT_STREQ("opus", gcodec.plname);
1176 EXPECT_EQ(1, gcodec.channels);
1177 EXPECT_EQ(32000, gcodec.rate);
1178}
1179
1180// Test that with bitrate=0 and stereo=0,
1181// channels and bitrate are 1 and 32000.
1182TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGood0Bitrate0Stereo) {
solenbergff976312016-03-30 23:28:51 -07001183 EXPECT_TRUE(SetupSendStream());
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001184 int channel_num = voe_.GetLastChannel();
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001185 cricket::AudioSendParameters parameters;
1186 parameters.codecs.push_back(kOpusCodec);
1187 parameters.codecs[0].bitrate = 0;
1188 parameters.codecs[0].params["stereo"] = "0";
1189 EXPECT_TRUE(channel_->SetSendParameters(parameters));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001190 webrtc::CodecInst gcodec;
1191 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
1192 EXPECT_STREQ("opus", gcodec.plname);
1193 EXPECT_EQ(1, gcodec.channels);
1194 EXPECT_EQ(32000, gcodec.rate);
1195}
1196
henrike@webrtc.org1e09a712013-07-26 19:17:59 +00001197// Test that with bitrate=invalid and stereo=0,
1198// channels and bitrate are 1 and 32000.
1199TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodXBitrate0Stereo) {
solenbergff976312016-03-30 23:28:51 -07001200 EXPECT_TRUE(SetupSendStream());
henrike@webrtc.org1e09a712013-07-26 19:17:59 +00001201 int channel_num = voe_.GetLastChannel();
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001202 cricket::AudioSendParameters parameters;
1203 parameters.codecs.push_back(kOpusCodec);
1204 parameters.codecs[0].params["stereo"] = "0";
henrike@webrtc.org1e09a712013-07-26 19:17:59 +00001205 webrtc::CodecInst gcodec;
1206
buildbot@webrtc.org9d446f22014-10-23 12:22:06 +00001207 // bitrate that's out of the range between 6000 and 510000 will be clamped.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001208 parameters.codecs[0].bitrate = 5999;
1209 EXPECT_TRUE(channel_->SetSendParameters(parameters));
henrike@webrtc.org1e09a712013-07-26 19:17:59 +00001210 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
1211 EXPECT_STREQ("opus", gcodec.plname);
1212 EXPECT_EQ(1, gcodec.channels);
buildbot@webrtc.org9d446f22014-10-23 12:22:06 +00001213 EXPECT_EQ(6000, gcodec.rate);
henrike@webrtc.org1e09a712013-07-26 19:17:59 +00001214
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001215 parameters.codecs[0].bitrate = 510001;
1216 EXPECT_TRUE(channel_->SetSendParameters(parameters));
henrike@webrtc.org1e09a712013-07-26 19:17:59 +00001217 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
1218 EXPECT_STREQ("opus", gcodec.plname);
1219 EXPECT_EQ(1, gcodec.channels);
buildbot@webrtc.org9d446f22014-10-23 12:22:06 +00001220 EXPECT_EQ(510000, gcodec.rate);
henrike@webrtc.org1e09a712013-07-26 19:17:59 +00001221}
1222
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001223// Test that with bitrate=0 and stereo=1,
1224// channels and bitrate are 2 and 64000.
1225TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGood0Bitrate1Stereo) {
solenbergff976312016-03-30 23:28:51 -07001226 EXPECT_TRUE(SetupSendStream());
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001227 int channel_num = voe_.GetLastChannel();
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001228 cricket::AudioSendParameters parameters;
1229 parameters.codecs.push_back(kOpusCodec);
1230 parameters.codecs[0].bitrate = 0;
1231 parameters.codecs[0].params["stereo"] = "1";
1232 EXPECT_TRUE(channel_->SetSendParameters(parameters));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001233 webrtc::CodecInst gcodec;
1234 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
1235 EXPECT_STREQ("opus", gcodec.plname);
1236 EXPECT_EQ(2, gcodec.channels);
1237 EXPECT_EQ(64000, gcodec.rate);
1238}
1239
henrike@webrtc.org1e09a712013-07-26 19:17:59 +00001240// Test that with bitrate=invalid and stereo=1,
1241// channels and bitrate are 2 and 64000.
1242TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodXBitrate1Stereo) {
solenbergff976312016-03-30 23:28:51 -07001243 EXPECT_TRUE(SetupSendStream());
henrike@webrtc.org1e09a712013-07-26 19:17:59 +00001244 int channel_num = voe_.GetLastChannel();
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001245 cricket::AudioSendParameters parameters;
1246 parameters.codecs.push_back(kOpusCodec);
1247 parameters.codecs[0].params["stereo"] = "1";
henrike@webrtc.org1e09a712013-07-26 19:17:59 +00001248 webrtc::CodecInst gcodec;
1249
buildbot@webrtc.org9d446f22014-10-23 12:22:06 +00001250 // bitrate that's out of the range between 6000 and 510000 will be clamped.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001251 parameters.codecs[0].bitrate = 5999;
1252 EXPECT_TRUE(channel_->SetSendParameters(parameters));
henrike@webrtc.org1e09a712013-07-26 19:17:59 +00001253 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
1254 EXPECT_STREQ("opus", gcodec.plname);
1255 EXPECT_EQ(2, gcodec.channels);
buildbot@webrtc.org9d446f22014-10-23 12:22:06 +00001256 EXPECT_EQ(6000, gcodec.rate);
henrike@webrtc.org1e09a712013-07-26 19:17:59 +00001257
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001258 parameters.codecs[0].bitrate = 510001;
1259 EXPECT_TRUE(channel_->SetSendParameters(parameters));
henrike@webrtc.org1e09a712013-07-26 19:17:59 +00001260 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
1261 EXPECT_STREQ("opus", gcodec.plname);
1262 EXPECT_EQ(2, gcodec.channels);
buildbot@webrtc.org9d446f22014-10-23 12:22:06 +00001263 EXPECT_EQ(510000, gcodec.rate);
henrike@webrtc.org1e09a712013-07-26 19:17:59 +00001264}
1265
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001266// Test that with bitrate=N and stereo unset,
1267// channels and bitrate are 1 and N.
1268TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrateNoStereo) {
solenbergff976312016-03-30 23:28:51 -07001269 EXPECT_TRUE(SetupSendStream());
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001270 int channel_num = voe_.GetLastChannel();
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001271 cricket::AudioSendParameters parameters;
1272 parameters.codecs.push_back(kOpusCodec);
1273 parameters.codecs[0].bitrate = 96000;
1274 EXPECT_TRUE(channel_->SetSendParameters(parameters));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001275 webrtc::CodecInst gcodec;
1276 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
1277 EXPECT_EQ(111, gcodec.pltype);
1278 EXPECT_EQ(96000, gcodec.rate);
1279 EXPECT_STREQ("opus", gcodec.plname);
1280 EXPECT_EQ(1, gcodec.channels);
1281 EXPECT_EQ(48000, gcodec.plfreq);
1282}
1283
1284// Test that with bitrate=N and stereo=0,
1285// channels and bitrate are 1 and N.
1286TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrate0Stereo) {
solenbergff976312016-03-30 23:28:51 -07001287 EXPECT_TRUE(SetupSendStream());
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001288 int channel_num = voe_.GetLastChannel();
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001289 cricket::AudioSendParameters parameters;
1290 parameters.codecs.push_back(kOpusCodec);
1291 parameters.codecs[0].bitrate = 30000;
1292 parameters.codecs[0].params["stereo"] = "0";
1293 EXPECT_TRUE(channel_->SetSendParameters(parameters));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001294 webrtc::CodecInst gcodec;
1295 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
1296 EXPECT_EQ(1, gcodec.channels);
1297 EXPECT_EQ(30000, gcodec.rate);
1298 EXPECT_STREQ("opus", gcodec.plname);
1299}
1300
1301// Test that with bitrate=N and without any parameters,
1302// channels and bitrate are 1 and N.
1303TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrateNoParameters) {
solenbergff976312016-03-30 23:28:51 -07001304 EXPECT_TRUE(SetupSendStream());
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001305 int channel_num = voe_.GetLastChannel();
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001306 cricket::AudioSendParameters parameters;
1307 parameters.codecs.push_back(kOpusCodec);
1308 parameters.codecs[0].bitrate = 30000;
1309 EXPECT_TRUE(channel_->SetSendParameters(parameters));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001310 webrtc::CodecInst gcodec;
1311 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
1312 EXPECT_EQ(1, gcodec.channels);
1313 EXPECT_EQ(30000, gcodec.rate);
1314 EXPECT_STREQ("opus", gcodec.plname);
1315}
1316
1317// Test that with bitrate=N and stereo=1,
1318// channels and bitrate are 2 and N.
1319TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrate1Stereo) {
solenbergff976312016-03-30 23:28:51 -07001320 EXPECT_TRUE(SetupSendStream());
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001321 int channel_num = voe_.GetLastChannel();
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001322 cricket::AudioSendParameters parameters;
1323 parameters.codecs.push_back(kOpusCodec);
1324 parameters.codecs[0].bitrate = 30000;
1325 parameters.codecs[0].params["stereo"] = "1";
1326 EXPECT_TRUE(channel_->SetSendParameters(parameters));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001327 webrtc::CodecInst gcodec;
1328 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
1329 EXPECT_EQ(2, gcodec.channels);
1330 EXPECT_EQ(30000, gcodec.rate);
1331 EXPECT_STREQ("opus", gcodec.plname);
1332}
1333
henrike@webrtc.org1e09a712013-07-26 19:17:59 +00001334// Test that bitrate will be overridden by the "maxaveragebitrate" parameter.
1335// Also test that the "maxaveragebitrate" can't be set to values outside the
1336// range of 6000 and 510000
1337TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusMaxAverageBitrate) {
solenbergff976312016-03-30 23:28:51 -07001338 EXPECT_TRUE(SetupSendStream());
henrike@webrtc.org1e09a712013-07-26 19:17:59 +00001339 int channel_num = voe_.GetLastChannel();
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001340 cricket::AudioSendParameters parameters;
1341 parameters.codecs.push_back(kOpusCodec);
1342 parameters.codecs[0].bitrate = 30000;
henrike@webrtc.org1e09a712013-07-26 19:17:59 +00001343 webrtc::CodecInst gcodec;
1344
1345 // Ignore if less than 6000.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001346 parameters.codecs[0].params["maxaveragebitrate"] = "5999";
1347 EXPECT_TRUE(channel_->SetSendParameters(parameters));
henrike@webrtc.org1e09a712013-07-26 19:17:59 +00001348 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
buildbot@webrtc.org9d446f22014-10-23 12:22:06 +00001349 EXPECT_EQ(6000, gcodec.rate);
henrike@webrtc.org1e09a712013-07-26 19:17:59 +00001350
1351 // Ignore if larger than 510000.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001352 parameters.codecs[0].params["maxaveragebitrate"] = "510001";
1353 EXPECT_TRUE(channel_->SetSendParameters(parameters));
henrike@webrtc.org1e09a712013-07-26 19:17:59 +00001354 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
buildbot@webrtc.org9d446f22014-10-23 12:22:06 +00001355 EXPECT_EQ(510000, gcodec.rate);
henrike@webrtc.org1e09a712013-07-26 19:17:59 +00001356
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001357 parameters.codecs[0].params["maxaveragebitrate"] = "200000";
1358 EXPECT_TRUE(channel_->SetSendParameters(parameters));
henrike@webrtc.org1e09a712013-07-26 19:17:59 +00001359 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
1360 EXPECT_EQ(200000, gcodec.rate);
1361}
1362
wu@webrtc.orgcadf9042013-08-30 21:24:16 +00001363// Test that we can enable NACK with opus as caller.
1364TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecEnableNackAsCaller) {
solenbergff976312016-03-30 23:28:51 -07001365 EXPECT_TRUE(SetupSendStream());
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001366 cricket::AudioSendParameters parameters;
1367 parameters.codecs.push_back(kOpusCodec);
1368 parameters.codecs[0].AddFeedbackParam(
1369 cricket::FeedbackParam(cricket::kRtcpFbParamNack,
1370 cricket::kParamValueEmpty));
solenberg971cab02016-06-14 10:02:41 -07001371 EXPECT_EQ(0, GetSendStreamConfig(kSsrc1).rtp.nack.rtp_history_ms);
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001372 EXPECT_TRUE(channel_->SetSendParameters(parameters));
solenberg971cab02016-06-14 10:02:41 -07001373 EXPECT_EQ(kRtpHistoryMs, GetSendStreamConfig(kSsrc1).rtp.nack.rtp_history_ms);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001374}
1375
wu@webrtc.orgcadf9042013-08-30 21:24:16 +00001376// Test that we can enable NACK with opus as callee.
1377TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecEnableNackAsCallee) {
solenbergff976312016-03-30 23:28:51 -07001378 EXPECT_TRUE(SetupRecvStream());
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001379 cricket::AudioSendParameters parameters;
1380 parameters.codecs.push_back(kOpusCodec);
1381 parameters.codecs[0].AddFeedbackParam(
1382 cricket::FeedbackParam(cricket::kRtcpFbParamNack,
1383 cricket::kParamValueEmpty));
solenberg8189b022016-06-14 12:13:00 -07001384 EXPECT_EQ(0, GetRecvStreamConfig(kSsrc1).rtp.nack.rtp_history_ms);
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001385 EXPECT_TRUE(channel_->SetSendParameters(parameters));
deadbeefb56069e2016-05-06 04:57:03 -07001386 // NACK should be enabled even with no send stream.
solenberg8189b022016-06-14 12:13:00 -07001387 EXPECT_EQ(kRtpHistoryMs, GetRecvStreamConfig(kSsrc1).rtp.nack.rtp_history_ms);
wu@webrtc.orgcadf9042013-08-30 21:24:16 +00001388
1389 EXPECT_TRUE(channel_->AddSendStream(
1390 cricket::StreamParams::CreateLegacy(kSsrc1)));
solenberg971cab02016-06-14 10:02:41 -07001391 EXPECT_EQ(kRtpHistoryMs, GetSendStreamConfig(kSsrc1).rtp.nack.rtp_history_ms);
wu@webrtc.orgcadf9042013-08-30 21:24:16 +00001392}
1393
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001394// Test that we can enable NACK on receive streams.
1395TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecEnableNackRecvStreams) {
solenbergff976312016-03-30 23:28:51 -07001396 EXPECT_TRUE(SetupSendStream());
solenberg8189b022016-06-14 12:13:00 -07001397 EXPECT_TRUE(AddRecvStream(kSsrc2));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001398 cricket::AudioSendParameters parameters;
1399 parameters.codecs.push_back(kOpusCodec);
1400 parameters.codecs[0].AddFeedbackParam(
1401 cricket::FeedbackParam(cricket::kRtcpFbParamNack,
1402 cricket::kParamValueEmpty));
solenberg971cab02016-06-14 10:02:41 -07001403 EXPECT_EQ(0, GetSendStreamConfig(kSsrc1).rtp.nack.rtp_history_ms);
solenberg8189b022016-06-14 12:13:00 -07001404 EXPECT_EQ(0, GetRecvStreamConfig(kSsrc2).rtp.nack.rtp_history_ms);
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001405 EXPECT_TRUE(channel_->SetSendParameters(parameters));
solenberg971cab02016-06-14 10:02:41 -07001406 EXPECT_EQ(kRtpHistoryMs, GetSendStreamConfig(kSsrc1).rtp.nack.rtp_history_ms);
solenberg8189b022016-06-14 12:13:00 -07001407 EXPECT_EQ(kRtpHistoryMs, GetRecvStreamConfig(kSsrc2).rtp.nack.rtp_history_ms);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001408}
1409
1410// Test that we can disable NACK.
1411TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecDisableNack) {
solenbergff976312016-03-30 23:28:51 -07001412 EXPECT_TRUE(SetupSendStream());
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001413 cricket::AudioSendParameters parameters;
1414 parameters.codecs.push_back(kOpusCodec);
1415 parameters.codecs[0].AddFeedbackParam(
1416 cricket::FeedbackParam(cricket::kRtcpFbParamNack,
1417 cricket::kParamValueEmpty));
1418 EXPECT_TRUE(channel_->SetSendParameters(parameters));
solenberg971cab02016-06-14 10:02:41 -07001419 EXPECT_EQ(kRtpHistoryMs, GetSendStreamConfig(kSsrc1).rtp.nack.rtp_history_ms);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001420
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001421 parameters.codecs.clear();
1422 parameters.codecs.push_back(kOpusCodec);
1423 EXPECT_TRUE(channel_->SetSendParameters(parameters));
solenberg971cab02016-06-14 10:02:41 -07001424 EXPECT_EQ(0, GetSendStreamConfig(kSsrc1).rtp.nack.rtp_history_ms);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001425}
1426
1427// Test that we can disable NACK on receive streams.
1428TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecDisableNackRecvStreams) {
solenbergff976312016-03-30 23:28:51 -07001429 EXPECT_TRUE(SetupSendStream());
solenberg8189b022016-06-14 12:13:00 -07001430 EXPECT_TRUE(AddRecvStream(kSsrc2));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001431 cricket::AudioSendParameters parameters;
1432 parameters.codecs.push_back(kOpusCodec);
1433 parameters.codecs[0].AddFeedbackParam(
1434 cricket::FeedbackParam(cricket::kRtcpFbParamNack,
1435 cricket::kParamValueEmpty));
1436 EXPECT_TRUE(channel_->SetSendParameters(parameters));
solenberg971cab02016-06-14 10:02:41 -07001437 EXPECT_EQ(kRtpHistoryMs, GetSendStreamConfig(kSsrc1).rtp.nack.rtp_history_ms);
solenberg8189b022016-06-14 12:13:00 -07001438 EXPECT_EQ(kRtpHistoryMs, GetRecvStreamConfig(kSsrc2).rtp.nack.rtp_history_ms);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001439
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001440 parameters.codecs.clear();
1441 parameters.codecs.push_back(kOpusCodec);
1442 EXPECT_TRUE(channel_->SetSendParameters(parameters));
solenberg971cab02016-06-14 10:02:41 -07001443 EXPECT_EQ(0, GetSendStreamConfig(kSsrc1).rtp.nack.rtp_history_ms);
solenberg8189b022016-06-14 12:13:00 -07001444 EXPECT_EQ(0, GetRecvStreamConfig(kSsrc2).rtp.nack.rtp_history_ms);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001445}
1446
1447// Test that NACK is enabled on a new receive stream.
1448TEST_F(WebRtcVoiceEngineTestFake, AddRecvStreamEnableNack) {
solenbergff976312016-03-30 23:28:51 -07001449 EXPECT_TRUE(SetupSendStream());
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001450 cricket::AudioSendParameters parameters;
1451 parameters.codecs.push_back(kIsacCodec);
1452 parameters.codecs.push_back(kCn16000Codec);
1453 parameters.codecs[0].AddFeedbackParam(
1454 cricket::FeedbackParam(cricket::kRtcpFbParamNack,
1455 cricket::kParamValueEmpty));
1456 EXPECT_TRUE(channel_->SetSendParameters(parameters));
solenberg971cab02016-06-14 10:02:41 -07001457 EXPECT_EQ(kRtpHistoryMs, GetSendStreamConfig(kSsrc1).rtp.nack.rtp_history_ms);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001458
solenberg8189b022016-06-14 12:13:00 -07001459 EXPECT_TRUE(AddRecvStream(kSsrc2));
1460 EXPECT_EQ(kRtpHistoryMs, GetRecvStreamConfig(kSsrc2).rtp.nack.rtp_history_ms);
1461 EXPECT_TRUE(AddRecvStream(kSsrc3));
1462 EXPECT_EQ(kRtpHistoryMs, GetRecvStreamConfig(kSsrc3).rtp.nack.rtp_history_ms);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001463}
1464
buildbot@webrtc.orgae740dd2014-06-17 10:56:41 +00001465// Test that without useinbandfec, Opus FEC is off.
buildbot@webrtc.orgd27d9ae2014-06-19 01:56:46 +00001466TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecNoOpusFec) {
solenbergff976312016-03-30 23:28:51 -07001467 EXPECT_TRUE(SetupSendStream());
buildbot@webrtc.orgae740dd2014-06-17 10:56:41 +00001468 int channel_num = voe_.GetLastChannel();
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001469 cricket::AudioSendParameters parameters;
1470 parameters.codecs.push_back(kOpusCodec);
1471 EXPECT_TRUE(channel_->SetSendParameters(parameters));
buildbot@webrtc.orgae740dd2014-06-17 10:56:41 +00001472 EXPECT_FALSE(voe_.GetCodecFEC(channel_num));
1473}
1474
1475// Test that with useinbandfec=0, Opus FEC is off.
buildbot@webrtc.orgd27d9ae2014-06-19 01:56:46 +00001476TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusDisableFec) {
solenbergff976312016-03-30 23:28:51 -07001477 EXPECT_TRUE(SetupSendStream());
buildbot@webrtc.orgae740dd2014-06-17 10:56:41 +00001478 int channel_num = voe_.GetLastChannel();
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001479 cricket::AudioSendParameters parameters;
1480 parameters.codecs.push_back(kOpusCodec);
1481 parameters.codecs[0].bitrate = 0;
1482 parameters.codecs[0].params["useinbandfec"] = "0";
1483 EXPECT_TRUE(channel_->SetSendParameters(parameters));
buildbot@webrtc.orgae740dd2014-06-17 10:56:41 +00001484 EXPECT_FALSE(voe_.GetCodecFEC(channel_num));
1485 webrtc::CodecInst gcodec;
1486 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
1487 EXPECT_STREQ("opus", gcodec.plname);
1488 EXPECT_EQ(1, gcodec.channels);
1489 EXPECT_EQ(32000, gcodec.rate);
1490}
1491
1492// Test that with useinbandfec=1, Opus FEC is on.
buildbot@webrtc.orgd27d9ae2014-06-19 01:56:46 +00001493TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusEnableFec) {
solenbergff976312016-03-30 23:28:51 -07001494 EXPECT_TRUE(SetupSendStream());
buildbot@webrtc.orgae740dd2014-06-17 10:56:41 +00001495 int channel_num = voe_.GetLastChannel();
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001496 cricket::AudioSendParameters parameters;
1497 parameters.codecs.push_back(kOpusCodec);
1498 parameters.codecs[0].bitrate = 0;
1499 parameters.codecs[0].params["useinbandfec"] = "1";
1500 EXPECT_TRUE(channel_->SetSendParameters(parameters));
buildbot@webrtc.orgae740dd2014-06-17 10:56:41 +00001501 EXPECT_TRUE(voe_.GetCodecFEC(channel_num));
1502 webrtc::CodecInst gcodec;
1503 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
1504 EXPECT_STREQ("opus", gcodec.plname);
1505 EXPECT_EQ(1, gcodec.channels);
1506 EXPECT_EQ(32000, gcodec.rate);
1507}
1508
1509// Test that with useinbandfec=1, stereo=1, Opus FEC is on.
buildbot@webrtc.orgd27d9ae2014-06-19 01:56:46 +00001510TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusEnableFecStereo) {
solenbergff976312016-03-30 23:28:51 -07001511 EXPECT_TRUE(SetupSendStream());
buildbot@webrtc.orgae740dd2014-06-17 10:56:41 +00001512 int channel_num = voe_.GetLastChannel();
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001513 cricket::AudioSendParameters parameters;
1514 parameters.codecs.push_back(kOpusCodec);
1515 parameters.codecs[0].bitrate = 0;
1516 parameters.codecs[0].params["stereo"] = "1";
1517 parameters.codecs[0].params["useinbandfec"] = "1";
1518 EXPECT_TRUE(channel_->SetSendParameters(parameters));
buildbot@webrtc.orgae740dd2014-06-17 10:56:41 +00001519 EXPECT_TRUE(voe_.GetCodecFEC(channel_num));
1520 webrtc::CodecInst gcodec;
1521 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
1522 EXPECT_STREQ("opus", gcodec.plname);
1523 EXPECT_EQ(2, gcodec.channels);
1524 EXPECT_EQ(64000, gcodec.rate);
1525}
1526
1527// Test that with non-Opus, codec FEC is off.
buildbot@webrtc.orgd27d9ae2014-06-19 01:56:46 +00001528TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecIsacNoFec) {
solenbergff976312016-03-30 23:28:51 -07001529 EXPECT_TRUE(SetupSendStream());
buildbot@webrtc.orgae740dd2014-06-17 10:56:41 +00001530 int channel_num = voe_.GetLastChannel();
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001531 cricket::AudioSendParameters parameters;
1532 parameters.codecs.push_back(kIsacCodec);
1533 EXPECT_TRUE(channel_->SetSendParameters(parameters));
buildbot@webrtc.orgae740dd2014-06-17 10:56:41 +00001534 EXPECT_FALSE(voe_.GetCodecFEC(channel_num));
1535}
buildbot@webrtc.org3ffa1f92014-07-02 19:51:26 +00001536
1537// Test the with non-Opus, even if useinbandfec=1, FEC is off.
1538TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecIsacWithParamNoFec) {
solenbergff976312016-03-30 23:28:51 -07001539 EXPECT_TRUE(SetupSendStream());
buildbot@webrtc.org3ffa1f92014-07-02 19:51:26 +00001540 int channel_num = voe_.GetLastChannel();
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001541 cricket::AudioSendParameters parameters;
1542 parameters.codecs.push_back(kIsacCodec);
1543 parameters.codecs[0].params["useinbandfec"] = "1";
1544 EXPECT_TRUE(channel_->SetSendParameters(parameters));
buildbot@webrtc.org3ffa1f92014-07-02 19:51:26 +00001545 EXPECT_FALSE(voe_.GetCodecFEC(channel_num));
1546}
buildbot@webrtc.org5d639b32014-09-10 07:57:12 +00001547
1548// Test that Opus FEC status can be changed.
1549TEST_F(WebRtcVoiceEngineTestFake, ChangeOpusFecStatus) {
solenbergff976312016-03-30 23:28:51 -07001550 EXPECT_TRUE(SetupSendStream());
buildbot@webrtc.org5d639b32014-09-10 07:57:12 +00001551 int channel_num = voe_.GetLastChannel();
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001552 cricket::AudioSendParameters parameters;
1553 parameters.codecs.push_back(kOpusCodec);
1554 EXPECT_TRUE(channel_->SetSendParameters(parameters));
buildbot@webrtc.org5d639b32014-09-10 07:57:12 +00001555 EXPECT_FALSE(voe_.GetCodecFEC(channel_num));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001556 parameters.codecs[0].params["useinbandfec"] = "1";
1557 EXPECT_TRUE(channel_->SetSendParameters(parameters));
buildbot@webrtc.org5d639b32014-09-10 07:57:12 +00001558 EXPECT_TRUE(voe_.GetCodecFEC(channel_num));
1559}
1560
stefanba4c0e42016-02-04 04:12:24 -08001561TEST_F(WebRtcVoiceEngineTestFake, TransportCcCanBeEnabledAndDisabled) {
solenbergff976312016-03-30 23:28:51 -07001562 EXPECT_TRUE(SetupChannel());
stefanba4c0e42016-02-04 04:12:24 -08001563 cricket::AudioSendParameters send_parameters;
1564 send_parameters.codecs.push_back(kOpusCodec);
1565 EXPECT_TRUE(send_parameters.codecs[0].feedback_params.params().empty());
1566 EXPECT_TRUE(channel_->SetSendParameters(send_parameters));
1567
1568 cricket::AudioRecvParameters recv_parameters;
1569 recv_parameters.codecs.push_back(kIsacCodec);
1570 EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters));
solenberg8189b022016-06-14 12:13:00 -07001571 EXPECT_TRUE(AddRecvStream(kSsrc1));
stefanba4c0e42016-02-04 04:12:24 -08001572 ASSERT_TRUE(call_.GetAudioReceiveStream(kSsrc1) != nullptr);
1573 EXPECT_FALSE(
1574 call_.GetAudioReceiveStream(kSsrc1)->GetConfig().rtp.transport_cc);
1575
ossudedfd282016-06-14 07:12:39 -07001576 send_parameters.codecs = engine_->send_codecs();
stefanba4c0e42016-02-04 04:12:24 -08001577 EXPECT_TRUE(channel_->SetSendParameters(send_parameters));
1578 ASSERT_TRUE(call_.GetAudioReceiveStream(kSsrc1) != nullptr);
1579 EXPECT_TRUE(
1580 call_.GetAudioReceiveStream(kSsrc1)->GetConfig().rtp.transport_cc);
1581}
1582
buildbot@webrtc.org5d639b32014-09-10 07:57:12 +00001583// Test maxplaybackrate <= 8000 triggers Opus narrow band mode.
1584TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateNb) {
solenbergff976312016-03-30 23:28:51 -07001585 EXPECT_TRUE(SetupSendStream());
buildbot@webrtc.org5d639b32014-09-10 07:57:12 +00001586 int channel_num = voe_.GetLastChannel();
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001587 cricket::AudioSendParameters parameters;
1588 parameters.codecs.push_back(kOpusCodec);
1589 parameters.codecs[0].bitrate = 0;
1590 parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 8000);
1591 EXPECT_TRUE(channel_->SetSendParameters(parameters));
buildbot@webrtc.org5d639b32014-09-10 07:57:12 +00001592 EXPECT_EQ(cricket::kOpusBandwidthNb,
1593 voe_.GetMaxEncodingBandwidth(channel_num));
1594 webrtc::CodecInst gcodec;
1595 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
1596 EXPECT_STREQ("opus", gcodec.plname);
minyue@webrtc.org2dc6f312014-10-31 05:33:10 +00001597
1598 EXPECT_EQ(12000, gcodec.rate);
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001599 parameters.codecs[0].SetParam(cricket::kCodecParamStereo, "1");
1600 EXPECT_TRUE(channel_->SetSendParameters(parameters));
minyue@webrtc.org2dc6f312014-10-31 05:33:10 +00001601 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
1602 EXPECT_EQ(24000, gcodec.rate);
buildbot@webrtc.org5d639b32014-09-10 07:57:12 +00001603}
1604
1605// Test 8000 < maxplaybackrate <= 12000 triggers Opus medium band mode.
1606TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateMb) {
solenbergff976312016-03-30 23:28:51 -07001607 EXPECT_TRUE(SetupSendStream());
buildbot@webrtc.org5d639b32014-09-10 07:57:12 +00001608 int channel_num = voe_.GetLastChannel();
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001609 cricket::AudioSendParameters parameters;
1610 parameters.codecs.push_back(kOpusCodec);
1611 parameters.codecs[0].bitrate = 0;
1612 parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 8001);
1613 EXPECT_TRUE(channel_->SetSendParameters(parameters));
buildbot@webrtc.org5d639b32014-09-10 07:57:12 +00001614 EXPECT_EQ(cricket::kOpusBandwidthMb,
1615 voe_.GetMaxEncodingBandwidth(channel_num));
1616 webrtc::CodecInst gcodec;
1617 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
1618 EXPECT_STREQ("opus", gcodec.plname);
minyue@webrtc.org2dc6f312014-10-31 05:33:10 +00001619
1620 EXPECT_EQ(20000, gcodec.rate);
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001621 parameters.codecs[0].SetParam(cricket::kCodecParamStereo, "1");
1622 EXPECT_TRUE(channel_->SetSendParameters(parameters));
minyue@webrtc.org2dc6f312014-10-31 05:33:10 +00001623 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
1624 EXPECT_EQ(40000, gcodec.rate);
buildbot@webrtc.org5d639b32014-09-10 07:57:12 +00001625}
1626
1627// Test 12000 < maxplaybackrate <= 16000 triggers Opus wide band mode.
1628TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateWb) {
solenbergff976312016-03-30 23:28:51 -07001629 EXPECT_TRUE(SetupSendStream());
buildbot@webrtc.org5d639b32014-09-10 07:57:12 +00001630 int channel_num = voe_.GetLastChannel();
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001631 cricket::AudioSendParameters parameters;
1632 parameters.codecs.push_back(kOpusCodec);
1633 parameters.codecs[0].bitrate = 0;
1634 parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 12001);
1635 EXPECT_TRUE(channel_->SetSendParameters(parameters));
buildbot@webrtc.org5d639b32014-09-10 07:57:12 +00001636 EXPECT_EQ(cricket::kOpusBandwidthWb,
1637 voe_.GetMaxEncodingBandwidth(channel_num));
1638 webrtc::CodecInst gcodec;
1639 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
1640 EXPECT_STREQ("opus", gcodec.plname);
minyue@webrtc.org2dc6f312014-10-31 05:33:10 +00001641
1642 EXPECT_EQ(20000, gcodec.rate);
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001643 parameters.codecs[0].SetParam(cricket::kCodecParamStereo, "1");
1644 EXPECT_TRUE(channel_->SetSendParameters(parameters));
minyue@webrtc.org2dc6f312014-10-31 05:33:10 +00001645 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
1646 EXPECT_EQ(40000, gcodec.rate);
buildbot@webrtc.org5d639b32014-09-10 07:57:12 +00001647}
1648
1649// Test 16000 < maxplaybackrate <= 24000 triggers Opus super wide band mode.
1650TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateSwb) {
solenbergff976312016-03-30 23:28:51 -07001651 EXPECT_TRUE(SetupSendStream());
buildbot@webrtc.org5d639b32014-09-10 07:57:12 +00001652 int channel_num = voe_.GetLastChannel();
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001653 cricket::AudioSendParameters parameters;
1654 parameters.codecs.push_back(kOpusCodec);
1655 parameters.codecs[0].bitrate = 0;
1656 parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 16001);
1657 EXPECT_TRUE(channel_->SetSendParameters(parameters));
buildbot@webrtc.org5d639b32014-09-10 07:57:12 +00001658 EXPECT_EQ(cricket::kOpusBandwidthSwb,
1659 voe_.GetMaxEncodingBandwidth(channel_num));
1660 webrtc::CodecInst gcodec;
1661 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
1662 EXPECT_STREQ("opus", gcodec.plname);
minyue@webrtc.org2dc6f312014-10-31 05:33:10 +00001663
buildbot@webrtc.org5d639b32014-09-10 07:57:12 +00001664 EXPECT_EQ(32000, gcodec.rate);
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001665 parameters.codecs[0].SetParam(cricket::kCodecParamStereo, "1");
1666 EXPECT_TRUE(channel_->SetSendParameters(parameters));
minyue@webrtc.org2dc6f312014-10-31 05:33:10 +00001667 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
1668 EXPECT_EQ(64000, gcodec.rate);
buildbot@webrtc.org5d639b32014-09-10 07:57:12 +00001669}
1670
1671// Test 24000 < maxplaybackrate triggers Opus full band mode.
1672TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateFb) {
solenbergff976312016-03-30 23:28:51 -07001673 EXPECT_TRUE(SetupSendStream());
buildbot@webrtc.org5d639b32014-09-10 07:57:12 +00001674 int channel_num = voe_.GetLastChannel();
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001675 cricket::AudioSendParameters parameters;
1676 parameters.codecs.push_back(kOpusCodec);
1677 parameters.codecs[0].bitrate = 0;
1678 parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 24001);
1679 EXPECT_TRUE(channel_->SetSendParameters(parameters));
buildbot@webrtc.org5d639b32014-09-10 07:57:12 +00001680 EXPECT_EQ(cricket::kOpusBandwidthFb,
1681 voe_.GetMaxEncodingBandwidth(channel_num));
1682 webrtc::CodecInst gcodec;
1683 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
1684 EXPECT_STREQ("opus", gcodec.plname);
minyue@webrtc.org2dc6f312014-10-31 05:33:10 +00001685
buildbot@webrtc.org5d639b32014-09-10 07:57:12 +00001686 EXPECT_EQ(32000, gcodec.rate);
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001687 parameters.codecs[0].SetParam(cricket::kCodecParamStereo, "1");
1688 EXPECT_TRUE(channel_->SetSendParameters(parameters));
minyue@webrtc.org2dc6f312014-10-31 05:33:10 +00001689 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
1690 EXPECT_EQ(64000, gcodec.rate);
buildbot@webrtc.org5d639b32014-09-10 07:57:12 +00001691}
1692
1693// Test Opus that without maxplaybackrate, default playback rate is used.
1694TEST_F(WebRtcVoiceEngineTestFake, DefaultOpusMaxPlaybackRate) {
solenbergff976312016-03-30 23:28:51 -07001695 EXPECT_TRUE(SetupSendStream());
buildbot@webrtc.org5d639b32014-09-10 07:57:12 +00001696 int channel_num = voe_.GetLastChannel();
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001697 cricket::AudioSendParameters parameters;
1698 parameters.codecs.push_back(kOpusCodec);
1699 EXPECT_TRUE(channel_->SetSendParameters(parameters));
buildbot@webrtc.org5d639b32014-09-10 07:57:12 +00001700 EXPECT_EQ(cricket::kOpusBandwidthFb,
1701 voe_.GetMaxEncodingBandwidth(channel_num));
1702}
1703
1704// Test the with non-Opus, maxplaybackrate has no effect.
1705TEST_F(WebRtcVoiceEngineTestFake, SetNonOpusMaxPlaybackRate) {
solenbergff976312016-03-30 23:28:51 -07001706 EXPECT_TRUE(SetupSendStream());
buildbot@webrtc.org5d639b32014-09-10 07:57:12 +00001707 int channel_num = voe_.GetLastChannel();
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001708 cricket::AudioSendParameters parameters;
1709 parameters.codecs.push_back(kIsacCodec);
1710 parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 32000);
1711 EXPECT_TRUE(channel_->SetSendParameters(parameters));
buildbot@webrtc.org5d639b32014-09-10 07:57:12 +00001712 EXPECT_EQ(0, voe_.GetMaxEncodingBandwidth(channel_num));
1713}
1714
1715// Test maxplaybackrate can be set on two streams.
1716TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateOnTwoStreams) {
solenbergff976312016-03-30 23:28:51 -07001717 EXPECT_TRUE(SetupSendStream());
buildbot@webrtc.org5d639b32014-09-10 07:57:12 +00001718 int channel_num = voe_.GetLastChannel();
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001719 cricket::AudioSendParameters parameters;
1720 parameters.codecs.push_back(kOpusCodec);
1721 EXPECT_TRUE(channel_->SetSendParameters(parameters));
buildbot@webrtc.org5d639b32014-09-10 07:57:12 +00001722 // Default bandwidth is 24000.
1723 EXPECT_EQ(cricket::kOpusBandwidthFb,
1724 voe_.GetMaxEncodingBandwidth(channel_num));
1725
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001726 parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 8000);
buildbot@webrtc.org5d639b32014-09-10 07:57:12 +00001727
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001728 EXPECT_TRUE(channel_->SetSendParameters(parameters));
buildbot@webrtc.org5d639b32014-09-10 07:57:12 +00001729 EXPECT_EQ(cricket::kOpusBandwidthNb,
1730 voe_.GetMaxEncodingBandwidth(channel_num));
1731
1732 channel_->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc2));
1733 channel_num = voe_.GetLastChannel();
1734 EXPECT_EQ(cricket::kOpusBandwidthNb,
1735 voe_.GetMaxEncodingBandwidth(channel_num));
1736}
buildbot@webrtc.orgae740dd2014-06-17 10:56:41 +00001737
Minyue Li7100dcd2015-03-27 05:05:59 +01001738// Test that with usedtx=0, Opus DTX is off.
1739TEST_F(WebRtcVoiceEngineTestFake, DisableOpusDtxOnOpus) {
solenbergff976312016-03-30 23:28:51 -07001740 EXPECT_TRUE(SetupSendStream());
Minyue Li7100dcd2015-03-27 05:05:59 +01001741 int channel_num = voe_.GetLastChannel();
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001742 cricket::AudioSendParameters parameters;
1743 parameters.codecs.push_back(kOpusCodec);
1744 parameters.codecs[0].params["usedtx"] = "0";
1745 EXPECT_TRUE(channel_->SetSendParameters(parameters));
Minyue Li7100dcd2015-03-27 05:05:59 +01001746 EXPECT_FALSE(voe_.GetOpusDtx(channel_num));
1747}
1748
1749// Test that with usedtx=1, Opus DTX is on.
1750TEST_F(WebRtcVoiceEngineTestFake, EnableOpusDtxOnOpus) {
solenbergff976312016-03-30 23:28:51 -07001751 EXPECT_TRUE(SetupSendStream());
Minyue Li7100dcd2015-03-27 05:05:59 +01001752 int channel_num = voe_.GetLastChannel();
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001753 cricket::AudioSendParameters parameters;
1754 parameters.codecs.push_back(kOpusCodec);
1755 parameters.codecs[0].params["usedtx"] = "1";
1756 EXPECT_TRUE(channel_->SetSendParameters(parameters));
Minyue Li7100dcd2015-03-27 05:05:59 +01001757 EXPECT_TRUE(voe_.GetOpusDtx(channel_num));
1758 EXPECT_FALSE(voe_.GetVAD(channel_num)); // Opus DTX should not affect VAD.
1759}
1760
1761// Test that usedtx=1 works with stereo Opus.
1762TEST_F(WebRtcVoiceEngineTestFake, EnableOpusDtxOnOpusStereo) {
solenbergff976312016-03-30 23:28:51 -07001763 EXPECT_TRUE(SetupSendStream());
Minyue Li7100dcd2015-03-27 05:05:59 +01001764 int channel_num = voe_.GetLastChannel();
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001765 cricket::AudioSendParameters parameters;
1766 parameters.codecs.push_back(kOpusCodec);
1767 parameters.codecs[0].params["usedtx"] = "1";
1768 parameters.codecs[0].params["stereo"] = "1";
1769 EXPECT_TRUE(channel_->SetSendParameters(parameters));
Minyue Li7100dcd2015-03-27 05:05:59 +01001770 EXPECT_TRUE(voe_.GetOpusDtx(channel_num));
1771 EXPECT_FALSE(voe_.GetVAD(channel_num)); // Opus DTX should not affect VAD.
1772}
1773
1774// Test that usedtx=1 does not work with non Opus.
1775TEST_F(WebRtcVoiceEngineTestFake, CannotEnableOpusDtxOnNonOpus) {
solenbergff976312016-03-30 23:28:51 -07001776 EXPECT_TRUE(SetupSendStream());
Minyue Li7100dcd2015-03-27 05:05:59 +01001777 int channel_num = voe_.GetLastChannel();
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001778 cricket::AudioSendParameters parameters;
1779 parameters.codecs.push_back(kIsacCodec);
1780 parameters.codecs[0].params["usedtx"] = "1";
1781 EXPECT_TRUE(channel_->SetSendParameters(parameters));
Minyue Li7100dcd2015-03-27 05:05:59 +01001782 EXPECT_FALSE(voe_.GetOpusDtx(channel_num));
1783}
1784
minyue@webrtc.orgf9b5c1b2015-02-17 12:36:41 +00001785// Test that we can switch back and forth between Opus and ISAC with CN.
1786TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsIsacOpusSwitching) {
solenbergff976312016-03-30 23:28:51 -07001787 EXPECT_TRUE(SetupSendStream());
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001788 int channel_num = voe_.GetLastChannel();
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001789 cricket::AudioSendParameters opus_parameters;
1790 opus_parameters.codecs.push_back(kOpusCodec);
1791 EXPECT_TRUE(channel_->SetSendParameters(opus_parameters));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001792 webrtc::CodecInst gcodec;
1793 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
minyue@webrtc.orgf9b5c1b2015-02-17 12:36:41 +00001794 EXPECT_EQ(111, gcodec.pltype);
1795 EXPECT_STREQ("opus", gcodec.plname);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001796
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001797 cricket::AudioSendParameters isac_parameters;
1798 isac_parameters.codecs.push_back(kIsacCodec);
1799 isac_parameters.codecs.push_back(kCn16000Codec);
1800 isac_parameters.codecs.push_back(kOpusCodec);
1801 EXPECT_TRUE(channel_->SetSendParameters(isac_parameters));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001802 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
1803 EXPECT_EQ(103, gcodec.pltype);
1804 EXPECT_STREQ("ISAC", gcodec.plname);
1805
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001806 EXPECT_TRUE(channel_->SetSendParameters(opus_parameters));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001807 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
minyue@webrtc.orgf9b5c1b2015-02-17 12:36:41 +00001808 EXPECT_EQ(111, gcodec.pltype);
1809 EXPECT_STREQ("opus", gcodec.plname);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001810}
1811
1812// Test that we handle various ways of specifying bitrate.
1813TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsBitrate) {
solenbergff976312016-03-30 23:28:51 -07001814 EXPECT_TRUE(SetupSendStream());
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001815 int channel_num = voe_.GetLastChannel();
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001816 cricket::AudioSendParameters parameters;
1817 parameters.codecs.push_back(kIsacCodec); // bitrate == 32000
1818 EXPECT_TRUE(channel_->SetSendParameters(parameters));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001819 webrtc::CodecInst gcodec;
1820 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
1821 EXPECT_EQ(103, gcodec.pltype);
1822 EXPECT_STREQ("ISAC", gcodec.plname);
1823 EXPECT_EQ(32000, gcodec.rate);
1824
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001825 parameters.codecs[0].bitrate = 0; // bitrate == default
1826 EXPECT_TRUE(channel_->SetSendParameters(parameters));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001827 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
1828 EXPECT_EQ(103, gcodec.pltype);
1829 EXPECT_STREQ("ISAC", gcodec.plname);
1830 EXPECT_EQ(-1, gcodec.rate);
1831
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001832 parameters.codecs[0].bitrate = 28000; // bitrate == 28000
1833 EXPECT_TRUE(channel_->SetSendParameters(parameters));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001834 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
1835 EXPECT_EQ(103, gcodec.pltype);
1836 EXPECT_STREQ("ISAC", gcodec.plname);
1837 EXPECT_EQ(28000, gcodec.rate);
1838
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001839 parameters.codecs[0] = kPcmuCodec; // bitrate == 64000
1840 EXPECT_TRUE(channel_->SetSendParameters(parameters));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001841 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
1842 EXPECT_EQ(0, gcodec.pltype);
1843 EXPECT_STREQ("PCMU", gcodec.plname);
1844 EXPECT_EQ(64000, gcodec.rate);
1845
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001846 parameters.codecs[0].bitrate = 0; // bitrate == default
1847 EXPECT_TRUE(channel_->SetSendParameters(parameters));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001848 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
1849 EXPECT_EQ(0, gcodec.pltype);
1850 EXPECT_STREQ("PCMU", gcodec.plname);
1851 EXPECT_EQ(64000, gcodec.rate);
1852
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001853 parameters.codecs[0] = kOpusCodec;
1854 parameters.codecs[0].bitrate = 0; // bitrate == default
1855 EXPECT_TRUE(channel_->SetSendParameters(parameters));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001856 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
1857 EXPECT_EQ(111, gcodec.pltype);
1858 EXPECT_STREQ("opus", gcodec.plname);
1859 EXPECT_EQ(32000, gcodec.rate);
1860}
1861
Brave Yao5225dd82015-03-26 07:39:19 +08001862// Test that we could set packet size specified in kCodecParamPTime.
1863TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsPTimeAsPacketSize) {
solenbergff976312016-03-30 23:28:51 -07001864 EXPECT_TRUE(SetupSendStream());
Brave Yao5225dd82015-03-26 07:39:19 +08001865 int channel_num = voe_.GetLastChannel();
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001866 cricket::AudioSendParameters parameters;
1867 parameters.codecs.push_back(kOpusCodec);
1868 parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 40); // Within range.
1869 EXPECT_TRUE(channel_->SetSendParameters(parameters));
Brave Yao5225dd82015-03-26 07:39:19 +08001870 webrtc::CodecInst gcodec;
1871 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
1872 EXPECT_EQ(1920, gcodec.pacsize); // Opus gets 40ms.
1873
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001874 parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 5); // Below range.
1875 EXPECT_TRUE(channel_->SetSendParameters(parameters));
Brave Yao5225dd82015-03-26 07:39:19 +08001876 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
1877 EXPECT_EQ(480, gcodec.pacsize); // Opus gets 10ms.
1878
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001879 parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 80); // Beyond range.
1880 EXPECT_TRUE(channel_->SetSendParameters(parameters));
Brave Yao5225dd82015-03-26 07:39:19 +08001881 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
1882 EXPECT_EQ(2880, gcodec.pacsize); // Opus gets 60ms.
1883
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001884 parameters.codecs[0] = kIsacCodec; // Also try Isac, with unsupported size.
1885 parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 40); // Within range.
1886 EXPECT_TRUE(channel_->SetSendParameters(parameters));
Brave Yao5225dd82015-03-26 07:39:19 +08001887 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
1888 EXPECT_EQ(480, gcodec.pacsize); // Isac gets 30ms as the next smallest value.
1889
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001890 parameters.codecs[0] = kG722CodecSdp; // Try G722 @8kHz as negotiated in SDP.
1891 parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 40);
1892 EXPECT_TRUE(channel_->SetSendParameters(parameters));
Brave Yao5225dd82015-03-26 07:39:19 +08001893 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
1894 EXPECT_EQ(640, gcodec.pacsize); // G722 gets 40ms @16kHz as defined in VoE.
1895}
1896
henrike@webrtc.org704bf9e2014-02-27 17:52:04 +00001897// Test that we fail if no codecs are specified.
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001898TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsNoCodecs) {
solenbergff976312016-03-30 23:28:51 -07001899 EXPECT_TRUE(SetupSendStream());
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001900 cricket::AudioSendParameters parameters;
1901 EXPECT_FALSE(channel_->SetSendParameters(parameters));
henrike@webrtc.org704bf9e2014-02-27 17:52:04 +00001902}
1903
1904// Test that we can set send codecs even with telephone-event codec as the first
1905// one on the list.
1906TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsDTMFOnTop) {
solenbergff976312016-03-30 23:28:51 -07001907 EXPECT_TRUE(SetupSendStream());
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001908 int channel_num = voe_.GetLastChannel();
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001909 cricket::AudioSendParameters parameters;
1910 parameters.codecs.push_back(kTelephoneEventCodec);
1911 parameters.codecs.push_back(kIsacCodec);
1912 parameters.codecs.push_back(kPcmuCodec);
1913 parameters.codecs[0].id = 98; // DTMF
1914 parameters.codecs[1].id = 96;
1915 EXPECT_TRUE(channel_->SetSendParameters(parameters));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001916 webrtc::CodecInst gcodec;
1917 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
henrike@webrtc.org704bf9e2014-02-27 17:52:04 +00001918 EXPECT_EQ(96, gcodec.pltype);
1919 EXPECT_STREQ("ISAC", gcodec.plname);
Fredrik Solenbergb5727682015-12-04 15:22:19 +01001920 EXPECT_TRUE(channel_->CanInsertDtmf());
henrike@webrtc.org704bf9e2014-02-27 17:52:04 +00001921}
1922
solenberg31642aa2016-03-14 08:00:37 -07001923// Test that payload type range is limited for telephone-event codec.
1924TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsDTMFPayloadTypeOutOfRange) {
solenbergff976312016-03-30 23:28:51 -07001925 EXPECT_TRUE(SetupSendStream());
solenberg31642aa2016-03-14 08:00:37 -07001926 cricket::AudioSendParameters parameters;
1927 parameters.codecs.push_back(kTelephoneEventCodec);
1928 parameters.codecs.push_back(kIsacCodec);
1929 parameters.codecs[0].id = 0; // DTMF
1930 parameters.codecs[1].id = 96;
1931 EXPECT_TRUE(channel_->SetSendParameters(parameters));
1932 EXPECT_TRUE(channel_->CanInsertDtmf());
1933 parameters.codecs[0].id = 128; // DTMF
1934 EXPECT_FALSE(channel_->SetSendParameters(parameters));
1935 EXPECT_FALSE(channel_->CanInsertDtmf());
1936 parameters.codecs[0].id = 127;
1937 EXPECT_TRUE(channel_->SetSendParameters(parameters));
1938 EXPECT_TRUE(channel_->CanInsertDtmf());
1939 parameters.codecs[0].id = -1; // DTMF
1940 EXPECT_FALSE(channel_->SetSendParameters(parameters));
1941 EXPECT_FALSE(channel_->CanInsertDtmf());
1942}
1943
henrike@webrtc.org704bf9e2014-02-27 17:52:04 +00001944// Test that we can set send codecs even with CN codec as the first
1945// one on the list.
1946TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNOnTop) {
solenbergff976312016-03-30 23:28:51 -07001947 EXPECT_TRUE(SetupSendStream());
henrike@webrtc.org704bf9e2014-02-27 17:52:04 +00001948 int channel_num = voe_.GetLastChannel();
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001949 cricket::AudioSendParameters parameters;
1950 parameters.codecs.push_back(kCn16000Codec);
1951 parameters.codecs.push_back(kIsacCodec);
1952 parameters.codecs.push_back(kPcmuCodec);
1953 parameters.codecs[0].id = 98; // wideband CN
1954 parameters.codecs[1].id = 96;
1955 EXPECT_TRUE(channel_->SetSendParameters(parameters));
henrike@webrtc.org704bf9e2014-02-27 17:52:04 +00001956 webrtc::CodecInst gcodec;
1957 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
1958 EXPECT_EQ(96, gcodec.pltype);
1959 EXPECT_STREQ("ISAC", gcodec.plname);
1960 EXPECT_EQ(98, voe_.GetSendCNPayloadType(channel_num, true));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001961}
1962
wu@webrtc.orgcadf9042013-08-30 21:24:16 +00001963// Test that we set VAD and DTMF types correctly as caller.
1964TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNandDTMFAsCaller) {
solenbergff976312016-03-30 23:28:51 -07001965 EXPECT_TRUE(SetupSendStream());
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001966 int channel_num = voe_.GetLastChannel();
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001967 cricket::AudioSendParameters parameters;
1968 parameters.codecs.push_back(kIsacCodec);
1969 parameters.codecs.push_back(kPcmuCodec);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001970 // TODO(juberti): cn 32000
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001971 parameters.codecs.push_back(kCn16000Codec);
1972 parameters.codecs.push_back(kCn8000Codec);
1973 parameters.codecs.push_back(kTelephoneEventCodec);
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001974 parameters.codecs[0].id = 96;
1975 parameters.codecs[2].id = 97; // wideband CN
1976 parameters.codecs[4].id = 98; // DTMF
1977 EXPECT_TRUE(channel_->SetSendParameters(parameters));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001978 webrtc::CodecInst gcodec;
1979 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
1980 EXPECT_EQ(96, gcodec.pltype);
1981 EXPECT_STREQ("ISAC", gcodec.plname);
1982 EXPECT_TRUE(voe_.GetVAD(channel_num));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001983 EXPECT_EQ(13, voe_.GetSendCNPayloadType(channel_num, false));
1984 EXPECT_EQ(97, voe_.GetSendCNPayloadType(channel_num, true));
Fredrik Solenbergb5727682015-12-04 15:22:19 +01001985 EXPECT_TRUE(channel_->CanInsertDtmf());
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001986}
1987
wu@webrtc.orgcadf9042013-08-30 21:24:16 +00001988// Test that we set VAD and DTMF types correctly as callee.
1989TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNandDTMFAsCallee) {
solenbergff976312016-03-30 23:28:51 -07001990 EXPECT_TRUE(SetupChannel());
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001991 cricket::AudioSendParameters parameters;
1992 parameters.codecs.push_back(kIsacCodec);
1993 parameters.codecs.push_back(kPcmuCodec);
wu@webrtc.orgcadf9042013-08-30 21:24:16 +00001994 // TODO(juberti): cn 32000
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001995 parameters.codecs.push_back(kCn16000Codec);
1996 parameters.codecs.push_back(kCn8000Codec);
1997 parameters.codecs.push_back(kTelephoneEventCodec);
Fredrik Solenbergb071a192015-09-17 16:42:56 +02001998 parameters.codecs[0].id = 96;
1999 parameters.codecs[2].id = 97; // wideband CN
2000 parameters.codecs[4].id = 98; // DTMF
2001 EXPECT_TRUE(channel_->SetSendParameters(parameters));
wu@webrtc.orgcadf9042013-08-30 21:24:16 +00002002 EXPECT_TRUE(channel_->AddSendStream(
2003 cricket::StreamParams::CreateLegacy(kSsrc1)));
solenberg0a617e22015-10-20 15:49:38 -07002004 int channel_num = voe_.GetLastChannel();
wu@webrtc.orgcadf9042013-08-30 21:24:16 +00002005
2006 webrtc::CodecInst gcodec;
2007 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
2008 EXPECT_EQ(96, gcodec.pltype);
2009 EXPECT_STREQ("ISAC", gcodec.plname);
2010 EXPECT_TRUE(voe_.GetVAD(channel_num));
wu@webrtc.orgcadf9042013-08-30 21:24:16 +00002011 EXPECT_EQ(13, voe_.GetSendCNPayloadType(channel_num, false));
2012 EXPECT_EQ(97, voe_.GetSendCNPayloadType(channel_num, true));
Fredrik Solenbergb5727682015-12-04 15:22:19 +01002013 EXPECT_TRUE(channel_->CanInsertDtmf());
wu@webrtc.orgcadf9042013-08-30 21:24:16 +00002014}
2015
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002016// Test that we only apply VAD if we have a CN codec that matches the
2017// send codec clockrate.
2018TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNNoMatch) {
solenbergff976312016-03-30 23:28:51 -07002019 EXPECT_TRUE(SetupSendStream());
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002020 int channel_num = voe_.GetLastChannel();
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002021 cricket::AudioSendParameters parameters;
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002022 // Set ISAC(16K) and CN(16K). VAD should be activated.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002023 parameters.codecs.push_back(kIsacCodec);
2024 parameters.codecs.push_back(kCn16000Codec);
2025 parameters.codecs[1].id = 97;
2026 EXPECT_TRUE(channel_->SetSendParameters(parameters));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002027 webrtc::CodecInst gcodec;
2028 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
2029 EXPECT_STREQ("ISAC", gcodec.plname);
2030 EXPECT_TRUE(voe_.GetVAD(channel_num));
2031 EXPECT_EQ(97, voe_.GetSendCNPayloadType(channel_num, true));
2032 // Set PCMU(8K) and CN(16K). VAD should not be activated.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002033 parameters.codecs[0] = kPcmuCodec;
2034 EXPECT_TRUE(channel_->SetSendParameters(parameters));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002035 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
2036 EXPECT_STREQ("PCMU", gcodec.plname);
2037 EXPECT_FALSE(voe_.GetVAD(channel_num));
2038 // Set PCMU(8K) and CN(8K). VAD should be activated.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002039 parameters.codecs[1] = kCn8000Codec;
2040 EXPECT_TRUE(channel_->SetSendParameters(parameters));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002041 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
2042 EXPECT_STREQ("PCMU", gcodec.plname);
2043 EXPECT_TRUE(voe_.GetVAD(channel_num));
2044 EXPECT_EQ(13, voe_.GetSendCNPayloadType(channel_num, false));
Brave Yao5225dd82015-03-26 07:39:19 +08002045 // Set ISAC(16K) and CN(8K). VAD should not be activated.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002046 parameters.codecs[0] = kIsacCodec;
2047 EXPECT_TRUE(channel_->SetSendParameters(parameters));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002048 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
2049 EXPECT_STREQ("ISAC", gcodec.plname);
2050 EXPECT_FALSE(voe_.GetVAD(channel_num));
2051}
2052
2053// Test that we perform case-insensitive matching of codec names.
2054TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCaseInsensitive) {
solenbergff976312016-03-30 23:28:51 -07002055 EXPECT_TRUE(SetupSendStream());
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002056 int channel_num = voe_.GetLastChannel();
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002057 cricket::AudioSendParameters parameters;
2058 parameters.codecs.push_back(kIsacCodec);
2059 parameters.codecs.push_back(kPcmuCodec);
2060 parameters.codecs.push_back(kCn16000Codec);
2061 parameters.codecs.push_back(kCn8000Codec);
2062 parameters.codecs.push_back(kTelephoneEventCodec);
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002063 parameters.codecs[0].name = "iSaC";
2064 parameters.codecs[0].id = 96;
2065 parameters.codecs[2].id = 97; // wideband CN
2066 parameters.codecs[4].id = 98; // DTMF
2067 EXPECT_TRUE(channel_->SetSendParameters(parameters));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002068 webrtc::CodecInst gcodec;
2069 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
2070 EXPECT_EQ(96, gcodec.pltype);
2071 EXPECT_STREQ("ISAC", gcodec.plname);
2072 EXPECT_TRUE(voe_.GetVAD(channel_num));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002073 EXPECT_EQ(13, voe_.GetSendCNPayloadType(channel_num, false));
2074 EXPECT_EQ(97, voe_.GetSendCNPayloadType(channel_num, true));
Fredrik Solenbergb5727682015-12-04 15:22:19 +01002075 EXPECT_TRUE(channel_->CanInsertDtmf());
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002076}
2077
stefanba4c0e42016-02-04 04:12:24 -08002078class WebRtcVoiceEngineWithSendSideBweTest : public WebRtcVoiceEngineTestFake {
2079 public:
2080 WebRtcVoiceEngineWithSendSideBweTest()
2081 : WebRtcVoiceEngineTestFake("WebRTC-Audio-SendSideBwe/Enabled/") {}
2082};
2083
2084TEST_F(WebRtcVoiceEngineWithSendSideBweTest,
2085 SupportsTransportSequenceNumberHeaderExtension) {
solenbergbc37fc82016-04-04 09:54:44 -07002086 cricket::RtpCapabilities capabilities = engine_->GetCapabilities();
stefanba4c0e42016-02-04 04:12:24 -08002087 ASSERT_FALSE(capabilities.header_extensions.empty());
isheriff6f8d6862016-05-26 11:24:55 -07002088 for (const webrtc::RtpExtension& extension : capabilities.header_extensions) {
2089 if (extension.uri == webrtc::RtpExtension::kTransportSequenceNumberUri) {
2090 EXPECT_EQ(webrtc::RtpExtension::kTransportSequenceNumberDefaultId,
stefanba4c0e42016-02-04 04:12:24 -08002091 extension.id);
2092 return;
2093 }
2094 }
2095 FAIL() << "Transport sequence number extension not in header-extension list.";
2096}
2097
buildbot@webrtc.org150835e2014-05-06 15:54:38 +00002098// Test support for audio level header extension.
2099TEST_F(WebRtcVoiceEngineTestFake, SendAudioLevelHeaderExtensions) {
isheriff6f8d6862016-05-26 11:24:55 -07002100 TestSetSendRtpHeaderExtensions(webrtc::RtpExtension::kAudioLevelUri);
henrike@webrtc.org79047f92014-03-06 23:46:59 +00002101}
buildbot@webrtc.org150835e2014-05-06 15:54:38 +00002102TEST_F(WebRtcVoiceEngineTestFake, RecvAudioLevelHeaderExtensions) {
isheriff6f8d6862016-05-26 11:24:55 -07002103 TestSetRecvRtpHeaderExtensions(webrtc::RtpExtension::kAudioLevelUri);
buildbot@webrtc.org150835e2014-05-06 15:54:38 +00002104}
henrike@webrtc.org79047f92014-03-06 23:46:59 +00002105
buildbot@webrtc.org150835e2014-05-06 15:54:38 +00002106// Test support for absolute send time header extension.
2107TEST_F(WebRtcVoiceEngineTestFake, SendAbsoluteSendTimeHeaderExtensions) {
isheriff6f8d6862016-05-26 11:24:55 -07002108 TestSetSendRtpHeaderExtensions(webrtc::RtpExtension::kAbsSendTimeUri);
buildbot@webrtc.org150835e2014-05-06 15:54:38 +00002109}
2110TEST_F(WebRtcVoiceEngineTestFake, RecvAbsoluteSendTimeHeaderExtensions) {
isheriff6f8d6862016-05-26 11:24:55 -07002111 TestSetRecvRtpHeaderExtensions(webrtc::RtpExtension::kAbsSendTimeUri);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002112}
2113
solenberg1ac56142015-10-13 03:58:19 -07002114// Test that we can create a channel and start sending on it.
2115TEST_F(WebRtcVoiceEngineTestFake, Send) {
solenbergff976312016-03-30 23:28:51 -07002116 EXPECT_TRUE(SetupSendStream());
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002117 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
solenbergd53a3f92016-04-14 13:56:37 -07002118 SetSend(channel_, true);
Taylor Brandstetter1a018dc2016-03-08 12:37:39 -08002119 EXPECT_TRUE(GetSendStream(kSsrc1).IsSending());
solenbergd53a3f92016-04-14 13:56:37 -07002120 SetSend(channel_, false);
Taylor Brandstetter1a018dc2016-03-08 12:37:39 -08002121 EXPECT_FALSE(GetSendStream(kSsrc1).IsSending());
2122}
2123
2124// Test that a channel will send if and only if it has a source and is enabled
2125// for sending.
2126TEST_F(WebRtcVoiceEngineTestFake, SendStateWithAndWithoutSource) {
solenbergff976312016-03-30 23:28:51 -07002127 EXPECT_TRUE(SetupSendStream());
Taylor Brandstetter1a018dc2016-03-08 12:37:39 -08002128 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
2129 EXPECT_TRUE(channel_->SetAudioSend(kSsrc1, true, nullptr, nullptr));
solenbergd53a3f92016-04-14 13:56:37 -07002130 SetSend(channel_, true);
Taylor Brandstetter1a018dc2016-03-08 12:37:39 -08002131 EXPECT_FALSE(GetSendStream(kSsrc1).IsSending());
2132 EXPECT_TRUE(channel_->SetAudioSend(kSsrc1, true, nullptr, &fake_source_));
2133 EXPECT_TRUE(GetSendStream(kSsrc1).IsSending());
2134 EXPECT_TRUE(channel_->SetAudioSend(kSsrc1, true, nullptr, nullptr));
2135 EXPECT_FALSE(GetSendStream(kSsrc1).IsSending());
solenberg1ac56142015-10-13 03:58:19 -07002136}
2137
solenberg94218532016-06-16 10:53:22 -07002138// Test that a channel is muted/unmuted.
2139TEST_F(WebRtcVoiceEngineTestFake, SendStateMuteUnmute) {
2140 EXPECT_TRUE(SetupSendStream());
2141 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
2142 EXPECT_FALSE(GetSendStream(kSsrc1).muted());
2143 EXPECT_TRUE(channel_->SetAudioSend(kSsrc1, true, nullptr, nullptr));
2144 EXPECT_FALSE(GetSendStream(kSsrc1).muted());
2145 EXPECT_TRUE(channel_->SetAudioSend(kSsrc1, false, nullptr, nullptr));
2146 EXPECT_TRUE(GetSendStream(kSsrc1).muted());
2147}
2148
solenberg6d6e7c52016-04-13 09:07:30 -07002149// Test that SetSendParameters() does not alter a stream's send state.
2150TEST_F(WebRtcVoiceEngineTestFake, SendStateWhenStreamsAreRecreated) {
2151 EXPECT_TRUE(SetupSendStream());
2152 EXPECT_FALSE(GetSendStream(kSsrc1).IsSending());
2153
2154 // Turn on sending.
solenbergd53a3f92016-04-14 13:56:37 -07002155 SetSend(channel_, true);
solenberg6d6e7c52016-04-13 09:07:30 -07002156 EXPECT_TRUE(GetSendStream(kSsrc1).IsSending());
2157
2158 // Changing RTP header extensions will recreate the AudioSendStream.
2159 send_parameters_.extensions.push_back(
isheriff6f8d6862016-05-26 11:24:55 -07002160 webrtc::RtpExtension(webrtc::RtpExtension::kAudioLevelUri, 12));
solenberg6d6e7c52016-04-13 09:07:30 -07002161 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
2162 EXPECT_TRUE(GetSendStream(kSsrc1).IsSending());
2163
2164 // Turn off sending.
solenbergd53a3f92016-04-14 13:56:37 -07002165 SetSend(channel_, false);
solenberg6d6e7c52016-04-13 09:07:30 -07002166 EXPECT_FALSE(GetSendStream(kSsrc1).IsSending());
2167
2168 // Changing RTP header extensions will recreate the AudioSendStream.
2169 send_parameters_.extensions.clear();
2170 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
2171 EXPECT_FALSE(GetSendStream(kSsrc1).IsSending());
2172}
2173
solenberg1ac56142015-10-13 03:58:19 -07002174// Test that we can create a channel and start playing out on it.
2175TEST_F(WebRtcVoiceEngineTestFake, Playout) {
solenbergff976312016-03-30 23:28:51 -07002176 EXPECT_TRUE(SetupRecvStream());
solenberg1ac56142015-10-13 03:58:19 -07002177 int channel_num = voe_.GetLastChannel();
2178 EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
2179 EXPECT_TRUE(channel_->SetPlayout(true));
2180 EXPECT_TRUE(voe_.GetPlayout(channel_num));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002181 EXPECT_TRUE(channel_->SetPlayout(false));
2182 EXPECT_FALSE(voe_.GetPlayout(channel_num));
2183}
2184
wu@webrtc.org9dba5252013-08-05 20:36:57 +00002185// Test that we can add and remove send streams.
2186TEST_F(WebRtcVoiceEngineTestFake, CreateAndDeleteMultipleSendStreams) {
2187 SetupForMultiSendStream();
2188
wu@webrtc.org9dba5252013-08-05 20:36:57 +00002189 // Set the global state for sending.
solenbergd53a3f92016-04-14 13:56:37 -07002190 SetSend(channel_, true);
wu@webrtc.org9dba5252013-08-05 20:36:57 +00002191
solenbergc96df772015-10-21 13:01:53 -07002192 for (uint32_t ssrc : kSsrcs4) {
wu@webrtc.org9dba5252013-08-05 20:36:57 +00002193 EXPECT_TRUE(channel_->AddSendStream(
solenbergc96df772015-10-21 13:01:53 -07002194 cricket::StreamParams::CreateLegacy(ssrc)));
Taylor Brandstetter1a018dc2016-03-08 12:37:39 -08002195 EXPECT_TRUE(channel_->SetAudioSend(ssrc, true, nullptr, &fake_source_));
wu@webrtc.org9dba5252013-08-05 20:36:57 +00002196 // Verify that we are in a sending state for all the created streams.
Taylor Brandstetter1a018dc2016-03-08 12:37:39 -08002197 EXPECT_TRUE(GetSendStream(ssrc).IsSending());
wu@webrtc.org9dba5252013-08-05 20:36:57 +00002198 }
tfarina5237aaf2015-11-10 23:44:30 -08002199 EXPECT_EQ(arraysize(kSsrcs4), call_.GetAudioSendStreams().size());
wu@webrtc.org9dba5252013-08-05 20:36:57 +00002200
solenbergc96df772015-10-21 13:01:53 -07002201 // Delete the send streams.
2202 for (uint32_t ssrc : kSsrcs4) {
2203 EXPECT_TRUE(channel_->RemoveSendStream(ssrc));
solenberg3a941542015-11-16 07:34:50 -08002204 EXPECT_FALSE(call_.GetAudioSendStream(ssrc));
solenbergc96df772015-10-21 13:01:53 -07002205 EXPECT_FALSE(channel_->RemoveSendStream(ssrc));
wu@webrtc.org9dba5252013-08-05 20:36:57 +00002206 }
solenbergc96df772015-10-21 13:01:53 -07002207 EXPECT_EQ(0u, call_.GetAudioSendStreams().size());
wu@webrtc.org9dba5252013-08-05 20:36:57 +00002208}
2209
2210// Test SetSendCodecs correctly configure the codecs in all send streams.
2211TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsWithMultipleSendStreams) {
2212 SetupForMultiSendStream();
2213
wu@webrtc.org9dba5252013-08-05 20:36:57 +00002214 // Create send streams.
solenbergc96df772015-10-21 13:01:53 -07002215 for (uint32_t ssrc : kSsrcs4) {
wu@webrtc.org9dba5252013-08-05 20:36:57 +00002216 EXPECT_TRUE(channel_->AddSendStream(
solenbergc96df772015-10-21 13:01:53 -07002217 cricket::StreamParams::CreateLegacy(ssrc)));
wu@webrtc.org9dba5252013-08-05 20:36:57 +00002218 }
2219
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002220 cricket::AudioSendParameters parameters;
wu@webrtc.org9dba5252013-08-05 20:36:57 +00002221 // Set ISAC(16K) and CN(16K). VAD should be activated.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002222 parameters.codecs.push_back(kIsacCodec);
2223 parameters.codecs.push_back(kCn16000Codec);
2224 parameters.codecs[1].id = 97;
2225 EXPECT_TRUE(channel_->SetSendParameters(parameters));
wu@webrtc.org9dba5252013-08-05 20:36:57 +00002226
2227 // Verify ISAC and VAD are corrected configured on all send channels.
2228 webrtc::CodecInst gcodec;
solenbergc96df772015-10-21 13:01:53 -07002229 for (uint32_t ssrc : kSsrcs4) {
solenberg3a941542015-11-16 07:34:50 -08002230 int channel_num = GetSendStreamConfig(ssrc).voe_channel_id;
wu@webrtc.org9dba5252013-08-05 20:36:57 +00002231 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
2232 EXPECT_STREQ("ISAC", gcodec.plname);
2233 EXPECT_TRUE(voe_.GetVAD(channel_num));
2234 EXPECT_EQ(97, voe_.GetSendCNPayloadType(channel_num, true));
2235 }
2236
2237 // Change to PCMU(8K) and CN(16K). VAD should not be activated.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002238 parameters.codecs[0] = kPcmuCodec;
2239 EXPECT_TRUE(channel_->SetSendParameters(parameters));
solenbergc96df772015-10-21 13:01:53 -07002240 for (uint32_t ssrc : kSsrcs4) {
solenberg3a941542015-11-16 07:34:50 -08002241 int channel_num = GetSendStreamConfig(ssrc).voe_channel_id;
wu@webrtc.org9dba5252013-08-05 20:36:57 +00002242 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
2243 EXPECT_STREQ("PCMU", gcodec.plname);
2244 EXPECT_FALSE(voe_.GetVAD(channel_num));
2245 }
2246}
2247
2248// Test we can SetSend on all send streams correctly.
2249TEST_F(WebRtcVoiceEngineTestFake, SetSendWithMultipleSendStreams) {
2250 SetupForMultiSendStream();
2251
Taylor Brandstetter1a018dc2016-03-08 12:37:39 -08002252 // Create the send channels and they should be a "not sending" date.
solenbergc96df772015-10-21 13:01:53 -07002253 for (uint32_t ssrc : kSsrcs4) {
wu@webrtc.org9dba5252013-08-05 20:36:57 +00002254 EXPECT_TRUE(channel_->AddSendStream(
solenbergc96df772015-10-21 13:01:53 -07002255 cricket::StreamParams::CreateLegacy(ssrc)));
Taylor Brandstetter1a018dc2016-03-08 12:37:39 -08002256 EXPECT_TRUE(channel_->SetAudioSend(ssrc, true, nullptr, &fake_source_));
2257 EXPECT_FALSE(GetSendStream(ssrc).IsSending());
wu@webrtc.org9dba5252013-08-05 20:36:57 +00002258 }
2259
2260 // Set the global state for starting sending.
solenbergd53a3f92016-04-14 13:56:37 -07002261 SetSend(channel_, true);
solenbergc96df772015-10-21 13:01:53 -07002262 for (uint32_t ssrc : kSsrcs4) {
wu@webrtc.org9dba5252013-08-05 20:36:57 +00002263 // Verify that we are in a sending state for all the send streams.
Taylor Brandstetter1a018dc2016-03-08 12:37:39 -08002264 EXPECT_TRUE(GetSendStream(ssrc).IsSending());
wu@webrtc.org9dba5252013-08-05 20:36:57 +00002265 }
2266
2267 // Set the global state for stopping sending.
solenbergd53a3f92016-04-14 13:56:37 -07002268 SetSend(channel_, false);
solenbergc96df772015-10-21 13:01:53 -07002269 for (uint32_t ssrc : kSsrcs4) {
wu@webrtc.org9dba5252013-08-05 20:36:57 +00002270 // Verify that we are in a stop state for all the send streams.
Taylor Brandstetter1a018dc2016-03-08 12:37:39 -08002271 EXPECT_FALSE(GetSendStream(ssrc).IsSending());
wu@webrtc.org9dba5252013-08-05 20:36:57 +00002272 }
2273}
2274
2275// Test we can set the correct statistics on all send streams.
2276TEST_F(WebRtcVoiceEngineTestFake, GetStatsWithMultipleSendStreams) {
2277 SetupForMultiSendStream();
2278
wu@webrtc.org9dba5252013-08-05 20:36:57 +00002279 // Create send streams.
solenbergc96df772015-10-21 13:01:53 -07002280 for (uint32_t ssrc : kSsrcs4) {
wu@webrtc.org9dba5252013-08-05 20:36:57 +00002281 EXPECT_TRUE(channel_->AddSendStream(
solenbergc96df772015-10-21 13:01:53 -07002282 cricket::StreamParams::CreateLegacy(ssrc)));
wu@webrtc.org9dba5252013-08-05 20:36:57 +00002283 }
solenberg85a04962015-10-27 03:35:21 -07002284
buildbot@webrtc.org7e71b772014-06-13 01:14:01 +00002285 // Create a receive stream to check that none of the send streams end up in
2286 // the receive stream stats.
solenberg8189b022016-06-14 12:13:00 -07002287 EXPECT_TRUE(AddRecvStream(kSsrc2));
solenberg971cab02016-06-14 10:02:41 -07002288
wu@webrtc.org9dba5252013-08-05 20:36:57 +00002289 // We need send codec to be set to get all stats.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002290 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
2291 EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
solenberg971cab02016-06-14 10:02:41 -07002292 SetAudioSendStreamStats();
wu@webrtc.org9dba5252013-08-05 20:36:57 +00002293
solenberg85a04962015-10-27 03:35:21 -07002294 // Check stats for the added streams.
2295 {
2296 cricket::VoiceMediaInfo info;
2297 EXPECT_EQ(true, channel_->GetStats(&info));
wu@webrtc.org9dba5252013-08-05 20:36:57 +00002298
solenberg85a04962015-10-27 03:35:21 -07002299 // We have added 4 send streams. We should see empty stats for all.
tfarina5237aaf2015-11-10 23:44:30 -08002300 EXPECT_EQ(static_cast<size_t>(arraysize(kSsrcs4)), info.senders.size());
solenberg85a04962015-10-27 03:35:21 -07002301 for (const auto& sender : info.senders) {
solenberg566ef242015-11-06 15:34:49 -08002302 VerifyVoiceSenderInfo(sender, false);
solenberg85a04962015-10-27 03:35:21 -07002303 }
2304
2305 // We have added one receive stream. We should see empty stats.
2306 EXPECT_EQ(info.receivers.size(), 1u);
2307 EXPECT_EQ(info.receivers[0].ssrc(), 0);
wu@webrtc.org9dba5252013-08-05 20:36:57 +00002308 }
solenberg1ac56142015-10-13 03:58:19 -07002309
Fredrik Solenberg4f4ec0a2015-10-22 10:49:27 +02002310 // Remove the kSsrc2 stream. No receiver stats.
solenberg85a04962015-10-27 03:35:21 -07002311 {
2312 cricket::VoiceMediaInfo info;
2313 EXPECT_TRUE(channel_->RemoveRecvStream(kSsrc2));
2314 EXPECT_EQ(true, channel_->GetStats(&info));
tfarina5237aaf2015-11-10 23:44:30 -08002315 EXPECT_EQ(static_cast<size_t>(arraysize(kSsrcs4)), info.senders.size());
solenberg85a04962015-10-27 03:35:21 -07002316 EXPECT_EQ(0u, info.receivers.size());
2317 }
buildbot@webrtc.org7e71b772014-06-13 01:14:01 +00002318
Fredrik Solenberg4f4ec0a2015-10-22 10:49:27 +02002319 // Deliver a new packet - a default receive stream should be created and we
2320 // should see stats again.
solenberg85a04962015-10-27 03:35:21 -07002321 {
2322 cricket::VoiceMediaInfo info;
2323 DeliverPacket(kPcmuFrame, sizeof(kPcmuFrame));
2324 SetAudioReceiveStreamStats();
2325 EXPECT_EQ(true, channel_->GetStats(&info));
tfarina5237aaf2015-11-10 23:44:30 -08002326 EXPECT_EQ(static_cast<size_t>(arraysize(kSsrcs4)), info.senders.size());
solenberg85a04962015-10-27 03:35:21 -07002327 EXPECT_EQ(1u, info.receivers.size());
2328 VerifyVoiceReceiverInfo(info.receivers[0]);
2329 }
wu@webrtc.org9dba5252013-08-05 20:36:57 +00002330}
2331
wu@webrtc.org9dba5252013-08-05 20:36:57 +00002332// Test that we can add and remove receive streams, and do proper send/playout.
2333// We can receive on multiple streams while sending one stream.
2334TEST_F(WebRtcVoiceEngineTestFake, PlayoutWithMultipleStreams) {
solenbergff976312016-03-30 23:28:51 -07002335 EXPECT_TRUE(SetupSendStream());
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002336 int channel_num1 = voe_.GetLastChannel();
2337
solenberg1ac56142015-10-13 03:58:19 -07002338 // Start playout without a receive stream.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002339 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002340 EXPECT_TRUE(channel_->SetPlayout(true));
solenberg1ac56142015-10-13 03:58:19 -07002341 EXPECT_FALSE(voe_.GetPlayout(channel_num1));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002342
solenberg1ac56142015-10-13 03:58:19 -07002343 // Adding another stream should enable playout on the new stream only.
solenberg8189b022016-06-14 12:13:00 -07002344 EXPECT_TRUE(AddRecvStream(kSsrc2));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002345 int channel_num2 = voe_.GetLastChannel();
solenbergd53a3f92016-04-14 13:56:37 -07002346 SetSend(channel_, true);
Taylor Brandstetter1a018dc2016-03-08 12:37:39 -08002347 EXPECT_TRUE(GetSendStream(kSsrc1).IsSending());
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002348
solenberg1ac56142015-10-13 03:58:19 -07002349 // Make sure only the new stream is played out.
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002350 EXPECT_FALSE(voe_.GetPlayout(channel_num1));
2351 EXPECT_TRUE(voe_.GetPlayout(channel_num2));
2352
2353 // Adding yet another stream should have stream 2 and 3 enabled for playout.
solenberg8189b022016-06-14 12:13:00 -07002354 EXPECT_TRUE(AddRecvStream(kSsrc3));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002355 int channel_num3 = voe_.GetLastChannel();
2356 EXPECT_FALSE(voe_.GetPlayout(channel_num1));
2357 EXPECT_TRUE(voe_.GetPlayout(channel_num2));
2358 EXPECT_TRUE(voe_.GetPlayout(channel_num3));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002359
2360 // Stop sending.
solenbergd53a3f92016-04-14 13:56:37 -07002361 SetSend(channel_, false);
Taylor Brandstetter1a018dc2016-03-08 12:37:39 -08002362 EXPECT_FALSE(GetSendStream(kSsrc1).IsSending());
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002363
2364 // Stop playout.
2365 EXPECT_TRUE(channel_->SetPlayout(false));
2366 EXPECT_FALSE(voe_.GetPlayout(channel_num1));
2367 EXPECT_FALSE(voe_.GetPlayout(channel_num2));
2368 EXPECT_FALSE(voe_.GetPlayout(channel_num3));
2369
solenberg1ac56142015-10-13 03:58:19 -07002370 // Restart playout and make sure only recv streams are played out.
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002371 EXPECT_TRUE(channel_->SetPlayout(true));
2372 EXPECT_FALSE(voe_.GetPlayout(channel_num1));
2373 EXPECT_TRUE(voe_.GetPlayout(channel_num2));
2374 EXPECT_TRUE(voe_.GetPlayout(channel_num3));
2375
solenberg1ac56142015-10-13 03:58:19 -07002376 // Now remove the recv streams and verify that the send stream doesn't play.
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002377 EXPECT_TRUE(channel_->RemoveRecvStream(3));
2378 EXPECT_TRUE(channel_->RemoveRecvStream(2));
solenberg1ac56142015-10-13 03:58:19 -07002379 EXPECT_FALSE(voe_.GetPlayout(channel_num1));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002380}
2381
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002382// Test that we can create a channel configured for Codian bridges,
solenberg1ac56142015-10-13 03:58:19 -07002383// and start sending on it.
2384TEST_F(WebRtcVoiceEngineTestFake, CodianSend) {
solenbergff976312016-03-30 23:28:51 -07002385 EXPECT_TRUE(SetupSendStream());
solenberg246b8172015-12-08 09:50:23 -08002386 cricket::AudioOptions options_adjust_agc;
2387 options_adjust_agc.adjust_agc_delta = rtc::Optional<int>(-10);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002388 webrtc::AgcConfig agc_config;
2389 EXPECT_EQ(0, voe_.GetAgcConfig(agc_config));
2390 EXPECT_EQ(0, agc_config.targetLeveldBOv);
solenberg246b8172015-12-08 09:50:23 -08002391 send_parameters_.options = options_adjust_agc;
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002392 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
solenbergd53a3f92016-04-14 13:56:37 -07002393 SetSend(channel_, true);
Taylor Brandstetter1a018dc2016-03-08 12:37:39 -08002394 EXPECT_TRUE(GetSendStream(kSsrc1).IsSending());
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002395 EXPECT_EQ(0, voe_.GetAgcConfig(agc_config));
2396 EXPECT_EQ(agc_config.targetLeveldBOv, 10); // level was attenuated
solenbergd53a3f92016-04-14 13:56:37 -07002397 SetSend(channel_, false);
Taylor Brandstetter1a018dc2016-03-08 12:37:39 -08002398 EXPECT_FALSE(GetSendStream(kSsrc1).IsSending());
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002399 EXPECT_EQ(0, voe_.GetAgcConfig(agc_config));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002400}
2401
wu@webrtc.org97077a32013-10-25 21:18:33 +00002402TEST_F(WebRtcVoiceEngineTestFake, TxAgcConfigViaOptions) {
solenbergff976312016-03-30 23:28:51 -07002403 EXPECT_TRUE(SetupSendStream());
solenberg5b5129a2016-04-08 05:35:48 -07002404 EXPECT_CALL(adm_,
2405 BuiltInAGCIsAvailable()).Times(2).WillRepeatedly(Return(false));
wu@webrtc.org97077a32013-10-25 21:18:33 +00002406 webrtc::AgcConfig agc_config;
2407 EXPECT_EQ(0, voe_.GetAgcConfig(agc_config));
2408 EXPECT_EQ(0, agc_config.targetLeveldBOv);
solenberg246b8172015-12-08 09:50:23 -08002409 send_parameters_.options.tx_agc_target_dbov = rtc::Optional<uint16_t>(3);
2410 send_parameters_.options.tx_agc_digital_compression_gain =
2411 rtc::Optional<uint16_t>(9);
2412 send_parameters_.options.tx_agc_limiter = rtc::Optional<bool>(true);
2413 send_parameters_.options.auto_gain_control = rtc::Optional<bool>(true);
2414 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
wu@webrtc.org97077a32013-10-25 21:18:33 +00002415 EXPECT_EQ(0, voe_.GetAgcConfig(agc_config));
2416 EXPECT_EQ(3, agc_config.targetLeveldBOv);
2417 EXPECT_EQ(9, agc_config.digitalCompressionGaindB);
2418 EXPECT_TRUE(agc_config.limiterEnable);
2419
2420 // Check interaction with adjust_agc_delta. Both should be respected, for
2421 // backwards compatibility.
solenberg246b8172015-12-08 09:50:23 -08002422 send_parameters_.options.adjust_agc_delta = rtc::Optional<int>(-10);
2423 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
wu@webrtc.org97077a32013-10-25 21:18:33 +00002424 EXPECT_EQ(0, voe_.GetAgcConfig(agc_config));
2425 EXPECT_EQ(13, agc_config.targetLeveldBOv);
2426}
2427
wu@webrtc.org97077a32013-10-25 21:18:33 +00002428TEST_F(WebRtcVoiceEngineTestFake, SampleRatesViaOptions) {
solenbergff976312016-03-30 23:28:51 -07002429 EXPECT_TRUE(SetupSendStream());
solenberg5b5129a2016-04-08 05:35:48 -07002430 EXPECT_CALL(adm_, SetRecordingSampleRate(48000)).WillOnce(Return(0));
2431 EXPECT_CALL(adm_, SetPlayoutSampleRate(44100)).WillOnce(Return(0));
solenberg246b8172015-12-08 09:50:23 -08002432 send_parameters_.options.recording_sample_rate =
2433 rtc::Optional<uint32_t>(48000);
2434 send_parameters_.options.playout_sample_rate = rtc::Optional<uint32_t>(44100);
2435 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
wu@webrtc.org97077a32013-10-25 21:18:33 +00002436}
2437
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002438// Test that we can set the outgoing SSRC properly.
solenbergff976312016-03-30 23:28:51 -07002439// SSRC is set in SetupSendStream() by calling AddSendStream.
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002440TEST_F(WebRtcVoiceEngineTestFake, SetSendSsrc) {
solenbergff976312016-03-30 23:28:51 -07002441 EXPECT_TRUE(SetupSendStream());
solenberg3a941542015-11-16 07:34:50 -08002442 EXPECT_TRUE(call_.GetAudioSendStream(kSsrc1));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002443}
2444
2445TEST_F(WebRtcVoiceEngineTestFake, GetStats) {
2446 // Setup. We need send codec to be set to get all stats.
solenbergff976312016-03-30 23:28:51 -07002447 EXPECT_TRUE(SetupSendStream());
solenbergff976312016-03-30 23:28:51 -07002448 // SetupSendStream adds a send stream with kSsrc1, so the receive
solenberg1ac56142015-10-13 03:58:19 -07002449 // stream has to use a different SSRC.
solenberg8189b022016-06-14 12:13:00 -07002450 EXPECT_TRUE(AddRecvStream(kSsrc2));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002451 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
2452 EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
solenberg971cab02016-06-14 10:02:41 -07002453 SetAudioSendStreamStats();
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002454
solenberg85a04962015-10-27 03:35:21 -07002455 // Check stats for the added streams.
2456 {
2457 cricket::VoiceMediaInfo info;
2458 EXPECT_EQ(true, channel_->GetStats(&info));
2459
2460 // We have added one send stream. We should see the stats we've set.
2461 EXPECT_EQ(1u, info.senders.size());
solenberg566ef242015-11-06 15:34:49 -08002462 VerifyVoiceSenderInfo(info.senders[0], false);
solenberg85a04962015-10-27 03:35:21 -07002463 // We have added one receive stream. We should see empty stats.
2464 EXPECT_EQ(info.receivers.size(), 1u);
2465 EXPECT_EQ(info.receivers[0].ssrc(), 0);
2466 }
solenberg1ac56142015-10-13 03:58:19 -07002467
solenberg566ef242015-11-06 15:34:49 -08002468 // Start sending - this affects some reported stats.
2469 {
2470 cricket::VoiceMediaInfo info;
solenbergd53a3f92016-04-14 13:56:37 -07002471 SetSend(channel_, true);
solenberg566ef242015-11-06 15:34:49 -08002472 EXPECT_EQ(true, channel_->GetStats(&info));
2473 VerifyVoiceSenderInfo(info.senders[0], true);
2474 }
2475
Fredrik Solenberg4f4ec0a2015-10-22 10:49:27 +02002476 // Remove the kSsrc2 stream. No receiver stats.
solenberg85a04962015-10-27 03:35:21 -07002477 {
2478 cricket::VoiceMediaInfo info;
2479 EXPECT_TRUE(channel_->RemoveRecvStream(kSsrc2));
2480 EXPECT_EQ(true, channel_->GetStats(&info));
2481 EXPECT_EQ(1u, info.senders.size());
2482 EXPECT_EQ(0u, info.receivers.size());
2483 }
solenberg1ac56142015-10-13 03:58:19 -07002484
Fredrik Solenberg4f4ec0a2015-10-22 10:49:27 +02002485 // Deliver a new packet - a default receive stream should be created and we
2486 // should see stats again.
solenberg85a04962015-10-27 03:35:21 -07002487 {
2488 cricket::VoiceMediaInfo info;
2489 DeliverPacket(kPcmuFrame, sizeof(kPcmuFrame));
2490 SetAudioReceiveStreamStats();
2491 EXPECT_EQ(true, channel_->GetStats(&info));
2492 EXPECT_EQ(1u, info.senders.size());
2493 EXPECT_EQ(1u, info.receivers.size());
2494 VerifyVoiceReceiverInfo(info.receivers[0]);
2495 }
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002496}
2497
2498// Test that we can set the outgoing SSRC properly with multiple streams.
solenbergff976312016-03-30 23:28:51 -07002499// SSRC is set in SetupSendStream() by calling AddSendStream.
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002500TEST_F(WebRtcVoiceEngineTestFake, SetSendSsrcWithMultipleStreams) {
solenbergff976312016-03-30 23:28:51 -07002501 EXPECT_TRUE(SetupSendStream());
solenberg3a941542015-11-16 07:34:50 -08002502 EXPECT_TRUE(call_.GetAudioSendStream(kSsrc1));
solenberg8189b022016-06-14 12:13:00 -07002503 EXPECT_TRUE(AddRecvStream(kSsrc2));
solenberg7add0582015-11-20 09:59:34 -08002504 EXPECT_EQ(kSsrc1, GetRecvStreamConfig(kSsrc2).rtp.local_ssrc);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002505}
2506
2507// Test that the local SSRC is the same on sending and receiving channels if the
2508// receive channel is created before the send channel.
2509TEST_F(WebRtcVoiceEngineTestFake, SetSendSsrcAfterCreatingReceiveChannel) {
solenbergff976312016-03-30 23:28:51 -07002510 EXPECT_TRUE(SetupChannel());
solenberg8189b022016-06-14 12:13:00 -07002511 EXPECT_TRUE(AddRecvStream(1));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002512 int receive_channel_num = voe_.GetLastChannel();
2513 EXPECT_TRUE(channel_->AddSendStream(
2514 cricket::StreamParams::CreateLegacy(1234)));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002515
solenberg3a941542015-11-16 07:34:50 -08002516 EXPECT_TRUE(call_.GetAudioSendStream(1234));
solenberg85a04962015-10-27 03:35:21 -07002517 EXPECT_EQ(1234U, voe_.GetLocalSSRC(receive_channel_num));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002518}
2519
2520// Test that we can properly receive packets.
2521TEST_F(WebRtcVoiceEngineTestFake, Recv) {
solenbergff976312016-03-30 23:28:51 -07002522 EXPECT_TRUE(SetupChannel());
solenberg8189b022016-06-14 12:13:00 -07002523 EXPECT_TRUE(AddRecvStream(1));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002524 DeliverPacket(kPcmuFrame, sizeof(kPcmuFrame));
mflodman3d7db262016-04-29 00:57:13 -07002525
2526 EXPECT_TRUE(GetRecvStream(1).VerifyLastPacket(kPcmuFrame,
2527 sizeof(kPcmuFrame)));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002528}
2529
2530// Test that we can properly receive packets on multiple streams.
2531TEST_F(WebRtcVoiceEngineTestFake, RecvWithMultipleStreams) {
solenbergff976312016-03-30 23:28:51 -07002532 EXPECT_TRUE(SetupChannel());
mflodman3d7db262016-04-29 00:57:13 -07002533 const uint32_t ssrc1 = 1;
2534 const uint32_t ssrc2 = 2;
2535 const uint32_t ssrc3 = 3;
solenberg8189b022016-06-14 12:13:00 -07002536 EXPECT_TRUE(AddRecvStream(ssrc1));
2537 EXPECT_TRUE(AddRecvStream(ssrc2));
2538 EXPECT_TRUE(AddRecvStream(ssrc3));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002539 // Create packets with the right SSRCs.
mflodman3d7db262016-04-29 00:57:13 -07002540 unsigned char packets[4][sizeof(kPcmuFrame)];
tfarina5237aaf2015-11-10 23:44:30 -08002541 for (size_t i = 0; i < arraysize(packets); ++i) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002542 memcpy(packets[i], kPcmuFrame, sizeof(kPcmuFrame));
Peter Boström0c4e06b2015-10-07 12:23:21 +02002543 rtc::SetBE32(packets[i] + 8, static_cast<uint32_t>(i));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002544 }
mflodman3d7db262016-04-29 00:57:13 -07002545
2546 const cricket::FakeAudioReceiveStream& s1 = GetRecvStream(ssrc1);
2547 const cricket::FakeAudioReceiveStream& s2 = GetRecvStream(ssrc2);
2548 const cricket::FakeAudioReceiveStream& s3 = GetRecvStream(ssrc3);
2549
2550 EXPECT_EQ(s1.received_packets(), 0);
2551 EXPECT_EQ(s2.received_packets(), 0);
2552 EXPECT_EQ(s3.received_packets(), 0);
solenberg7e63ef02015-11-20 00:19:43 -08002553
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002554 DeliverPacket(packets[0], sizeof(packets[0]));
mflodman3d7db262016-04-29 00:57:13 -07002555 EXPECT_EQ(s1.received_packets(), 0);
2556 EXPECT_EQ(s2.received_packets(), 0);
2557 EXPECT_EQ(s3.received_packets(), 0);
solenberg7e63ef02015-11-20 00:19:43 -08002558
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002559 DeliverPacket(packets[1], sizeof(packets[1]));
mflodman3d7db262016-04-29 00:57:13 -07002560 EXPECT_EQ(s1.received_packets(), 1);
2561 EXPECT_TRUE(s1.VerifyLastPacket(packets[1], sizeof(packets[1])));
2562 EXPECT_EQ(s2.received_packets(), 0);
2563 EXPECT_EQ(s3.received_packets(), 0);
solenberg7e63ef02015-11-20 00:19:43 -08002564
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002565 DeliverPacket(packets[2], sizeof(packets[2]));
mflodman3d7db262016-04-29 00:57:13 -07002566 EXPECT_EQ(s1.received_packets(), 1);
2567 EXPECT_EQ(s2.received_packets(), 1);
2568 EXPECT_TRUE(s2.VerifyLastPacket(packets[2], sizeof(packets[2])));
2569 EXPECT_EQ(s3.received_packets(), 0);
solenberg7e63ef02015-11-20 00:19:43 -08002570
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002571 DeliverPacket(packets[3], sizeof(packets[3]));
mflodman3d7db262016-04-29 00:57:13 -07002572 EXPECT_EQ(s1.received_packets(), 1);
2573 EXPECT_EQ(s2.received_packets(), 1);
2574 EXPECT_EQ(s3.received_packets(), 1);
2575 EXPECT_TRUE(s3.VerifyLastPacket(packets[3], sizeof(packets[3])));
solenberg7e63ef02015-11-20 00:19:43 -08002576
mflodman3d7db262016-04-29 00:57:13 -07002577 EXPECT_TRUE(channel_->RemoveRecvStream(ssrc3));
2578 EXPECT_TRUE(channel_->RemoveRecvStream(ssrc2));
2579 EXPECT_TRUE(channel_->RemoveRecvStream(ssrc1));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002580}
2581
solenberg7e63ef02015-11-20 00:19:43 -08002582// Test that receiving on an unsignalled stream works (default channel will be
2583// created).
2584TEST_F(WebRtcVoiceEngineTestFake, RecvUnsignalled) {
solenbergff976312016-03-30 23:28:51 -07002585 EXPECT_TRUE(SetupChannel());
mflodman3d7db262016-04-29 00:57:13 -07002586 EXPECT_EQ(0, call_.GetAudioReceiveStreams().size());
2587
solenberg7e63ef02015-11-20 00:19:43 -08002588 DeliverPacket(kPcmuFrame, sizeof(kPcmuFrame));
mflodman3d7db262016-04-29 00:57:13 -07002589
2590 EXPECT_EQ(1, call_.GetAudioReceiveStreams().size());
2591 EXPECT_TRUE(GetRecvStream(1).VerifyLastPacket(kPcmuFrame,
2592 sizeof(kPcmuFrame)));
solenberg7e63ef02015-11-20 00:19:43 -08002593}
2594
2595// Test that receiving on an unsignalled stream works (default channel will be
2596// created), and that packets will be forwarded to the default channel
2597// regardless of their SSRCs.
2598TEST_F(WebRtcVoiceEngineTestFake, RecvUnsignalledWithSsrcSwitch) {
solenbergff976312016-03-30 23:28:51 -07002599 EXPECT_TRUE(SetupChannel());
mflodman3d7db262016-04-29 00:57:13 -07002600 unsigned char packet[sizeof(kPcmuFrame)];
solenberg7e63ef02015-11-20 00:19:43 -08002601 memcpy(packet, kPcmuFrame, sizeof(kPcmuFrame));
2602
mflodman3d7db262016-04-29 00:57:13 -07002603 // Note that ssrc = 0 is not supported.
2604 uint32_t ssrc = 1;
2605 for (; ssrc < 10; ++ssrc) {
solenberg7e63ef02015-11-20 00:19:43 -08002606 rtc::SetBE32(&packet[8], ssrc);
2607 DeliverPacket(packet, sizeof(packet));
mflodman3d7db262016-04-29 00:57:13 -07002608
2609 // Verify we only have one default stream.
2610 EXPECT_EQ(1, call_.GetAudioReceiveStreams().size());
2611 EXPECT_EQ(1, GetRecvStream(ssrc).received_packets());
2612 EXPECT_TRUE(GetRecvStream(ssrc).VerifyLastPacket(packet, sizeof(packet)));
solenberg7e63ef02015-11-20 00:19:43 -08002613 }
mflodman3d7db262016-04-29 00:57:13 -07002614
2615 // Sending the same ssrc again should not create a new stream.
2616 --ssrc;
2617 DeliverPacket(packet, sizeof(packet));
2618 EXPECT_EQ(1, call_.GetAudioReceiveStreams().size());
2619 EXPECT_EQ(2, GetRecvStream(ssrc).received_packets());
2620 EXPECT_TRUE(GetRecvStream(ssrc).VerifyLastPacket(packet, sizeof(packet)));
solenberg7e63ef02015-11-20 00:19:43 -08002621}
2622
2623// Test that a default channel is created even after a signalled stream has been
2624// added, and that this stream will get any packets for unknown SSRCs.
2625TEST_F(WebRtcVoiceEngineTestFake, RecvUnsignalledAfterSignalled) {
solenbergff976312016-03-30 23:28:51 -07002626 EXPECT_TRUE(SetupChannel());
mflodman3d7db262016-04-29 00:57:13 -07002627 unsigned char packet[sizeof(kPcmuFrame)];
solenberg7e63ef02015-11-20 00:19:43 -08002628 memcpy(packet, kPcmuFrame, sizeof(kPcmuFrame));
2629
2630 // Add a known stream, send packet and verify we got it.
mflodman3d7db262016-04-29 00:57:13 -07002631 const uint32_t signaled_ssrc = 1;
2632 rtc::SetBE32(&packet[8], signaled_ssrc);
solenberg8189b022016-06-14 12:13:00 -07002633 EXPECT_TRUE(AddRecvStream(signaled_ssrc));
solenberg7e63ef02015-11-20 00:19:43 -08002634 DeliverPacket(packet, sizeof(packet));
mflodman3d7db262016-04-29 00:57:13 -07002635 EXPECT_TRUE(GetRecvStream(signaled_ssrc).VerifyLastPacket(
2636 packet, sizeof(packet)));
solenberg7e63ef02015-11-20 00:19:43 -08002637
2638 // Note that the first unknown SSRC cannot be 0, because we only support
2639 // creating receive streams for SSRC!=0.
mflodman3d7db262016-04-29 00:57:13 -07002640 const uint32_t unsignaled_ssrc = 7011;
2641 rtc::SetBE32(&packet[8], unsignaled_ssrc);
solenberg7e63ef02015-11-20 00:19:43 -08002642 DeliverPacket(packet, sizeof(packet));
mflodman3d7db262016-04-29 00:57:13 -07002643 EXPECT_TRUE(GetRecvStream(unsignaled_ssrc).VerifyLastPacket(
2644 packet, sizeof(packet)));
2645 EXPECT_EQ(2, call_.GetAudioReceiveStreams().size());
2646
2647 DeliverPacket(packet, sizeof(packet));
2648 EXPECT_EQ(2, GetRecvStream(unsignaled_ssrc).received_packets());
2649
2650 rtc::SetBE32(&packet[8], signaled_ssrc);
2651 DeliverPacket(packet, sizeof(packet));
2652 EXPECT_EQ(2, GetRecvStream(signaled_ssrc).received_packets());
2653 EXPECT_EQ(2, call_.GetAudioReceiveStreams().size());
solenberg7e63ef02015-11-20 00:19:43 -08002654}
2655
solenberg0a617e22015-10-20 15:49:38 -07002656// Test that we properly handle failures to add a receive stream.
2657TEST_F(WebRtcVoiceEngineTestFake, AddRecvStreamFail) {
solenbergff976312016-03-30 23:28:51 -07002658 EXPECT_TRUE(SetupChannel());
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002659 voe_.set_fail_create_channel(true);
solenberg8189b022016-06-14 12:13:00 -07002660 EXPECT_FALSE(AddRecvStream(2));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002661}
2662
solenberg0a617e22015-10-20 15:49:38 -07002663// Test that we properly handle failures to add a send stream.
2664TEST_F(WebRtcVoiceEngineTestFake, AddSendStreamFail) {
solenbergff976312016-03-30 23:28:51 -07002665 EXPECT_TRUE(SetupChannel());
solenberg0a617e22015-10-20 15:49:38 -07002666 voe_.set_fail_create_channel(true);
2667 EXPECT_FALSE(channel_->AddSendStream(cricket::StreamParams::CreateLegacy(2)));
2668}
2669
solenberg1ac56142015-10-13 03:58:19 -07002670// Test that AddRecvStream creates new stream.
2671TEST_F(WebRtcVoiceEngineTestFake, AddRecvStream) {
solenbergff976312016-03-30 23:28:51 -07002672 EXPECT_TRUE(SetupRecvStream());
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002673 int channel_num = voe_.GetLastChannel();
solenberg8189b022016-06-14 12:13:00 -07002674 EXPECT_TRUE(AddRecvStream(1));
solenberg1ac56142015-10-13 03:58:19 -07002675 EXPECT_NE(channel_num, voe_.GetLastChannel());
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002676}
2677
2678// Test that after adding a recv stream, we do not decode more codecs than
2679// those previously passed into SetRecvCodecs.
2680TEST_F(WebRtcVoiceEngineTestFake, AddRecvStreamUnsupportedCodec) {
solenbergff976312016-03-30 23:28:51 -07002681 EXPECT_TRUE(SetupSendStream());
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002682 cricket::AudioRecvParameters parameters;
2683 parameters.codecs.push_back(kIsacCodec);
2684 parameters.codecs.push_back(kPcmuCodec);
2685 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
solenberg8189b022016-06-14 12:13:00 -07002686 EXPECT_TRUE(AddRecvStream(kSsrc1));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002687 int channel_num2 = voe_.GetLastChannel();
2688 webrtc::CodecInst gcodec;
tfarina5237aaf2015-11-10 23:44:30 -08002689 rtc::strcpyn(gcodec.plname, arraysize(gcodec.plname), "opus");
minyue@webrtc.orgf9b5c1b2015-02-17 12:36:41 +00002690 gcodec.plfreq = 48000;
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002691 gcodec.channels = 2;
2692 EXPECT_EQ(-1, voe_.GetRecPayloadType(channel_num2, gcodec));
2693}
2694
2695// Test that we properly clean up any streams that were added, even if
2696// not explicitly removed.
2697TEST_F(WebRtcVoiceEngineTestFake, StreamCleanup) {
solenbergff976312016-03-30 23:28:51 -07002698 EXPECT_TRUE(SetupSendStream());
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002699 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
solenberg8189b022016-06-14 12:13:00 -07002700 EXPECT_TRUE(AddRecvStream(1));
2701 EXPECT_TRUE(AddRecvStream(2));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002702 EXPECT_EQ(3, voe_.GetNumChannels()); // default channel + 2 added
2703 delete channel_;
2704 channel_ = NULL;
2705 EXPECT_EQ(0, voe_.GetNumChannels());
2706}
2707
wu@webrtc.org78187522013-10-07 23:32:02 +00002708TEST_F(WebRtcVoiceEngineTestFake, TestAddRecvStreamFailWithZeroSsrc) {
solenbergff976312016-03-30 23:28:51 -07002709 EXPECT_TRUE(SetupSendStream());
solenberg8189b022016-06-14 12:13:00 -07002710 EXPECT_FALSE(AddRecvStream(0));
wu@webrtc.org78187522013-10-07 23:32:02 +00002711}
2712
2713TEST_F(WebRtcVoiceEngineTestFake, TestNoLeakingWhenAddRecvStreamFail) {
solenbergff976312016-03-30 23:28:51 -07002714 EXPECT_TRUE(SetupChannel());
solenberg8189b022016-06-14 12:13:00 -07002715 EXPECT_TRUE(AddRecvStream(1));
solenberg1ac56142015-10-13 03:58:19 -07002716 // Manually delete channel to simulate a failure.
2717 int channel = voe_.GetLastChannel();
2718 EXPECT_EQ(0, voe_.DeleteChannel(channel));
2719 // Add recv stream 2 should work.
solenberg8189b022016-06-14 12:13:00 -07002720 EXPECT_TRUE(AddRecvStream(2));
wu@webrtc.org78187522013-10-07 23:32:02 +00002721 int new_channel = voe_.GetLastChannel();
solenberg1ac56142015-10-13 03:58:19 -07002722 EXPECT_NE(channel, new_channel);
2723 // The last created channel is deleted too.
2724 EXPECT_EQ(0, voe_.DeleteChannel(new_channel));
wu@webrtc.org78187522013-10-07 23:32:02 +00002725}
2726
wu@webrtc.orgcadf9042013-08-30 21:24:16 +00002727// Test the InsertDtmf on default send stream as caller.
2728TEST_F(WebRtcVoiceEngineTestFake, InsertDtmfOnDefaultSendStreamAsCaller) {
2729 TestInsertDtmf(0, true);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002730}
2731
wu@webrtc.orgcadf9042013-08-30 21:24:16 +00002732// Test the InsertDtmf on default send stream as callee
2733TEST_F(WebRtcVoiceEngineTestFake, InsertDtmfOnDefaultSendStreamAsCallee) {
2734 TestInsertDtmf(0, false);
2735}
2736
2737// Test the InsertDtmf on specified send stream as caller.
2738TEST_F(WebRtcVoiceEngineTestFake, InsertDtmfOnSendStreamAsCaller) {
2739 TestInsertDtmf(kSsrc1, true);
2740}
2741
2742// Test the InsertDtmf on specified send stream as callee.
2743TEST_F(WebRtcVoiceEngineTestFake, InsertDtmfOnSendStreamAsCallee) {
2744 TestInsertDtmf(kSsrc1, false);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002745}
2746
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002747TEST_F(WebRtcVoiceEngineTestFake, TestSetPlayoutError) {
solenbergff976312016-03-30 23:28:51 -07002748 EXPECT_TRUE(SetupSendStream());
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002749 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
solenbergd53a3f92016-04-14 13:56:37 -07002750 SetSend(channel_, true);
solenberg8189b022016-06-14 12:13:00 -07002751 EXPECT_TRUE(AddRecvStream(2));
2752 EXPECT_TRUE(AddRecvStream(3));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002753 EXPECT_TRUE(channel_->SetPlayout(true));
2754 voe_.set_playout_fail_channel(voe_.GetLastChannel() - 1);
2755 EXPECT_TRUE(channel_->SetPlayout(false));
2756 EXPECT_FALSE(channel_->SetPlayout(true));
2757}
2758
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002759TEST_F(WebRtcVoiceEngineTestFake, SetAudioOptions) {
solenbergff976312016-03-30 23:28:51 -07002760 EXPECT_TRUE(SetupSendStream());
solenberg5b5129a2016-04-08 05:35:48 -07002761 EXPECT_CALL(adm_,
2762 BuiltInAECIsAvailable()).Times(9).WillRepeatedly(Return(false));
2763 EXPECT_CALL(adm_,
2764 BuiltInAGCIsAvailable()).Times(4).WillRepeatedly(Return(false));
2765 EXPECT_CALL(adm_,
2766 BuiltInNSIsAvailable()).Times(2).WillRepeatedly(Return(false));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002767 bool ec_enabled;
2768 webrtc::EcModes ec_mode;
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002769 webrtc::AecmModes aecm_mode;
2770 bool cng_enabled;
2771 bool agc_enabled;
2772 webrtc::AgcModes agc_mode;
2773 webrtc::AgcConfig agc_config;
2774 bool ns_enabled;
2775 webrtc::NsModes ns_mode;
2776 bool highpass_filter_enabled;
2777 bool stereo_swapping_enabled;
2778 bool typing_detection_enabled;
2779 voe_.GetEcStatus(ec_enabled, ec_mode);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002780 voe_.GetAecmMode(aecm_mode, cng_enabled);
2781 voe_.GetAgcStatus(agc_enabled, agc_mode);
2782 voe_.GetAgcConfig(agc_config);
2783 voe_.GetNsStatus(ns_enabled, ns_mode);
2784 highpass_filter_enabled = voe_.IsHighPassFilterEnabled();
2785 stereo_swapping_enabled = voe_.IsStereoChannelSwappingEnabled();
2786 voe_.GetTypingDetectionStatus(typing_detection_enabled);
2787 EXPECT_TRUE(ec_enabled);
solenberg85a04962015-10-27 03:35:21 -07002788 EXPECT_TRUE(voe_.ec_metrics_enabled());
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002789 EXPECT_FALSE(cng_enabled);
2790 EXPECT_TRUE(agc_enabled);
2791 EXPECT_EQ(0, agc_config.targetLeveldBOv);
2792 EXPECT_TRUE(ns_enabled);
2793 EXPECT_TRUE(highpass_filter_enabled);
2794 EXPECT_FALSE(stereo_swapping_enabled);
2795 EXPECT_TRUE(typing_detection_enabled);
2796 EXPECT_EQ(ec_mode, webrtc::kEcConference);
2797 EXPECT_EQ(ns_mode, webrtc::kNsHighSuppression);
solenberg246b8172015-12-08 09:50:23 -08002798 EXPECT_EQ(50, voe_.GetNetEqCapacity());
2799 EXPECT_FALSE(voe_.GetNetEqFastAccelerate());
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002800
solenberg246b8172015-12-08 09:50:23 -08002801 // Nothing set in AudioOptions, so everything should be as default.
2802 send_parameters_.options = cricket::AudioOptions();
2803 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002804 voe_.GetEcStatus(ec_enabled, ec_mode);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002805 voe_.GetAecmMode(aecm_mode, cng_enabled);
2806 voe_.GetAgcStatus(agc_enabled, agc_mode);
2807 voe_.GetAgcConfig(agc_config);
2808 voe_.GetNsStatus(ns_enabled, ns_mode);
2809 highpass_filter_enabled = voe_.IsHighPassFilterEnabled();
2810 stereo_swapping_enabled = voe_.IsStereoChannelSwappingEnabled();
2811 voe_.GetTypingDetectionStatus(typing_detection_enabled);
2812 EXPECT_TRUE(ec_enabled);
solenberg85a04962015-10-27 03:35:21 -07002813 EXPECT_TRUE(voe_.ec_metrics_enabled());
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002814 EXPECT_FALSE(cng_enabled);
2815 EXPECT_TRUE(agc_enabled);
2816 EXPECT_EQ(0, agc_config.targetLeveldBOv);
2817 EXPECT_TRUE(ns_enabled);
2818 EXPECT_TRUE(highpass_filter_enabled);
2819 EXPECT_FALSE(stereo_swapping_enabled);
2820 EXPECT_TRUE(typing_detection_enabled);
2821 EXPECT_EQ(ec_mode, webrtc::kEcConference);
2822 EXPECT_EQ(ns_mode, webrtc::kNsHighSuppression);
solenberg246b8172015-12-08 09:50:23 -08002823 EXPECT_EQ(50, voe_.GetNetEqCapacity());
2824 EXPECT_FALSE(voe_.GetNetEqFastAccelerate());
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002825
2826 // Turn echo cancellation off
solenberg246b8172015-12-08 09:50:23 -08002827 send_parameters_.options.echo_cancellation = rtc::Optional<bool>(false);
2828 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002829 voe_.GetEcStatus(ec_enabled, ec_mode);
2830 EXPECT_FALSE(ec_enabled);
2831
2832 // Turn echo cancellation back on, with settings, and make sure
2833 // nothing else changed.
solenberg246b8172015-12-08 09:50:23 -08002834 send_parameters_.options.echo_cancellation = rtc::Optional<bool>(true);
2835 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002836 voe_.GetEcStatus(ec_enabled, ec_mode);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002837 voe_.GetAecmMode(aecm_mode, cng_enabled);
2838 voe_.GetAgcStatus(agc_enabled, agc_mode);
2839 voe_.GetAgcConfig(agc_config);
2840 voe_.GetNsStatus(ns_enabled, ns_mode);
2841 highpass_filter_enabled = voe_.IsHighPassFilterEnabled();
2842 stereo_swapping_enabled = voe_.IsStereoChannelSwappingEnabled();
2843 voe_.GetTypingDetectionStatus(typing_detection_enabled);
2844 EXPECT_TRUE(ec_enabled);
solenberg85a04962015-10-27 03:35:21 -07002845 EXPECT_TRUE(voe_.ec_metrics_enabled());
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002846 EXPECT_TRUE(agc_enabled);
2847 EXPECT_EQ(0, agc_config.targetLeveldBOv);
2848 EXPECT_TRUE(ns_enabled);
2849 EXPECT_TRUE(highpass_filter_enabled);
2850 EXPECT_FALSE(stereo_swapping_enabled);
2851 EXPECT_TRUE(typing_detection_enabled);
2852 EXPECT_EQ(ec_mode, webrtc::kEcConference);
2853 EXPECT_EQ(ns_mode, webrtc::kNsHighSuppression);
2854
Bjorn Volckerbf395c12015-03-25 22:45:56 +01002855 // Turn on delay agnostic aec and make sure nothing change w.r.t. echo
2856 // control.
solenberg246b8172015-12-08 09:50:23 -08002857 send_parameters_.options.delay_agnostic_aec = rtc::Optional<bool>(true);
2858 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
Bjorn Volckerbf395c12015-03-25 22:45:56 +01002859 voe_.GetEcStatus(ec_enabled, ec_mode);
Bjorn Volckerbf395c12015-03-25 22:45:56 +01002860 voe_.GetAecmMode(aecm_mode, cng_enabled);
2861 EXPECT_TRUE(ec_enabled);
solenberg85a04962015-10-27 03:35:21 -07002862 EXPECT_TRUE(voe_.ec_metrics_enabled());
Bjorn Volckerbf395c12015-03-25 22:45:56 +01002863 EXPECT_EQ(ec_mode, webrtc::kEcConference);
2864
2865 // Turn off echo cancellation and delay agnostic aec.
solenberg246b8172015-12-08 09:50:23 -08002866 send_parameters_.options.delay_agnostic_aec = rtc::Optional<bool>(false);
2867 send_parameters_.options.extended_filter_aec = rtc::Optional<bool>(false);
2868 send_parameters_.options.echo_cancellation = rtc::Optional<bool>(false);
2869 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
Bjorn Volckerbf395c12015-03-25 22:45:56 +01002870 voe_.GetEcStatus(ec_enabled, ec_mode);
2871 EXPECT_FALSE(ec_enabled);
2872 // Turning delay agnostic aec back on should also turn on echo cancellation.
solenberg246b8172015-12-08 09:50:23 -08002873 send_parameters_.options.delay_agnostic_aec = rtc::Optional<bool>(true);
2874 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
Bjorn Volckerbf395c12015-03-25 22:45:56 +01002875 voe_.GetEcStatus(ec_enabled, ec_mode);
Bjorn Volckerbf395c12015-03-25 22:45:56 +01002876 EXPECT_TRUE(ec_enabled);
solenberg85a04962015-10-27 03:35:21 -07002877 EXPECT_TRUE(voe_.ec_metrics_enabled());
Bjorn Volckerbf395c12015-03-25 22:45:56 +01002878 EXPECT_EQ(ec_mode, webrtc::kEcConference);
2879
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002880 // Turn off AGC
solenberg246b8172015-12-08 09:50:23 -08002881 send_parameters_.options.auto_gain_control = rtc::Optional<bool>(false);
2882 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002883 voe_.GetAgcStatus(agc_enabled, agc_mode);
2884 EXPECT_FALSE(agc_enabled);
2885
2886 // Turn AGC back on
solenberg246b8172015-12-08 09:50:23 -08002887 send_parameters_.options.auto_gain_control = rtc::Optional<bool>(true);
2888 send_parameters_.options.adjust_agc_delta = rtc::Optional<int>();
2889 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002890 voe_.GetAgcStatus(agc_enabled, agc_mode);
2891 EXPECT_TRUE(agc_enabled);
2892 voe_.GetAgcConfig(agc_config);
2893 EXPECT_EQ(0, agc_config.targetLeveldBOv);
2894
2895 // Turn off other options (and stereo swapping on).
solenberg246b8172015-12-08 09:50:23 -08002896 send_parameters_.options.noise_suppression = rtc::Optional<bool>(false);
2897 send_parameters_.options.highpass_filter = rtc::Optional<bool>(false);
2898 send_parameters_.options.typing_detection = rtc::Optional<bool>(false);
2899 send_parameters_.options.stereo_swapping = rtc::Optional<bool>(true);
2900 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002901 voe_.GetNsStatus(ns_enabled, ns_mode);
2902 highpass_filter_enabled = voe_.IsHighPassFilterEnabled();
2903 stereo_swapping_enabled = voe_.IsStereoChannelSwappingEnabled();
2904 voe_.GetTypingDetectionStatus(typing_detection_enabled);
2905 EXPECT_FALSE(ns_enabled);
2906 EXPECT_FALSE(highpass_filter_enabled);
2907 EXPECT_FALSE(typing_detection_enabled);
2908 EXPECT_TRUE(stereo_swapping_enabled);
2909
solenberg1ac56142015-10-13 03:58:19 -07002910 // Set options again to ensure it has no impact.
solenberg246b8172015-12-08 09:50:23 -08002911 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002912 voe_.GetEcStatus(ec_enabled, ec_mode);
2913 voe_.GetNsStatus(ns_enabled, ns_mode);
2914 EXPECT_TRUE(ec_enabled);
2915 EXPECT_EQ(webrtc::kEcConference, ec_mode);
2916 EXPECT_FALSE(ns_enabled);
2917 EXPECT_EQ(webrtc::kNsHighSuppression, ns_mode);
2918}
2919
mallinath@webrtc.orga27be8e2013-09-27 23:04:10 +00002920TEST_F(WebRtcVoiceEngineTestFake, DefaultOptions) {
solenbergff976312016-03-30 23:28:51 -07002921 EXPECT_TRUE(SetupSendStream());
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002922
2923 bool ec_enabled;
2924 webrtc::EcModes ec_mode;
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002925 bool agc_enabled;
2926 webrtc::AgcModes agc_mode;
2927 bool ns_enabled;
2928 webrtc::NsModes ns_mode;
2929 bool highpass_filter_enabled;
2930 bool stereo_swapping_enabled;
2931 bool typing_detection_enabled;
2932
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002933 voe_.GetEcStatus(ec_enabled, ec_mode);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002934 voe_.GetAgcStatus(agc_enabled, agc_mode);
2935 voe_.GetNsStatus(ns_enabled, ns_mode);
2936 highpass_filter_enabled = voe_.IsHighPassFilterEnabled();
2937 stereo_swapping_enabled = voe_.IsStereoChannelSwappingEnabled();
2938 voe_.GetTypingDetectionStatus(typing_detection_enabled);
2939 EXPECT_TRUE(ec_enabled);
2940 EXPECT_TRUE(agc_enabled);
2941 EXPECT_TRUE(ns_enabled);
2942 EXPECT_TRUE(highpass_filter_enabled);
mallinath@webrtc.orga27be8e2013-09-27 23:04:10 +00002943 EXPECT_TRUE(typing_detection_enabled);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002944 EXPECT_FALSE(stereo_swapping_enabled);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002945}
2946
2947TEST_F(WebRtcVoiceEngineTestFake, InitDoesNotOverwriteDefaultAgcConfig) {
2948 webrtc::AgcConfig set_config = {0};
2949 set_config.targetLeveldBOv = 3;
2950 set_config.digitalCompressionGaindB = 9;
2951 set_config.limiterEnable = true;
2952 EXPECT_EQ(0, voe_.SetAgcConfig(set_config));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002953
2954 webrtc::AgcConfig config = {0};
2955 EXPECT_EQ(0, voe_.GetAgcConfig(config));
2956 EXPECT_EQ(set_config.targetLeveldBOv, config.targetLeveldBOv);
2957 EXPECT_EQ(set_config.digitalCompressionGaindB,
2958 config.digitalCompressionGaindB);
2959 EXPECT_EQ(set_config.limiterEnable, config.limiterEnable);
2960}
2961
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002962TEST_F(WebRtcVoiceEngineTestFake, SetOptionOverridesViaChannels) {
solenbergff976312016-03-30 23:28:51 -07002963 EXPECT_TRUE(SetupSendStream());
solenberg5b5129a2016-04-08 05:35:48 -07002964 EXPECT_CALL(adm_,
2965 BuiltInAECIsAvailable()).Times(9).WillRepeatedly(Return(false));
2966 EXPECT_CALL(adm_,
2967 BuiltInAGCIsAvailable()).Times(9).WillRepeatedly(Return(false));
2968 EXPECT_CALL(adm_,
2969 BuiltInNSIsAvailable()).Times(9).WillRepeatedly(Return(false));
2970
kwiberg686a8ef2016-02-26 03:00:35 -08002971 std::unique_ptr<cricket::WebRtcVoiceMediaChannel> channel1(
solenbergbc37fc82016-04-04 09:54:44 -07002972 static_cast<cricket::WebRtcVoiceMediaChannel*>(engine_->CreateChannel(
nisse51542be2016-02-12 02:27:06 -08002973 &call_, cricket::MediaConfig(), cricket::AudioOptions())));
kwiberg686a8ef2016-02-26 03:00:35 -08002974 std::unique_ptr<cricket::WebRtcVoiceMediaChannel> channel2(
solenbergbc37fc82016-04-04 09:54:44 -07002975 static_cast<cricket::WebRtcVoiceMediaChannel*>(engine_->CreateChannel(
nisse51542be2016-02-12 02:27:06 -08002976 &call_, cricket::MediaConfig(), cricket::AudioOptions())));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002977
2978 // Have to add a stream to make SetSend work.
2979 cricket::StreamParams stream1;
2980 stream1.ssrcs.push_back(1);
2981 channel1->AddSendStream(stream1);
2982 cricket::StreamParams stream2;
2983 stream2.ssrcs.push_back(2);
2984 channel2->AddSendStream(stream2);
2985
2986 // AEC and AGC and NS
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002987 cricket::AudioSendParameters parameters_options_all = send_parameters_;
Karl Wibergbe579832015-11-10 22:34:18 +01002988 parameters_options_all.options.echo_cancellation = rtc::Optional<bool>(true);
2989 parameters_options_all.options.auto_gain_control = rtc::Optional<bool>(true);
2990 parameters_options_all.options.noise_suppression = rtc::Optional<bool>(true);
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002991 ASSERT_TRUE(channel1->SetSendParameters(parameters_options_all));
2992 EXPECT_EQ(parameters_options_all.options, channel1->options());
2993 ASSERT_TRUE(channel2->SetSendParameters(parameters_options_all));
2994 EXPECT_EQ(parameters_options_all.options, channel2->options());
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002995
2996 // unset NS
Fredrik Solenbergb071a192015-09-17 16:42:56 +02002997 cricket::AudioSendParameters parameters_options_no_ns = send_parameters_;
Karl Wibergbe579832015-11-10 22:34:18 +01002998 parameters_options_no_ns.options.noise_suppression =
2999 rtc::Optional<bool>(false);
Fredrik Solenbergb071a192015-09-17 16:42:56 +02003000 ASSERT_TRUE(channel1->SetSendParameters(parameters_options_no_ns));
3001 cricket::AudioOptions expected_options = parameters_options_all.options;
Karl Wibergbe579832015-11-10 22:34:18 +01003002 expected_options.echo_cancellation = rtc::Optional<bool>(true);
3003 expected_options.auto_gain_control = rtc::Optional<bool>(true);
3004 expected_options.noise_suppression = rtc::Optional<bool>(false);
solenberg66f43392015-09-09 01:36:22 -07003005 EXPECT_EQ(expected_options, channel1->options());
henrike@webrtc.org28e20752013-07-10 00:45:36 +00003006
3007 // unset AGC
Fredrik Solenbergb071a192015-09-17 16:42:56 +02003008 cricket::AudioSendParameters parameters_options_no_agc = send_parameters_;
Karl Wibergbe579832015-11-10 22:34:18 +01003009 parameters_options_no_agc.options.auto_gain_control =
3010 rtc::Optional<bool>(false);
Fredrik Solenbergb071a192015-09-17 16:42:56 +02003011 ASSERT_TRUE(channel2->SetSendParameters(parameters_options_no_agc));
Karl Wibergbe579832015-11-10 22:34:18 +01003012 expected_options.echo_cancellation = rtc::Optional<bool>(true);
3013 expected_options.auto_gain_control = rtc::Optional<bool>(false);
3014 expected_options.noise_suppression = rtc::Optional<bool>(true);
solenberg66f43392015-09-09 01:36:22 -07003015 EXPECT_EQ(expected_options, channel2->options());
henrike@webrtc.org28e20752013-07-10 00:45:36 +00003016
solenberg246b8172015-12-08 09:50:23 -08003017 ASSERT_TRUE(channel_->SetSendParameters(parameters_options_all));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00003018 bool ec_enabled;
3019 webrtc::EcModes ec_mode;
3020 bool agc_enabled;
3021 webrtc::AgcModes agc_mode;
3022 bool ns_enabled;
3023 webrtc::NsModes ns_mode;
3024 voe_.GetEcStatus(ec_enabled, ec_mode);
3025 voe_.GetAgcStatus(agc_enabled, agc_mode);
3026 voe_.GetNsStatus(ns_enabled, ns_mode);
3027 EXPECT_TRUE(ec_enabled);
3028 EXPECT_TRUE(agc_enabled);
3029 EXPECT_TRUE(ns_enabled);
3030
solenbergd53a3f92016-04-14 13:56:37 -07003031 SetSend(channel1.get(), true);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00003032 voe_.GetEcStatus(ec_enabled, ec_mode);
3033 voe_.GetAgcStatus(agc_enabled, agc_mode);
3034 voe_.GetNsStatus(ns_enabled, ns_mode);
3035 EXPECT_TRUE(ec_enabled);
3036 EXPECT_TRUE(agc_enabled);
3037 EXPECT_FALSE(ns_enabled);
3038
solenbergd53a3f92016-04-14 13:56:37 -07003039 SetSend(channel2.get(), true);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00003040 voe_.GetEcStatus(ec_enabled, ec_mode);
3041 voe_.GetAgcStatus(agc_enabled, agc_mode);
3042 voe_.GetNsStatus(ns_enabled, ns_mode);
3043 EXPECT_TRUE(ec_enabled);
3044 EXPECT_FALSE(agc_enabled);
3045 EXPECT_TRUE(ns_enabled);
3046
henrike@webrtc.org28e20752013-07-10 00:45:36 +00003047 // Make sure settings take effect while we are sending.
solenberg246b8172015-12-08 09:50:23 -08003048 ASSERT_TRUE(channel_->SetSendParameters(parameters_options_all));
Fredrik Solenbergb071a192015-09-17 16:42:56 +02003049 cricket::AudioSendParameters parameters_options_no_agc_nor_ns =
3050 send_parameters_;
kwiberg102c6a62015-10-30 02:47:38 -07003051 parameters_options_no_agc_nor_ns.options.auto_gain_control =
Karl Wibergbe579832015-11-10 22:34:18 +01003052 rtc::Optional<bool>(false);
kwiberg102c6a62015-10-30 02:47:38 -07003053 parameters_options_no_agc_nor_ns.options.noise_suppression =
Karl Wibergbe579832015-11-10 22:34:18 +01003054 rtc::Optional<bool>(false);
Taylor Brandstetter1a018dc2016-03-08 12:37:39 -08003055 channel2->SetSend(true);
Fredrik Solenbergb071a192015-09-17 16:42:56 +02003056 channel2->SetSendParameters(parameters_options_no_agc_nor_ns);
Karl Wibergbe579832015-11-10 22:34:18 +01003057 expected_options.echo_cancellation = rtc::Optional<bool>(true);
3058 expected_options.auto_gain_control = rtc::Optional<bool>(false);
3059 expected_options.noise_suppression = rtc::Optional<bool>(false);
solenberg66f43392015-09-09 01:36:22 -07003060 EXPECT_EQ(expected_options, channel2->options());
henrike@webrtc.org28e20752013-07-10 00:45:36 +00003061 voe_.GetEcStatus(ec_enabled, ec_mode);
3062 voe_.GetAgcStatus(agc_enabled, agc_mode);
3063 voe_.GetNsStatus(ns_enabled, ns_mode);
3064 EXPECT_TRUE(ec_enabled);
3065 EXPECT_FALSE(agc_enabled);
3066 EXPECT_FALSE(ns_enabled);
3067}
3068
wu@webrtc.orgde305012013-10-31 15:40:38 +00003069// This test verifies DSCP settings are properly applied on voice media channel.
3070TEST_F(WebRtcVoiceEngineTestFake, TestSetDscpOptions) {
solenbergff976312016-03-30 23:28:51 -07003071 EXPECT_TRUE(SetupSendStream());
nisse51542be2016-02-12 02:27:06 -08003072 cricket::FakeNetworkInterface network_interface;
3073 cricket::MediaConfig config;
kwiberg686a8ef2016-02-26 03:00:35 -08003074 std::unique_ptr<cricket::VoiceMediaChannel> channel;
nisse51542be2016-02-12 02:27:06 -08003075
solenbergbc37fc82016-04-04 09:54:44 -07003076 channel.reset(
3077 engine_->CreateChannel(&call_, config, cricket::AudioOptions()));
nisse51542be2016-02-12 02:27:06 -08003078 channel->SetInterface(&network_interface);
3079 // Default value when DSCP is disabled should be DSCP_DEFAULT.
3080 EXPECT_EQ(rtc::DSCP_DEFAULT, network_interface.dscp());
3081
3082 config.enable_dscp = true;
solenbergbc37fc82016-04-04 09:54:44 -07003083 channel.reset(
3084 engine_->CreateChannel(&call_, config, cricket::AudioOptions()));
nisse51542be2016-02-12 02:27:06 -08003085 channel->SetInterface(&network_interface);
3086 EXPECT_EQ(rtc::DSCP_EF, network_interface.dscp());
3087
3088 // Verify that setting the option to false resets the
3089 // DiffServCodePoint.
3090 config.enable_dscp = false;
solenbergbc37fc82016-04-04 09:54:44 -07003091 channel.reset(
3092 engine_->CreateChannel(&call_, config, cricket::AudioOptions()));
nisse51542be2016-02-12 02:27:06 -08003093 channel->SetInterface(&network_interface);
3094 // Default value when DSCP is disabled should be DSCP_DEFAULT.
3095 EXPECT_EQ(rtc::DSCP_DEFAULT, network_interface.dscp());
3096
3097 channel->SetInterface(nullptr);
wu@webrtc.orgde305012013-10-31 15:40:38 +00003098}
3099
solenberg1ac56142015-10-13 03:58:19 -07003100TEST_F(WebRtcVoiceEngineTestFake, TestGetReceiveChannelId) {
solenbergff976312016-03-30 23:28:51 -07003101 EXPECT_TRUE(SetupChannel());
henrike@webrtc.org28e20752013-07-10 00:45:36 +00003102 cricket::WebRtcVoiceMediaChannel* media_channel =
3103 static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_);
solenberg1ac56142015-10-13 03:58:19 -07003104 EXPECT_EQ(-1, media_channel->GetReceiveChannelId(0));
solenberg8189b022016-06-14 12:13:00 -07003105 EXPECT_TRUE(AddRecvStream(kSsrc1));
solenberg1ac56142015-10-13 03:58:19 -07003106 int channel_id = voe_.GetLastChannel();
3107 EXPECT_EQ(channel_id, media_channel->GetReceiveChannelId(kSsrc1));
3108 EXPECT_EQ(-1, media_channel->GetReceiveChannelId(kSsrc2));
solenberg8189b022016-06-14 12:13:00 -07003109 EXPECT_TRUE(AddRecvStream(kSsrc2));
solenberg1ac56142015-10-13 03:58:19 -07003110 int channel_id2 = voe_.GetLastChannel();
3111 EXPECT_EQ(channel_id2, media_channel->GetReceiveChannelId(kSsrc2));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00003112}
3113
solenberg1ac56142015-10-13 03:58:19 -07003114TEST_F(WebRtcVoiceEngineTestFake, TestGetSendChannelId) {
solenbergff976312016-03-30 23:28:51 -07003115 EXPECT_TRUE(SetupChannel());
henrike@webrtc.org28e20752013-07-10 00:45:36 +00003116 cricket::WebRtcVoiceMediaChannel* media_channel =
solenberg1ac56142015-10-13 03:58:19 -07003117 static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_);
3118 EXPECT_EQ(-1, media_channel->GetSendChannelId(0));
3119 EXPECT_TRUE(channel_->AddSendStream(
3120 cricket::StreamParams::CreateLegacy(kSsrc1)));
3121 int channel_id = voe_.GetLastChannel();
3122 EXPECT_EQ(channel_id, media_channel->GetSendChannelId(kSsrc1));
3123 EXPECT_EQ(-1, media_channel->GetSendChannelId(kSsrc2));
3124 EXPECT_TRUE(channel_->AddSendStream(
3125 cricket::StreamParams::CreateLegacy(kSsrc2)));
3126 int channel_id2 = voe_.GetLastChannel();
3127 EXPECT_EQ(channel_id2, media_channel->GetSendChannelId(kSsrc2));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00003128}
3129
solenberg4bac9c52015-10-09 02:32:53 -07003130TEST_F(WebRtcVoiceEngineTestFake, SetOutputVolume) {
solenbergff976312016-03-30 23:28:51 -07003131 EXPECT_TRUE(SetupChannel());
solenberg4bac9c52015-10-09 02:32:53 -07003132 EXPECT_FALSE(channel_->SetOutputVolume(kSsrc2, 0.5));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00003133 cricket::StreamParams stream;
3134 stream.ssrcs.push_back(kSsrc2);
3135 EXPECT_TRUE(channel_->AddRecvStream(stream));
solenberg1ac56142015-10-13 03:58:19 -07003136 int channel_id = voe_.GetLastChannel();
solenberg4bac9c52015-10-09 02:32:53 -07003137 EXPECT_TRUE(channel_->SetOutputVolume(kSsrc2, 3));
solenberg1ac56142015-10-13 03:58:19 -07003138 float scale = 0;
3139 EXPECT_EQ(0, voe_.GetChannelOutputVolumeScaling(channel_id, scale));
3140 EXPECT_DOUBLE_EQ(3, scale);
3141}
3142
3143TEST_F(WebRtcVoiceEngineTestFake, SetOutputVolumeDefaultRecvStream) {
solenbergff976312016-03-30 23:28:51 -07003144 EXPECT_TRUE(SetupChannel());
solenberg1ac56142015-10-13 03:58:19 -07003145 EXPECT_TRUE(channel_->SetOutputVolume(0, 2));
3146 DeliverPacket(kPcmuFrame, sizeof(kPcmuFrame));
3147 int channel_id = voe_.GetLastChannel();
3148 float scale = 0;
3149 EXPECT_EQ(0, voe_.GetChannelOutputVolumeScaling(channel_id, scale));
3150 EXPECT_DOUBLE_EQ(2, scale);
3151 EXPECT_TRUE(channel_->SetOutputVolume(0, 3));
solenbergbb741b32015-09-07 03:56:38 -07003152 EXPECT_EQ(0, voe_.GetChannelOutputVolumeScaling(channel_id, scale));
solenberg4bac9c52015-10-09 02:32:53 -07003153 EXPECT_DOUBLE_EQ(3, scale);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00003154}
3155
pbos8fc7fa72015-07-15 08:02:58 -07003156TEST_F(WebRtcVoiceEngineTestFake, SetsSyncGroupFromSyncLabel) {
Peter Boström0c4e06b2015-10-07 12:23:21 +02003157 const uint32_t kAudioSsrc = 123;
pbos8fc7fa72015-07-15 08:02:58 -07003158 const std::string kSyncLabel = "AvSyncLabel";
3159
solenbergff976312016-03-30 23:28:51 -07003160 EXPECT_TRUE(SetupSendStream());
pbos8fc7fa72015-07-15 08:02:58 -07003161 cricket::StreamParams sp = cricket::StreamParams::CreateLegacy(kAudioSsrc);
3162 sp.sync_label = kSyncLabel;
3163 // Creating two channels to make sure that sync label is set properly for both
3164 // the default voice channel and following ones.
3165 EXPECT_TRUE(channel_->AddRecvStream(sp));
3166 sp.ssrcs[0] += 1;
3167 EXPECT_TRUE(channel_->AddRecvStream(sp));
3168
Fredrik Solenberg709ed672015-09-15 12:26:33 +02003169 ASSERT_EQ(2, call_.GetAudioReceiveStreams().size());
pbos8fc7fa72015-07-15 08:02:58 -07003170 EXPECT_EQ(kSyncLabel,
Fredrik Solenberg709ed672015-09-15 12:26:33 +02003171 call_.GetAudioReceiveStream(kAudioSsrc)->GetConfig().sync_group)
pbos8fc7fa72015-07-15 08:02:58 -07003172 << "SyncGroup should be set based on sync_label";
3173 EXPECT_EQ(kSyncLabel,
Fredrik Solenberg709ed672015-09-15 12:26:33 +02003174 call_.GetAudioReceiveStream(kAudioSsrc + 1)->GetConfig().sync_group)
pbos8fc7fa72015-07-15 08:02:58 -07003175 << "SyncGroup should be set based on sync_label";
pbos8fc7fa72015-07-15 08:02:58 -07003176}
3177
solenberg3a941542015-11-16 07:34:50 -08003178// TODO(solenberg): Remove, once recv streams are configured through Call.
3179// (This is then covered by TestSetRecvRtpHeaderExtensions.)
pbos6bb1b6e2015-07-24 07:10:18 -07003180TEST_F(WebRtcVoiceEngineTestFake, ConfiguresAudioReceiveStreamRtpExtensions) {
Fredrik Solenberg4b60c732015-05-07 14:07:48 +02003181 // Test that setting the header extensions results in the expected state
3182 // changes on an associated Call.
Peter Boström0c4e06b2015-10-07 12:23:21 +02003183 std::vector<uint32_t> ssrcs;
Fredrik Solenberg4b60c732015-05-07 14:07:48 +02003184 ssrcs.push_back(223);
3185 ssrcs.push_back(224);
3186
solenbergff976312016-03-30 23:28:51 -07003187 EXPECT_TRUE(SetupSendStream());
Fredrik Solenberg4b60c732015-05-07 14:07:48 +02003188 cricket::WebRtcVoiceMediaChannel* media_channel =
3189 static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_);
Fredrik Solenbergb071a192015-09-17 16:42:56 +02003190 EXPECT_TRUE(media_channel->SetSendParameters(send_parameters_));
Peter Boström0c4e06b2015-10-07 12:23:21 +02003191 for (uint32_t ssrc : ssrcs) {
Fredrik Solenberg4b60c732015-05-07 14:07:48 +02003192 EXPECT_TRUE(media_channel->AddRecvStream(
3193 cricket::StreamParams::CreateLegacy(ssrc)));
3194 }
3195
Fredrik Solenberg709ed672015-09-15 12:26:33 +02003196 EXPECT_EQ(2, call_.GetAudioReceiveStreams().size());
Peter Boström0c4e06b2015-10-07 12:23:21 +02003197 for (uint32_t ssrc : ssrcs) {
Fredrik Solenberg709ed672015-09-15 12:26:33 +02003198 const auto* s = call_.GetAudioReceiveStream(ssrc);
Fredrik Solenberg4b60c732015-05-07 14:07:48 +02003199 EXPECT_NE(nullptr, s);
3200 EXPECT_EQ(0, s->GetConfig().rtp.extensions.size());
3201 }
3202
3203 // Set up receive extensions.
solenbergbc37fc82016-04-04 09:54:44 -07003204 cricket::RtpCapabilities capabilities = engine_->GetCapabilities();
Fredrik Solenbergb071a192015-09-17 16:42:56 +02003205 cricket::AudioRecvParameters recv_parameters;
Stefan Holmer9d69c3f2015-12-07 10:45:43 +01003206 recv_parameters.extensions = capabilities.header_extensions;
Fredrik Solenbergb071a192015-09-17 16:42:56 +02003207 channel_->SetRecvParameters(recv_parameters);
Fredrik Solenberg709ed672015-09-15 12:26:33 +02003208 EXPECT_EQ(2, call_.GetAudioReceiveStreams().size());
Peter Boström0c4e06b2015-10-07 12:23:21 +02003209 for (uint32_t ssrc : ssrcs) {
Fredrik Solenberg709ed672015-09-15 12:26:33 +02003210 const auto* s = call_.GetAudioReceiveStream(ssrc);
Fredrik Solenberg4b60c732015-05-07 14:07:48 +02003211 EXPECT_NE(nullptr, s);
3212 const auto& s_exts = s->GetConfig().rtp.extensions;
Stefan Holmer9d69c3f2015-12-07 10:45:43 +01003213 EXPECT_EQ(capabilities.header_extensions.size(), s_exts.size());
3214 for (const auto& e_ext : capabilities.header_extensions) {
Fredrik Solenberg4b60c732015-05-07 14:07:48 +02003215 for (const auto& s_ext : s_exts) {
3216 if (e_ext.id == s_ext.id) {
isheriff6f8d6862016-05-26 11:24:55 -07003217 EXPECT_EQ(e_ext.uri, s_ext.uri);
Fredrik Solenberg4b60c732015-05-07 14:07:48 +02003218 }
3219 }
3220 }
3221 }
3222
3223 // Disable receive extensions.
Fredrik Solenbergb071a192015-09-17 16:42:56 +02003224 channel_->SetRecvParameters(cricket::AudioRecvParameters());
Peter Boström0c4e06b2015-10-07 12:23:21 +02003225 for (uint32_t ssrc : ssrcs) {
Fredrik Solenberg709ed672015-09-15 12:26:33 +02003226 const auto* s = call_.GetAudioReceiveStream(ssrc);
Fredrik Solenberg4b60c732015-05-07 14:07:48 +02003227 EXPECT_NE(nullptr, s);
3228 EXPECT_EQ(0, s->GetConfig().rtp.extensions.size());
3229 }
Fredrik Solenberg4b60c732015-05-07 14:07:48 +02003230}
3231
3232TEST_F(WebRtcVoiceEngineTestFake, DeliverAudioPacket_Call) {
3233 // Test that packets are forwarded to the Call when configured accordingly.
Peter Boström0c4e06b2015-10-07 12:23:21 +02003234 const uint32_t kAudioSsrc = 1;
jbaucheec21bd2016-03-20 06:15:43 -07003235 rtc::CopyOnWriteBuffer kPcmuPacket(kPcmuFrame, sizeof(kPcmuFrame));
Fredrik Solenberg4b60c732015-05-07 14:07:48 +02003236 static const unsigned char kRtcp[] = {
3237 0x80, 0xc9, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
3238 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
3239 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3240 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
3241 };
jbaucheec21bd2016-03-20 06:15:43 -07003242 rtc::CopyOnWriteBuffer kRtcpPacket(kRtcp, sizeof(kRtcp));
Fredrik Solenberg4b60c732015-05-07 14:07:48 +02003243
solenbergff976312016-03-30 23:28:51 -07003244 EXPECT_TRUE(SetupSendStream());
Fredrik Solenberg4b60c732015-05-07 14:07:48 +02003245 cricket::WebRtcVoiceMediaChannel* media_channel =
3246 static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_);
Fredrik Solenbergb071a192015-09-17 16:42:56 +02003247 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
Fredrik Solenberg4b60c732015-05-07 14:07:48 +02003248 EXPECT_TRUE(media_channel->AddRecvStream(
3249 cricket::StreamParams::CreateLegacy(kAudioSsrc)));
3250
Fredrik Solenberg709ed672015-09-15 12:26:33 +02003251 EXPECT_EQ(1, call_.GetAudioReceiveStreams().size());
Fredrik Solenberg4b60c732015-05-07 14:07:48 +02003252 const cricket::FakeAudioReceiveStream* s =
Fredrik Solenberg709ed672015-09-15 12:26:33 +02003253 call_.GetAudioReceiveStream(kAudioSsrc);
Fredrik Solenberg4b60c732015-05-07 14:07:48 +02003254 EXPECT_EQ(0, s->received_packets());
3255 channel_->OnPacketReceived(&kPcmuPacket, rtc::PacketTime());
3256 EXPECT_EQ(1, s->received_packets());
3257 channel_->OnRtcpReceived(&kRtcpPacket, rtc::PacketTime());
3258 EXPECT_EQ(2, s->received_packets());
Fredrik Solenberg4b60c732015-05-07 14:07:48 +02003259}
Minyue2013aec2015-05-13 14:14:42 +02003260
solenberg0a617e22015-10-20 15:49:38 -07003261// All receive channels should be associated with the first send channel,
solenberg1ac56142015-10-13 03:58:19 -07003262// since they do not send RTCP SR.
solenberg0a617e22015-10-20 15:49:38 -07003263TEST_F(WebRtcVoiceEngineTestFake, AssociateFirstSendChannel) {
solenbergff976312016-03-30 23:28:51 -07003264 EXPECT_TRUE(SetupSendStream());
Fredrik Solenbergb071a192015-09-17 16:42:56 +02003265 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
solenberg8fb30c32015-10-13 03:06:58 -07003266 int default_channel = voe_.GetLastChannel();
solenberg8189b022016-06-14 12:13:00 -07003267 EXPECT_TRUE(AddRecvStream(1));
Minyue2013aec2015-05-13 14:14:42 +02003268 int recv_ch = voe_.GetLastChannel();
3269 EXPECT_NE(recv_ch, default_channel);
3270 EXPECT_EQ(voe_.GetAssociateSendChannel(recv_ch), default_channel);
3271 EXPECT_TRUE(channel_->AddSendStream(cricket::StreamParams::CreateLegacy(2)));
3272 EXPECT_EQ(voe_.GetAssociateSendChannel(recv_ch), default_channel);
solenberg8189b022016-06-14 12:13:00 -07003273 EXPECT_TRUE(AddRecvStream(3));
solenberg1ac56142015-10-13 03:58:19 -07003274 recv_ch = voe_.GetLastChannel();
3275 EXPECT_NE(recv_ch, default_channel);
3276 EXPECT_EQ(voe_.GetAssociateSendChannel(recv_ch), default_channel);
Minyue2013aec2015-05-13 14:14:42 +02003277}
3278
3279TEST_F(WebRtcVoiceEngineTestFake, AssociateChannelResetUponDeleteChannnel) {
solenbergff976312016-03-30 23:28:51 -07003280 EXPECT_TRUE(SetupSendStream());
Fredrik Solenbergb071a192015-09-17 16:42:56 +02003281 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
Minyue2013aec2015-05-13 14:14:42 +02003282
solenberg8189b022016-06-14 12:13:00 -07003283 EXPECT_TRUE(AddRecvStream(1));
Minyue2013aec2015-05-13 14:14:42 +02003284 int recv_ch = voe_.GetLastChannel();
3285
3286 EXPECT_TRUE(channel_->AddSendStream(cricket::StreamParams::CreateLegacy(2)));
3287 int send_ch = voe_.GetLastChannel();
3288
3289 // Manually associate |recv_ch| to |send_ch|. This test is to verify a
3290 // deleting logic, i.e., deleting |send_ch| will reset the associate send
3291 // channel of |recv_ch|.This is not a common case, since, normally, only the
3292 // default channel can be associated. However, the default is not deletable.
3293 // So we force the |recv_ch| to associate with a non-default channel.
3294 EXPECT_EQ(0, voe_.AssociateSendChannel(recv_ch, send_ch));
3295 EXPECT_EQ(voe_.GetAssociateSendChannel(recv_ch), send_ch);
3296
3297 EXPECT_TRUE(channel_->RemoveSendStream(2));
3298 EXPECT_EQ(voe_.GetAssociateSendChannel(recv_ch), -1);
3299}
stefan658910c2015-09-03 05:48:32 -07003300
deadbeef884f5852016-01-15 09:20:04 -08003301TEST_F(WebRtcVoiceEngineTestFake, SetRawAudioSink) {
solenbergff976312016-03-30 23:28:51 -07003302 EXPECT_TRUE(SetupChannel());
kwiberg686a8ef2016-02-26 03:00:35 -08003303 std::unique_ptr<FakeAudioSink> fake_sink_1(new FakeAudioSink());
3304 std::unique_ptr<FakeAudioSink> fake_sink_2(new FakeAudioSink());
deadbeef884f5852016-01-15 09:20:04 -08003305
3306 // Setting the sink before a recv stream exists should do nothing.
3307 channel_->SetRawAudioSink(kSsrc1, std::move(fake_sink_1));
solenberg8189b022016-06-14 12:13:00 -07003308 EXPECT_TRUE(AddRecvStream(kSsrc1));
deadbeef884f5852016-01-15 09:20:04 -08003309 EXPECT_EQ(nullptr, GetRecvStream(kSsrc1).sink());
3310
3311 // Now try actually setting the sink.
3312 channel_->SetRawAudioSink(kSsrc1, std::move(fake_sink_2));
3313 EXPECT_NE(nullptr, GetRecvStream(kSsrc1).sink());
3314
3315 // Now try resetting it.
3316 channel_->SetRawAudioSink(kSsrc1, nullptr);
3317 EXPECT_EQ(nullptr, GetRecvStream(kSsrc1).sink());
3318}
3319
3320TEST_F(WebRtcVoiceEngineTestFake, SetRawAudioSinkDefaultRecvStream) {
solenbergff976312016-03-30 23:28:51 -07003321 EXPECT_TRUE(SetupChannel());
kwiberg686a8ef2016-02-26 03:00:35 -08003322 std::unique_ptr<FakeAudioSink> fake_sink_1(new FakeAudioSink());
3323 std::unique_ptr<FakeAudioSink> fake_sink_2(new FakeAudioSink());
deadbeef884f5852016-01-15 09:20:04 -08003324
3325 // Should be able to set a default sink even when no stream exists.
3326 channel_->SetRawAudioSink(0, std::move(fake_sink_1));
3327
3328 // Create default channel and ensure it's assigned the default sink.
3329 DeliverPacket(kPcmuFrame, sizeof(kPcmuFrame));
3330 EXPECT_NE(nullptr, GetRecvStream(0x01).sink());
3331
3332 // Try resetting the default sink.
3333 channel_->SetRawAudioSink(0, nullptr);
3334 EXPECT_EQ(nullptr, GetRecvStream(0x01).sink());
3335
3336 // Try setting the default sink while the default stream exists.
3337 channel_->SetRawAudioSink(0, std::move(fake_sink_2));
3338 EXPECT_NE(nullptr, GetRecvStream(0x01).sink());
3339
3340 // If we remove and add a default stream, it should get the same sink.
3341 EXPECT_TRUE(channel_->RemoveRecvStream(0x01));
3342 DeliverPacket(kPcmuFrame, sizeof(kPcmuFrame));
3343 EXPECT_NE(nullptr, GetRecvStream(0x01).sink());
3344}
3345
skvlad7a43d252016-03-22 15:32:27 -07003346// Test that, just like the video channel, the voice channel communicates the
3347// network state to the call.
3348TEST_F(WebRtcVoiceEngineTestFake, OnReadyToSendSignalsNetworkState) {
solenbergff976312016-03-30 23:28:51 -07003349 EXPECT_TRUE(SetupChannel());
skvlad7a43d252016-03-22 15:32:27 -07003350
3351 EXPECT_EQ(webrtc::kNetworkUp,
3352 call_.GetNetworkState(webrtc::MediaType::AUDIO));
3353 EXPECT_EQ(webrtc::kNetworkUp,
3354 call_.GetNetworkState(webrtc::MediaType::VIDEO));
3355
3356 channel_->OnReadyToSend(false);
3357 EXPECT_EQ(webrtc::kNetworkDown,
3358 call_.GetNetworkState(webrtc::MediaType::AUDIO));
3359 EXPECT_EQ(webrtc::kNetworkUp,
3360 call_.GetNetworkState(webrtc::MediaType::VIDEO));
3361
3362 channel_->OnReadyToSend(true);
3363 EXPECT_EQ(webrtc::kNetworkUp,
3364 call_.GetNetworkState(webrtc::MediaType::AUDIO));
3365 EXPECT_EQ(webrtc::kNetworkUp,
3366 call_.GetNetworkState(webrtc::MediaType::VIDEO));
3367}
3368
stefan658910c2015-09-03 05:48:32 -07003369// Tests that the library initializes and shuts down properly.
3370TEST(WebRtcVoiceEngineTest, StartupShutdown) {
ossu29b1a8d2016-06-13 07:34:51 -07003371 using testing::_;
3372 using testing::AnyNumber;
3373
3374 // If the VoiceEngine wants to gather available codecs early, that's fine but
3375 // we never want it to create a decoder at this stage.
3376 rtc::scoped_refptr<webrtc::MockAudioDecoderFactory> factory =
3377 new rtc::RefCountedObject<webrtc::MockAudioDecoderFactory>;
3378 ON_CALL(*factory.get(), GetSupportedFormats())
3379 .WillByDefault(Return(std::vector<webrtc::SdpAudioFormat>()));
3380 EXPECT_CALL(*factory.get(), GetSupportedFormats())
3381 .Times(AnyNumber());
3382 EXPECT_CALL(*factory.get(), MakeAudioDecoderMock(_, _)).Times(0);
3383
3384 cricket::WebRtcVoiceEngine engine(nullptr, factory);
kwiberg686a8ef2016-02-26 03:00:35 -08003385 std::unique_ptr<webrtc::Call> call(
Fredrik Solenberg709ed672015-09-15 12:26:33 +02003386 webrtc::Call::Create(webrtc::Call::Config()));
nisse51542be2016-02-12 02:27:06 -08003387 cricket::VoiceMediaChannel* channel = engine.CreateChannel(
3388 call.get(), cricket::MediaConfig(), cricket::AudioOptions());
stefan658910c2015-09-03 05:48:32 -07003389 EXPECT_TRUE(channel != nullptr);
3390 delete channel;
solenbergff976312016-03-30 23:28:51 -07003391}
stefan658910c2015-09-03 05:48:32 -07003392
solenbergff976312016-03-30 23:28:51 -07003393// Tests that reference counting on the external ADM is correct.
solenbergbc37fc82016-04-04 09:54:44 -07003394TEST(WebRtcVoiceEngineTest, StartupShutdownWithExternalADM) {
3395 testing::NiceMock<webrtc::test::MockAudioDeviceModule> adm;
3396 EXPECT_CALL(adm, AddRef()).Times(3).WillRepeatedly(Return(0));
3397 EXPECT_CALL(adm, Release()).Times(3).WillRepeatedly(Return(0));
solenbergff976312016-03-30 23:28:51 -07003398 {
ossu29b1a8d2016-06-13 07:34:51 -07003399 cricket::WebRtcVoiceEngine engine(&adm, nullptr);
solenbergff976312016-03-30 23:28:51 -07003400 std::unique_ptr<webrtc::Call> call(
3401 webrtc::Call::Create(webrtc::Call::Config()));
3402 cricket::VoiceMediaChannel* channel = engine.CreateChannel(
3403 call.get(), cricket::MediaConfig(), cricket::AudioOptions());
3404 EXPECT_TRUE(channel != nullptr);
3405 delete channel;
3406 }
stefan658910c2015-09-03 05:48:32 -07003407}
3408
3409// Tests that the library is configured with the codecs we want.
ossudedfd282016-06-14 07:12:39 -07003410// TODO(ossu): This test should move into the builtin audio codecs module
3411// eventually.
stefan658910c2015-09-03 05:48:32 -07003412TEST(WebRtcVoiceEngineTest, HasCorrectCodecs) {
ossu29b1a8d2016-06-13 07:34:51 -07003413 // TODO(ossu): These tests should move into a future "builtin audio codecs"
3414 // module.
3415
stefan658910c2015-09-03 05:48:32 -07003416 // Check codecs by name.
solenberg26c8c912015-11-27 04:00:25 -08003417 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(
deadbeef67cf2c12016-04-13 10:07:16 -07003418 cricket::AudioCodec(96, "OPUS", 48000, 0, 2), nullptr));
solenberg26c8c912015-11-27 04:00:25 -08003419 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(
deadbeef67cf2c12016-04-13 10:07:16 -07003420 cricket::AudioCodec(96, "ISAC", 16000, 0, 1), nullptr));
solenberg26c8c912015-11-27 04:00:25 -08003421 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(
deadbeef67cf2c12016-04-13 10:07:16 -07003422 cricket::AudioCodec(96, "ISAC", 32000, 0, 1), nullptr));
stefan658910c2015-09-03 05:48:32 -07003423 // Check that name matching is case-insensitive.
solenberg26c8c912015-11-27 04:00:25 -08003424 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(
deadbeef67cf2c12016-04-13 10:07:16 -07003425 cricket::AudioCodec(96, "ILBC", 8000, 0, 1), nullptr));
solenberg26c8c912015-11-27 04:00:25 -08003426 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(
deadbeef67cf2c12016-04-13 10:07:16 -07003427 cricket::AudioCodec(96, "iLBC", 8000, 0, 1), nullptr));
solenberg26c8c912015-11-27 04:00:25 -08003428 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(
deadbeef67cf2c12016-04-13 10:07:16 -07003429 cricket::AudioCodec(96, "PCMU", 8000, 0, 1), nullptr));
solenberg26c8c912015-11-27 04:00:25 -08003430 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(
deadbeef67cf2c12016-04-13 10:07:16 -07003431 cricket::AudioCodec(96, "PCMA", 8000, 0, 1), nullptr));
solenberg26c8c912015-11-27 04:00:25 -08003432 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(
deadbeef67cf2c12016-04-13 10:07:16 -07003433 cricket::AudioCodec(96, "G722", 8000, 0, 1), nullptr));
solenberg26c8c912015-11-27 04:00:25 -08003434 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(
deadbeef67cf2c12016-04-13 10:07:16 -07003435 cricket::AudioCodec(96, "CN", 32000, 0, 1), nullptr));
solenberg26c8c912015-11-27 04:00:25 -08003436 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(
deadbeef67cf2c12016-04-13 10:07:16 -07003437 cricket::AudioCodec(96, "CN", 16000, 0, 1), nullptr));
solenberg26c8c912015-11-27 04:00:25 -08003438 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(
deadbeef67cf2c12016-04-13 10:07:16 -07003439 cricket::AudioCodec(96, "CN", 8000, 0, 1), nullptr));
solenberg26c8c912015-11-27 04:00:25 -08003440 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(
deadbeef67cf2c12016-04-13 10:07:16 -07003441 cricket::AudioCodec(96, "telephone-event", 8000, 0, 1), nullptr));
stefan658910c2015-09-03 05:48:32 -07003442 // Check codecs with an id by id.
solenberg26c8c912015-11-27 04:00:25 -08003443 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(
deadbeef67cf2c12016-04-13 10:07:16 -07003444 cricket::AudioCodec(0, "", 8000, 0, 1), nullptr)); // PCMU
solenberg26c8c912015-11-27 04:00:25 -08003445 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(
deadbeef67cf2c12016-04-13 10:07:16 -07003446 cricket::AudioCodec(8, "", 8000, 0, 1), nullptr)); // PCMA
solenberg26c8c912015-11-27 04:00:25 -08003447 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(
deadbeef67cf2c12016-04-13 10:07:16 -07003448 cricket::AudioCodec(9, "", 8000, 0, 1), nullptr)); // G722
solenberg26c8c912015-11-27 04:00:25 -08003449 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(
deadbeef67cf2c12016-04-13 10:07:16 -07003450 cricket::AudioCodec(13, "", 8000, 0, 1), nullptr)); // CN
stefan658910c2015-09-03 05:48:32 -07003451 // Check sample/bitrate matching.
solenberg26c8c912015-11-27 04:00:25 -08003452 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(
deadbeef67cf2c12016-04-13 10:07:16 -07003453 cricket::AudioCodec(0, "PCMU", 8000, 64000, 1), nullptr));
stefan658910c2015-09-03 05:48:32 -07003454 // Check that bad codecs fail.
solenberg26c8c912015-11-27 04:00:25 -08003455 EXPECT_FALSE(cricket::WebRtcVoiceEngine::ToCodecInst(
deadbeef67cf2c12016-04-13 10:07:16 -07003456 cricket::AudioCodec(99, "ABCD", 0, 0, 1), nullptr));
solenberg26c8c912015-11-27 04:00:25 -08003457 EXPECT_FALSE(cricket::WebRtcVoiceEngine::ToCodecInst(
deadbeef67cf2c12016-04-13 10:07:16 -07003458 cricket::AudioCodec(88, "", 0, 0, 1), nullptr));
solenberg26c8c912015-11-27 04:00:25 -08003459 EXPECT_FALSE(cricket::WebRtcVoiceEngine::ToCodecInst(
deadbeef67cf2c12016-04-13 10:07:16 -07003460 cricket::AudioCodec(0, "", 0, 0, 2), nullptr));
solenberg26c8c912015-11-27 04:00:25 -08003461 EXPECT_FALSE(cricket::WebRtcVoiceEngine::ToCodecInst(
deadbeef67cf2c12016-04-13 10:07:16 -07003462 cricket::AudioCodec(0, "", 5000, 0, 1), nullptr));
solenberg26c8c912015-11-27 04:00:25 -08003463 EXPECT_FALSE(cricket::WebRtcVoiceEngine::ToCodecInst(
deadbeef67cf2c12016-04-13 10:07:16 -07003464 cricket::AudioCodec(0, "", 0, 5000, 1), nullptr));
solenberg26c8c912015-11-27 04:00:25 -08003465
stefan658910c2015-09-03 05:48:32 -07003466 // Verify the payload id of common audio codecs, including CN, ISAC, and G722.
ossu29b1a8d2016-06-13 07:34:51 -07003467 cricket::WebRtcVoiceEngine engine(nullptr,
3468 webrtc::CreateBuiltinAudioDecoderFactory());
stefan658910c2015-09-03 05:48:32 -07003469 for (std::vector<cricket::AudioCodec>::const_iterator it =
ossudedfd282016-06-14 07:12:39 -07003470 engine.send_codecs().begin(); it != engine.send_codecs().end(); ++it) {
stefan658910c2015-09-03 05:48:32 -07003471 if (it->name == "CN" && it->clockrate == 16000) {
3472 EXPECT_EQ(105, it->id);
3473 } else if (it->name == "CN" && it->clockrate == 32000) {
3474 EXPECT_EQ(106, it->id);
3475 } else if (it->name == "ISAC" && it->clockrate == 16000) {
3476 EXPECT_EQ(103, it->id);
3477 } else if (it->name == "ISAC" && it->clockrate == 32000) {
3478 EXPECT_EQ(104, it->id);
3479 } else if (it->name == "G722" && it->clockrate == 8000) {
3480 EXPECT_EQ(9, it->id);
3481 } else if (it->name == "telephone-event") {
3482 EXPECT_EQ(126, it->id);
stefan658910c2015-09-03 05:48:32 -07003483 } else if (it->name == "opus") {
3484 EXPECT_EQ(111, it->id);
3485 ASSERT_TRUE(it->params.find("minptime") != it->params.end());
3486 EXPECT_EQ("10", it->params.find("minptime")->second);
stefan658910c2015-09-03 05:48:32 -07003487 ASSERT_TRUE(it->params.find("useinbandfec") != it->params.end());
3488 EXPECT_EQ("1", it->params.find("useinbandfec")->second);
3489 }
3490 }
stefan658910c2015-09-03 05:48:32 -07003491}
3492
3493// Tests that VoE supports at least 32 channels
3494TEST(WebRtcVoiceEngineTest, Has32Channels) {
ossu29b1a8d2016-06-13 07:34:51 -07003495 cricket::WebRtcVoiceEngine engine(nullptr, nullptr);
kwiberg686a8ef2016-02-26 03:00:35 -08003496 std::unique_ptr<webrtc::Call> call(
Fredrik Solenberg709ed672015-09-15 12:26:33 +02003497 webrtc::Call::Create(webrtc::Call::Config()));
stefan658910c2015-09-03 05:48:32 -07003498
3499 cricket::VoiceMediaChannel* channels[32];
3500 int num_channels = 0;
tfarina5237aaf2015-11-10 23:44:30 -08003501 while (num_channels < arraysize(channels)) {
nisse51542be2016-02-12 02:27:06 -08003502 cricket::VoiceMediaChannel* channel = engine.CreateChannel(
3503 call.get(), cricket::MediaConfig(), cricket::AudioOptions());
stefan658910c2015-09-03 05:48:32 -07003504 if (!channel)
3505 break;
stefan658910c2015-09-03 05:48:32 -07003506 channels[num_channels++] = channel;
3507 }
3508
tfarina5237aaf2015-11-10 23:44:30 -08003509 int expected = arraysize(channels);
stefan658910c2015-09-03 05:48:32 -07003510 EXPECT_EQ(expected, num_channels);
3511
3512 while (num_channels > 0) {
3513 delete channels[--num_channels];
3514 }
stefan658910c2015-09-03 05:48:32 -07003515}
3516
3517// Test that we set our preferred codecs properly.
3518TEST(WebRtcVoiceEngineTest, SetRecvCodecs) {
ossu29b1a8d2016-06-13 07:34:51 -07003519 // TODO(ossu): I'm not sure of the intent of this test. It's either:
3520 // - Check that our builtin codecs are usable by Channel.
3521 // - The codecs provided by the engine is usable by Channel.
3522 // It does not check that the codecs in the RecvParameters are actually
3523 // what we sent in - though it's probably reasonable to expect so, if
3524 // SetRecvParameters returns true.
3525 // I think it will become clear once audio decoder injection is completed.
3526 cricket::WebRtcVoiceEngine engine(
3527 nullptr, webrtc::CreateBuiltinAudioDecoderFactory());
kwiberg686a8ef2016-02-26 03:00:35 -08003528 std::unique_ptr<webrtc::Call> call(
Fredrik Solenberg709ed672015-09-15 12:26:33 +02003529 webrtc::Call::Create(webrtc::Call::Config()));
nisse51542be2016-02-12 02:27:06 -08003530 cricket::WebRtcVoiceMediaChannel channel(&engine, cricket::MediaConfig(),
3531 cricket::AudioOptions(), call.get());
Fredrik Solenbergb071a192015-09-17 16:42:56 +02003532 cricket::AudioRecvParameters parameters;
ossudedfd282016-06-14 07:12:39 -07003533 parameters.codecs = engine.recv_codecs();
Fredrik Solenbergb071a192015-09-17 16:42:56 +02003534 EXPECT_TRUE(channel.SetRecvParameters(parameters));
stefan658910c2015-09-03 05:48:32 -07003535}