1 /* 2 * libjingle 3 * Copyright 2008 Google Inc. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions are met: 7 * 8 * 1. Redistributions of source code must retain the above copyright notice, 9 * this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright notice, 11 * this list of conditions and the following disclaimer in the documentation 12 * and/or other materials provided with the distribution. 13 * 3. The name of the author may not be used to endorse or promote products 14 * derived from this software without specific prior written permission. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED 17 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 18 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO 19 * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 20 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 21 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; 22 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 23 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 24 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 25 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 26 */ 27 28 #ifdef WIN32 29 #include "webrtc/base/win32.h" 30 #include <objbase.h> 31 #endif 32 33 #include "webrtc/base/byteorder.h" 34 #include "webrtc/base/gunit.h" 35 #include "talk/media/base/constants.h" 36 #include "talk/media/base/fakemediaengine.h" 37 #include "talk/media/base/fakemediaprocessor.h" 38 #include "talk/media/base/fakenetworkinterface.h" 39 #include "talk/media/base/fakertp.h" 40 #include "talk/media/webrtc/fakewebrtcvoiceengine.h" 41 #include "talk/media/webrtc/webrtcvie.h" 42 #include "talk/media/webrtc/webrtcvoiceengine.h" 43 #include "talk/p2p/base/fakesession.h" 44 #include "talk/session/media/channel.h" 45 46 // Tests for the WebRtcVoiceEngine/VoiceChannel code. 47 48 using cricket::kRtpAudioLevelHeaderExtension; 49 using cricket::kRtpAbsoluteSenderTimeHeaderExtension; 50 51 static const cricket::AudioCodec kPcmuCodec(0, "PCMU", 8000, 64000, 1, 0); 52 static const cricket::AudioCodec kIsacCodec(103, "ISAC", 16000, 32000, 1, 0); 53 static const cricket::AudioCodec kCeltCodec(110, "CELT", 32000, 64000, 2, 0); 54 static const cricket::AudioCodec kOpusCodec(111, "opus", 48000, 64000, 2, 0); 55 static const cricket::AudioCodec kRedCodec(117, "red", 8000, 0, 1, 0); 56 static const cricket::AudioCodec kCn8000Codec(13, "CN", 8000, 0, 1, 0); 57 static const cricket::AudioCodec kCn16000Codec(105, "CN", 16000, 0, 1, 0); 58 static const cricket::AudioCodec 59 kTelephoneEventCodec(106, "telephone-event", 8000, 0, 1, 0); 60 static const cricket::AudioCodec* const kAudioCodecs[] = { 61 &kPcmuCodec, &kIsacCodec, &kCeltCodec, &kOpusCodec, &kRedCodec, 62 &kCn8000Codec, &kCn16000Codec, &kTelephoneEventCodec, 63 }; 64 const char kRingbackTone[] = "RIFF____WAVE____ABCD1234"; 65 static uint32 kSsrc1 = 0x99; 66 static uint32 kSsrc2 = 0x98; 67 68 class FakeVoEWrapper : public cricket::VoEWrapper { 69 public: 70 explicit FakeVoEWrapper(cricket::FakeWebRtcVoiceEngine* engine) 71 : cricket::VoEWrapper(engine, // processing 72 engine, // base 73 engine, // codec 74 engine, // dtmf 75 engine, // file 76 engine, // hw 77 engine, // media 78 engine, // neteq 79 engine, // network 80 engine, // rtp 81 engine, // sync 82 engine) { // volume 83 } 84 }; 85 86 class FakeVoETraceWrapper : public cricket::VoETraceWrapper { 87 public: 88 virtual int SetTraceFilter(const unsigned int filter) { 89 filter_ = filter; 90 return 0; 91 } 92 virtual int SetTraceFile(const char* fileNameUTF8) { 93 return 0; 94 } 95 virtual int SetTraceCallback(webrtc::TraceCallback* callback) { 96 return 0; 97 } 98 unsigned int filter_; 99 }; 100 101 class WebRtcVoiceEngineTestFake : public testing::Test { 102 public: 103 class ChannelErrorListener : public sigslot::has_slots<> { 104 public: 105 explicit ChannelErrorListener(cricket::VoiceMediaChannel* channel) 106 : ssrc_(0), error_(cricket::VoiceMediaChannel::ERROR_NONE) { 107 ASSERT(channel != NULL); 108 channel->SignalMediaError.connect( 109 this, &ChannelErrorListener::OnVoiceChannelError); 110 } 111 void OnVoiceChannelError(uint32 ssrc, 112 cricket::VoiceMediaChannel::Error error) { 113 ssrc_ = ssrc; 114 error_ = error; 115 } 116 void Reset() { 117 ssrc_ = 0; 118 error_ = cricket::VoiceMediaChannel::ERROR_NONE; 119 } 120 uint32 ssrc() const { 121 return ssrc_; 122 } 123 cricket::VoiceMediaChannel::Error error() const { 124 return error_; 125 } 126 127 private: 128 uint32 ssrc_; 129 cricket::VoiceMediaChannel::Error error_; 130 }; 131 132 WebRtcVoiceEngineTestFake() 133 : voe_(kAudioCodecs, ARRAY_SIZE(kAudioCodecs)), 134 voe_sc_(kAudioCodecs, ARRAY_SIZE(kAudioCodecs)), 135 trace_wrapper_(new FakeVoETraceWrapper()), 136 engine_(new FakeVoEWrapper(&voe_), 137 new FakeVoEWrapper(&voe_sc_), 138 trace_wrapper_), 139 channel_(NULL), soundclip_(NULL) { 140 options_conference_.conference_mode.Set(true); 141 options_adjust_agc_.adjust_agc_delta.Set(-10); 142 } 143 bool SetupEngineWithoutStream() { 144 if (!engine_.Init(rtc::Thread::Current())) { 145 return false; 146 } 147 channel_ = engine_.CreateChannel(); 148 return (channel_ != NULL); 149 } 150 bool SetupEngine() { 151 if (!SetupEngineWithoutStream()) { 152 return false; 153 } 154 return channel_->AddSendStream( 155 cricket::StreamParams::CreateLegacy(kSsrc1)); 156 } 157 void SetupForMultiSendStream() { 158 EXPECT_TRUE(SetupEngine()); 159 // Remove stream added in Setup, which is corresponding to default channel. 160 int default_channel_num = voe_.GetLastChannel(); 161 uint32 default_send_ssrc = 0u; 162 EXPECT_EQ(0, voe_.GetLocalSSRC(default_channel_num, default_send_ssrc)); 163 EXPECT_EQ(kSsrc1, default_send_ssrc); 164 EXPECT_TRUE(channel_->RemoveSendStream(default_send_ssrc)); 165 166 // Verify the default channel still exists. 167 EXPECT_EQ(0, voe_.GetLocalSSRC(default_channel_num, default_send_ssrc)); 168 } 169 void DeliverPacket(const void* data, int len) { 170 rtc::Buffer packet(data, len); 171 channel_->OnPacketReceived(&packet, rtc::PacketTime()); 172 } 173 virtual void TearDown() { 174 delete soundclip_; 175 delete channel_; 176 engine_.Terminate(); 177 } 178 179 void TestInsertDtmf(uint32 ssrc, bool caller) { 180 EXPECT_TRUE(engine_.Init(rtc::Thread::Current())); 181 channel_ = engine_.CreateChannel(); 182 EXPECT_TRUE(channel_ != NULL); 183 if (caller) { 184 // if this is a caller, local description will be applied and add the 185 // send stream. 186 EXPECT_TRUE(channel_->AddSendStream( 187 cricket::StreamParams::CreateLegacy(kSsrc1))); 188 } 189 int channel_id = voe_.GetLastChannel(); 190 191 // Test we can only InsertDtmf when the other side supports telephone-event. 192 std::vector<cricket::AudioCodec> codecs; 193 codecs.push_back(kPcmuCodec); 194 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 195 EXPECT_TRUE(channel_->SetSend(cricket::SEND_MICROPHONE)); 196 EXPECT_FALSE(channel_->CanInsertDtmf()); 197 EXPECT_FALSE(channel_->InsertDtmf(ssrc, 1, 111, cricket::DF_SEND)); 198 codecs.push_back(kTelephoneEventCodec); 199 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 200 EXPECT_TRUE(channel_->CanInsertDtmf()); 201 202 if (!caller) { 203 // There's no active send channel yet. 204 EXPECT_FALSE(channel_->InsertDtmf(ssrc, 2, 123, cricket::DF_SEND)); 205 EXPECT_TRUE(channel_->AddSendStream( 206 cricket::StreamParams::CreateLegacy(kSsrc1))); 207 } 208 209 // Check we fail if the ssrc is invalid. 210 EXPECT_FALSE(channel_->InsertDtmf(-1, 1, 111, cricket::DF_SEND)); 211 212 // Test send 213 EXPECT_FALSE(voe_.WasSendTelephoneEventCalled(channel_id, 2, 123)); 214 EXPECT_TRUE(channel_->InsertDtmf(ssrc, 2, 123, cricket::DF_SEND)); 215 EXPECT_TRUE(voe_.WasSendTelephoneEventCalled(channel_id, 2, 123)); 216 217 // Test play 218 EXPECT_FALSE(voe_.WasPlayDtmfToneCalled(3, 134)); 219 EXPECT_TRUE(channel_->InsertDtmf(ssrc, 3, 134, cricket::DF_PLAY)); 220 EXPECT_TRUE(voe_.WasPlayDtmfToneCalled(3, 134)); 221 222 // Test send and play 223 EXPECT_FALSE(voe_.WasSendTelephoneEventCalled(channel_id, 4, 145)); 224 EXPECT_FALSE(voe_.WasPlayDtmfToneCalled(4, 145)); 225 EXPECT_TRUE(channel_->InsertDtmf(ssrc, 4, 145, 226 cricket::DF_PLAY | cricket::DF_SEND)); 227 EXPECT_TRUE(voe_.WasSendTelephoneEventCalled(channel_id, 4, 145)); 228 EXPECT_TRUE(voe_.WasPlayDtmfToneCalled(4, 145)); 229 } 230 231 // Test that send bandwidth is set correctly. 232 // |codec| is the codec under test. 233 // |max_bitrate| is a parameter to set to SetMaxSendBandwidth(). 234 // |expected_result| is the expected result from SetMaxSendBandwidth(). 235 // |expected_bitrate| is the expected audio bitrate afterward. 236 void TestSendBandwidth(const cricket::AudioCodec& codec, 237 int max_bitrate, 238 bool expected_result, 239 int expected_bitrate) { 240 int channel_num = voe_.GetLastChannel(); 241 std::vector<cricket::AudioCodec> codecs; 242 243 codecs.push_back(codec); 244 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 245 246 bool result = channel_->SetMaxSendBandwidth(max_bitrate); 247 EXPECT_EQ(expected_result, result); 248 249 webrtc::CodecInst temp_codec; 250 EXPECT_FALSE(voe_.GetSendCodec(channel_num, temp_codec)); 251 252 EXPECT_EQ(expected_bitrate, temp_codec.rate); 253 } 254 255 void TestSetSendRtpHeaderExtensions(const std::string& ext) { 256 EXPECT_TRUE(SetupEngineWithoutStream()); 257 int channel_num = voe_.GetLastChannel(); 258 259 // Ensure extensions are off by default. 260 EXPECT_EQ(-1, voe_.GetSendRtpExtensionId(channel_num, ext)); 261 262 std::vector<cricket::RtpHeaderExtension> extensions; 263 // Ensure unknown extensions won't cause an error. 264 extensions.push_back(cricket::RtpHeaderExtension( 265 "urn:ietf:params:unknownextention", 1)); 266 EXPECT_TRUE(channel_->SetSendRtpHeaderExtensions(extensions)); 267 EXPECT_EQ(-1, voe_.GetSendRtpExtensionId(channel_num, ext)); 268 269 // Ensure extensions stay off with an empty list of headers. 270 extensions.clear(); 271 EXPECT_TRUE(channel_->SetSendRtpHeaderExtensions(extensions)); 272 EXPECT_EQ(-1, voe_.GetSendRtpExtensionId(channel_num, ext)); 273 274 // Ensure extension is set properly. 275 const int id = 1; 276 extensions.push_back(cricket::RtpHeaderExtension(ext, id)); 277 EXPECT_TRUE(channel_->SetSendRtpHeaderExtensions(extensions)); 278 EXPECT_EQ(id, voe_.GetSendRtpExtensionId(channel_num, ext)); 279 280 // Ensure extension is set properly on new channel. 281 // The first stream to occupy the default channel. 282 EXPECT_TRUE(channel_->AddSendStream( 283 cricket::StreamParams::CreateLegacy(123))); 284 EXPECT_TRUE(channel_->AddSendStream( 285 cricket::StreamParams::CreateLegacy(234))); 286 int new_channel_num = voe_.GetLastChannel(); 287 EXPECT_NE(channel_num, new_channel_num); 288 EXPECT_EQ(id, voe_.GetSendRtpExtensionId(new_channel_num, ext)); 289 290 // Ensure all extensions go back off with an empty list. 291 extensions.clear(); 292 EXPECT_TRUE(channel_->SetSendRtpHeaderExtensions(extensions)); 293 EXPECT_EQ(-1, voe_.GetSendRtpExtensionId(channel_num, ext)); 294 EXPECT_EQ(-1, voe_.GetSendRtpExtensionId(new_channel_num, ext)); 295 } 296 297 void TestSetRecvRtpHeaderExtensions(const std::string& ext) { 298 EXPECT_TRUE(SetupEngineWithoutStream()); 299 int channel_num = voe_.GetLastChannel(); 300 301 // Ensure extensions are off by default. 302 EXPECT_EQ(-1, voe_.GetReceiveRtpExtensionId(channel_num, ext)); 303 304 std::vector<cricket::RtpHeaderExtension> extensions; 305 // Ensure unknown extensions won't cause an error. 306 extensions.push_back(cricket::RtpHeaderExtension( 307 "urn:ietf:params:unknownextention", 1)); 308 EXPECT_TRUE(channel_->SetRecvRtpHeaderExtensions(extensions)); 309 EXPECT_EQ(-1, voe_.GetReceiveRtpExtensionId(channel_num, ext)); 310 311 // Ensure extensions stay off with an empty list of headers. 312 extensions.clear(); 313 EXPECT_TRUE(channel_->SetRecvRtpHeaderExtensions(extensions)); 314 EXPECT_EQ(-1, voe_.GetReceiveRtpExtensionId(channel_num, ext)); 315 316 // Ensure extension is set properly. 317 const int id = 2; 318 extensions.push_back(cricket::RtpHeaderExtension(ext, id)); 319 EXPECT_TRUE(channel_->SetRecvRtpHeaderExtensions(extensions)); 320 EXPECT_EQ(id, voe_.GetReceiveRtpExtensionId(channel_num, ext)); 321 322 // Ensure extension is set properly on new channel. 323 // The first stream to occupy the default channel. 324 EXPECT_TRUE(channel_->AddRecvStream( 325 cricket::StreamParams::CreateLegacy(345))); 326 EXPECT_TRUE(channel_->AddRecvStream( 327 cricket::StreamParams::CreateLegacy(456))); 328 int new_channel_num = voe_.GetLastChannel(); 329 EXPECT_NE(channel_num, new_channel_num); 330 EXPECT_EQ(id, voe_.GetReceiveRtpExtensionId(new_channel_num, ext)); 331 332 // Ensure all extensions go back off with an empty list. 333 extensions.clear(); 334 EXPECT_TRUE(channel_->SetRecvRtpHeaderExtensions(extensions)); 335 EXPECT_EQ(-1, voe_.GetReceiveRtpExtensionId(channel_num, ext)); 336 EXPECT_EQ(-1, voe_.GetReceiveRtpExtensionId(new_channel_num, ext)); 337 } 338 339 protected: 340 cricket::FakeWebRtcVoiceEngine voe_; 341 cricket::FakeWebRtcVoiceEngine voe_sc_; 342 FakeVoETraceWrapper* trace_wrapper_; 343 cricket::WebRtcVoiceEngine engine_; 344 cricket::VoiceMediaChannel* channel_; 345 cricket::SoundclipMedia* soundclip_; 346 347 cricket::AudioOptions options_conference_; 348 cricket::AudioOptions options_adjust_agc_; 349 }; 350 351 // Tests that our stub library "works". 352 TEST_F(WebRtcVoiceEngineTestFake, StartupShutdown) { 353 EXPECT_FALSE(voe_.IsInited()); 354 EXPECT_FALSE(voe_sc_.IsInited()); 355 EXPECT_TRUE(engine_.Init(rtc::Thread::Current())); 356 EXPECT_TRUE(voe_.IsInited()); 357 // The soundclip engine is lazily initialized. 358 EXPECT_FALSE(voe_sc_.IsInited()); 359 engine_.Terminate(); 360 EXPECT_FALSE(voe_.IsInited()); 361 EXPECT_FALSE(voe_sc_.IsInited()); 362 } 363 364 // Tests that we can create and destroy a channel. 365 TEST_F(WebRtcVoiceEngineTestFake, CreateChannel) { 366 EXPECT_TRUE(engine_.Init(rtc::Thread::Current())); 367 channel_ = engine_.CreateChannel(); 368 EXPECT_TRUE(channel_ != NULL); 369 } 370 371 // Tests that we properly handle failures in CreateChannel. 372 TEST_F(WebRtcVoiceEngineTestFake, CreateChannelFail) { 373 voe_.set_fail_create_channel(true); 374 EXPECT_TRUE(engine_.Init(rtc::Thread::Current())); 375 channel_ = engine_.CreateChannel(); 376 EXPECT_TRUE(channel_ == NULL); 377 } 378 379 // Tests that the list of supported codecs is created properly and ordered 380 // correctly 381 TEST_F(WebRtcVoiceEngineTestFake, CodecPreference) { 382 const std::vector<cricket::AudioCodec>& codecs = engine_.codecs(); 383 ASSERT_FALSE(codecs.empty()); 384 EXPECT_STRCASEEQ("opus", codecs[0].name.c_str()); 385 EXPECT_EQ(48000, codecs[0].clockrate); 386 EXPECT_EQ(2, codecs[0].channels); 387 EXPECT_EQ(64000, codecs[0].bitrate); 388 int pref = codecs[0].preference; 389 for (size_t i = 1; i < codecs.size(); ++i) { 390 EXPECT_GT(pref, codecs[i].preference); 391 pref = codecs[i].preference; 392 } 393 } 394 395 // Tests that we can find codecs by name or id, and that we interpret the 396 // clockrate and bitrate fields properly. 397 TEST_F(WebRtcVoiceEngineTestFake, FindCodec) { 398 cricket::AudioCodec codec; 399 webrtc::CodecInst codec_inst; 400 // Find PCMU with explicit clockrate and bitrate. 401 EXPECT_TRUE(engine_.FindWebRtcCodec(kPcmuCodec, &codec_inst)); 402 // Find ISAC with explicit clockrate and 0 bitrate. 403 EXPECT_TRUE(engine_.FindWebRtcCodec(kIsacCodec, &codec_inst)); 404 // Find telephone-event with explicit clockrate and 0 bitrate. 405 EXPECT_TRUE(engine_.FindWebRtcCodec(kTelephoneEventCodec, &codec_inst)); 406 // Find ISAC with a different payload id. 407 codec = kIsacCodec; 408 codec.id = 127; 409 EXPECT_TRUE(engine_.FindWebRtcCodec(codec, &codec_inst)); 410 EXPECT_EQ(codec.id, codec_inst.pltype); 411 // Find PCMU with a 0 clockrate. 412 codec = kPcmuCodec; 413 codec.clockrate = 0; 414 EXPECT_TRUE(engine_.FindWebRtcCodec(codec, &codec_inst)); 415 EXPECT_EQ(codec.id, codec_inst.pltype); 416 EXPECT_EQ(8000, codec_inst.plfreq); 417 // Find PCMU with a 0 bitrate. 418 codec = kPcmuCodec; 419 codec.bitrate = 0; 420 EXPECT_TRUE(engine_.FindWebRtcCodec(codec, &codec_inst)); 421 EXPECT_EQ(codec.id, codec_inst.pltype); 422 EXPECT_EQ(64000, codec_inst.rate); 423 // Find ISAC with an explicit bitrate. 424 codec = kIsacCodec; 425 codec.bitrate = 32000; 426 EXPECT_TRUE(engine_.FindWebRtcCodec(codec, &codec_inst)); 427 EXPECT_EQ(codec.id, codec_inst.pltype); 428 EXPECT_EQ(32000, codec_inst.rate); 429 } 430 431 // Test that we set our inbound codecs properly, including changing PT. 432 TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecs) { 433 EXPECT_TRUE(SetupEngine()); 434 int channel_num = voe_.GetLastChannel(); 435 std::vector<cricket::AudioCodec> codecs; 436 codecs.push_back(kIsacCodec); 437 codecs.push_back(kPcmuCodec); 438 codecs.push_back(kTelephoneEventCodec); 439 codecs[0].id = 106; // collide with existing telephone-event 440 codecs[2].id = 126; 441 EXPECT_TRUE(channel_->SetRecvCodecs(codecs)); 442 webrtc::CodecInst gcodec; 443 rtc::strcpyn(gcodec.plname, ARRAY_SIZE(gcodec.plname), "ISAC"); 444 gcodec.plfreq = 16000; 445 gcodec.channels = 1; 446 EXPECT_EQ(0, voe_.GetRecPayloadType(channel_num, gcodec)); 447 EXPECT_EQ(106, gcodec.pltype); 448 EXPECT_STREQ("ISAC", gcodec.plname); 449 rtc::strcpyn(gcodec.plname, ARRAY_SIZE(gcodec.plname), 450 "telephone-event"); 451 gcodec.plfreq = 8000; 452 EXPECT_EQ(0, voe_.GetRecPayloadType(channel_num, gcodec)); 453 EXPECT_EQ(126, gcodec.pltype); 454 EXPECT_STREQ("telephone-event", gcodec.plname); 455 } 456 457 // Test that we fail to set an unknown inbound codec. 458 TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecsUnsupportedCodec) { 459 EXPECT_TRUE(SetupEngine()); 460 std::vector<cricket::AudioCodec> codecs; 461 codecs.push_back(kIsacCodec); 462 codecs.push_back(cricket::AudioCodec(127, "XYZ", 32000, 0, 1, 0)); 463 EXPECT_FALSE(channel_->SetRecvCodecs(codecs)); 464 } 465 466 // Test that we fail if we have duplicate types in the inbound list. 467 TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecsDuplicatePayloadType) { 468 EXPECT_TRUE(SetupEngine()); 469 std::vector<cricket::AudioCodec> codecs; 470 codecs.push_back(kIsacCodec); 471 codecs.push_back(kCn16000Codec); 472 codecs[1].id = kIsacCodec.id; 473 EXPECT_FALSE(channel_->SetRecvCodecs(codecs)); 474 } 475 476 // Test that we can decode OPUS without stereo parameters. 477 TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecsWithOpusNoStereo) { 478 EXPECT_TRUE(SetupEngine()); 479 EXPECT_TRUE(channel_->SetOptions(options_conference_)); 480 std::vector<cricket::AudioCodec> codecs; 481 codecs.push_back(kIsacCodec); 482 codecs.push_back(kPcmuCodec); 483 codecs.push_back(kOpusCodec); 484 EXPECT_TRUE(channel_->SetRecvCodecs(codecs)); 485 EXPECT_TRUE(channel_->AddRecvStream( 486 cricket::StreamParams::CreateLegacy(kSsrc1))); 487 int channel_num2 = voe_.GetLastChannel(); 488 webrtc::CodecInst opus; 489 engine_.FindWebRtcCodec(kOpusCodec, &opus); 490 // Even without stereo parameters, recv codecs still specify channels = 2. 491 EXPECT_EQ(2, opus.channels); 492 EXPECT_EQ(111, opus.pltype); 493 EXPECT_STREQ("opus", opus.plname); 494 opus.pltype = 0; 495 EXPECT_EQ(0, voe_.GetRecPayloadType(channel_num2, opus)); 496 EXPECT_EQ(111, opus.pltype); 497 } 498 499 // Test that we can decode OPUS with stereo = 0. 500 TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecsWithOpus0Stereo) { 501 EXPECT_TRUE(SetupEngine()); 502 EXPECT_TRUE(channel_->SetOptions(options_conference_)); 503 std::vector<cricket::AudioCodec> codecs; 504 codecs.push_back(kIsacCodec); 505 codecs.push_back(kPcmuCodec); 506 codecs.push_back(kOpusCodec); 507 codecs[2].params["stereo"] = "0"; 508 EXPECT_TRUE(channel_->SetRecvCodecs(codecs)); 509 EXPECT_TRUE(channel_->AddRecvStream( 510 cricket::StreamParams::CreateLegacy(kSsrc1))); 511 int channel_num2 = voe_.GetLastChannel(); 512 webrtc::CodecInst opus; 513 engine_.FindWebRtcCodec(kOpusCodec, &opus); 514 // Even when stereo is off, recv codecs still specify channels = 2. 515 EXPECT_EQ(2, opus.channels); 516 EXPECT_EQ(111, opus.pltype); 517 EXPECT_STREQ("opus", opus.plname); 518 opus.pltype = 0; 519 EXPECT_EQ(0, voe_.GetRecPayloadType(channel_num2, opus)); 520 EXPECT_EQ(111, opus.pltype); 521 } 522 523 // Test that we can decode OPUS with stereo = 1. 524 TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecsWithOpus1Stereo) { 525 EXPECT_TRUE(SetupEngine()); 526 EXPECT_TRUE(channel_->SetOptions(options_conference_)); 527 std::vector<cricket::AudioCodec> codecs; 528 codecs.push_back(kIsacCodec); 529 codecs.push_back(kPcmuCodec); 530 codecs.push_back(kOpusCodec); 531 codecs[2].params["stereo"] = "1"; 532 EXPECT_TRUE(channel_->SetRecvCodecs(codecs)); 533 EXPECT_TRUE(channel_->AddRecvStream( 534 cricket::StreamParams::CreateLegacy(kSsrc1))); 535 int channel_num2 = voe_.GetLastChannel(); 536 webrtc::CodecInst opus; 537 engine_.FindWebRtcCodec(kOpusCodec, &opus); 538 EXPECT_EQ(2, opus.channels); 539 EXPECT_EQ(111, opus.pltype); 540 EXPECT_STREQ("opus", opus.plname); 541 opus.pltype = 0; 542 EXPECT_EQ(0, voe_.GetRecPayloadType(channel_num2, opus)); 543 EXPECT_EQ(111, opus.pltype); 544 } 545 546 // Test that changes to recv codecs are applied to all streams. 547 TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecsWithMultipleStreams) { 548 EXPECT_TRUE(SetupEngine()); 549 EXPECT_TRUE(channel_->SetOptions(options_conference_)); 550 std::vector<cricket::AudioCodec> codecs; 551 codecs.push_back(kIsacCodec); 552 codecs.push_back(kPcmuCodec); 553 codecs.push_back(kTelephoneEventCodec); 554 codecs[0].id = 106; // collide with existing telephone-event 555 codecs[2].id = 126; 556 EXPECT_TRUE(channel_->SetRecvCodecs(codecs)); 557 EXPECT_TRUE(channel_->AddRecvStream( 558 cricket::StreamParams::CreateLegacy(kSsrc1))); 559 int channel_num2 = voe_.GetLastChannel(); 560 webrtc::CodecInst gcodec; 561 rtc::strcpyn(gcodec.plname, ARRAY_SIZE(gcodec.plname), "ISAC"); 562 gcodec.plfreq = 16000; 563 gcodec.channels = 1; 564 EXPECT_EQ(0, voe_.GetRecPayloadType(channel_num2, gcodec)); 565 EXPECT_EQ(106, gcodec.pltype); 566 EXPECT_STREQ("ISAC", gcodec.plname); 567 rtc::strcpyn(gcodec.plname, ARRAY_SIZE(gcodec.plname), 568 "telephone-event"); 569 gcodec.plfreq = 8000; 570 gcodec.channels = 1; 571 EXPECT_EQ(0, voe_.GetRecPayloadType(channel_num2, gcodec)); 572 EXPECT_EQ(126, gcodec.pltype); 573 EXPECT_STREQ("telephone-event", gcodec.plname); 574 } 575 576 TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecsAfterAddingStreams) { 577 EXPECT_TRUE(SetupEngine()); 578 EXPECT_TRUE(channel_->SetOptions(options_conference_)); 579 std::vector<cricket::AudioCodec> codecs; 580 codecs.push_back(kIsacCodec); 581 codecs[0].id = 106; // collide with existing telephone-event 582 583 EXPECT_TRUE(channel_->AddRecvStream( 584 cricket::StreamParams::CreateLegacy(kSsrc1))); 585 EXPECT_TRUE(channel_->SetRecvCodecs(codecs)); 586 587 int channel_num2 = voe_.GetLastChannel(); 588 webrtc::CodecInst gcodec; 589 rtc::strcpyn(gcodec.plname, ARRAY_SIZE(gcodec.plname), "ISAC"); 590 gcodec.plfreq = 16000; 591 gcodec.channels = 1; 592 EXPECT_EQ(0, voe_.GetRecPayloadType(channel_num2, gcodec)); 593 EXPECT_EQ(106, gcodec.pltype); 594 EXPECT_STREQ("ISAC", gcodec.plname); 595 } 596 597 // Test that we can apply the same set of codecs again while playing. 598 TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecsWhilePlaying) { 599 EXPECT_TRUE(SetupEngine()); 600 int channel_num = voe_.GetLastChannel(); 601 std::vector<cricket::AudioCodec> codecs; 602 codecs.push_back(kIsacCodec); 603 codecs.push_back(kCn16000Codec); 604 EXPECT_TRUE(channel_->SetRecvCodecs(codecs)); 605 EXPECT_TRUE(channel_->SetPlayout(true)); 606 EXPECT_TRUE(channel_->SetRecvCodecs(codecs)); 607 608 // Changing the payload type of a codec should fail. 609 codecs[0].id = 127; 610 EXPECT_FALSE(channel_->SetRecvCodecs(codecs)); 611 EXPECT_TRUE(voe_.GetPlayout(channel_num)); 612 } 613 614 // Test that we can add a codec while playing. 615 TEST_F(WebRtcVoiceEngineTestFake, AddRecvCodecsWhilePlaying) { 616 EXPECT_TRUE(SetupEngine()); 617 int channel_num = voe_.GetLastChannel(); 618 std::vector<cricket::AudioCodec> codecs; 619 codecs.push_back(kIsacCodec); 620 codecs.push_back(kCn16000Codec); 621 EXPECT_TRUE(channel_->SetRecvCodecs(codecs)); 622 EXPECT_TRUE(channel_->SetPlayout(true)); 623 624 codecs.push_back(kOpusCodec); 625 EXPECT_TRUE(channel_->SetRecvCodecs(codecs)); 626 EXPECT_TRUE(voe_.GetPlayout(channel_num)); 627 webrtc::CodecInst gcodec; 628 EXPECT_TRUE(engine_.FindWebRtcCodec(kOpusCodec, &gcodec)); 629 EXPECT_EQ(kOpusCodec.id, gcodec.pltype); 630 } 631 632 TEST_F(WebRtcVoiceEngineTestFake, SetSendBandwidthAuto) { 633 EXPECT_TRUE(SetupEngine()); 634 EXPECT_TRUE(channel_->SetSendCodecs(engine_.codecs())); 635 636 // Test that when autobw is enabled, bitrate is kept as the default 637 // value. autobw is enabled for the following tests because the target 638 // bitrate is <= 0. 639 640 // ISAC, default bitrate == 32000. 641 TestSendBandwidth(kIsacCodec, 0, true, 32000); 642 643 // PCMU, default bitrate == 64000. 644 TestSendBandwidth(kPcmuCodec, -1, true, 64000); 645 646 // CELT, default bitrate == 64000. 647 TestSendBandwidth(kCeltCodec, 0, true, 64000); 648 649 // opus, default bitrate == 64000. 650 TestSendBandwidth(kOpusCodec, -1, true, 64000); 651 } 652 653 TEST_F(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthMultiRateAsCaller) { 654 EXPECT_TRUE(SetupEngine()); 655 EXPECT_TRUE(channel_->SetSendCodecs(engine_.codecs())); 656 657 // Test that the bitrate of a multi-rate codec is always the maximum. 658 659 // ISAC, default bitrate == 32000. 660 TestSendBandwidth(kIsacCodec, 128000, true, 128000); 661 TestSendBandwidth(kIsacCodec, 16000, true, 16000); 662 663 // CELT, default bitrate == 64000. 664 TestSendBandwidth(kCeltCodec, 96000, true, 96000); 665 TestSendBandwidth(kCeltCodec, 32000, true, 32000); 666 667 // opus, default bitrate == 64000. 668 TestSendBandwidth(kOpusCodec, 96000, true, 96000); 669 TestSendBandwidth(kOpusCodec, 48000, true, 48000); 670 } 671 672 TEST_F(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthFixedRateAsCaller) { 673 EXPECT_TRUE(SetupEngine()); 674 EXPECT_TRUE(channel_->SetSendCodecs(engine_.codecs())); 675 676 // Test that we can only set a maximum bitrate for a fixed-rate codec 677 // if it's bigger than the fixed rate. 678 679 // PCMU, fixed bitrate == 64000. 680 TestSendBandwidth(kPcmuCodec, 0, true, 64000); 681 TestSendBandwidth(kPcmuCodec, 1, false, 64000); 682 TestSendBandwidth(kPcmuCodec, 128000, true, 64000); 683 TestSendBandwidth(kPcmuCodec, 32000, false, 64000); 684 TestSendBandwidth(kPcmuCodec, 64000, true, 64000); 685 TestSendBandwidth(kPcmuCodec, 63999, false, 64000); 686 TestSendBandwidth(kPcmuCodec, 64001, true, 64000); 687 } 688 689 TEST_F(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthMultiRateAsCallee) { 690 EXPECT_TRUE(engine_.Init(rtc::Thread::Current())); 691 channel_ = engine_.CreateChannel(); 692 EXPECT_TRUE(channel_ != NULL); 693 EXPECT_TRUE(channel_->SetSendCodecs(engine_.codecs())); 694 695 int desired_bitrate = 128000; 696 EXPECT_TRUE(channel_->SetMaxSendBandwidth(desired_bitrate)); 697 698 EXPECT_TRUE(channel_->AddSendStream( 699 cricket::StreamParams::CreateLegacy(kSsrc1))); 700 701 int channel_num = voe_.GetLastChannel(); 702 webrtc::CodecInst codec; 703 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, codec)); 704 EXPECT_EQ(desired_bitrate, codec.rate); 705 } 706 707 // Test that bitrate cannot be set for CBR codecs. 708 // Bitrate is ignored if it is higher than the fixed bitrate. 709 // Bitrate less then the fixed bitrate is an error. 710 TEST_F(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthCbr) { 711 EXPECT_TRUE(SetupEngine()); 712 EXPECT_TRUE(channel_->SetSendCodecs(engine_.codecs())); 713 714 webrtc::CodecInst codec; 715 int channel_num = voe_.GetLastChannel(); 716 std::vector<cricket::AudioCodec> codecs; 717 718 // PCMU, default bitrate == 64000. 719 codecs.push_back(kPcmuCodec); 720 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 721 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, codec)); 722 EXPECT_EQ(64000, codec.rate); 723 EXPECT_TRUE(channel_->SetMaxSendBandwidth(128000)); 724 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, codec)); 725 EXPECT_EQ(64000, codec.rate); 726 EXPECT_FALSE(channel_->SetMaxSendBandwidth(128)); 727 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, codec)); 728 EXPECT_EQ(64000, codec.rate); 729 } 730 731 // Test that we apply codecs properly. 732 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecs) { 733 EXPECT_TRUE(SetupEngine()); 734 int channel_num = voe_.GetLastChannel(); 735 std::vector<cricket::AudioCodec> codecs; 736 codecs.push_back(kIsacCodec); 737 codecs.push_back(kPcmuCodec); 738 codecs.push_back(kRedCodec); 739 codecs[0].id = 96; 740 codecs[0].bitrate = 48000; 741 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 742 EXPECT_EQ(1, voe_.GetNumSetSendCodecs()); 743 webrtc::CodecInst gcodec; 744 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); 745 EXPECT_EQ(96, gcodec.pltype); 746 EXPECT_EQ(48000, gcodec.rate); 747 EXPECT_STREQ("ISAC", gcodec.plname); 748 EXPECT_FALSE(voe_.GetVAD(channel_num)); 749 EXPECT_FALSE(voe_.GetRED(channel_num)); 750 EXPECT_EQ(13, voe_.GetSendCNPayloadType(channel_num, false)); 751 EXPECT_EQ(105, voe_.GetSendCNPayloadType(channel_num, true)); 752 EXPECT_EQ(106, voe_.GetSendTelephoneEventPayloadType(channel_num)); 753 } 754 755 // Test that VoE Channel doesn't call SetSendCodec again if same codec is tried 756 // to apply. 757 TEST_F(WebRtcVoiceEngineTestFake, DontResetSetSendCodec) { 758 EXPECT_TRUE(SetupEngine()); 759 std::vector<cricket::AudioCodec> codecs; 760 codecs.push_back(kIsacCodec); 761 codecs.push_back(kPcmuCodec); 762 codecs.push_back(kRedCodec); 763 codecs[0].id = 96; 764 codecs[0].bitrate = 48000; 765 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 766 EXPECT_EQ(1, voe_.GetNumSetSendCodecs()); 767 // Calling SetSendCodec again with same codec which is already set. 768 // In this case media channel shouldn't send codec to VoE. 769 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 770 EXPECT_EQ(1, voe_.GetNumSetSendCodecs()); 771 } 772 773 // Test that if clockrate is not 48000 for opus, we fail. 774 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusBadClockrate) { 775 EXPECT_TRUE(SetupEngine()); 776 std::vector<cricket::AudioCodec> codecs; 777 codecs.push_back(kOpusCodec); 778 codecs[0].bitrate = 0; 779 codecs[0].clockrate = 50000; 780 EXPECT_FALSE(channel_->SetSendCodecs(codecs)); 781 } 782 783 // Test that if channels=0 for opus, we fail. 784 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusBad0ChannelsNoStereo) { 785 EXPECT_TRUE(SetupEngine()); 786 std::vector<cricket::AudioCodec> codecs; 787 codecs.push_back(kOpusCodec); 788 codecs[0].bitrate = 0; 789 codecs[0].channels = 0; 790 EXPECT_FALSE(channel_->SetSendCodecs(codecs)); 791 } 792 793 // Test that if channels=0 for opus, we fail. 794 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusBad0Channels1Stereo) { 795 EXPECT_TRUE(SetupEngine()); 796 std::vector<cricket::AudioCodec> codecs; 797 codecs.push_back(kOpusCodec); 798 codecs[0].bitrate = 0; 799 codecs[0].channels = 0; 800 codecs[0].params["stereo"] = "1"; 801 EXPECT_FALSE(channel_->SetSendCodecs(codecs)); 802 } 803 804 // Test that if channel is 1 for opus and there's no stereo, we fail. 805 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpus1ChannelNoStereo) { 806 EXPECT_TRUE(SetupEngine()); 807 std::vector<cricket::AudioCodec> codecs; 808 codecs.push_back(kOpusCodec); 809 codecs[0].bitrate = 0; 810 codecs[0].channels = 1; 811 EXPECT_FALSE(channel_->SetSendCodecs(codecs)); 812 } 813 814 // Test that if channel is 1 for opus and stereo=0, we fail. 815 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusBad1Channel0Stereo) { 816 EXPECT_TRUE(SetupEngine()); 817 std::vector<cricket::AudioCodec> codecs; 818 codecs.push_back(kOpusCodec); 819 codecs[0].bitrate = 0; 820 codecs[0].channels = 1; 821 codecs[0].params["stereo"] = "0"; 822 EXPECT_FALSE(channel_->SetSendCodecs(codecs)); 823 } 824 825 // Test that if channel is 1 for opus and stereo=1, we fail. 826 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusBad1Channel1Stereo) { 827 EXPECT_TRUE(SetupEngine()); 828 std::vector<cricket::AudioCodec> codecs; 829 codecs.push_back(kOpusCodec); 830 codecs[0].bitrate = 0; 831 codecs[0].channels = 1; 832 codecs[0].params["stereo"] = "1"; 833 EXPECT_FALSE(channel_->SetSendCodecs(codecs)); 834 } 835 836 // Test that with bitrate=0 and no stereo, 837 // channels and bitrate are 1 and 32000. 838 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGood0BitrateNoStereo) { 839 EXPECT_TRUE(SetupEngine()); 840 int channel_num = voe_.GetLastChannel(); 841 std::vector<cricket::AudioCodec> codecs; 842 codecs.push_back(kOpusCodec); 843 codecs[0].bitrate = 0; 844 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 845 webrtc::CodecInst gcodec; 846 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); 847 EXPECT_STREQ("opus", gcodec.plname); 848 EXPECT_EQ(1, gcodec.channels); 849 EXPECT_EQ(32000, gcodec.rate); 850 } 851 852 // Test that with bitrate=0 and stereo=0, 853 // channels and bitrate are 1 and 32000. 854 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGood0Bitrate0Stereo) { 855 EXPECT_TRUE(SetupEngine()); 856 int channel_num = voe_.GetLastChannel(); 857 std::vector<cricket::AudioCodec> codecs; 858 codecs.push_back(kOpusCodec); 859 codecs[0].bitrate = 0; 860 codecs[0].params["stereo"] = "0"; 861 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 862 webrtc::CodecInst gcodec; 863 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); 864 EXPECT_STREQ("opus", gcodec.plname); 865 EXPECT_EQ(1, gcodec.channels); 866 EXPECT_EQ(32000, gcodec.rate); 867 } 868 869 // Test that with bitrate=invalid and stereo=0, 870 // channels and bitrate are 1 and 32000. 871 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodXBitrate0Stereo) { 872 EXPECT_TRUE(SetupEngine()); 873 int channel_num = voe_.GetLastChannel(); 874 std::vector<cricket::AudioCodec> codecs; 875 codecs.push_back(kOpusCodec); 876 codecs[0].params["stereo"] = "0"; 877 webrtc::CodecInst gcodec; 878 879 // bitrate that's out of the range between 6000 and 510000 will be considered 880 // as invalid and ignored. 881 codecs[0].bitrate = 5999; 882 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 883 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); 884 EXPECT_STREQ("opus", gcodec.plname); 885 EXPECT_EQ(1, gcodec.channels); 886 EXPECT_EQ(32000, gcodec.rate); 887 888 codecs[0].bitrate = 510001; 889 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 890 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); 891 EXPECT_STREQ("opus", gcodec.plname); 892 EXPECT_EQ(1, gcodec.channels); 893 EXPECT_EQ(32000, gcodec.rate); 894 } 895 896 // Test that with bitrate=0 and stereo=1, 897 // channels and bitrate are 2 and 64000. 898 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGood0Bitrate1Stereo) { 899 EXPECT_TRUE(SetupEngine()); 900 int channel_num = voe_.GetLastChannel(); 901 std::vector<cricket::AudioCodec> codecs; 902 codecs.push_back(kOpusCodec); 903 codecs[0].bitrate = 0; 904 codecs[0].params["stereo"] = "1"; 905 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 906 webrtc::CodecInst gcodec; 907 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); 908 EXPECT_STREQ("opus", gcodec.plname); 909 EXPECT_EQ(2, gcodec.channels); 910 EXPECT_EQ(64000, gcodec.rate); 911 } 912 913 // Test that with bitrate=invalid and stereo=1, 914 // channels and bitrate are 2 and 64000. 915 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodXBitrate1Stereo) { 916 EXPECT_TRUE(SetupEngine()); 917 int channel_num = voe_.GetLastChannel(); 918 std::vector<cricket::AudioCodec> codecs; 919 codecs.push_back(kOpusCodec); 920 codecs[0].params["stereo"] = "1"; 921 webrtc::CodecInst gcodec; 922 923 // bitrate that's out of the range between 6000 and 510000 will be considered 924 // as invalid and ignored. 925 codecs[0].bitrate = 5999; 926 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 927 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); 928 EXPECT_STREQ("opus", gcodec.plname); 929 EXPECT_EQ(2, gcodec.channels); 930 EXPECT_EQ(64000, gcodec.rate); 931 932 codecs[0].bitrate = 510001; 933 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 934 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); 935 EXPECT_STREQ("opus", gcodec.plname); 936 EXPECT_EQ(2, gcodec.channels); 937 EXPECT_EQ(64000, gcodec.rate); 938 } 939 940 // Test that with bitrate=N and stereo unset, 941 // channels and bitrate are 1 and N. 942 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrateNoStereo) { 943 EXPECT_TRUE(SetupEngine()); 944 int channel_num = voe_.GetLastChannel(); 945 std::vector<cricket::AudioCodec> codecs; 946 codecs.push_back(kOpusCodec); 947 codecs[0].bitrate = 96000; 948 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 949 webrtc::CodecInst gcodec; 950 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); 951 EXPECT_EQ(111, gcodec.pltype); 952 EXPECT_EQ(96000, gcodec.rate); 953 EXPECT_STREQ("opus", gcodec.plname); 954 EXPECT_EQ(1, gcodec.channels); 955 EXPECT_EQ(48000, gcodec.plfreq); 956 } 957 958 // Test that with bitrate=N and stereo=0, 959 // channels and bitrate are 1 and N. 960 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrate0Stereo) { 961 EXPECT_TRUE(SetupEngine()); 962 int channel_num = voe_.GetLastChannel(); 963 std::vector<cricket::AudioCodec> codecs; 964 codecs.push_back(kOpusCodec); 965 codecs[0].bitrate = 30000; 966 codecs[0].params["stereo"] = "0"; 967 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 968 webrtc::CodecInst gcodec; 969 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); 970 EXPECT_EQ(1, gcodec.channels); 971 EXPECT_EQ(30000, gcodec.rate); 972 EXPECT_STREQ("opus", gcodec.plname); 973 } 974 975 // Test that with bitrate=N and without any parameters, 976 // channels and bitrate are 1 and N. 977 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrateNoParameters) { 978 EXPECT_TRUE(SetupEngine()); 979 int channel_num = voe_.GetLastChannel(); 980 std::vector<cricket::AudioCodec> codecs; 981 codecs.push_back(kOpusCodec); 982 codecs[0].bitrate = 30000; 983 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 984 webrtc::CodecInst gcodec; 985 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); 986 EXPECT_EQ(1, gcodec.channels); 987 EXPECT_EQ(30000, gcodec.rate); 988 EXPECT_STREQ("opus", gcodec.plname); 989 } 990 991 // Test that with bitrate=N and stereo=1, 992 // channels and bitrate are 2 and N. 993 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrate1Stereo) { 994 EXPECT_TRUE(SetupEngine()); 995 int channel_num = voe_.GetLastChannel(); 996 std::vector<cricket::AudioCodec> codecs; 997 codecs.push_back(kOpusCodec); 998 codecs[0].bitrate = 30000; 999 codecs[0].params["stereo"] = "1"; 1000 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 1001 webrtc::CodecInst gcodec; 1002 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); 1003 EXPECT_EQ(2, gcodec.channels); 1004 EXPECT_EQ(30000, gcodec.rate); 1005 EXPECT_STREQ("opus", gcodec.plname); 1006 } 1007 1008 // Test that bitrate will be overridden by the "maxaveragebitrate" parameter. 1009 // Also test that the "maxaveragebitrate" can't be set to values outside the 1010 // range of 6000 and 510000 1011 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusMaxAverageBitrate) { 1012 EXPECT_TRUE(SetupEngine()); 1013 int channel_num = voe_.GetLastChannel(); 1014 std::vector<cricket::AudioCodec> codecs; 1015 codecs.push_back(kOpusCodec); 1016 codecs[0].bitrate = 30000; 1017 webrtc::CodecInst gcodec; 1018 1019 // Ignore if less than 6000. 1020 codecs[0].params["maxaveragebitrate"] = "5999"; 1021 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 1022 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); 1023 EXPECT_EQ(30000, gcodec.rate); 1024 1025 // Ignore if larger than 510000. 1026 codecs[0].params["maxaveragebitrate"] = "510001"; 1027 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 1028 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); 1029 EXPECT_EQ(30000, gcodec.rate); 1030 1031 codecs[0].params["maxaveragebitrate"] = "200000"; 1032 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 1033 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); 1034 EXPECT_EQ(200000, gcodec.rate); 1035 } 1036 1037 // Test that we can enable NACK with opus as caller. 1038 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecEnableNackAsCaller) { 1039 EXPECT_TRUE(SetupEngine()); 1040 int channel_num = voe_.GetLastChannel(); 1041 std::vector<cricket::AudioCodec> codecs; 1042 codecs.push_back(kOpusCodec); 1043 codecs[0].AddFeedbackParam(cricket::FeedbackParam(cricket::kRtcpFbParamNack, 1044 cricket::kParamValueEmpty)); 1045 EXPECT_FALSE(voe_.GetNACK(channel_num)); 1046 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 1047 EXPECT_TRUE(voe_.GetNACK(channel_num)); 1048 } 1049 1050 // Test that we can enable NACK with opus as callee. 1051 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecEnableNackAsCallee) { 1052 EXPECT_TRUE(engine_.Init(rtc::Thread::Current())); 1053 channel_ = engine_.CreateChannel(); 1054 EXPECT_TRUE(channel_ != NULL); 1055 1056 int channel_num = voe_.GetLastChannel(); 1057 std::vector<cricket::AudioCodec> codecs; 1058 codecs.push_back(kOpusCodec); 1059 codecs[0].AddFeedbackParam(cricket::FeedbackParam(cricket::kRtcpFbParamNack, 1060 cricket::kParamValueEmpty)); 1061 EXPECT_FALSE(voe_.GetNACK(channel_num)); 1062 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 1063 EXPECT_FALSE(voe_.GetNACK(channel_num)); 1064 1065 EXPECT_TRUE(channel_->AddSendStream( 1066 cricket::StreamParams::CreateLegacy(kSsrc1))); 1067 EXPECT_TRUE(voe_.GetNACK(channel_num)); 1068 } 1069 1070 // Test that we can enable NACK on receive streams. 1071 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecEnableNackRecvStreams) { 1072 EXPECT_TRUE(SetupEngine()); 1073 EXPECT_TRUE(channel_->SetOptions(options_conference_)); 1074 int channel_num1 = voe_.GetLastChannel(); 1075 EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(2))); 1076 int channel_num2 = voe_.GetLastChannel(); 1077 std::vector<cricket::AudioCodec> codecs; 1078 codecs.push_back(kOpusCodec); 1079 codecs[0].AddFeedbackParam(cricket::FeedbackParam(cricket::kRtcpFbParamNack, 1080 cricket::kParamValueEmpty)); 1081 EXPECT_FALSE(voe_.GetNACK(channel_num1)); 1082 EXPECT_FALSE(voe_.GetNACK(channel_num2)); 1083 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 1084 EXPECT_TRUE(voe_.GetNACK(channel_num1)); 1085 EXPECT_TRUE(voe_.GetNACK(channel_num2)); 1086 } 1087 1088 // Test that we can disable NACK. 1089 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecDisableNack) { 1090 EXPECT_TRUE(SetupEngine()); 1091 int channel_num = voe_.GetLastChannel(); 1092 std::vector<cricket::AudioCodec> codecs; 1093 codecs.push_back(kOpusCodec); 1094 codecs[0].AddFeedbackParam(cricket::FeedbackParam(cricket::kRtcpFbParamNack, 1095 cricket::kParamValueEmpty)); 1096 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 1097 EXPECT_TRUE(voe_.GetNACK(channel_num)); 1098 1099 codecs.clear(); 1100 codecs.push_back(kOpusCodec); 1101 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 1102 EXPECT_FALSE(voe_.GetNACK(channel_num)); 1103 } 1104 1105 // Test that we can disable NACK on receive streams. 1106 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecDisableNackRecvStreams) { 1107 EXPECT_TRUE(SetupEngine()); 1108 EXPECT_TRUE(channel_->SetOptions(options_conference_)); 1109 int channel_num1 = voe_.GetLastChannel(); 1110 EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(2))); 1111 int channel_num2 = voe_.GetLastChannel(); 1112 std::vector<cricket::AudioCodec> codecs; 1113 codecs.push_back(kOpusCodec); 1114 codecs[0].AddFeedbackParam(cricket::FeedbackParam(cricket::kRtcpFbParamNack, 1115 cricket::kParamValueEmpty)); 1116 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 1117 EXPECT_TRUE(voe_.GetNACK(channel_num1)); 1118 EXPECT_TRUE(voe_.GetNACK(channel_num2)); 1119 1120 codecs.clear(); 1121 codecs.push_back(kOpusCodec); 1122 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 1123 EXPECT_FALSE(voe_.GetNACK(channel_num1)); 1124 EXPECT_FALSE(voe_.GetNACK(channel_num2)); 1125 } 1126 1127 // Test that NACK is enabled on a new receive stream. 1128 TEST_F(WebRtcVoiceEngineTestFake, AddRecvStreamEnableNack) { 1129 EXPECT_TRUE(SetupEngine()); 1130 EXPECT_TRUE(channel_->SetOptions(options_conference_)); 1131 int channel_num = voe_.GetLastChannel(); 1132 std::vector<cricket::AudioCodec> codecs; 1133 codecs.push_back(kIsacCodec); 1134 codecs[0].AddFeedbackParam(cricket::FeedbackParam(cricket::kRtcpFbParamNack, 1135 cricket::kParamValueEmpty)); 1136 codecs.push_back(kCn16000Codec); 1137 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 1138 EXPECT_TRUE(voe_.GetNACK(channel_num)); 1139 1140 EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(2))); 1141 channel_num = voe_.GetLastChannel(); 1142 EXPECT_TRUE(voe_.GetNACK(channel_num)); 1143 EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(3))); 1144 channel_num = voe_.GetLastChannel(); 1145 EXPECT_TRUE(voe_.GetNACK(channel_num)); 1146 } 1147 1148 #ifdef USE_WEBRTC_DEV_BRANCH 1149 // Test that without useinbandfec, Opus FEC is off. 1150 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecNoOpusFec) { 1151 EXPECT_TRUE(SetupEngine()); 1152 int channel_num = voe_.GetLastChannel(); 1153 std::vector<cricket::AudioCodec> codecs; 1154 codecs.push_back(kOpusCodec); 1155 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 1156 EXPECT_FALSE(voe_.GetCodecFEC(channel_num)); 1157 } 1158 1159 // Test that with useinbandfec=0, Opus FEC is off. 1160 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusDisableFec) { 1161 EXPECT_TRUE(SetupEngine()); 1162 int channel_num = voe_.GetLastChannel(); 1163 std::vector<cricket::AudioCodec> codecs; 1164 codecs.push_back(kOpusCodec); 1165 codecs[0].bitrate = 0; 1166 codecs[0].params["useinbandfec"] = "0"; 1167 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 1168 EXPECT_FALSE(voe_.GetCodecFEC(channel_num)); 1169 webrtc::CodecInst gcodec; 1170 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); 1171 EXPECT_STREQ("opus", gcodec.plname); 1172 EXPECT_EQ(1, gcodec.channels); 1173 EXPECT_EQ(32000, gcodec.rate); 1174 } 1175 1176 // Test that with useinbandfec=1, Opus FEC is on. 1177 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusEnableFec) { 1178 EXPECT_TRUE(SetupEngine()); 1179 int channel_num = voe_.GetLastChannel(); 1180 std::vector<cricket::AudioCodec> codecs; 1181 codecs.push_back(kOpusCodec); 1182 codecs[0].bitrate = 0; 1183 codecs[0].params["useinbandfec"] = "1"; 1184 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 1185 EXPECT_TRUE(voe_.GetCodecFEC(channel_num)); 1186 webrtc::CodecInst gcodec; 1187 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); 1188 EXPECT_STREQ("opus", gcodec.plname); 1189 EXPECT_EQ(1, gcodec.channels); 1190 EXPECT_EQ(32000, gcodec.rate); 1191 } 1192 1193 // Test that with useinbandfec=1, stereo=1, Opus FEC is on. 1194 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusEnableFecStereo) { 1195 EXPECT_TRUE(SetupEngine()); 1196 int channel_num = voe_.GetLastChannel(); 1197 std::vector<cricket::AudioCodec> codecs; 1198 codecs.push_back(kOpusCodec); 1199 codecs[0].bitrate = 0; 1200 codecs[0].params["stereo"] = "1"; 1201 codecs[0].params["useinbandfec"] = "1"; 1202 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 1203 EXPECT_TRUE(voe_.GetCodecFEC(channel_num)); 1204 webrtc::CodecInst gcodec; 1205 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); 1206 EXPECT_STREQ("opus", gcodec.plname); 1207 EXPECT_EQ(2, gcodec.channels); 1208 EXPECT_EQ(64000, gcodec.rate); 1209 } 1210 1211 // Test that with non-Opus, codec FEC is off. 1212 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecIsacNoFec) { 1213 EXPECT_TRUE(SetupEngine()); 1214 int channel_num = voe_.GetLastChannel(); 1215 std::vector<cricket::AudioCodec> codecs; 1216 codecs.push_back(kIsacCodec); 1217 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 1218 EXPECT_FALSE(voe_.GetCodecFEC(channel_num)); 1219 } 1220 1221 // Test the with non-Opus, even if useinbandfec=1, FEC is off. 1222 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecIsacWithParamNoFec) { 1223 EXPECT_TRUE(SetupEngine()); 1224 int channel_num = voe_.GetLastChannel(); 1225 std::vector<cricket::AudioCodec> codecs; 1226 codecs.push_back(kIsacCodec); 1227 codecs[0].params["useinbandfec"] = "1"; 1228 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 1229 EXPECT_FALSE(voe_.GetCodecFEC(channel_num)); 1230 } 1231 1232 // Test that Opus FEC status can be changed. 1233 TEST_F(WebRtcVoiceEngineTestFake, ChangeOpusFecStatus) { 1234 EXPECT_TRUE(SetupEngine()); 1235 int channel_num = voe_.GetLastChannel(); 1236 std::vector<cricket::AudioCodec> codecs; 1237 codecs.push_back(kOpusCodec); 1238 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 1239 EXPECT_FALSE(voe_.GetCodecFEC(channel_num)); 1240 codecs[0].params["useinbandfec"] = "1"; 1241 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 1242 EXPECT_TRUE(voe_.GetCodecFEC(channel_num)); 1243 } 1244 1245 // Test maxplaybackrate <= 8000 triggers Opus narrow band mode. 1246 TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateNb) { 1247 EXPECT_TRUE(SetupEngine()); 1248 int channel_num = voe_.GetLastChannel(); 1249 std::vector<cricket::AudioCodec> codecs; 1250 codecs.push_back(kOpusCodec); 1251 codecs[0].bitrate = 0; 1252 codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 8000); 1253 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 1254 EXPECT_EQ(cricket::kOpusBandwidthNb, 1255 voe_.GetMaxEncodingBandwidth(channel_num)); 1256 webrtc::CodecInst gcodec; 1257 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); 1258 EXPECT_STREQ("opus", gcodec.plname); 1259 // TODO(minyue): Default bit rate is not but can in future be affected by 1260 // kCodecParamMaxPlaybackRate. 1261 EXPECT_EQ(32000, gcodec.rate); 1262 } 1263 1264 // Test 8000 < maxplaybackrate <= 12000 triggers Opus medium band mode. 1265 TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateMb) { 1266 EXPECT_TRUE(SetupEngine()); 1267 int channel_num = voe_.GetLastChannel(); 1268 std::vector<cricket::AudioCodec> codecs; 1269 codecs.push_back(kOpusCodec); 1270 codecs[0].bitrate = 0; 1271 codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 8001); 1272 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 1273 EXPECT_EQ(cricket::kOpusBandwidthMb, 1274 voe_.GetMaxEncodingBandwidth(channel_num)); 1275 webrtc::CodecInst gcodec; 1276 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); 1277 EXPECT_STREQ("opus", gcodec.plname); 1278 // TODO(minyue): Default bit rate is not but can in future be affected by 1279 // kCodecParamMaxPlaybackRate. 1280 EXPECT_EQ(32000, gcodec.rate); 1281 } 1282 1283 // Test 12000 < maxplaybackrate <= 16000 triggers Opus wide band mode. 1284 TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateWb) { 1285 EXPECT_TRUE(SetupEngine()); 1286 int channel_num = voe_.GetLastChannel(); 1287 std::vector<cricket::AudioCodec> codecs; 1288 codecs.push_back(kOpusCodec); 1289 codecs[0].bitrate = 0; 1290 codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 12001); 1291 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 1292 EXPECT_EQ(cricket::kOpusBandwidthWb, 1293 voe_.GetMaxEncodingBandwidth(channel_num)); 1294 webrtc::CodecInst gcodec; 1295 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); 1296 EXPECT_STREQ("opus", gcodec.plname); 1297 // TODO(minyue): Default bit rate is not but can in future be affected by 1298 // kCodecParamMaxPlaybackRate. 1299 EXPECT_EQ(32000, gcodec.rate); 1300 } 1301 1302 // Test 16000 < maxplaybackrate <= 24000 triggers Opus super wide band mode. 1303 TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateSwb) { 1304 EXPECT_TRUE(SetupEngine()); 1305 int channel_num = voe_.GetLastChannel(); 1306 std::vector<cricket::AudioCodec> codecs; 1307 codecs.push_back(kOpusCodec); 1308 codecs[0].bitrate = 0; 1309 codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 16001); 1310 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 1311 EXPECT_EQ(cricket::kOpusBandwidthSwb, 1312 voe_.GetMaxEncodingBandwidth(channel_num)); 1313 webrtc::CodecInst gcodec; 1314 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); 1315 EXPECT_STREQ("opus", gcodec.plname); 1316 // TODO(minyue): Default bit rate is not but can in future be affected by 1317 // kCodecParamMaxPlaybackRate. 1318 EXPECT_EQ(32000, gcodec.rate); 1319 } 1320 1321 // Test 24000 < maxplaybackrate triggers Opus full band mode. 1322 TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateFb) { 1323 EXPECT_TRUE(SetupEngine()); 1324 int channel_num = voe_.GetLastChannel(); 1325 std::vector<cricket::AudioCodec> codecs; 1326 codecs.push_back(kOpusCodec); 1327 codecs[0].bitrate = 0; 1328 codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 24001); 1329 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 1330 EXPECT_EQ(cricket::kOpusBandwidthFb, 1331 voe_.GetMaxEncodingBandwidth(channel_num)); 1332 webrtc::CodecInst gcodec; 1333 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); 1334 EXPECT_STREQ("opus", gcodec.plname); 1335 // TODO(minyue): Default bit rate is not but can in future be affected by 1336 // kCodecParamMaxPlaybackRate. 1337 EXPECT_EQ(32000, gcodec.rate); 1338 } 1339 1340 // Test Opus that without maxplaybackrate, default playback rate is used. 1341 TEST_F(WebRtcVoiceEngineTestFake, DefaultOpusMaxPlaybackRate) { 1342 EXPECT_TRUE(SetupEngine()); 1343 int channel_num = voe_.GetLastChannel(); 1344 std::vector<cricket::AudioCodec> codecs; 1345 codecs.push_back(kOpusCodec); 1346 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 1347 EXPECT_EQ(cricket::kOpusBandwidthFb, 1348 voe_.GetMaxEncodingBandwidth(channel_num)); 1349 } 1350 1351 // Test the with non-Opus, maxplaybackrate has no effect. 1352 TEST_F(WebRtcVoiceEngineTestFake, SetNonOpusMaxPlaybackRate) { 1353 EXPECT_TRUE(SetupEngine()); 1354 int channel_num = voe_.GetLastChannel(); 1355 std::vector<cricket::AudioCodec> codecs; 1356 codecs.push_back(kIsacCodec); 1357 codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 32000); 1358 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 1359 EXPECT_EQ(0, voe_.GetMaxEncodingBandwidth(channel_num)); 1360 } 1361 1362 // Test maxplaybackrate can be set on two streams. 1363 TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateOnTwoStreams) { 1364 EXPECT_TRUE(SetupEngine()); 1365 int channel_num = voe_.GetLastChannel(); 1366 std::vector<cricket::AudioCodec> codecs; 1367 codecs.push_back(kOpusCodec); 1368 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 1369 // Default bandwidth is 24000. 1370 EXPECT_EQ(cricket::kOpusBandwidthFb, 1371 voe_.GetMaxEncodingBandwidth(channel_num)); 1372 1373 codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 8000); 1374 1375 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 1376 EXPECT_EQ(cricket::kOpusBandwidthNb, 1377 voe_.GetMaxEncodingBandwidth(channel_num)); 1378 1379 channel_->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc2)); 1380 channel_num = voe_.GetLastChannel(); 1381 EXPECT_EQ(cricket::kOpusBandwidthNb, 1382 voe_.GetMaxEncodingBandwidth(channel_num)); 1383 } 1384 #endif // USE_WEBRTC_DEV_BRANCH 1385 1386 // Test that we can apply CELT with stereo mode but fail with mono mode. 1387 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCelt) { 1388 EXPECT_TRUE(SetupEngine()); 1389 int channel_num = voe_.GetLastChannel(); 1390 std::vector<cricket::AudioCodec> codecs; 1391 codecs.push_back(kCeltCodec); 1392 codecs.push_back(kIsacCodec); 1393 codecs[0].id = 96; 1394 codecs[0].channels = 2; 1395 codecs[0].bitrate = 96000; 1396 codecs[1].bitrate = 64000; 1397 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 1398 webrtc::CodecInst gcodec; 1399 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); 1400 EXPECT_EQ(96, gcodec.pltype); 1401 EXPECT_EQ(96000, gcodec.rate); 1402 EXPECT_EQ(2, gcodec.channels); 1403 EXPECT_STREQ("CELT", gcodec.plname); 1404 // Doesn't support mono, expect it to fall back to the next codec in the list. 1405 codecs[0].channels = 1; 1406 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 1407 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); 1408 EXPECT_EQ(103, gcodec.pltype); 1409 EXPECT_EQ(1, gcodec.channels); 1410 EXPECT_EQ(64000, gcodec.rate); 1411 EXPECT_STREQ("ISAC", gcodec.plname); 1412 } 1413 1414 // Test that we can switch back and forth between CELT and ISAC with CN. 1415 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsIsacCeltSwitching) { 1416 EXPECT_TRUE(SetupEngine()); 1417 int channel_num = voe_.GetLastChannel(); 1418 std::vector<cricket::AudioCodec> celt_codecs; 1419 celt_codecs.push_back(kCeltCodec); 1420 EXPECT_TRUE(channel_->SetSendCodecs(celt_codecs)); 1421 webrtc::CodecInst gcodec; 1422 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); 1423 EXPECT_EQ(110, gcodec.pltype); 1424 EXPECT_STREQ("CELT", gcodec.plname); 1425 1426 std::vector<cricket::AudioCodec> isac_codecs; 1427 isac_codecs.push_back(kIsacCodec); 1428 isac_codecs.push_back(kCn16000Codec); 1429 isac_codecs.push_back(kCeltCodec); 1430 EXPECT_TRUE(channel_->SetSendCodecs(isac_codecs)); 1431 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); 1432 EXPECT_EQ(103, gcodec.pltype); 1433 EXPECT_STREQ("ISAC", gcodec.plname); 1434 1435 EXPECT_TRUE(channel_->SetSendCodecs(celt_codecs)); 1436 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); 1437 EXPECT_EQ(110, gcodec.pltype); 1438 EXPECT_STREQ("CELT", gcodec.plname); 1439 } 1440 1441 // Test that we handle various ways of specifying bitrate. 1442 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsBitrate) { 1443 EXPECT_TRUE(SetupEngine()); 1444 int channel_num = voe_.GetLastChannel(); 1445 std::vector<cricket::AudioCodec> codecs; 1446 codecs.push_back(kIsacCodec); // bitrate == 32000 1447 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 1448 webrtc::CodecInst gcodec; 1449 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); 1450 EXPECT_EQ(103, gcodec.pltype); 1451 EXPECT_STREQ("ISAC", gcodec.plname); 1452 EXPECT_EQ(32000, gcodec.rate); 1453 1454 codecs[0].bitrate = 0; // bitrate == default 1455 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 1456 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); 1457 EXPECT_EQ(103, gcodec.pltype); 1458 EXPECT_STREQ("ISAC", gcodec.plname); 1459 EXPECT_EQ(-1, gcodec.rate); 1460 1461 codecs[0].bitrate = 28000; // bitrate == 28000 1462 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 1463 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); 1464 EXPECT_EQ(103, gcodec.pltype); 1465 EXPECT_STREQ("ISAC", gcodec.plname); 1466 EXPECT_EQ(28000, gcodec.rate); 1467 1468 codecs[0] = kPcmuCodec; // bitrate == 64000 1469 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 1470 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); 1471 EXPECT_EQ(0, gcodec.pltype); 1472 EXPECT_STREQ("PCMU", gcodec.plname); 1473 EXPECT_EQ(64000, gcodec.rate); 1474 1475 codecs[0].bitrate = 0; // bitrate == default 1476 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 1477 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); 1478 EXPECT_EQ(0, gcodec.pltype); 1479 EXPECT_STREQ("PCMU", gcodec.plname); 1480 EXPECT_EQ(64000, gcodec.rate); 1481 1482 codecs[0] = kOpusCodec; 1483 codecs[0].bitrate = 0; // bitrate == default 1484 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 1485 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); 1486 EXPECT_EQ(111, gcodec.pltype); 1487 EXPECT_STREQ("opus", gcodec.plname); 1488 EXPECT_EQ(32000, gcodec.rate); 1489 } 1490 1491 // Test that we fail if no codecs are specified. 1492 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsNoCodecs) { 1493 EXPECT_TRUE(SetupEngine()); 1494 std::vector<cricket::AudioCodec> codecs; 1495 EXPECT_FALSE(channel_->SetSendCodecs(codecs)); 1496 } 1497 1498 // Test that we can set send codecs even with telephone-event codec as the first 1499 // one on the list. 1500 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsDTMFOnTop) { 1501 EXPECT_TRUE(SetupEngine()); 1502 int channel_num = voe_.GetLastChannel(); 1503 std::vector<cricket::AudioCodec> codecs; 1504 codecs.push_back(kTelephoneEventCodec); 1505 codecs.push_back(kIsacCodec); 1506 codecs.push_back(kPcmuCodec); 1507 codecs[0].id = 98; // DTMF 1508 codecs[1].id = 96; 1509 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 1510 webrtc::CodecInst gcodec; 1511 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); 1512 EXPECT_EQ(96, gcodec.pltype); 1513 EXPECT_STREQ("ISAC", gcodec.plname); 1514 EXPECT_EQ(98, voe_.GetSendTelephoneEventPayloadType(channel_num)); 1515 } 1516 1517 // Test that we can set send codecs even with CN codec as the first 1518 // one on the list. 1519 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNOnTop) { 1520 EXPECT_TRUE(SetupEngine()); 1521 int channel_num = voe_.GetLastChannel(); 1522 std::vector<cricket::AudioCodec> codecs; 1523 codecs.push_back(kCn16000Codec); 1524 codecs.push_back(kIsacCodec); 1525 codecs.push_back(kPcmuCodec); 1526 codecs[0].id = 98; // wideband CN 1527 codecs[1].id = 96; 1528 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 1529 webrtc::CodecInst gcodec; 1530 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); 1531 EXPECT_EQ(96, gcodec.pltype); 1532 EXPECT_STREQ("ISAC", gcodec.plname); 1533 EXPECT_EQ(98, voe_.GetSendCNPayloadType(channel_num, true)); 1534 } 1535 1536 // Test that we set VAD and DTMF types correctly as caller. 1537 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNandDTMFAsCaller) { 1538 EXPECT_TRUE(SetupEngine()); 1539 int channel_num = voe_.GetLastChannel(); 1540 std::vector<cricket::AudioCodec> codecs; 1541 codecs.push_back(kIsacCodec); 1542 codecs.push_back(kPcmuCodec); 1543 // TODO(juberti): cn 32000 1544 codecs.push_back(kCn16000Codec); 1545 codecs.push_back(kCn8000Codec); 1546 codecs.push_back(kTelephoneEventCodec); 1547 codecs.push_back(kRedCodec); 1548 codecs[0].id = 96; 1549 codecs[2].id = 97; // wideband CN 1550 codecs[4].id = 98; // DTMF 1551 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 1552 webrtc::CodecInst gcodec; 1553 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); 1554 EXPECT_EQ(96, gcodec.pltype); 1555 EXPECT_STREQ("ISAC", gcodec.plname); 1556 EXPECT_TRUE(voe_.GetVAD(channel_num)); 1557 EXPECT_FALSE(voe_.GetRED(channel_num)); 1558 EXPECT_EQ(13, voe_.GetSendCNPayloadType(channel_num, false)); 1559 EXPECT_EQ(97, voe_.GetSendCNPayloadType(channel_num, true)); 1560 EXPECT_EQ(98, voe_.GetSendTelephoneEventPayloadType(channel_num)); 1561 } 1562 1563 // Test that we set VAD and DTMF types correctly as callee. 1564 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNandDTMFAsCallee) { 1565 EXPECT_TRUE(engine_.Init(rtc::Thread::Current())); 1566 channel_ = engine_.CreateChannel(); 1567 EXPECT_TRUE(channel_ != NULL); 1568 1569 int channel_num = voe_.GetLastChannel(); 1570 std::vector<cricket::AudioCodec> codecs; 1571 codecs.push_back(kIsacCodec); 1572 codecs.push_back(kPcmuCodec); 1573 // TODO(juberti): cn 32000 1574 codecs.push_back(kCn16000Codec); 1575 codecs.push_back(kCn8000Codec); 1576 codecs.push_back(kTelephoneEventCodec); 1577 codecs.push_back(kRedCodec); 1578 codecs[0].id = 96; 1579 codecs[2].id = 97; // wideband CN 1580 codecs[4].id = 98; // DTMF 1581 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 1582 EXPECT_TRUE(channel_->AddSendStream( 1583 cricket::StreamParams::CreateLegacy(kSsrc1))); 1584 1585 webrtc::CodecInst gcodec; 1586 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); 1587 EXPECT_EQ(96, gcodec.pltype); 1588 EXPECT_STREQ("ISAC", gcodec.plname); 1589 EXPECT_TRUE(voe_.GetVAD(channel_num)); 1590 EXPECT_FALSE(voe_.GetRED(channel_num)); 1591 EXPECT_EQ(13, voe_.GetSendCNPayloadType(channel_num, false)); 1592 EXPECT_EQ(97, voe_.GetSendCNPayloadType(channel_num, true)); 1593 EXPECT_EQ(98, voe_.GetSendTelephoneEventPayloadType(channel_num)); 1594 } 1595 1596 // Test that we only apply VAD if we have a CN codec that matches the 1597 // send codec clockrate. 1598 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNNoMatch) { 1599 EXPECT_TRUE(SetupEngine()); 1600 int channel_num = voe_.GetLastChannel(); 1601 std::vector<cricket::AudioCodec> codecs; 1602 // Set ISAC(16K) and CN(16K). VAD should be activated. 1603 codecs.push_back(kIsacCodec); 1604 codecs.push_back(kCn16000Codec); 1605 codecs[1].id = 97; 1606 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 1607 webrtc::CodecInst gcodec; 1608 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); 1609 EXPECT_STREQ("ISAC", gcodec.plname); 1610 EXPECT_TRUE(voe_.GetVAD(channel_num)); 1611 EXPECT_EQ(97, voe_.GetSendCNPayloadType(channel_num, true)); 1612 // Set PCMU(8K) and CN(16K). VAD should not be activated. 1613 codecs[0] = kPcmuCodec; 1614 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 1615 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); 1616 EXPECT_STREQ("PCMU", gcodec.plname); 1617 EXPECT_FALSE(voe_.GetVAD(channel_num)); 1618 // Set PCMU(8K) and CN(8K). VAD should be activated. 1619 codecs[1] = kCn8000Codec; 1620 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 1621 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); 1622 EXPECT_STREQ("PCMU", gcodec.plname); 1623 EXPECT_TRUE(voe_.GetVAD(channel_num)); 1624 EXPECT_EQ(13, voe_.GetSendCNPayloadType(channel_num, false)); 1625 // Set ISAC(16K) and CN(8K). VAD should not be activated. 1626 codecs[0] = kIsacCodec; 1627 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 1628 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); 1629 EXPECT_STREQ("ISAC", gcodec.plname); 1630 EXPECT_FALSE(voe_.GetVAD(channel_num)); 1631 } 1632 1633 // Test that we perform case-insensitive matching of codec names. 1634 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCaseInsensitive) { 1635 EXPECT_TRUE(SetupEngine()); 1636 int channel_num = voe_.GetLastChannel(); 1637 std::vector<cricket::AudioCodec> codecs; 1638 codecs.push_back(kIsacCodec); 1639 codecs.push_back(kPcmuCodec); 1640 codecs.push_back(kCn16000Codec); 1641 codecs.push_back(kCn8000Codec); 1642 codecs.push_back(kTelephoneEventCodec); 1643 codecs.push_back(kRedCodec); 1644 codecs[0].name = "iSaC"; 1645 codecs[0].id = 96; 1646 codecs[2].id = 97; // wideband CN 1647 codecs[4].id = 98; // DTMF 1648 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 1649 webrtc::CodecInst gcodec; 1650 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); 1651 EXPECT_EQ(96, gcodec.pltype); 1652 EXPECT_STREQ("ISAC", gcodec.plname); 1653 EXPECT_TRUE(voe_.GetVAD(channel_num)); 1654 EXPECT_FALSE(voe_.GetRED(channel_num)); 1655 EXPECT_EQ(13, voe_.GetSendCNPayloadType(channel_num, false)); 1656 EXPECT_EQ(97, voe_.GetSendCNPayloadType(channel_num, true)); 1657 EXPECT_EQ(98, voe_.GetSendTelephoneEventPayloadType(channel_num)); 1658 } 1659 1660 // Test that we set up RED correctly as caller. 1661 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsREDAsCaller) { 1662 EXPECT_TRUE(SetupEngine()); 1663 int channel_num = voe_.GetLastChannel(); 1664 std::vector<cricket::AudioCodec> codecs; 1665 codecs.push_back(kRedCodec); 1666 codecs.push_back(kIsacCodec); 1667 codecs.push_back(kPcmuCodec); 1668 codecs[0].id = 127; 1669 codecs[0].params[""] = "96/96"; 1670 codecs[1].id = 96; 1671 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 1672 webrtc::CodecInst gcodec; 1673 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); 1674 EXPECT_EQ(96, gcodec.pltype); 1675 EXPECT_STREQ("ISAC", gcodec.plname); 1676 EXPECT_TRUE(voe_.GetRED(channel_num)); 1677 EXPECT_EQ(127, voe_.GetSendREDPayloadType(channel_num)); 1678 } 1679 1680 // Test that we set up RED correctly as callee. 1681 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsREDAsCallee) { 1682 EXPECT_TRUE(engine_.Init(rtc::Thread::Current())); 1683 channel_ = engine_.CreateChannel(); 1684 EXPECT_TRUE(channel_ != NULL); 1685 1686 int channel_num = voe_.GetLastChannel(); 1687 std::vector<cricket::AudioCodec> codecs; 1688 codecs.push_back(kRedCodec); 1689 codecs.push_back(kIsacCodec); 1690 codecs.push_back(kPcmuCodec); 1691 codecs[0].id = 127; 1692 codecs[0].params[""] = "96/96"; 1693 codecs[1].id = 96; 1694 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 1695 EXPECT_TRUE(channel_->AddSendStream( 1696 cricket::StreamParams::CreateLegacy(kSsrc1))); 1697 webrtc::CodecInst gcodec; 1698 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); 1699 EXPECT_EQ(96, gcodec.pltype); 1700 EXPECT_STREQ("ISAC", gcodec.plname); 1701 EXPECT_TRUE(voe_.GetRED(channel_num)); 1702 EXPECT_EQ(127, voe_.GetSendREDPayloadType(channel_num)); 1703 } 1704 1705 // Test that we set up RED correctly if params are omitted. 1706 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsREDNoParams) { 1707 EXPECT_TRUE(SetupEngine()); 1708 int channel_num = voe_.GetLastChannel(); 1709 std::vector<cricket::AudioCodec> codecs; 1710 codecs.push_back(kRedCodec); 1711 codecs.push_back(kIsacCodec); 1712 codecs.push_back(kPcmuCodec); 1713 codecs[0].id = 127; 1714 codecs[1].id = 96; 1715 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 1716 webrtc::CodecInst gcodec; 1717 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); 1718 EXPECT_EQ(96, gcodec.pltype); 1719 EXPECT_STREQ("ISAC", gcodec.plname); 1720 EXPECT_TRUE(voe_.GetRED(channel_num)); 1721 EXPECT_EQ(127, voe_.GetSendREDPayloadType(channel_num)); 1722 } 1723 1724 // Test that we ignore RED if the parameters aren't named the way we expect. 1725 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsBadRED1) { 1726 EXPECT_TRUE(SetupEngine()); 1727 int channel_num = voe_.GetLastChannel(); 1728 std::vector<cricket::AudioCodec> codecs; 1729 codecs.push_back(kRedCodec); 1730 codecs.push_back(kIsacCodec); 1731 codecs.push_back(kPcmuCodec); 1732 codecs[0].id = 127; 1733 codecs[0].params["ABC"] = "96/96"; 1734 codecs[1].id = 96; 1735 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 1736 webrtc::CodecInst gcodec; 1737 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); 1738 EXPECT_EQ(96, gcodec.pltype); 1739 EXPECT_STREQ("ISAC", gcodec.plname); 1740 EXPECT_FALSE(voe_.GetRED(channel_num)); 1741 } 1742 1743 // Test that we ignore RED if it uses different primary/secondary encoding. 1744 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsBadRED2) { 1745 EXPECT_TRUE(SetupEngine()); 1746 int channel_num = voe_.GetLastChannel(); 1747 std::vector<cricket::AudioCodec> codecs; 1748 codecs.push_back(kRedCodec); 1749 codecs.push_back(kIsacCodec); 1750 codecs.push_back(kPcmuCodec); 1751 codecs[0].id = 127; 1752 codecs[0].params[""] = "96/0"; 1753 codecs[1].id = 96; 1754 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 1755 webrtc::CodecInst gcodec; 1756 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); 1757 EXPECT_EQ(96, gcodec.pltype); 1758 EXPECT_STREQ("ISAC", gcodec.plname); 1759 EXPECT_FALSE(voe_.GetRED(channel_num)); 1760 } 1761 1762 // Test that we ignore RED if it uses more than 2 encodings. 1763 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsBadRED3) { 1764 EXPECT_TRUE(SetupEngine()); 1765 int channel_num = voe_.GetLastChannel(); 1766 std::vector<cricket::AudioCodec> codecs; 1767 codecs.push_back(kRedCodec); 1768 codecs.push_back(kIsacCodec); 1769 codecs.push_back(kPcmuCodec); 1770 codecs[0].id = 127; 1771 codecs[0].params[""] = "96/96/96"; 1772 codecs[1].id = 96; 1773 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 1774 webrtc::CodecInst gcodec; 1775 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); 1776 EXPECT_EQ(96, gcodec.pltype); 1777 EXPECT_STREQ("ISAC", gcodec.plname); 1778 EXPECT_FALSE(voe_.GetRED(channel_num)); 1779 } 1780 1781 // Test that we ignore RED if it has bogus codec ids. 1782 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsBadRED4) { 1783 EXPECT_TRUE(SetupEngine()); 1784 int channel_num = voe_.GetLastChannel(); 1785 std::vector<cricket::AudioCodec> codecs; 1786 codecs.push_back(kRedCodec); 1787 codecs.push_back(kIsacCodec); 1788 codecs.push_back(kPcmuCodec); 1789 codecs[0].id = 127; 1790 codecs[0].params[""] = "ABC/ABC"; 1791 codecs[1].id = 96; 1792 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 1793 webrtc::CodecInst gcodec; 1794 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); 1795 EXPECT_EQ(96, gcodec.pltype); 1796 EXPECT_STREQ("ISAC", gcodec.plname); 1797 EXPECT_FALSE(voe_.GetRED(channel_num)); 1798 } 1799 1800 // Test that we ignore RED if it refers to a codec that is not present. 1801 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsBadRED5) { 1802 EXPECT_TRUE(SetupEngine()); 1803 int channel_num = voe_.GetLastChannel(); 1804 std::vector<cricket::AudioCodec> codecs; 1805 codecs.push_back(kRedCodec); 1806 codecs.push_back(kIsacCodec); 1807 codecs.push_back(kPcmuCodec); 1808 codecs[0].id = 127; 1809 codecs[0].params[""] = "97/97"; 1810 codecs[1].id = 96; 1811 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 1812 webrtc::CodecInst gcodec; 1813 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); 1814 EXPECT_EQ(96, gcodec.pltype); 1815 EXPECT_STREQ("ISAC", gcodec.plname); 1816 EXPECT_FALSE(voe_.GetRED(channel_num)); 1817 } 1818 1819 // Test support for audio level header extension. 1820 TEST_F(WebRtcVoiceEngineTestFake, SendAudioLevelHeaderExtensions) { 1821 TestSetSendRtpHeaderExtensions(kRtpAudioLevelHeaderExtension); 1822 } 1823 TEST_F(WebRtcVoiceEngineTestFake, RecvAudioLevelHeaderExtensions) { 1824 TestSetRecvRtpHeaderExtensions(kRtpAudioLevelHeaderExtension); 1825 } 1826 1827 // Test support for absolute send time header extension. 1828 TEST_F(WebRtcVoiceEngineTestFake, SendAbsoluteSendTimeHeaderExtensions) { 1829 TestSetSendRtpHeaderExtensions(kRtpAbsoluteSenderTimeHeaderExtension); 1830 } 1831 TEST_F(WebRtcVoiceEngineTestFake, RecvAbsoluteSendTimeHeaderExtensions) { 1832 TestSetRecvRtpHeaderExtensions(kRtpAbsoluteSenderTimeHeaderExtension); 1833 } 1834 1835 // Test that we can create a channel and start sending/playing out on it. 1836 TEST_F(WebRtcVoiceEngineTestFake, SendAndPlayout) { 1837 EXPECT_TRUE(SetupEngine()); 1838 int channel_num = voe_.GetLastChannel(); 1839 std::vector<cricket::AudioCodec> codecs; 1840 codecs.push_back(kPcmuCodec); 1841 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 1842 EXPECT_TRUE(channel_->SetSend(cricket::SEND_MICROPHONE)); 1843 EXPECT_TRUE(voe_.GetSend(channel_num)); 1844 EXPECT_TRUE(channel_->SetPlayout(true)); 1845 EXPECT_TRUE(voe_.GetPlayout(channel_num)); 1846 EXPECT_TRUE(channel_->SetSend(cricket::SEND_NOTHING)); 1847 EXPECT_FALSE(voe_.GetSend(channel_num)); 1848 EXPECT_TRUE(channel_->SetPlayout(false)); 1849 EXPECT_FALSE(voe_.GetPlayout(channel_num)); 1850 } 1851 1852 // Test that we can add and remove send streams. 1853 TEST_F(WebRtcVoiceEngineTestFake, CreateAndDeleteMultipleSendStreams) { 1854 SetupForMultiSendStream(); 1855 1856 static const uint32 kSsrcs4[] = {1, 2, 3, 4}; 1857 1858 // Set the global state for sending. 1859 EXPECT_TRUE(channel_->SetSend(cricket::SEND_MICROPHONE)); 1860 1861 for (unsigned int i = 0; i < ARRAY_SIZE(kSsrcs4); ++i) { 1862 EXPECT_TRUE(channel_->AddSendStream( 1863 cricket::StreamParams::CreateLegacy(kSsrcs4[i]))); 1864 1865 // Verify that we are in a sending state for all the created streams. 1866 int channel_num = voe_.GetChannelFromLocalSsrc(kSsrcs4[i]); 1867 EXPECT_TRUE(voe_.GetSend(channel_num)); 1868 } 1869 1870 // Remove the first send channel, which is the default channel. It will only 1871 // recycle the default channel but not delete it. 1872 EXPECT_TRUE(channel_->RemoveSendStream(kSsrcs4[0])); 1873 // Stream should already be Removed from the send stream list. 1874 EXPECT_FALSE(channel_->RemoveSendStream(kSsrcs4[0])); 1875 // But the default still exists. 1876 EXPECT_EQ(0, voe_.GetChannelFromLocalSsrc(kSsrcs4[0])); 1877 1878 // Delete the rest of send channel streams. 1879 for (unsigned int i = 1; i < ARRAY_SIZE(kSsrcs4); ++i) { 1880 EXPECT_TRUE(channel_->RemoveSendStream(kSsrcs4[i])); 1881 // Stream should already be deleted. 1882 EXPECT_FALSE(channel_->RemoveSendStream(kSsrcs4[i])); 1883 EXPECT_EQ(-1, voe_.GetChannelFromLocalSsrc(kSsrcs4[i])); 1884 } 1885 } 1886 1887 // Test SetSendCodecs correctly configure the codecs in all send streams. 1888 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsWithMultipleSendStreams) { 1889 SetupForMultiSendStream(); 1890 1891 static const uint32 kSsrcs4[] = {1, 2, 3, 4}; 1892 // Create send streams. 1893 for (unsigned int i = 0; i < ARRAY_SIZE(kSsrcs4); ++i) { 1894 EXPECT_TRUE(channel_->AddSendStream( 1895 cricket::StreamParams::CreateLegacy(kSsrcs4[i]))); 1896 } 1897 1898 std::vector<cricket::AudioCodec> codecs; 1899 // Set ISAC(16K) and CN(16K). VAD should be activated. 1900 codecs.push_back(kIsacCodec); 1901 codecs.push_back(kCn16000Codec); 1902 codecs[1].id = 97; 1903 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 1904 1905 // Verify ISAC and VAD are corrected configured on all send channels. 1906 webrtc::CodecInst gcodec; 1907 for (unsigned int i = 0; i < ARRAY_SIZE(kSsrcs4); ++i) { 1908 int channel_num = voe_.GetChannelFromLocalSsrc(kSsrcs4[i]); 1909 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); 1910 EXPECT_STREQ("ISAC", gcodec.plname); 1911 EXPECT_TRUE(voe_.GetVAD(channel_num)); 1912 EXPECT_EQ(97, voe_.GetSendCNPayloadType(channel_num, true)); 1913 } 1914 1915 // Change to PCMU(8K) and CN(16K). VAD should not be activated. 1916 codecs[0] = kPcmuCodec; 1917 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 1918 for (unsigned int i = 0; i < ARRAY_SIZE(kSsrcs4); ++i) { 1919 int channel_num = voe_.GetChannelFromLocalSsrc(kSsrcs4[i]); 1920 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); 1921 EXPECT_STREQ("PCMU", gcodec.plname); 1922 EXPECT_FALSE(voe_.GetVAD(channel_num)); 1923 } 1924 } 1925 1926 // Test we can SetSend on all send streams correctly. 1927 TEST_F(WebRtcVoiceEngineTestFake, SetSendWithMultipleSendStreams) { 1928 SetupForMultiSendStream(); 1929 1930 static const uint32 kSsrcs4[] = {1, 2, 3, 4}; 1931 // Create the send channels and they should be a SEND_NOTHING date. 1932 for (unsigned int i = 0; i < ARRAY_SIZE(kSsrcs4); ++i) { 1933 EXPECT_TRUE(channel_->AddSendStream( 1934 cricket::StreamParams::CreateLegacy(kSsrcs4[i]))); 1935 int channel_num = voe_.GetLastChannel(); 1936 EXPECT_FALSE(voe_.GetSend(channel_num)); 1937 } 1938 1939 // Set the global state for starting sending. 1940 EXPECT_TRUE(channel_->SetSend(cricket::SEND_MICROPHONE)); 1941 for (unsigned int i = 0; i < ARRAY_SIZE(kSsrcs4); ++i) { 1942 // Verify that we are in a sending state for all the send streams. 1943 int channel_num = voe_.GetChannelFromLocalSsrc(kSsrcs4[i]); 1944 EXPECT_TRUE(voe_.GetSend(channel_num)); 1945 } 1946 1947 // Set the global state for stopping sending. 1948 EXPECT_TRUE(channel_->SetSend(cricket::SEND_NOTHING)); 1949 for (unsigned int i = 1; i < ARRAY_SIZE(kSsrcs4); ++i) { 1950 // Verify that we are in a stop state for all the send streams. 1951 int channel_num = voe_.GetChannelFromLocalSsrc(kSsrcs4[i]); 1952 EXPECT_FALSE(voe_.GetSend(channel_num)); 1953 } 1954 } 1955 1956 // Test we can set the correct statistics on all send streams. 1957 TEST_F(WebRtcVoiceEngineTestFake, GetStatsWithMultipleSendStreams) { 1958 SetupForMultiSendStream(); 1959 1960 static const uint32 kSsrcs4[] = {1, 2, 3, 4}; 1961 // Create send streams. 1962 for (unsigned int i = 0; i < ARRAY_SIZE(kSsrcs4); ++i) { 1963 EXPECT_TRUE(channel_->AddSendStream( 1964 cricket::StreamParams::CreateLegacy(kSsrcs4[i]))); 1965 } 1966 // Create a receive stream to check that none of the send streams end up in 1967 // the receive stream stats. 1968 EXPECT_TRUE(channel_->AddRecvStream( 1969 cricket::StreamParams::CreateLegacy(kSsrc2))); 1970 // We need send codec to be set to get all stats. 1971 std::vector<cricket::AudioCodec> codecs; 1972 codecs.push_back(kPcmuCodec); 1973 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 1974 EXPECT_TRUE(channel_->SetRecvCodecs(codecs)); 1975 1976 cricket::VoiceMediaInfo info; 1977 EXPECT_EQ(true, channel_->GetStats(&info)); 1978 EXPECT_EQ(static_cast<size_t>(ARRAY_SIZE(kSsrcs4)), info.senders.size()); 1979 1980 // Verify the statistic information is correct. 1981 for (unsigned int i = 0; i < ARRAY_SIZE(kSsrcs4); ++i) { 1982 EXPECT_EQ(kSsrcs4[i], info.senders[i].ssrc()); 1983 EXPECT_EQ(kPcmuCodec.name, info.senders[i].codec_name); 1984 EXPECT_EQ(cricket::kIntStatValue, info.senders[i].bytes_sent); 1985 EXPECT_EQ(cricket::kIntStatValue, info.senders[i].packets_sent); 1986 EXPECT_EQ(cricket::kIntStatValue, info.senders[i].packets_lost); 1987 EXPECT_EQ(cricket::kFractionLostStatValue, info.senders[i].fraction_lost); 1988 EXPECT_EQ(cricket::kIntStatValue, info.senders[i].ext_seqnum); 1989 EXPECT_EQ(cricket::kIntStatValue, info.senders[i].rtt_ms); 1990 EXPECT_EQ(cricket::kIntStatValue, info.senders[i].jitter_ms); 1991 EXPECT_EQ(kPcmuCodec.name, info.senders[i].codec_name); 1992 } 1993 1994 EXPECT_EQ(0u, info.receivers.size()); 1995 DeliverPacket(kPcmuFrame, sizeof(kPcmuFrame)); 1996 EXPECT_EQ(true, channel_->GetStats(&info)); 1997 1998 EXPECT_EQ(1u, info.receivers.size()); 1999 EXPECT_EQ(cricket::kIntStatValue, info.receivers[0].bytes_rcvd); 2000 EXPECT_EQ(cricket::kIntStatValue, info.receivers[0].packets_rcvd); 2001 EXPECT_EQ(cricket::kIntStatValue, info.receivers[0].packets_lost); 2002 EXPECT_EQ(cricket::kIntStatValue, info.receivers[0].ext_seqnum); 2003 EXPECT_EQ(kPcmuCodec.name, info.receivers[0].codec_name); 2004 } 2005 2006 // Test that we can add and remove receive streams, and do proper send/playout. 2007 // We can receive on multiple streams while sending one stream. 2008 TEST_F(WebRtcVoiceEngineTestFake, PlayoutWithMultipleStreams) { 2009 EXPECT_TRUE(SetupEngine()); 2010 int channel_num1 = voe_.GetLastChannel(); 2011 2012 // Start playout on the default channel. 2013 EXPECT_TRUE(channel_->SetOptions(options_conference_)); 2014 EXPECT_TRUE(channel_->SetPlayout(true)); 2015 EXPECT_TRUE(voe_.GetPlayout(channel_num1)); 2016 2017 // Adding another stream should disable playout on the default channel. 2018 EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(2))); 2019 int channel_num2 = voe_.GetLastChannel(); 2020 std::vector<cricket::AudioCodec> codecs; 2021 codecs.push_back(kPcmuCodec); 2022 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 2023 EXPECT_TRUE(channel_->SetSend(cricket::SEND_MICROPHONE)); 2024 EXPECT_TRUE(voe_.GetSend(channel_num1)); 2025 EXPECT_FALSE(voe_.GetSend(channel_num2)); 2026 2027 // Make sure only the new channel is played out. 2028 EXPECT_FALSE(voe_.GetPlayout(channel_num1)); 2029 EXPECT_TRUE(voe_.GetPlayout(channel_num2)); 2030 2031 // Adding yet another stream should have stream 2 and 3 enabled for playout. 2032 EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(3))); 2033 int channel_num3 = voe_.GetLastChannel(); 2034 EXPECT_FALSE(voe_.GetPlayout(channel_num1)); 2035 EXPECT_TRUE(voe_.GetPlayout(channel_num2)); 2036 EXPECT_TRUE(voe_.GetPlayout(channel_num3)); 2037 EXPECT_FALSE(voe_.GetSend(channel_num3)); 2038 2039 // Stop sending. 2040 EXPECT_TRUE(channel_->SetSend(cricket::SEND_NOTHING)); 2041 EXPECT_FALSE(voe_.GetSend(channel_num1)); 2042 EXPECT_FALSE(voe_.GetSend(channel_num2)); 2043 EXPECT_FALSE(voe_.GetSend(channel_num3)); 2044 2045 // Stop playout. 2046 EXPECT_TRUE(channel_->SetPlayout(false)); 2047 EXPECT_FALSE(voe_.GetPlayout(channel_num1)); 2048 EXPECT_FALSE(voe_.GetPlayout(channel_num2)); 2049 EXPECT_FALSE(voe_.GetPlayout(channel_num3)); 2050 2051 // Restart playout and make sure the default channel still is not played out. 2052 EXPECT_TRUE(channel_->SetPlayout(true)); 2053 EXPECT_FALSE(voe_.GetPlayout(channel_num1)); 2054 EXPECT_TRUE(voe_.GetPlayout(channel_num2)); 2055 EXPECT_TRUE(voe_.GetPlayout(channel_num3)); 2056 2057 // Now remove the new streams and verify that the default channel is 2058 // played out again. 2059 EXPECT_TRUE(channel_->RemoveRecvStream(3)); 2060 EXPECT_TRUE(channel_->RemoveRecvStream(2)); 2061 2062 EXPECT_TRUE(voe_.GetPlayout(channel_num1)); 2063 } 2064 2065 // Test that we can set the devices to use. 2066 TEST_F(WebRtcVoiceEngineTestFake, SetDevices) { 2067 EXPECT_TRUE(SetupEngine()); 2068 int channel_num = voe_.GetLastChannel(); 2069 std::vector<cricket::AudioCodec> codecs; 2070 codecs.push_back(kPcmuCodec); 2071 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 2072 2073 cricket::Device default_dev(cricket::kFakeDefaultDeviceName, 2074 cricket::kFakeDefaultDeviceId); 2075 cricket::Device dev(cricket::kFakeDeviceName, 2076 cricket::kFakeDeviceId); 2077 2078 // Test SetDevices() while not sending or playing. 2079 EXPECT_TRUE(engine_.SetDevices(&default_dev, &default_dev)); 2080 2081 // Test SetDevices() while sending and playing. 2082 EXPECT_TRUE(engine_.SetLocalMonitor(true)); 2083 EXPECT_TRUE(channel_->SetSend(cricket::SEND_MICROPHONE)); 2084 EXPECT_TRUE(channel_->SetPlayout(true)); 2085 EXPECT_TRUE(voe_.GetRecordingMicrophone()); 2086 EXPECT_TRUE(voe_.GetSend(channel_num)); 2087 EXPECT_TRUE(voe_.GetPlayout(channel_num)); 2088 2089 EXPECT_TRUE(engine_.SetDevices(&dev, &dev)); 2090 2091 EXPECT_TRUE(voe_.GetRecordingMicrophone()); 2092 EXPECT_TRUE(voe_.GetSend(channel_num)); 2093 EXPECT_TRUE(voe_.GetPlayout(channel_num)); 2094 2095 // Test that failure to open newly selected devices does not prevent opening 2096 // ones after that. 2097 voe_.set_fail_start_recording_microphone(true); 2098 voe_.set_playout_fail_channel(channel_num); 2099 voe_.set_send_fail_channel(channel_num); 2100 2101 EXPECT_FALSE(engine_.SetDevices(&default_dev, &default_dev)); 2102 2103 EXPECT_FALSE(voe_.GetRecordingMicrophone()); 2104 EXPECT_FALSE(voe_.GetSend(channel_num)); 2105 EXPECT_FALSE(voe_.GetPlayout(channel_num)); 2106 2107 voe_.set_fail_start_recording_microphone(false); 2108 voe_.set_playout_fail_channel(-1); 2109 voe_.set_send_fail_channel(-1); 2110 2111 EXPECT_TRUE(engine_.SetDevices(&dev, &dev)); 2112 2113 EXPECT_TRUE(voe_.GetRecordingMicrophone()); 2114 EXPECT_TRUE(voe_.GetSend(channel_num)); 2115 EXPECT_TRUE(voe_.GetPlayout(channel_num)); 2116 } 2117 2118 // Test that we can set the devices to use even if we failed to 2119 // open the initial ones. 2120 TEST_F(WebRtcVoiceEngineTestFake, SetDevicesWithInitiallyBadDevices) { 2121 EXPECT_TRUE(SetupEngine()); 2122 int channel_num = voe_.GetLastChannel(); 2123 std::vector<cricket::AudioCodec> codecs; 2124 codecs.push_back(kPcmuCodec); 2125 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 2126 2127 cricket::Device default_dev(cricket::kFakeDefaultDeviceName, 2128 cricket::kFakeDefaultDeviceId); 2129 cricket::Device dev(cricket::kFakeDeviceName, 2130 cricket::kFakeDeviceId); 2131 2132 // Test that failure to open devices selected before starting 2133 // send/play does not prevent opening newly selected ones after that. 2134 voe_.set_fail_start_recording_microphone(true); 2135 voe_.set_playout_fail_channel(channel_num); 2136 voe_.set_send_fail_channel(channel_num); 2137 2138 EXPECT_TRUE(engine_.SetDevices(&default_dev, &default_dev)); 2139 2140 EXPECT_FALSE(engine_.SetLocalMonitor(true)); 2141 EXPECT_FALSE(channel_->SetSend(cricket::SEND_MICROPHONE)); 2142 EXPECT_FALSE(channel_->SetPlayout(true)); 2143 EXPECT_FALSE(voe_.GetRecordingMicrophone()); 2144 EXPECT_FALSE(voe_.GetSend(channel_num)); 2145 EXPECT_FALSE(voe_.GetPlayout(channel_num)); 2146 2147 voe_.set_fail_start_recording_microphone(false); 2148 voe_.set_playout_fail_channel(-1); 2149 voe_.set_send_fail_channel(-1); 2150 2151 EXPECT_TRUE(engine_.SetDevices(&dev, &dev)); 2152 2153 EXPECT_TRUE(voe_.GetRecordingMicrophone()); 2154 EXPECT_TRUE(voe_.GetSend(channel_num)); 2155 EXPECT_TRUE(voe_.GetPlayout(channel_num)); 2156 } 2157 2158 // Test that we can create a channel configured for multi-point conferences, 2159 // and start sending/playing out on it. 2160 TEST_F(WebRtcVoiceEngineTestFake, ConferenceSendAndPlayout) { 2161 EXPECT_TRUE(SetupEngine()); 2162 int channel_num = voe_.GetLastChannel(); 2163 EXPECT_TRUE(channel_->SetOptions(options_conference_)); 2164 std::vector<cricket::AudioCodec> codecs; 2165 codecs.push_back(kPcmuCodec); 2166 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 2167 EXPECT_TRUE(channel_->SetSend(cricket::SEND_MICROPHONE)); 2168 EXPECT_TRUE(voe_.GetSend(channel_num)); 2169 } 2170 2171 // Test that we can create a channel configured for Codian bridges, 2172 // and start sending/playing out on it. 2173 TEST_F(WebRtcVoiceEngineTestFake, CodianSendAndPlayout) { 2174 EXPECT_TRUE(SetupEngine()); 2175 int channel_num = voe_.GetLastChannel(); 2176 webrtc::AgcConfig agc_config; 2177 EXPECT_EQ(0, voe_.GetAgcConfig(agc_config)); 2178 EXPECT_EQ(0, agc_config.targetLeveldBOv); 2179 EXPECT_TRUE(channel_->SetOptions(options_adjust_agc_)); 2180 std::vector<cricket::AudioCodec> codecs; 2181 codecs.push_back(kPcmuCodec); 2182 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 2183 EXPECT_TRUE(channel_->SetSend(cricket::SEND_MICROPHONE)); 2184 EXPECT_TRUE(voe_.GetSend(channel_num)); 2185 EXPECT_EQ(0, voe_.GetAgcConfig(agc_config)); 2186 EXPECT_EQ(agc_config.targetLeveldBOv, 10); // level was attenuated 2187 EXPECT_TRUE(channel_->SetPlayout(true)); 2188 EXPECT_TRUE(voe_.GetPlayout(channel_num)); 2189 EXPECT_TRUE(channel_->SetSend(cricket::SEND_NOTHING)); 2190 EXPECT_FALSE(voe_.GetSend(channel_num)); 2191 EXPECT_EQ(0, voe_.GetAgcConfig(agc_config)); 2192 EXPECT_EQ(0, agc_config.targetLeveldBOv); // level was restored 2193 EXPECT_TRUE(channel_->SetPlayout(false)); 2194 EXPECT_FALSE(voe_.GetPlayout(channel_num)); 2195 } 2196 2197 TEST_F(WebRtcVoiceEngineTestFake, TxAgcConfigViaOptions) { 2198 EXPECT_TRUE(SetupEngine()); 2199 webrtc::AgcConfig agc_config; 2200 EXPECT_EQ(0, voe_.GetAgcConfig(agc_config)); 2201 EXPECT_EQ(0, agc_config.targetLeveldBOv); 2202 2203 cricket::AudioOptions options; 2204 options.tx_agc_target_dbov.Set(3); 2205 options.tx_agc_digital_compression_gain.Set(9); 2206 options.tx_agc_limiter.Set(true); 2207 options.auto_gain_control.Set(true); 2208 EXPECT_TRUE(engine_.SetOptions(options)); 2209 2210 EXPECT_EQ(0, voe_.GetAgcConfig(agc_config)); 2211 EXPECT_EQ(3, agc_config.targetLeveldBOv); 2212 EXPECT_EQ(9, agc_config.digitalCompressionGaindB); 2213 EXPECT_TRUE(agc_config.limiterEnable); 2214 2215 // Check interaction with adjust_agc_delta. Both should be respected, for 2216 // backwards compatibility. 2217 options.adjust_agc_delta.Set(-10); 2218 EXPECT_TRUE(engine_.SetOptions(options)); 2219 2220 EXPECT_EQ(0, voe_.GetAgcConfig(agc_config)); 2221 EXPECT_EQ(13, agc_config.targetLeveldBOv); 2222 } 2223 2224 TEST_F(WebRtcVoiceEngineTestFake, RxAgcConfigViaOptions) { 2225 EXPECT_TRUE(SetupEngine()); 2226 int channel_num = voe_.GetLastChannel(); 2227 cricket::AudioOptions options; 2228 options.rx_agc_target_dbov.Set(6); 2229 options.rx_agc_digital_compression_gain.Set(0); 2230 options.rx_agc_limiter.Set(true); 2231 options.rx_auto_gain_control.Set(true); 2232 EXPECT_TRUE(channel_->SetOptions(options)); 2233 2234 webrtc::AgcConfig agc_config; 2235 EXPECT_EQ(0, engine_.voe()->processing()->GetRxAgcConfig( 2236 channel_num, agc_config)); 2237 EXPECT_EQ(6, agc_config.targetLeveldBOv); 2238 EXPECT_EQ(0, agc_config.digitalCompressionGaindB); 2239 EXPECT_TRUE(agc_config.limiterEnable); 2240 } 2241 2242 TEST_F(WebRtcVoiceEngineTestFake, SampleRatesViaOptions) { 2243 EXPECT_TRUE(SetupEngine()); 2244 cricket::AudioOptions options; 2245 options.recording_sample_rate.Set(48000u); 2246 options.playout_sample_rate.Set(44100u); 2247 EXPECT_TRUE(engine_.SetOptions(options)); 2248 2249 unsigned int recording_sample_rate, playout_sample_rate; 2250 EXPECT_EQ(0, voe_.RecordingSampleRate(&recording_sample_rate)); 2251 EXPECT_EQ(0, voe_.PlayoutSampleRate(&playout_sample_rate)); 2252 EXPECT_EQ(48000u, recording_sample_rate); 2253 EXPECT_EQ(44100u, playout_sample_rate); 2254 } 2255 2256 TEST_F(WebRtcVoiceEngineTestFake, TraceFilterViaTraceOptions) { 2257 EXPECT_TRUE(SetupEngine()); 2258 engine_.SetLogging(rtc::LS_INFO, ""); 2259 EXPECT_EQ( 2260 // Info: 2261 webrtc::kTraceStateInfo | webrtc::kTraceInfo | 2262 // Warning: 2263 webrtc::kTraceTerseInfo | webrtc::kTraceWarning | 2264 // Error: 2265 webrtc::kTraceError | webrtc::kTraceCritical, 2266 static_cast<int>(trace_wrapper_->filter_)); 2267 // Now set it explicitly 2268 std::string filter = 2269 "tracefilter " + rtc::ToString(webrtc::kTraceDefault); 2270 engine_.SetLogging(rtc::LS_VERBOSE, filter.c_str()); 2271 EXPECT_EQ(static_cast<unsigned int>(webrtc::kTraceDefault), 2272 trace_wrapper_->filter_); 2273 } 2274 2275 // Test that we can set the outgoing SSRC properly. 2276 // SSRC is set in SetupEngine by calling AddSendStream. 2277 TEST_F(WebRtcVoiceEngineTestFake, SetSendSsrc) { 2278 EXPECT_TRUE(SetupEngine()); 2279 int channel_num = voe_.GetLastChannel(); 2280 unsigned int send_ssrc; 2281 EXPECT_EQ(0, voe_.GetLocalSSRC(channel_num, send_ssrc)); 2282 EXPECT_NE(0U, send_ssrc); 2283 EXPECT_EQ(0, voe_.GetLocalSSRC(channel_num, send_ssrc)); 2284 EXPECT_EQ(kSsrc1, send_ssrc); 2285 } 2286 2287 TEST_F(WebRtcVoiceEngineTestFake, GetStats) { 2288 // Setup. We need send codec to be set to get all stats. 2289 EXPECT_TRUE(SetupEngine()); 2290 // SetupEngine adds a send stream with kSsrc1, so the receive stream has to 2291 // use a different SSRC. 2292 EXPECT_TRUE(channel_->AddRecvStream( 2293 cricket::StreamParams::CreateLegacy(kSsrc2))); 2294 std::vector<cricket::AudioCodec> codecs; 2295 codecs.push_back(kPcmuCodec); 2296 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 2297 EXPECT_TRUE(channel_->SetRecvCodecs(codecs)); 2298 2299 cricket::VoiceMediaInfo info; 2300 EXPECT_EQ(true, channel_->GetStats(&info)); 2301 EXPECT_EQ(1u, info.senders.size()); 2302 EXPECT_EQ(kSsrc1, info.senders[0].ssrc()); 2303 EXPECT_EQ(kPcmuCodec.name, info.senders[0].codec_name); 2304 EXPECT_EQ(cricket::kIntStatValue, info.senders[0].bytes_sent); 2305 EXPECT_EQ(cricket::kIntStatValue, info.senders[0].packets_sent); 2306 EXPECT_EQ(cricket::kIntStatValue, info.senders[0].packets_lost); 2307 EXPECT_EQ(cricket::kFractionLostStatValue, info.senders[0].fraction_lost); 2308 EXPECT_EQ(cricket::kIntStatValue, info.senders[0].ext_seqnum); 2309 EXPECT_EQ(cricket::kIntStatValue, info.senders[0].rtt_ms); 2310 EXPECT_EQ(cricket::kIntStatValue, info.senders[0].jitter_ms); 2311 EXPECT_EQ(kPcmuCodec.name, info.senders[0].codec_name); 2312 // TODO(sriniv): Add testing for more fields. These are not populated 2313 // in FakeWebrtcVoiceEngine yet. 2314 // EXPECT_EQ(cricket::kIntStatValue, info.senders[0].audio_level); 2315 // EXPECT_EQ(cricket::kIntStatValue, info.senders[0].echo_delay_median_ms); 2316 // EXPECT_EQ(cricket::kIntStatValue, info.senders[0].echo_delay_std_ms); 2317 // EXPECT_EQ(cricket::kIntStatValue, info.senders[0].echo_return_loss); 2318 // EXPECT_EQ(cricket::kIntStatValue, 2319 // info.senders[0].echo_return_loss_enhancement); 2320 2321 EXPECT_EQ(0u, info.receivers.size()); 2322 DeliverPacket(kPcmuFrame, sizeof(kPcmuFrame)); 2323 EXPECT_EQ(true, channel_->GetStats(&info)); 2324 EXPECT_EQ(1u, info.receivers.size()); 2325 2326 EXPECT_EQ(cricket::kIntStatValue, info.receivers[0].bytes_rcvd); 2327 EXPECT_EQ(cricket::kIntStatValue, info.receivers[0].packets_rcvd); 2328 EXPECT_EQ(cricket::kIntStatValue, info.receivers[0].packets_lost); 2329 EXPECT_EQ(cricket::kIntStatValue, info.receivers[0].ext_seqnum); 2330 EXPECT_EQ(kPcmuCodec.name, info.receivers[0].codec_name); 2331 // TODO(sriniv): Add testing for more receiver fields. 2332 } 2333 2334 // Test that we can set the outgoing SSRC properly with multiple streams. 2335 // SSRC is set in SetupEngine by calling AddSendStream. 2336 TEST_F(WebRtcVoiceEngineTestFake, SetSendSsrcWithMultipleStreams) { 2337 EXPECT_TRUE(SetupEngine()); 2338 EXPECT_TRUE(channel_->SetOptions(options_conference_)); 2339 int channel_num1 = voe_.GetLastChannel(); 2340 unsigned int send_ssrc; 2341 EXPECT_EQ(0, voe_.GetLocalSSRC(channel_num1, send_ssrc)); 2342 EXPECT_EQ(kSsrc1, send_ssrc); 2343 2344 EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(2))); 2345 int channel_num2 = voe_.GetLastChannel(); 2346 EXPECT_EQ(0, voe_.GetLocalSSRC(channel_num2, send_ssrc)); 2347 EXPECT_EQ(kSsrc1, send_ssrc); 2348 } 2349 2350 // Test that the local SSRC is the same on sending and receiving channels if the 2351 // receive channel is created before the send channel. 2352 TEST_F(WebRtcVoiceEngineTestFake, SetSendSsrcAfterCreatingReceiveChannel) { 2353 EXPECT_TRUE(engine_.Init(rtc::Thread::Current())); 2354 channel_ = engine_.CreateChannel(); 2355 EXPECT_TRUE(channel_->SetOptions(options_conference_)); 2356 2357 EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1))); 2358 int receive_channel_num = voe_.GetLastChannel(); 2359 EXPECT_TRUE(channel_->AddSendStream( 2360 cricket::StreamParams::CreateLegacy(1234))); 2361 int send_channel_num = voe_.GetLastChannel(); 2362 2363 unsigned int ssrc = 0; 2364 EXPECT_EQ(0, voe_.GetLocalSSRC(send_channel_num, ssrc)); 2365 EXPECT_EQ(1234U, ssrc); 2366 ssrc = 0; 2367 EXPECT_EQ(0, voe_.GetLocalSSRC(receive_channel_num, ssrc)); 2368 EXPECT_EQ(1234U, ssrc); 2369 } 2370 2371 // Test that we can properly receive packets. 2372 TEST_F(WebRtcVoiceEngineTestFake, Recv) { 2373 EXPECT_TRUE(SetupEngine()); 2374 int channel_num = voe_.GetLastChannel(); 2375 DeliverPacket(kPcmuFrame, sizeof(kPcmuFrame)); 2376 EXPECT_TRUE(voe_.CheckPacket(channel_num, kPcmuFrame, 2377 sizeof(kPcmuFrame))); 2378 } 2379 2380 // Test that we can properly receive packets on multiple streams. 2381 TEST_F(WebRtcVoiceEngineTestFake, RecvWithMultipleStreams) { 2382 EXPECT_TRUE(SetupEngine()); 2383 EXPECT_TRUE(channel_->SetOptions(options_conference_)); 2384 EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1))); 2385 int channel_num1 = voe_.GetLastChannel(); 2386 EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(2))); 2387 int channel_num2 = voe_.GetLastChannel(); 2388 EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(3))); 2389 int channel_num3 = voe_.GetLastChannel(); 2390 // Create packets with the right SSRCs. 2391 char packets[4][sizeof(kPcmuFrame)]; 2392 for (size_t i = 0; i < ARRAY_SIZE(packets); ++i) { 2393 memcpy(packets[i], kPcmuFrame, sizeof(kPcmuFrame)); 2394 rtc::SetBE32(packets[i] + 8, static_cast<uint32>(i)); 2395 } 2396 EXPECT_TRUE(voe_.CheckNoPacket(channel_num1)); 2397 EXPECT_TRUE(voe_.CheckNoPacket(channel_num2)); 2398 EXPECT_TRUE(voe_.CheckNoPacket(channel_num3)); 2399 DeliverPacket(packets[0], sizeof(packets[0])); 2400 EXPECT_TRUE(voe_.CheckNoPacket(channel_num1)); 2401 EXPECT_TRUE(voe_.CheckNoPacket(channel_num2)); 2402 EXPECT_TRUE(voe_.CheckNoPacket(channel_num3)); 2403 DeliverPacket(packets[1], sizeof(packets[1])); 2404 EXPECT_TRUE(voe_.CheckPacket(channel_num1, packets[1], 2405 sizeof(packets[1]))); 2406 EXPECT_TRUE(voe_.CheckNoPacket(channel_num2)); 2407 EXPECT_TRUE(voe_.CheckNoPacket(channel_num3)); 2408 DeliverPacket(packets[2], sizeof(packets[2])); 2409 EXPECT_TRUE(voe_.CheckNoPacket(channel_num1)); 2410 EXPECT_TRUE(voe_.CheckPacket(channel_num2, packets[2], 2411 sizeof(packets[2]))); 2412 EXPECT_TRUE(voe_.CheckNoPacket(channel_num3)); 2413 DeliverPacket(packets[3], sizeof(packets[3])); 2414 EXPECT_TRUE(voe_.CheckNoPacket(channel_num1)); 2415 EXPECT_TRUE(voe_.CheckNoPacket(channel_num2)); 2416 EXPECT_TRUE(voe_.CheckPacket(channel_num3, packets[3], 2417 sizeof(packets[3]))); 2418 EXPECT_TRUE(channel_->RemoveRecvStream(3)); 2419 EXPECT_TRUE(channel_->RemoveRecvStream(2)); 2420 EXPECT_TRUE(channel_->RemoveRecvStream(1)); 2421 } 2422 2423 // Test that we properly handle failures to add a stream. 2424 TEST_F(WebRtcVoiceEngineTestFake, AddStreamFail) { 2425 EXPECT_TRUE(SetupEngine()); 2426 voe_.set_fail_create_channel(true); 2427 EXPECT_TRUE(channel_->SetOptions(options_conference_)); 2428 EXPECT_FALSE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(2))); 2429 2430 // In 1:1 call, we should not try to create a new channel. 2431 cricket::AudioOptions options_no_conference_; 2432 options_no_conference_.conference_mode.Set(false); 2433 EXPECT_TRUE(channel_->SetOptions(options_no_conference_)); 2434 EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(2))); 2435 } 2436 2437 // Test that AddRecvStream doesn't create new channel for 1:1 call. 2438 TEST_F(WebRtcVoiceEngineTestFake, AddRecvStream1On1) { 2439 EXPECT_TRUE(SetupEngine()); 2440 int channel_num = voe_.GetLastChannel(); 2441 EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1))); 2442 EXPECT_EQ(channel_num, voe_.GetLastChannel()); 2443 } 2444 2445 // Test that after adding a recv stream, we do not decode more codecs than 2446 // those previously passed into SetRecvCodecs. 2447 TEST_F(WebRtcVoiceEngineTestFake, AddRecvStreamUnsupportedCodec) { 2448 EXPECT_TRUE(SetupEngine()); 2449 EXPECT_TRUE(channel_->SetOptions(options_conference_)); 2450 std::vector<cricket::AudioCodec> codecs; 2451 codecs.push_back(kIsacCodec); 2452 codecs.push_back(kPcmuCodec); 2453 EXPECT_TRUE(channel_->SetRecvCodecs(codecs)); 2454 EXPECT_TRUE(channel_->AddRecvStream( 2455 cricket::StreamParams::CreateLegacy(kSsrc1))); 2456 int channel_num2 = voe_.GetLastChannel(); 2457 webrtc::CodecInst gcodec; 2458 rtc::strcpyn(gcodec.plname, ARRAY_SIZE(gcodec.plname), "CELT"); 2459 gcodec.plfreq = 32000; 2460 gcodec.channels = 2; 2461 EXPECT_EQ(-1, voe_.GetRecPayloadType(channel_num2, gcodec)); 2462 } 2463 2464 // Test that we properly clean up any streams that were added, even if 2465 // not explicitly removed. 2466 TEST_F(WebRtcVoiceEngineTestFake, StreamCleanup) { 2467 EXPECT_TRUE(SetupEngine()); 2468 EXPECT_TRUE(channel_->SetOptions(options_conference_)); 2469 EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1))); 2470 EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(2))); 2471 EXPECT_EQ(3, voe_.GetNumChannels()); // default channel + 2 added 2472 delete channel_; 2473 channel_ = NULL; 2474 EXPECT_EQ(0, voe_.GetNumChannels()); 2475 } 2476 2477 TEST_F(WebRtcVoiceEngineTestFake, TestAddRecvStreamFailWithZeroSsrc) { 2478 EXPECT_TRUE(SetupEngine()); 2479 EXPECT_FALSE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(0))); 2480 } 2481 2482 TEST_F(WebRtcVoiceEngineTestFake, TestNoLeakingWhenAddRecvStreamFail) { 2483 EXPECT_TRUE(SetupEngine()); 2484 // Stream 1 reuses default channel. 2485 EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1))); 2486 // Manually delete default channel to simulate a failure. 2487 int default_channel = voe_.GetLastChannel(); 2488 EXPECT_EQ(0, voe_.DeleteChannel(default_channel)); 2489 // Add recv stream 2 should fail because default channel is gone. 2490 EXPECT_FALSE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(2))); 2491 int new_channel = voe_.GetLastChannel(); 2492 EXPECT_NE(default_channel, new_channel); 2493 // The last created channel should have already been deleted. 2494 EXPECT_EQ(-1, voe_.DeleteChannel(new_channel)); 2495 } 2496 2497 // Test the InsertDtmf on default send stream as caller. 2498 TEST_F(WebRtcVoiceEngineTestFake, InsertDtmfOnDefaultSendStreamAsCaller) { 2499 TestInsertDtmf(0, true); 2500 } 2501 2502 // Test the InsertDtmf on default send stream as callee 2503 TEST_F(WebRtcVoiceEngineTestFake, InsertDtmfOnDefaultSendStreamAsCallee) { 2504 TestInsertDtmf(0, false); 2505 } 2506 2507 // Test the InsertDtmf on specified send stream as caller. 2508 TEST_F(WebRtcVoiceEngineTestFake, InsertDtmfOnSendStreamAsCaller) { 2509 TestInsertDtmf(kSsrc1, true); 2510 } 2511 2512 // Test the InsertDtmf on specified send stream as callee. 2513 TEST_F(WebRtcVoiceEngineTestFake, InsertDtmfOnSendStreamAsCallee) { 2514 TestInsertDtmf(kSsrc1, false); 2515 } 2516 2517 // Test that we can play a ringback tone properly in a single-stream call. 2518 TEST_F(WebRtcVoiceEngineTestFake, PlayRingback) { 2519 EXPECT_TRUE(SetupEngine()); 2520 int channel_num = voe_.GetLastChannel(); 2521 EXPECT_EQ(0, voe_.IsPlayingFileLocally(channel_num)); 2522 // Check we fail if no ringback tone specified. 2523 EXPECT_FALSE(channel_->PlayRingbackTone(0, true, true)); 2524 EXPECT_EQ(0, voe_.IsPlayingFileLocally(channel_num)); 2525 // Check we can set and play a ringback tone. 2526 EXPECT_TRUE(channel_->SetRingbackTone( 2527 kRingbackTone, static_cast<int>(strlen(kRingbackTone)))); 2528 EXPECT_TRUE(channel_->PlayRingbackTone(0, true, true)); 2529 EXPECT_EQ(1, voe_.IsPlayingFileLocally(channel_num)); 2530 // Check we can stop the tone manually. 2531 EXPECT_TRUE(channel_->PlayRingbackTone(0, false, false)); 2532 EXPECT_EQ(0, voe_.IsPlayingFileLocally(channel_num)); 2533 // Check we stop the tone if a packet arrives. 2534 EXPECT_TRUE(channel_->PlayRingbackTone(0, true, true)); 2535 EXPECT_EQ(1, voe_.IsPlayingFileLocally(channel_num)); 2536 DeliverPacket(kPcmuFrame, sizeof(kPcmuFrame)); 2537 EXPECT_EQ(0, voe_.IsPlayingFileLocally(channel_num)); 2538 } 2539 2540 // Test that we can play a ringback tone properly in a multi-stream call. 2541 TEST_F(WebRtcVoiceEngineTestFake, PlayRingbackWithMultipleStreams) { 2542 EXPECT_TRUE(SetupEngine()); 2543 EXPECT_TRUE(channel_->SetOptions(options_conference_)); 2544 EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1))); 2545 EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(2))); 2546 int channel_num = voe_.GetLastChannel(); 2547 EXPECT_EQ(0, voe_.IsPlayingFileLocally(channel_num)); 2548 // Check we fail if no ringback tone specified. 2549 EXPECT_FALSE(channel_->PlayRingbackTone(2, true, true)); 2550 EXPECT_EQ(0, voe_.IsPlayingFileLocally(channel_num)); 2551 // Check we can set and play a ringback tone on the correct ssrc. 2552 EXPECT_TRUE(channel_->SetRingbackTone( 2553 kRingbackTone, static_cast<int>(strlen(kRingbackTone)))); 2554 EXPECT_FALSE(channel_->PlayRingbackTone(77, true, true)); 2555 EXPECT_TRUE(channel_->PlayRingbackTone(2, true, true)); 2556 EXPECT_EQ(1, voe_.IsPlayingFileLocally(channel_num)); 2557 // Check we can stop the tone manually. 2558 EXPECT_TRUE(channel_->PlayRingbackTone(2, false, false)); 2559 EXPECT_EQ(0, voe_.IsPlayingFileLocally(channel_num)); 2560 // Check we stop the tone if a packet arrives, but only with the right SSRC. 2561 EXPECT_TRUE(channel_->PlayRingbackTone(2, true, true)); 2562 EXPECT_EQ(1, voe_.IsPlayingFileLocally(channel_num)); 2563 // Send a packet with SSRC 1; the tone should not stop. 2564 DeliverPacket(kPcmuFrame, sizeof(kPcmuFrame)); 2565 EXPECT_EQ(1, voe_.IsPlayingFileLocally(channel_num)); 2566 // Send a packet with SSRC 2; the tone should stop. 2567 char packet[sizeof(kPcmuFrame)]; 2568 memcpy(packet, kPcmuFrame, sizeof(kPcmuFrame)); 2569 rtc::SetBE32(packet + 8, 2); 2570 DeliverPacket(packet, sizeof(packet)); 2571 EXPECT_EQ(0, voe_.IsPlayingFileLocally(channel_num)); 2572 } 2573 2574 // Tests creating soundclips, and make sure they come from the right engine. 2575 TEST_F(WebRtcVoiceEngineTestFake, CreateSoundclip) { 2576 EXPECT_TRUE(engine_.Init(rtc::Thread::Current())); 2577 EXPECT_FALSE(voe_sc_.IsInited()); 2578 soundclip_ = engine_.CreateSoundclip(); 2579 EXPECT_TRUE(voe_sc_.IsInited()); 2580 ASSERT_TRUE(soundclip_ != NULL); 2581 EXPECT_EQ(0, voe_.GetNumChannels()); 2582 EXPECT_EQ(1, voe_sc_.GetNumChannels()); 2583 int channel_num = voe_sc_.GetLastChannel(); 2584 EXPECT_TRUE(voe_sc_.GetPlayout(channel_num)); 2585 delete soundclip_; 2586 soundclip_ = NULL; 2587 EXPECT_EQ(0, voe_sc_.GetNumChannels()); 2588 // Make sure the soundclip engine is uninitialized on shutdown, now that 2589 // we've initialized it by creating a soundclip. 2590 engine_.Terminate(); 2591 EXPECT_FALSE(voe_sc_.IsInited()); 2592 } 2593 2594 // Tests playing out a fake sound. 2595 TEST_F(WebRtcVoiceEngineTestFake, PlaySoundclip) { 2596 static const char kZeroes[16000] = {}; 2597 EXPECT_TRUE(engine_.Init(rtc::Thread::Current())); 2598 soundclip_ = engine_.CreateSoundclip(); 2599 ASSERT_TRUE(soundclip_ != NULL); 2600 EXPECT_TRUE(soundclip_->PlaySound(kZeroes, sizeof(kZeroes), 0)); 2601 } 2602 2603 TEST_F(WebRtcVoiceEngineTestFake, MediaEngineCallbackOnError) { 2604 rtc::scoped_ptr<ChannelErrorListener> listener; 2605 cricket::WebRtcVoiceMediaChannel* media_channel; 2606 unsigned int ssrc = 0; 2607 2608 EXPECT_TRUE(SetupEngine()); 2609 EXPECT_TRUE(channel_->SetOptions(options_conference_)); 2610 EXPECT_TRUE(channel_->SetSend(cricket::SEND_MICROPHONE)); 2611 2612 media_channel = static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_); 2613 listener.reset(new ChannelErrorListener(channel_)); 2614 2615 // Test on WebRtc VoE channel. 2616 voe_.TriggerCallbackOnError(media_channel->voe_channel(), 2617 VE_SATURATION_WARNING); 2618 EXPECT_EQ(cricket::VoiceMediaChannel::ERROR_REC_DEVICE_SATURATION, 2619 listener->error()); 2620 EXPECT_NE(-1, voe_.GetLocalSSRC(voe_.GetLastChannel(), ssrc)); 2621 EXPECT_EQ(ssrc, listener->ssrc()); 2622 2623 listener->Reset(); 2624 voe_.TriggerCallbackOnError(-1, VE_TYPING_NOISE_WARNING); 2625 EXPECT_EQ(cricket::VoiceMediaChannel::ERROR_REC_TYPING_NOISE_DETECTED, 2626 listener->error()); 2627 EXPECT_EQ(0U, listener->ssrc()); 2628 2629 // Add another stream and test on that. 2630 ++ssrc; 2631 EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy( 2632 ssrc))); 2633 listener->Reset(); 2634 voe_.TriggerCallbackOnError(voe_.GetLastChannel(), 2635 VE_SATURATION_WARNING); 2636 EXPECT_EQ(cricket::VoiceMediaChannel::ERROR_REC_DEVICE_SATURATION, 2637 listener->error()); 2638 EXPECT_EQ(ssrc, listener->ssrc()); 2639 2640 // Testing a non-existing channel. 2641 listener->Reset(); 2642 voe_.TriggerCallbackOnError(voe_.GetLastChannel() + 2, 2643 VE_SATURATION_WARNING); 2644 EXPECT_EQ(0, listener->error()); 2645 } 2646 2647 TEST_F(WebRtcVoiceEngineTestFake, TestSetPlayoutError) { 2648 EXPECT_TRUE(SetupEngine()); 2649 EXPECT_TRUE(channel_->SetOptions(options_conference_)); 2650 std::vector<cricket::AudioCodec> codecs; 2651 codecs.push_back(kPcmuCodec); 2652 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); 2653 EXPECT_TRUE(channel_->SetSend(cricket::SEND_MICROPHONE)); 2654 EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(2))); 2655 EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(3))); 2656 EXPECT_TRUE(channel_->SetPlayout(true)); 2657 voe_.set_playout_fail_channel(voe_.GetLastChannel() - 1); 2658 EXPECT_TRUE(channel_->SetPlayout(false)); 2659 EXPECT_FALSE(channel_->SetPlayout(true)); 2660 } 2661 2662 // Test that the Registering/Unregistering with the 2663 // webrtcvoiceengine works as expected 2664 TEST_F(WebRtcVoiceEngineTestFake, RegisterVoiceProcessor) { 2665 EXPECT_TRUE(SetupEngine()); 2666 EXPECT_TRUE(channel_->SetOptions(options_conference_)); 2667 EXPECT_TRUE(channel_->AddRecvStream( 2668 cricket::StreamParams::CreateLegacy(kSsrc2))); 2669 cricket::FakeMediaProcessor vp_1; 2670 cricket::FakeMediaProcessor vp_2; 2671 2672 EXPECT_FALSE(engine_.RegisterProcessor(kSsrc2, &vp_1, cricket::MPD_TX)); 2673 EXPECT_TRUE(engine_.RegisterProcessor(kSsrc2, &vp_1, cricket::MPD_RX)); 2674 EXPECT_TRUE(engine_.RegisterProcessor(kSsrc2, &vp_2, cricket::MPD_RX)); 2675 voe_.TriggerProcessPacket(cricket::MPD_RX); 2676 voe_.TriggerProcessPacket(cricket::MPD_TX); 2677 2678 EXPECT_TRUE(voe_.IsExternalMediaProcessorRegistered()); 2679 EXPECT_EQ(1, vp_1.voice_frame_count()); 2680 EXPECT_EQ(1, vp_2.voice_frame_count()); 2681 2682 EXPECT_TRUE(engine_.UnregisterProcessor(kSsrc2, 2683 &vp_2, 2684 cricket::MPD_RX)); 2685 voe_.TriggerProcessPacket(cricket::MPD_RX); 2686 EXPECT_TRUE(voe_.IsExternalMediaProcessorRegistered()); 2687 EXPECT_EQ(1, vp_2.voice_frame_count()); 2688 EXPECT_EQ(2, vp_1.voice_frame_count()); 2689 2690 EXPECT_TRUE(engine_.UnregisterProcessor(kSsrc2, 2691 &vp_1, 2692 cricket::MPD_RX)); 2693 voe_.TriggerProcessPacket(cricket::MPD_RX); 2694 EXPECT_FALSE(voe_.IsExternalMediaProcessorRegistered()); 2695 EXPECT_EQ(2, vp_1.voice_frame_count()); 2696 2697 EXPECT_FALSE(engine_.RegisterProcessor(kSsrc1, &vp_1, cricket::MPD_RX)); 2698 EXPECT_TRUE(engine_.RegisterProcessor(kSsrc1, &vp_1, cricket::MPD_TX)); 2699 voe_.TriggerProcessPacket(cricket::MPD_RX); 2700 voe_.TriggerProcessPacket(cricket::MPD_TX); 2701 EXPECT_TRUE(voe_.IsExternalMediaProcessorRegistered()); 2702 EXPECT_EQ(3, vp_1.voice_frame_count()); 2703 2704 EXPECT_TRUE(engine_.UnregisterProcessor(kSsrc1, 2705 &vp_1, 2706 cricket::MPD_RX_AND_TX)); 2707 voe_.TriggerProcessPacket(cricket::MPD_TX); 2708 EXPECT_FALSE(voe_.IsExternalMediaProcessorRegistered()); 2709 EXPECT_EQ(3, vp_1.voice_frame_count()); 2710 EXPECT_TRUE(channel_->RemoveRecvStream(kSsrc2)); 2711 EXPECT_FALSE(engine_.RegisterProcessor(kSsrc2, &vp_1, cricket::MPD_RX)); 2712 EXPECT_FALSE(voe_.IsExternalMediaProcessorRegistered()); 2713 2714 // Test that we can register a processor on the receive channel on SSRC 0. 2715 // This tests the 1:1 case when the receive SSRC is unknown. 2716 EXPECT_TRUE(engine_.RegisterProcessor(0, &vp_1, cricket::MPD_RX)); 2717 voe_.TriggerProcessPacket(cricket::MPD_RX); 2718 EXPECT_TRUE(voe_.IsExternalMediaProcessorRegistered()); 2719 EXPECT_EQ(4, vp_1.voice_frame_count()); 2720 EXPECT_TRUE(engine_.UnregisterProcessor(0, 2721 &vp_1, 2722 cricket::MPD_RX)); 2723 2724 // The following tests test that FindChannelNumFromSsrc is doing 2725 // what we expect. 2726 // pick an invalid ssrc and make sure we can't register 2727 EXPECT_FALSE(engine_.RegisterProcessor(99, 2728 &vp_1, 2729 cricket::MPD_RX)); 2730 EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1))); 2731 EXPECT_TRUE(engine_.RegisterProcessor(1, 2732 &vp_1, 2733 cricket::MPD_RX)); 2734 EXPECT_TRUE(engine_.UnregisterProcessor(1, 2735 &vp_1, 2736 cricket::MPD_RX)); 2737 EXPECT_FALSE(engine_.RegisterProcessor(1, 2738 &vp_1, 2739 cricket::MPD_TX)); 2740 EXPECT_TRUE(channel_->RemoveRecvStream(1)); 2741 } 2742 2743 TEST_F(WebRtcVoiceEngineTestFake, SetAudioOptions) { 2744 EXPECT_TRUE(SetupEngine()); 2745 2746 bool ec_enabled; 2747 webrtc::EcModes ec_mode; 2748 bool ec_metrics_enabled; 2749 webrtc::AecmModes aecm_mode; 2750 bool cng_enabled; 2751 bool agc_enabled; 2752 webrtc::AgcModes agc_mode; 2753 webrtc::AgcConfig agc_config; 2754 bool ns_enabled; 2755 webrtc::NsModes ns_mode; 2756 bool highpass_filter_enabled; 2757 bool stereo_swapping_enabled; 2758 bool typing_detection_enabled; 2759 voe_.GetEcStatus(ec_enabled, ec_mode); 2760 voe_.GetEcMetricsStatus(ec_metrics_enabled); 2761 voe_.GetAecmMode(aecm_mode, cng_enabled); 2762 voe_.GetAgcStatus(agc_enabled, agc_mode); 2763 voe_.GetAgcConfig(agc_config); 2764 voe_.GetNsStatus(ns_enabled, ns_mode); 2765 highpass_filter_enabled = voe_.IsHighPassFilterEnabled(); 2766 stereo_swapping_enabled = voe_.IsStereoChannelSwappingEnabled(); 2767 voe_.GetTypingDetectionStatus(typing_detection_enabled); 2768 EXPECT_TRUE(ec_enabled); 2769 EXPECT_TRUE(ec_metrics_enabled); 2770 EXPECT_FALSE(cng_enabled); 2771 EXPECT_TRUE(agc_enabled); 2772 EXPECT_EQ(0, agc_config.targetLeveldBOv); 2773 EXPECT_TRUE(ns_enabled); 2774 EXPECT_TRUE(highpass_filter_enabled); 2775 EXPECT_FALSE(stereo_swapping_enabled); 2776 EXPECT_TRUE(typing_detection_enabled); 2777 EXPECT_EQ(ec_mode, webrtc::kEcConference); 2778 EXPECT_EQ(ns_mode, webrtc::kNsHighSuppression); 2779 2780 // Nothing set, so all ignored. 2781 cricket::AudioOptions options; 2782 ASSERT_TRUE(engine_.SetOptions(options)); 2783 voe_.GetEcStatus(ec_enabled, ec_mode); 2784 voe_.GetEcMetricsStatus(ec_metrics_enabled); 2785 voe_.GetAecmMode(aecm_mode, cng_enabled); 2786 voe_.GetAgcStatus(agc_enabled, agc_mode); 2787 voe_.GetAgcConfig(agc_config); 2788 voe_.GetNsStatus(ns_enabled, ns_mode); 2789 highpass_filter_enabled = voe_.IsHighPassFilterEnabled(); 2790 stereo_swapping_enabled = voe_.IsStereoChannelSwappingEnabled(); 2791 voe_.GetTypingDetectionStatus(typing_detection_enabled); 2792 EXPECT_TRUE(ec_enabled); 2793 EXPECT_TRUE(ec_metrics_enabled); 2794 EXPECT_FALSE(cng_enabled); 2795 EXPECT_TRUE(agc_enabled); 2796 EXPECT_EQ(0, agc_config.targetLeveldBOv); 2797 EXPECT_TRUE(ns_enabled); 2798 EXPECT_TRUE(highpass_filter_enabled); 2799 EXPECT_FALSE(stereo_swapping_enabled); 2800 EXPECT_TRUE(typing_detection_enabled); 2801 EXPECT_EQ(ec_mode, webrtc::kEcConference); 2802 EXPECT_EQ(ns_mode, webrtc::kNsHighSuppression); 2803 2804 // Turn echo cancellation off 2805 options.echo_cancellation.Set(false); 2806 ASSERT_TRUE(engine_.SetOptions(options)); 2807 voe_.GetEcStatus(ec_enabled, ec_mode); 2808 EXPECT_FALSE(ec_enabled); 2809 2810 // Turn echo cancellation back on, with settings, and make sure 2811 // nothing else changed. 2812 options.echo_cancellation.Set(true); 2813 ASSERT_TRUE(engine_.SetOptions(options)); 2814 voe_.GetEcStatus(ec_enabled, ec_mode); 2815 voe_.GetEcMetricsStatus(ec_metrics_enabled); 2816 voe_.GetAecmMode(aecm_mode, cng_enabled); 2817 voe_.GetAgcStatus(agc_enabled, agc_mode); 2818 voe_.GetAgcConfig(agc_config); 2819 voe_.GetNsStatus(ns_enabled, ns_mode); 2820 highpass_filter_enabled = voe_.IsHighPassFilterEnabled(); 2821 stereo_swapping_enabled = voe_.IsStereoChannelSwappingEnabled(); 2822 voe_.GetTypingDetectionStatus(typing_detection_enabled); 2823 EXPECT_TRUE(ec_enabled); 2824 EXPECT_TRUE(ec_metrics_enabled); 2825 EXPECT_TRUE(agc_enabled); 2826 EXPECT_EQ(0, agc_config.targetLeveldBOv); 2827 EXPECT_TRUE(ns_enabled); 2828 EXPECT_TRUE(highpass_filter_enabled); 2829 EXPECT_FALSE(stereo_swapping_enabled); 2830 EXPECT_TRUE(typing_detection_enabled); 2831 EXPECT_EQ(ec_mode, webrtc::kEcConference); 2832 EXPECT_EQ(ns_mode, webrtc::kNsHighSuppression); 2833 2834 // Turn off AGC 2835 options.auto_gain_control.Set(false); 2836 ASSERT_TRUE(engine_.SetOptions(options)); 2837 voe_.GetAgcStatus(agc_enabled, agc_mode); 2838 EXPECT_FALSE(agc_enabled); 2839 2840 // Turn AGC back on 2841 options.auto_gain_control.Set(true); 2842 options.adjust_agc_delta.Clear(); 2843 ASSERT_TRUE(engine_.SetOptions(options)); 2844 voe_.GetAgcStatus(agc_enabled, agc_mode); 2845 EXPECT_TRUE(agc_enabled); 2846 voe_.GetAgcConfig(agc_config); 2847 EXPECT_EQ(0, agc_config.targetLeveldBOv); 2848 2849 // Turn off other options (and stereo swapping on). 2850 options.noise_suppression.Set(false); 2851 options.highpass_filter.Set(false); 2852 options.typing_detection.Set(false); 2853 options.stereo_swapping.Set(true); 2854 ASSERT_TRUE(engine_.SetOptions(options)); 2855 voe_.GetNsStatus(ns_enabled, ns_mode); 2856 highpass_filter_enabled = voe_.IsHighPassFilterEnabled(); 2857 stereo_swapping_enabled = voe_.IsStereoChannelSwappingEnabled(); 2858 voe_.GetTypingDetectionStatus(typing_detection_enabled); 2859 EXPECT_FALSE(ns_enabled); 2860 EXPECT_FALSE(highpass_filter_enabled); 2861 EXPECT_FALSE(typing_detection_enabled); 2862 EXPECT_TRUE(stereo_swapping_enabled); 2863 2864 // Turn on "conference mode" to ensure it has no impact. 2865 options.conference_mode.Set(true); 2866 ASSERT_TRUE(engine_.SetOptions(options)); 2867 voe_.GetEcStatus(ec_enabled, ec_mode); 2868 voe_.GetNsStatus(ns_enabled, ns_mode); 2869 EXPECT_TRUE(ec_enabled); 2870 EXPECT_EQ(webrtc::kEcConference, ec_mode); 2871 EXPECT_FALSE(ns_enabled); 2872 EXPECT_EQ(webrtc::kNsHighSuppression, ns_mode); 2873 } 2874 2875 TEST_F(WebRtcVoiceEngineTestFake, DefaultOptions) { 2876 EXPECT_TRUE(SetupEngine()); 2877 2878 bool ec_enabled; 2879 webrtc::EcModes ec_mode; 2880 bool ec_metrics_enabled; 2881 bool agc_enabled; 2882 webrtc::AgcModes agc_mode; 2883 bool ns_enabled; 2884 webrtc::NsModes ns_mode; 2885 bool highpass_filter_enabled; 2886 bool stereo_swapping_enabled; 2887 bool typing_detection_enabled; 2888 2889 voe_.GetEcStatus(ec_enabled, ec_mode); 2890 voe_.GetEcMetricsStatus(ec_metrics_enabled); 2891 voe_.GetAgcStatus(agc_enabled, agc_mode); 2892 voe_.GetNsStatus(ns_enabled, ns_mode); 2893 highpass_filter_enabled = voe_.IsHighPassFilterEnabled(); 2894 stereo_swapping_enabled = voe_.IsStereoChannelSwappingEnabled(); 2895 voe_.GetTypingDetectionStatus(typing_detection_enabled); 2896 EXPECT_TRUE(ec_enabled); 2897 EXPECT_TRUE(agc_enabled); 2898 EXPECT_TRUE(ns_enabled); 2899 EXPECT_TRUE(highpass_filter_enabled); 2900 EXPECT_TRUE(typing_detection_enabled); 2901 EXPECT_FALSE(stereo_swapping_enabled); 2902 } 2903 2904 TEST_F(WebRtcVoiceEngineTestFake, InitDoesNotOverwriteDefaultAgcConfig) { 2905 webrtc::AgcConfig set_config = {0}; 2906 set_config.targetLeveldBOv = 3; 2907 set_config.digitalCompressionGaindB = 9; 2908 set_config.limiterEnable = true; 2909 EXPECT_EQ(0, voe_.SetAgcConfig(set_config)); 2910 EXPECT_TRUE(engine_.Init(rtc::Thread::Current())); 2911 2912 webrtc::AgcConfig config = {0}; 2913 EXPECT_EQ(0, voe_.GetAgcConfig(config)); 2914 EXPECT_EQ(set_config.targetLeveldBOv, config.targetLeveldBOv); 2915 EXPECT_EQ(set_config.digitalCompressionGaindB, 2916 config.digitalCompressionGaindB); 2917 EXPECT_EQ(set_config.limiterEnable, config.limiterEnable); 2918 } 2919 2920 TEST_F(WebRtcVoiceEngineTestFake, SetOptionOverridesViaChannels) { 2921 EXPECT_TRUE(SetupEngine()); 2922 rtc::scoped_ptr<cricket::VoiceMediaChannel> channel1( 2923 engine_.CreateChannel()); 2924 rtc::scoped_ptr<cricket::VoiceMediaChannel> channel2( 2925 engine_.CreateChannel()); 2926 2927 // Have to add a stream to make SetSend work. 2928 cricket::StreamParams stream1; 2929 stream1.ssrcs.push_back(1); 2930 channel1->AddSendStream(stream1); 2931 cricket::StreamParams stream2; 2932 stream2.ssrcs.push_back(2); 2933 channel2->AddSendStream(stream2); 2934 2935 // AEC and AGC and NS 2936 cricket::AudioOptions options_all; 2937 options_all.echo_cancellation.Set(true); 2938 options_all.auto_gain_control.Set(true); 2939 options_all.noise_suppression.Set(true); 2940 2941 ASSERT_TRUE(channel1->SetOptions(options_all)); 2942 cricket::AudioOptions expected_options = options_all; 2943 cricket::AudioOptions actual_options; 2944 ASSERT_TRUE(channel1->GetOptions(&actual_options)); 2945 EXPECT_EQ(expected_options, actual_options); 2946 ASSERT_TRUE(channel2->SetOptions(options_all)); 2947 ASSERT_TRUE(channel2->GetOptions(&actual_options)); 2948 EXPECT_EQ(expected_options, actual_options); 2949 2950 // unset NS 2951 cricket::AudioOptions options_no_ns; 2952 options_no_ns.noise_suppression.Set(false); 2953 ASSERT_TRUE(channel1->SetOptions(options_no_ns)); 2954 2955 expected_options.echo_cancellation.Set(true); 2956 expected_options.auto_gain_control.Set(true); 2957 expected_options.noise_suppression.Set(false); 2958 ASSERT_TRUE(channel1->GetOptions(&actual_options)); 2959 EXPECT_EQ(expected_options, actual_options); 2960 2961 // unset AGC 2962 cricket::AudioOptions options_no_agc; 2963 options_no_agc.auto_gain_control.Set(false); 2964 ASSERT_TRUE(channel2->SetOptions(options_no_agc)); 2965 2966 expected_options.echo_cancellation.Set(true); 2967 expected_options.auto_gain_control.Set(false); 2968 expected_options.noise_suppression.Set(true); 2969 ASSERT_TRUE(channel2->GetOptions(&actual_options)); 2970 EXPECT_EQ(expected_options, actual_options); 2971 2972 ASSERT_TRUE(engine_.SetOptions(options_all)); 2973 bool ec_enabled; 2974 webrtc::EcModes ec_mode; 2975 bool agc_enabled; 2976 webrtc::AgcModes agc_mode; 2977 bool ns_enabled; 2978 webrtc::NsModes ns_mode; 2979 voe_.GetEcStatus(ec_enabled, ec_mode); 2980 voe_.GetAgcStatus(agc_enabled, agc_mode); 2981 voe_.GetNsStatus(ns_enabled, ns_mode); 2982 EXPECT_TRUE(ec_enabled); 2983 EXPECT_TRUE(agc_enabled); 2984 EXPECT_TRUE(ns_enabled); 2985 2986 channel1->SetSend(cricket::SEND_MICROPHONE); 2987 voe_.GetEcStatus(ec_enabled, ec_mode); 2988 voe_.GetAgcStatus(agc_enabled, agc_mode); 2989 voe_.GetNsStatus(ns_enabled, ns_mode); 2990 EXPECT_TRUE(ec_enabled); 2991 EXPECT_TRUE(agc_enabled); 2992 EXPECT_FALSE(ns_enabled); 2993 2994 channel1->SetSend(cricket::SEND_NOTHING); 2995 voe_.GetEcStatus(ec_enabled, ec_mode); 2996 voe_.GetAgcStatus(agc_enabled, agc_mode); 2997 voe_.GetNsStatus(ns_enabled, ns_mode); 2998 EXPECT_TRUE(ec_enabled); 2999 EXPECT_TRUE(agc_enabled); 3000 EXPECT_TRUE(ns_enabled); 3001 3002 channel2->SetSend(cricket::SEND_MICROPHONE); 3003 voe_.GetEcStatus(ec_enabled, ec_mode); 3004 voe_.GetAgcStatus(agc_enabled, agc_mode); 3005 voe_.GetNsStatus(ns_enabled, ns_mode); 3006 EXPECT_TRUE(ec_enabled); 3007 EXPECT_FALSE(agc_enabled); 3008 EXPECT_TRUE(ns_enabled); 3009 3010 channel2->SetSend(cricket::SEND_NOTHING); 3011 voe_.GetEcStatus(ec_enabled, ec_mode); 3012 voe_.GetAgcStatus(agc_enabled, agc_mode); 3013 voe_.GetNsStatus(ns_enabled, ns_mode); 3014 EXPECT_TRUE(ec_enabled); 3015 EXPECT_TRUE(agc_enabled); 3016 EXPECT_TRUE(ns_enabled); 3017 3018 // Make sure settings take effect while we are sending. 3019 ASSERT_TRUE(engine_.SetOptions(options_all)); 3020 cricket::AudioOptions options_no_agc_nor_ns; 3021 options_no_agc_nor_ns.auto_gain_control.Set(false); 3022 options_no_agc_nor_ns.noise_suppression.Set(false); 3023 channel2->SetSend(cricket::SEND_MICROPHONE); 3024 channel2->SetOptions(options_no_agc_nor_ns); 3025 3026 expected_options.echo_cancellation.Set(true); 3027 expected_options.auto_gain_control.Set(false); 3028 expected_options.noise_suppression.Set(false); 3029 ASSERT_TRUE(channel2->GetOptions(&actual_options)); 3030 EXPECT_EQ(expected_options, actual_options); 3031 voe_.GetEcStatus(ec_enabled, ec_mode); 3032 voe_.GetAgcStatus(agc_enabled, agc_mode); 3033 voe_.GetNsStatus(ns_enabled, ns_mode); 3034 EXPECT_TRUE(ec_enabled); 3035 EXPECT_FALSE(agc_enabled); 3036 EXPECT_FALSE(ns_enabled); 3037 } 3038 3039 // This test verifies DSCP settings are properly applied on voice media channel. 3040 TEST_F(WebRtcVoiceEngineTestFake, TestSetDscpOptions) { 3041 EXPECT_TRUE(SetupEngine()); 3042 rtc::scoped_ptr<cricket::VoiceMediaChannel> channel( 3043 engine_.CreateChannel()); 3044 rtc::scoped_ptr<cricket::FakeNetworkInterface> network_interface( 3045 new cricket::FakeNetworkInterface); 3046 channel->SetInterface(network_interface.get()); 3047 cricket::AudioOptions options; 3048 options.dscp.Set(true); 3049 EXPECT_TRUE(channel->SetOptions(options)); 3050 EXPECT_EQ(rtc::DSCP_EF, network_interface->dscp()); 3051 // Verify previous value is not modified if dscp option is not set. 3052 cricket::AudioOptions options1; 3053 EXPECT_TRUE(channel->SetOptions(options1)); 3054 EXPECT_EQ(rtc::DSCP_EF, network_interface->dscp()); 3055 options.dscp.Set(false); 3056 EXPECT_TRUE(channel->SetOptions(options)); 3057 EXPECT_EQ(rtc::DSCP_DEFAULT, network_interface->dscp()); 3058 } 3059 3060 TEST(WebRtcVoiceEngineTest, TestDefaultOptionsBeforeInit) { 3061 cricket::WebRtcVoiceEngine engine; 3062 cricket::AudioOptions options = engine.GetOptions(); 3063 // The default options should have at least a few things set. We purposefully 3064 // don't check the option values here, though. 3065 EXPECT_TRUE(options.echo_cancellation.IsSet()); 3066 EXPECT_TRUE(options.auto_gain_control.IsSet()); 3067 EXPECT_TRUE(options.noise_suppression.IsSet()); 3068 } 3069 3070 // Test that GetReceiveChannelNum returns the default channel for the first 3071 // recv stream in 1-1 calls. 3072 TEST_F(WebRtcVoiceEngineTestFake, TestGetReceiveChannelNumIn1To1Calls) { 3073 EXPECT_TRUE(SetupEngine()); 3074 cricket::WebRtcVoiceMediaChannel* media_channel = 3075 static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_); 3076 // Test that GetChannelNum returns the default channel if the SSRC is unknown. 3077 EXPECT_EQ(media_channel->voe_channel(), 3078 media_channel->GetReceiveChannelNum(0)); 3079 cricket::StreamParams stream; 3080 stream.ssrcs.push_back(kSsrc2); 3081 EXPECT_TRUE(channel_->AddRecvStream(stream)); 3082 EXPECT_EQ(media_channel->voe_channel(), 3083 media_channel->GetReceiveChannelNum(kSsrc2)); 3084 } 3085 3086 // Test that GetReceiveChannelNum doesn't return the default channel for the 3087 // first recv stream in conference calls. 3088 TEST_F(WebRtcVoiceEngineTestFake, TestGetChannelNumInConferenceCalls) { 3089 EXPECT_TRUE(SetupEngine()); 3090 EXPECT_TRUE(channel_->SetOptions(options_conference_)); 3091 cricket::StreamParams stream; 3092 stream.ssrcs.push_back(kSsrc2); 3093 EXPECT_TRUE(channel_->AddRecvStream(stream)); 3094 cricket::WebRtcVoiceMediaChannel* media_channel = 3095 static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_); 3096 EXPECT_LT(media_channel->voe_channel(), 3097 media_channel->GetReceiveChannelNum(kSsrc2)); 3098 } 3099 3100 TEST_F(WebRtcVoiceEngineTestFake, SetOutputScaling) { 3101 EXPECT_TRUE(SetupEngine()); 3102 double left, right; 3103 EXPECT_TRUE(channel_->SetOutputScaling(0, 1, 2)); 3104 EXPECT_TRUE(channel_->GetOutputScaling(0, &left, &right)); 3105 EXPECT_DOUBLE_EQ(1, left); 3106 EXPECT_DOUBLE_EQ(2, right); 3107 3108 EXPECT_FALSE(channel_->SetOutputScaling(kSsrc2, 1, 2)); 3109 cricket::StreamParams stream; 3110 stream.ssrcs.push_back(kSsrc2); 3111 EXPECT_TRUE(channel_->AddRecvStream(stream)); 3112 3113 EXPECT_TRUE(channel_->SetOutputScaling(kSsrc2, 2, 1)); 3114 EXPECT_TRUE(channel_->GetOutputScaling(kSsrc2, &left, &right)); 3115 EXPECT_DOUBLE_EQ(2, left); 3116 EXPECT_DOUBLE_EQ(1, right); 3117 } 3118 3119 // Tests for the actual WebRtc VoE library. 3120 3121 // Tests that the library initializes and shuts down properly. 3122 TEST(WebRtcVoiceEngineTest, StartupShutdown) { 3123 cricket::WebRtcVoiceEngine engine; 3124 EXPECT_TRUE(engine.Init(rtc::Thread::Current())); 3125 cricket::VoiceMediaChannel* channel = engine.CreateChannel(); 3126 EXPECT_TRUE(channel != NULL); 3127 delete channel; 3128 engine.Terminate(); 3129 3130 // Reinit to catch regression where VoiceEngineObserver reference is lost 3131 EXPECT_TRUE(engine.Init(rtc::Thread::Current())); 3132 engine.Terminate(); 3133 } 3134 3135 // Tests that the logging from the library is cleartext. 3136 TEST(WebRtcVoiceEngineTest, DISABLED_HasUnencryptedLogging) { 3137 cricket::WebRtcVoiceEngine engine; 3138 rtc::scoped_ptr<rtc::MemoryStream> stream( 3139 new rtc::MemoryStream); 3140 size_t size = 0; 3141 bool cleartext = true; 3142 rtc::LogMessage::AddLogToStream(stream.get(), rtc::LS_VERBOSE); 3143 engine.SetLogging(rtc::LS_VERBOSE, ""); 3144 EXPECT_TRUE(engine.Init(rtc::Thread::Current())); 3145 EXPECT_TRUE(stream->GetSize(&size)); 3146 EXPECT_GT(size, 0U); 3147 engine.Terminate(); 3148 rtc::LogMessage::RemoveLogToStream(stream.get()); 3149 const char* buf = stream->GetBuffer(); 3150 for (size_t i = 0; i < size && cleartext; ++i) { 3151 int ch = static_cast<int>(buf[i]); 3152 ASSERT_GE(ch, 0) << "Out of bounds character in WebRtc VoE log: " 3153 << std::hex << ch; 3154 cleartext = (isprint(ch) || isspace(ch)); 3155 } 3156 EXPECT_TRUE(cleartext); 3157 } 3158 3159 // Tests we do not see any references to a monitor thread being spun up 3160 // when initiating the engine. 3161 TEST(WebRtcVoiceEngineTest, HasNoMonitorThread) { 3162 cricket::WebRtcVoiceEngine engine; 3163 rtc::scoped_ptr<rtc::MemoryStream> stream( 3164 new rtc::MemoryStream); 3165 rtc::LogMessage::AddLogToStream(stream.get(), rtc::LS_VERBOSE); 3166 engine.SetLogging(rtc::LS_VERBOSE, ""); 3167 EXPECT_TRUE(engine.Init(rtc::Thread::Current())); 3168 engine.Terminate(); 3169 rtc::LogMessage::RemoveLogToStream(stream.get()); 3170 3171 size_t size = 0; 3172 EXPECT_TRUE(stream->GetSize(&size)); 3173 EXPECT_GT(size, 0U); 3174 const std::string logs(stream->GetBuffer(), size); 3175 EXPECT_NE(std::string::npos, logs.find("ProcessThread")); 3176 } 3177 3178 // Tests that the library is configured with the codecs we want. 3179 TEST(WebRtcVoiceEngineTest, HasCorrectCodecs) { 3180 cricket::WebRtcVoiceEngine engine; 3181 // Check codecs by name. 3182 EXPECT_TRUE(engine.FindCodec( 3183 cricket::AudioCodec(96, "OPUS", 48000, 0, 2, 0))); 3184 EXPECT_TRUE(engine.FindCodec( 3185 cricket::AudioCodec(96, "ISAC", 16000, 0, 1, 0))); 3186 EXPECT_TRUE(engine.FindCodec( 3187 cricket::AudioCodec(96, "ISAC", 32000, 0, 1, 0))); 3188 // Check that name matching is case-insensitive. 3189 EXPECT_TRUE(engine.FindCodec( 3190 cricket::AudioCodec(96, "ILBC", 8000, 0, 1, 0))); 3191 EXPECT_TRUE(engine.FindCodec( 3192 cricket::AudioCodec(96, "iLBC", 8000, 0, 1, 0))); 3193 EXPECT_TRUE(engine.FindCodec( 3194 cricket::AudioCodec(96, "PCMU", 8000, 0, 1, 0))); 3195 EXPECT_TRUE(engine.FindCodec( 3196 cricket::AudioCodec(96, "PCMA", 8000, 0, 1, 0))); 3197 EXPECT_TRUE(engine.FindCodec( 3198 cricket::AudioCodec(96, "G722", 16000, 0, 1, 0))); 3199 EXPECT_TRUE(engine.FindCodec( 3200 cricket::AudioCodec(96, "red", 8000, 0, 1, 0))); 3201 EXPECT_TRUE(engine.FindCodec( 3202 cricket::AudioCodec(96, "CN", 32000, 0, 1, 0))); 3203 EXPECT_TRUE(engine.FindCodec( 3204 cricket::AudioCodec(96, "CN", 16000, 0, 1, 0))); 3205 EXPECT_TRUE(engine.FindCodec( 3206 cricket::AudioCodec(96, "CN", 8000, 0, 1, 0))); 3207 EXPECT_TRUE(engine.FindCodec( 3208 cricket::AudioCodec(96, "telephone-event", 8000, 0, 1, 0))); 3209 // Check codecs with an id by id. 3210 EXPECT_TRUE(engine.FindCodec( 3211 cricket::AudioCodec(0, "", 8000, 0, 1, 0))); // PCMU 3212 EXPECT_TRUE(engine.FindCodec( 3213 cricket::AudioCodec(8, "", 8000, 0, 1, 0))); // PCMA 3214 EXPECT_TRUE(engine.FindCodec( 3215 cricket::AudioCodec(9, "", 16000, 0, 1, 0))); // G722 3216 EXPECT_TRUE(engine.FindCodec( 3217 cricket::AudioCodec(13, "", 8000, 0, 1, 0))); // CN 3218 // Check sample/bitrate matching. 3219 EXPECT_TRUE(engine.FindCodec( 3220 cricket::AudioCodec(0, "PCMU", 8000, 64000, 1, 0))); 3221 // Check that bad codecs fail. 3222 EXPECT_FALSE(engine.FindCodec(cricket::AudioCodec(99, "ABCD", 0, 0, 1, 0))); 3223 EXPECT_FALSE(engine.FindCodec(cricket::AudioCodec(88, "", 0, 0, 1, 0))); 3224 EXPECT_FALSE(engine.FindCodec(cricket::AudioCodec(0, "", 0, 0, 2, 0))); 3225 EXPECT_FALSE(engine.FindCodec(cricket::AudioCodec(0, "", 5000, 0, 1, 0))); 3226 EXPECT_FALSE(engine.FindCodec(cricket::AudioCodec(0, "", 0, 5000, 1, 0))); 3227 // Verify the payload id of common audio codecs, including CN, ISAC, and G722. 3228 for (std::vector<cricket::AudioCodec>::const_iterator it = 3229 engine.codecs().begin(); it != engine.codecs().end(); ++it) { 3230 if (it->name == "CN" && it->clockrate == 16000) { 3231 EXPECT_EQ(105, it->id); 3232 } else if (it->name == "CN" && it->clockrate == 32000) { 3233 EXPECT_EQ(106, it->id); 3234 } else if (it->name == "ISAC" && it->clockrate == 16000) { 3235 EXPECT_EQ(103, it->id); 3236 } else if (it->name == "ISAC" && it->clockrate == 32000) { 3237 EXPECT_EQ(104, it->id); 3238 } else if (it->name == "G722" && it->clockrate == 16000) { 3239 EXPECT_EQ(9, it->id); 3240 } else if (it->name == "telephone-event") { 3241 EXPECT_EQ(126, it->id); 3242 } else if (it->name == "red") { 3243 EXPECT_EQ(127, it->id); 3244 } else if (it->name == "opus") { 3245 EXPECT_EQ(111, it->id); 3246 ASSERT_TRUE(it->params.find("minptime") != it->params.end()); 3247 EXPECT_EQ("10", it->params.find("minptime")->second); 3248 ASSERT_TRUE(it->params.find("maxptime") != it->params.end()); 3249 EXPECT_EQ("60", it->params.find("maxptime")->second); 3250 } 3251 } 3252 3253 engine.Terminate(); 3254 } 3255 3256 // Tests that VoE supports at least 32 channels 3257 TEST(WebRtcVoiceEngineTest, Has32Channels) { 3258 cricket::WebRtcVoiceEngine engine; 3259 EXPECT_TRUE(engine.Init(rtc::Thread::Current())); 3260 3261 cricket::VoiceMediaChannel* channels[32]; 3262 int num_channels = 0; 3263 3264 while (num_channels < ARRAY_SIZE(channels)) { 3265 cricket::VoiceMediaChannel* channel = engine.CreateChannel(); 3266 if (!channel) 3267 break; 3268 3269 channels[num_channels++] = channel; 3270 } 3271 3272 int expected = ARRAY_SIZE(channels); 3273 EXPECT_EQ(expected, num_channels); 3274 3275 while (num_channels > 0) { 3276 delete channels[--num_channels]; 3277 } 3278 3279 engine.Terminate(); 3280 } 3281 3282 // Test that we set our preferred codecs properly. 3283 TEST(WebRtcVoiceEngineTest, SetRecvCodecs) { 3284 cricket::WebRtcVoiceEngine engine; 3285 EXPECT_TRUE(engine.Init(rtc::Thread::Current())); 3286 cricket::WebRtcVoiceMediaChannel channel(&engine); 3287 EXPECT_TRUE(channel.SetRecvCodecs(engine.codecs())); 3288 } 3289 3290 #ifdef WIN32 3291 // Test our workarounds to WebRtc VoE' munging of the coinit count 3292 TEST(WebRtcVoiceEngineTest, CoInitialize) { 3293 cricket::WebRtcVoiceEngine* engine = new cricket::WebRtcVoiceEngine(); 3294 3295 // Initial refcount should be 0. 3296 EXPECT_EQ(S_OK, CoInitializeEx(NULL, COINIT_MULTITHREADED)); 3297 3298 // Engine should start even with COM already inited. 3299 EXPECT_TRUE(engine->Init(rtc::Thread::Current())); 3300 engine->Terminate(); 3301 EXPECT_TRUE(engine->Init(rtc::Thread::Current())); 3302 engine->Terminate(); 3303 3304 // Refcount after terminate should be 1 (in reality 3); test if it is nonzero. 3305 EXPECT_EQ(S_FALSE, CoInitializeEx(NULL, COINIT_MULTITHREADED)); 3306 // Decrement refcount to (hopefully) 0. 3307 CoUninitialize(); 3308 CoUninitialize(); 3309 delete engine; 3310 3311 // Ensure refcount is 0. 3312 EXPECT_EQ(S_OK, CoInitializeEx(NULL, COINIT_MULTITHREADED)); 3313 CoUninitialize(); 3314 } 3315 #endif 3316 3317 TEST_F(WebRtcVoiceEngineTestFake, ChangeCombinedAudioVideoBweOption) { 3318 // Test that changing the combined_audio_video_bwe option results in the 3319 // expected state changes in VoiceEngine. 3320 cricket::ViEWrapper vie; 3321 const int kVieCh = 667; 3322 3323 EXPECT_TRUE(SetupEngine()); 3324 cricket::WebRtcVoiceMediaChannel* media_channel = 3325 static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_); 3326 EXPECT_TRUE(media_channel->SetupSharedBandwidthEstimation(vie.engine(), 3327 kVieCh)); 3328 EXPECT_TRUE(media_channel->AddRecvStream( 3329 cricket::StreamParams::CreateLegacy(2))); 3330 int recv_ch = voe_.GetLastChannel(); 3331 3332 // Combined BWE should not be set up yet. 3333 EXPECT_EQ(NULL, voe_.GetViENetwork(recv_ch)); 3334 EXPECT_EQ(-1, voe_.GetVideoChannel(recv_ch)); 3335 3336 // Enable combined BWE option - now it should be set up. 3337 cricket::AudioOptions options; 3338 options.combined_audio_video_bwe.Set(true); 3339 EXPECT_TRUE(media_channel->SetOptions(options)); 3340 EXPECT_EQ(vie.network(), voe_.GetViENetwork(recv_ch)); 3341 EXPECT_EQ(kVieCh, voe_.GetVideoChannel(recv_ch)); 3342 3343 // Disable combined BWE option - should be disabled again. 3344 options.combined_audio_video_bwe.Set(false); 3345 EXPECT_TRUE(media_channel->SetOptions(options)); 3346 EXPECT_EQ(NULL, voe_.GetViENetwork(recv_ch)); 3347 EXPECT_EQ(-1, voe_.GetVideoChannel(recv_ch)); 3348 3349 EXPECT_TRUE(media_channel->SetupSharedBandwidthEstimation(NULL, -1)); 3350 } 3351 3352 TEST_F(WebRtcVoiceEngineTestFake, SetupSharedBandwidthEstimation) { 3353 // Test that calling SetupSharedBandwidthEstimation() on the voice media 3354 // channel results in the expected state changes in VoiceEngine. 3355 cricket::ViEWrapper vie1; 3356 cricket::ViEWrapper vie2; 3357 const int kVieCh1 = 667; 3358 const int kVieCh2 = 70; 3359 3360 EXPECT_TRUE(SetupEngine()); 3361 cricket::WebRtcVoiceMediaChannel* media_channel = 3362 static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_); 3363 cricket::AudioOptions options; 3364 options.combined_audio_video_bwe.Set(true); 3365 EXPECT_TRUE(media_channel->SetOptions(options)); 3366 EXPECT_TRUE(media_channel->AddRecvStream( 3367 cricket::StreamParams::CreateLegacy(2))); 3368 int recv_ch = voe_.GetLastChannel(); 3369 3370 // Combined BWE should not be set up yet. 3371 EXPECT_EQ(NULL, voe_.GetViENetwork(recv_ch)); 3372 EXPECT_EQ(-1, voe_.GetVideoChannel(recv_ch)); 3373 3374 // Register - should be enabled. 3375 EXPECT_TRUE(media_channel->SetupSharedBandwidthEstimation(vie1.engine(), 3376 kVieCh1)); 3377 EXPECT_EQ(vie1.network(), voe_.GetViENetwork(recv_ch)); 3378 EXPECT_EQ(kVieCh1, voe_.GetVideoChannel(recv_ch)); 3379 3380 // Re-register - should still be enabled. 3381 EXPECT_TRUE(media_channel->SetupSharedBandwidthEstimation(vie2.engine(), 3382 kVieCh2)); 3383 EXPECT_EQ(vie2.network(), voe_.GetViENetwork(recv_ch)); 3384 EXPECT_EQ(kVieCh2, voe_.GetVideoChannel(recv_ch)); 3385 3386 // Unregister - should be disabled again. 3387 EXPECT_TRUE(media_channel->SetupSharedBandwidthEstimation(NULL, -1)); 3388 EXPECT_EQ(NULL, voe_.GetViENetwork(recv_ch)); 3389 EXPECT_EQ(-1, voe_.GetVideoChannel(recv_ch)); 3390 } 3391 3392 TEST_F(WebRtcVoiceEngineTestFake, ConfigureCombinedBweForNewRecvStreams) { 3393 // Test that adding receive streams after enabling combined bandwidth 3394 // estimation will correctly configure each channel. 3395 cricket::ViEWrapper vie; 3396 const int kVieCh = 667; 3397 3398 EXPECT_TRUE(SetupEngine()); 3399 cricket::WebRtcVoiceMediaChannel* media_channel = 3400 static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_); 3401 EXPECT_TRUE(media_channel->SetupSharedBandwidthEstimation(vie.engine(), 3402 kVieCh)); 3403 cricket::AudioOptions options; 3404 options.combined_audio_video_bwe.Set(true); 3405 EXPECT_TRUE(media_channel->SetOptions(options)); 3406 3407 static const uint32 kSsrcs[] = {1, 2, 3, 4}; 3408 int voe_channels[ARRAY_SIZE(kSsrcs)] = {0}; 3409 for (unsigned int i = 0; i < ARRAY_SIZE(kSsrcs); ++i) { 3410 EXPECT_TRUE(media_channel->AddRecvStream( 3411 cricket::StreamParams::CreateLegacy(kSsrcs[i]))); 3412 int recv_ch = media_channel->GetReceiveChannelNum(kSsrcs[i]); 3413 EXPECT_NE(-1, recv_ch); 3414 voe_channels[i] = recv_ch; 3415 EXPECT_EQ(vie.network(), voe_.GetViENetwork(recv_ch)); 3416 EXPECT_EQ(kVieCh, voe_.GetVideoChannel(recv_ch)); 3417 } 3418 3419 EXPECT_TRUE(media_channel->SetupSharedBandwidthEstimation(NULL, -1)); 3420 3421 for (unsigned int i = 0; i < ARRAY_SIZE(voe_channels); ++i) { 3422 EXPECT_EQ(NULL, voe_.GetViENetwork(voe_channels[i])); 3423 EXPECT_EQ(-1, voe_.GetVideoChannel(voe_channels[i])); 3424 } 3425 } 3426
