henrike@webrtc.org | 79047f9 | 2014-03-06 23:46:59 +0000 | [diff] [blame] | 1 | /* |
kjellander | 1afca73 | 2016-02-07 20:46:45 -0800 | [diff] [blame] | 2 | * Copyright (c) 2008 The WebRTC project authors. All Rights Reserved. |
henrike@webrtc.org | 79047f9 | 2014-03-06 23:46:59 +0000 | [diff] [blame] | 3 | * |
kjellander | 1afca73 | 2016-02-07 20:46:45 -0800 | [diff] [blame] | 4 | * Use of this source code is governed by a BSD-style license |
| 5 | * that can be found in the LICENSE file in the root of the source |
| 6 | * tree. An additional intellectual property rights grant can be found |
| 7 | * in the file PATENTS. All contributing project authors may |
| 8 | * be found in the AUTHORS file in the root of the source tree. |
henrike@webrtc.org | 79047f9 | 2014-03-06 23:46:59 +0000 | [diff] [blame] | 9 | */ |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 10 | |
kwiberg | 686a8ef | 2016-02-26 03:00:35 -0800 | [diff] [blame] | 11 | #include <memory> |
| 12 | |
kjellander@webrtc.org | 9b8df25 | 2016-02-12 06:47:59 +0100 | [diff] [blame] | 13 | #include "webrtc/pc/channel.h" |
tfarina | 5237aaf | 2015-11-10 23:44:30 -0800 | [diff] [blame] | 14 | #include "webrtc/base/arraysize.h" |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 15 | #include "webrtc/base/byteorder.h" |
| 16 | #include "webrtc/base/gunit.h" |
Fredrik Solenberg | 709ed67 | 2015-09-15 12:26:33 +0200 | [diff] [blame] | 17 | #include "webrtc/call.h" |
stefan | ba4c0e4 | 2016-02-04 04:12:24 -0800 | [diff] [blame] | 18 | #include "webrtc/p2p/base/faketransportcontroller.h" |
| 19 | #include "webrtc/test/field_trial.h" |
kjellander | a96e2d7 | 2016-02-04 23:52:28 -0800 | [diff] [blame] | 20 | #include "webrtc/media/base/fakemediaengine.h" |
| 21 | #include "webrtc/media/base/fakenetworkinterface.h" |
| 22 | #include "webrtc/media/base/fakertp.h" |
kjellander | f475277 | 2016-03-02 05:42:30 -0800 | [diff] [blame] | 23 | #include "webrtc/media/base/mediaconstants.h" |
kjellander@webrtc.org | 5ad1297 | 2016-02-12 06:39:40 +0100 | [diff] [blame] | 24 | #include "webrtc/media/engine/fakewebrtccall.h" |
| 25 | #include "webrtc/media/engine/fakewebrtcvoiceengine.h" |
| 26 | #include "webrtc/media/engine/webrtcvoiceengine.h" |
ossu | 29b1a8d | 2016-06-13 07:34:51 -0700 | [diff] [blame] | 27 | #include "webrtc/modules/audio_coding/codecs/builtin_audio_decoder_factory.h" |
| 28 | #include "webrtc/modules/audio_coding/codecs/mock/mock_audio_decoder_factory.h" |
solenberg | bc37fc8 | 2016-04-04 09:54:44 -0700 | [diff] [blame] | 29 | #include "webrtc/modules/audio_device/include/mock_audio_device.h" |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 30 | |
solenberg | bc37fc8 | 2016-04-04 09:54:44 -0700 | [diff] [blame] | 31 | using testing::Return; |
| 32 | using testing::StrictMock; |
buildbot@webrtc.org | 150835e | 2014-05-06 15:54:38 +0000 | [diff] [blame] | 33 | |
Fredrik Solenberg | 4f4ec0a | 2015-10-22 10:49:27 +0200 | [diff] [blame] | 34 | namespace { |
| 35 | |
deadbeef | 67cf2c1 | 2016-04-13 10:07:16 -0700 | [diff] [blame] | 36 | const cricket::AudioCodec kPcmuCodec(0, "PCMU", 8000, 64000, 1); |
| 37 | const cricket::AudioCodec kIsacCodec(103, "ISAC", 16000, 32000, 1); |
| 38 | const cricket::AudioCodec kOpusCodec(111, "opus", 48000, 64000, 2); |
| 39 | const cricket::AudioCodec kG722CodecVoE(9, "G722", 16000, 64000, 1); |
| 40 | const cricket::AudioCodec kG722CodecSdp(9, "G722", 8000, 64000, 1); |
deadbeef | 67cf2c1 | 2016-04-13 10:07:16 -0700 | [diff] [blame] | 41 | const cricket::AudioCodec kCn8000Codec(13, "CN", 8000, 0, 1); |
| 42 | const cricket::AudioCodec kCn16000Codec(105, "CN", 16000, 0, 1); |
| 43 | const cricket::AudioCodec kTelephoneEventCodec(106, |
| 44 | "telephone-event", |
| 45 | 8000, |
| 46 | 0, |
| 47 | 1); |
solenberg | 85a0496 | 2015-10-27 03:35:21 -0700 | [diff] [blame] | 48 | const uint32_t kSsrc1 = 0x99; |
Taylor Brandstetter | 1a018dc | 2016-03-08 12:37:39 -0800 | [diff] [blame] | 49 | const uint32_t kSsrc2 = 2; |
| 50 | const uint32_t kSsrc3 = 3; |
solenberg | 85a0496 | 2015-10-27 03:35:21 -0700 | [diff] [blame] | 51 | const uint32_t kSsrcs4[] = { 1, 2, 3, 4 }; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 52 | |
solenberg | 971cab0 | 2016-06-14 10:02:41 -0700 | [diff] [blame] | 53 | constexpr int kRtpHistoryMs = 5000; |
| 54 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 55 | class FakeVoEWrapper : public cricket::VoEWrapper { |
| 56 | public: |
| 57 | explicit FakeVoEWrapper(cricket::FakeWebRtcVoiceEngine* engine) |
| 58 | : cricket::VoEWrapper(engine, // processing |
| 59 | engine, // base |
| 60 | engine, // codec |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 61 | engine, // hw |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 62 | engine, // rtp |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 63 | engine) { // volume |
| 64 | } |
| 65 | }; |
Fredrik Solenberg | 4f4ec0a | 2015-10-22 10:49:27 +0200 | [diff] [blame] | 66 | } // namespace |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 67 | |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 68 | // Tests that our stub library "works". |
| 69 | TEST(WebRtcVoiceEngineTestStubLibrary, StartupShutdown) { |
solenberg | bc37fc8 | 2016-04-04 09:54:44 -0700 | [diff] [blame] | 70 | StrictMock<webrtc::test::MockAudioDeviceModule> adm; |
| 71 | EXPECT_CALL(adm, AddRef()).WillOnce(Return(0)); |
| 72 | EXPECT_CALL(adm, Release()).WillOnce(Return(0)); |
solenberg | 5b5129a | 2016-04-08 05:35:48 -0700 | [diff] [blame] | 73 | EXPECT_CALL(adm, BuiltInAECIsAvailable()).WillOnce(Return(false)); |
| 74 | EXPECT_CALL(adm, BuiltInAGCIsAvailable()).WillOnce(Return(false)); |
| 75 | EXPECT_CALL(adm, BuiltInNSIsAvailable()).WillOnce(Return(false)); |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 76 | cricket::FakeWebRtcVoiceEngine voe; |
| 77 | EXPECT_FALSE(voe.IsInited()); |
| 78 | { |
ossu | 29b1a8d | 2016-06-13 07:34:51 -0700 | [diff] [blame] | 79 | cricket::WebRtcVoiceEngine engine(&adm, nullptr, new FakeVoEWrapper(&voe)); |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 80 | EXPECT_TRUE(voe.IsInited()); |
| 81 | } |
| 82 | EXPECT_FALSE(voe.IsInited()); |
| 83 | } |
| 84 | |
deadbeef | 884f585 | 2016-01-15 09:20:04 -0800 | [diff] [blame] | 85 | class FakeAudioSink : public webrtc::AudioSinkInterface { |
| 86 | public: |
| 87 | void OnData(const Data& audio) override {} |
| 88 | }; |
| 89 | |
Taylor Brandstetter | 1a018dc | 2016-03-08 12:37:39 -0800 | [diff] [blame] | 90 | class FakeAudioSource : public cricket::AudioSource { |
| 91 | void SetSink(Sink* sink) override {} |
| 92 | }; |
| 93 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 94 | class WebRtcVoiceEngineTestFake : public testing::Test { |
| 95 | public: |
stefan | ba4c0e4 | 2016-02-04 04:12:24 -0800 | [diff] [blame] | 96 | WebRtcVoiceEngineTestFake() : WebRtcVoiceEngineTestFake("") {} |
| 97 | |
| 98 | explicit WebRtcVoiceEngineTestFake(const char* field_trials) |
solenberg | bc37fc8 | 2016-04-04 09:54:44 -0700 | [diff] [blame] | 99 | : call_(webrtc::Call::Config()), override_field_trials_(field_trials) { |
| 100 | EXPECT_CALL(adm_, AddRef()).WillOnce(Return(0)); |
| 101 | EXPECT_CALL(adm_, Release()).WillOnce(Return(0)); |
solenberg | 5b5129a | 2016-04-08 05:35:48 -0700 | [diff] [blame] | 102 | EXPECT_CALL(adm_, BuiltInAECIsAvailable()).WillOnce(Return(false)); |
| 103 | EXPECT_CALL(adm_, BuiltInAGCIsAvailable()).WillOnce(Return(false)); |
| 104 | EXPECT_CALL(adm_, BuiltInNSIsAvailable()).WillOnce(Return(false)); |
ossu | 29b1a8d | 2016-06-13 07:34:51 -0700 | [diff] [blame] | 105 | engine_.reset(new cricket::WebRtcVoiceEngine(&adm_, nullptr, |
solenberg | bc37fc8 | 2016-04-04 09:54:44 -0700 | [diff] [blame] | 106 | new FakeVoEWrapper(&voe_))); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 107 | send_parameters_.codecs.push_back(kPcmuCodec); |
| 108 | recv_parameters_.codecs.push_back(kPcmuCodec); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 109 | } |
solenberg | 8189b02 | 2016-06-14 12:13:00 -0700 | [diff] [blame] | 110 | |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 111 | bool SetupChannel() { |
solenberg | bc37fc8 | 2016-04-04 09:54:44 -0700 | [diff] [blame] | 112 | channel_ = engine_->CreateChannel(&call_, cricket::MediaConfig(), |
| 113 | cricket::AudioOptions()); |
Jelena Marusic | c28a896 | 2015-05-29 15:05:44 +0200 | [diff] [blame] | 114 | return (channel_ != nullptr); |
buildbot@webrtc.org | 150835e | 2014-05-06 15:54:38 +0000 | [diff] [blame] | 115 | } |
solenberg | 8189b02 | 2016-06-14 12:13:00 -0700 | [diff] [blame] | 116 | |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 117 | bool SetupRecvStream() { |
| 118 | if (!SetupChannel()) { |
solenberg | 1ac5614 | 2015-10-13 03:58:19 -0700 | [diff] [blame] | 119 | return false; |
| 120 | } |
solenberg | 8189b02 | 2016-06-14 12:13:00 -0700 | [diff] [blame] | 121 | return AddRecvStream(kSsrc1); |
solenberg | 1ac5614 | 2015-10-13 03:58:19 -0700 | [diff] [blame] | 122 | } |
solenberg | 8189b02 | 2016-06-14 12:13:00 -0700 | [diff] [blame] | 123 | |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 124 | bool SetupSendStream() { |
| 125 | if (!SetupChannel()) { |
buildbot@webrtc.org | 150835e | 2014-05-06 15:54:38 +0000 | [diff] [blame] | 126 | return false; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 127 | } |
Taylor Brandstetter | 1a018dc | 2016-03-08 12:37:39 -0800 | [diff] [blame] | 128 | if (!channel_->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc1))) { |
| 129 | return false; |
| 130 | } |
| 131 | return channel_->SetAudioSend(kSsrc1, true, nullptr, &fake_source_); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 132 | } |
solenberg | 8189b02 | 2016-06-14 12:13:00 -0700 | [diff] [blame] | 133 | |
| 134 | bool AddRecvStream(uint32_t ssrc) { |
| 135 | EXPECT_TRUE(channel_); |
| 136 | return channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(ssrc)); |
| 137 | } |
| 138 | |
wu@webrtc.org | 9dba525 | 2013-08-05 20:36:57 +0000 | [diff] [blame] | 139 | void SetupForMultiSendStream() { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 140 | EXPECT_TRUE(SetupSendStream()); |
solenberg | 0a617e2 | 2015-10-20 15:49:38 -0700 | [diff] [blame] | 141 | // Remove stream added in Setup. |
solenberg | 3a94154 | 2015-11-16 07:34:50 -0800 | [diff] [blame] | 142 | EXPECT_TRUE(call_.GetAudioSendStream(kSsrc1)); |
solenberg | 85a0496 | 2015-10-27 03:35:21 -0700 | [diff] [blame] | 143 | EXPECT_TRUE(channel_->RemoveSendStream(kSsrc1)); |
solenberg | 0a617e2 | 2015-10-20 15:49:38 -0700 | [diff] [blame] | 144 | // Verify the channel does not exist. |
solenberg | 3a94154 | 2015-11-16 07:34:50 -0800 | [diff] [blame] | 145 | EXPECT_FALSE(call_.GetAudioSendStream(kSsrc1)); |
wu@webrtc.org | 9dba525 | 2013-08-05 20:36:57 +0000 | [diff] [blame] | 146 | } |
solenberg | 8189b02 | 2016-06-14 12:13:00 -0700 | [diff] [blame] | 147 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 148 | void DeliverPacket(const void* data, int len) { |
jbauch | eec21bd | 2016-03-20 06:15:43 -0700 | [diff] [blame] | 149 | rtc::CopyOnWriteBuffer packet(reinterpret_cast<const uint8_t*>(data), len); |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 150 | channel_->OnPacketReceived(&packet, rtc::PacketTime()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 151 | } |
solenberg | 8189b02 | 2016-06-14 12:13:00 -0700 | [diff] [blame] | 152 | |
Fredrik Solenberg | aaf8ff2 | 2015-05-07 16:05:53 +0200 | [diff] [blame] | 153 | void TearDown() override { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 154 | delete channel_; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 155 | } |
| 156 | |
Fredrik Solenberg | b572768 | 2015-12-04 15:22:19 +0100 | [diff] [blame] | 157 | const cricket::FakeAudioSendStream& GetSendStream(uint32_t ssrc) { |
| 158 | const auto* send_stream = call_.GetAudioSendStream(ssrc); |
| 159 | EXPECT_TRUE(send_stream); |
| 160 | return *send_stream; |
| 161 | } |
| 162 | |
deadbeef | 884f585 | 2016-01-15 09:20:04 -0800 | [diff] [blame] | 163 | const cricket::FakeAudioReceiveStream& GetRecvStream(uint32_t ssrc) { |
| 164 | const auto* recv_stream = call_.GetAudioReceiveStream(ssrc); |
| 165 | EXPECT_TRUE(recv_stream); |
| 166 | return *recv_stream; |
| 167 | } |
| 168 | |
solenberg | 3a94154 | 2015-11-16 07:34:50 -0800 | [diff] [blame] | 169 | const webrtc::AudioSendStream::Config& GetSendStreamConfig(uint32_t ssrc) { |
Taylor Brandstetter | 1a018dc | 2016-03-08 12:37:39 -0800 | [diff] [blame] | 170 | return GetSendStream(ssrc).GetConfig(); |
solenberg | 3a94154 | 2015-11-16 07:34:50 -0800 | [diff] [blame] | 171 | } |
| 172 | |
solenberg | 7add058 | 2015-11-20 09:59:34 -0800 | [diff] [blame] | 173 | const webrtc::AudioReceiveStream::Config& GetRecvStreamConfig(uint32_t ssrc) { |
Taylor Brandstetter | 1a018dc | 2016-03-08 12:37:39 -0800 | [diff] [blame] | 174 | return GetRecvStream(ssrc).GetConfig(); |
solenberg | 7add058 | 2015-11-20 09:59:34 -0800 | [diff] [blame] | 175 | } |
| 176 | |
solenberg | d53a3f9 | 2016-04-14 13:56:37 -0700 | [diff] [blame] | 177 | void SetSend(cricket::VoiceMediaChannel* channel, bool enable) { |
| 178 | ASSERT_TRUE(channel); |
| 179 | if (enable) { |
| 180 | EXPECT_CALL(adm_, RecordingIsInitialized()).WillOnce(Return(false)); |
| 181 | EXPECT_CALL(adm_, Recording()).WillOnce(Return(false)); |
| 182 | EXPECT_CALL(adm_, InitRecording()).WillOnce(Return(0)); |
| 183 | } |
| 184 | channel->SetSend(enable); |
| 185 | } |
| 186 | |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 187 | void TestInsertDtmf(uint32_t ssrc, bool caller) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 188 | EXPECT_TRUE(SetupChannel()); |
wu@webrtc.org | cadf904 | 2013-08-30 21:24:16 +0000 | [diff] [blame] | 189 | if (caller) { |
solenberg | 0a617e2 | 2015-10-20 15:49:38 -0700 | [diff] [blame] | 190 | // If this is a caller, local description will be applied and add the |
wu@webrtc.org | cadf904 | 2013-08-30 21:24:16 +0000 | [diff] [blame] | 191 | // send stream. |
| 192 | EXPECT_TRUE(channel_->AddSendStream( |
| 193 | cricket::StreamParams::CreateLegacy(kSsrc1))); |
| 194 | } |
wu@webrtc.org | cadf904 | 2013-08-30 21:24:16 +0000 | [diff] [blame] | 195 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 196 | // Test we can only InsertDtmf when the other side supports telephone-event. |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 197 | EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); |
solenberg | d53a3f9 | 2016-04-14 13:56:37 -0700 | [diff] [blame] | 198 | SetSend(channel_, true); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 199 | EXPECT_FALSE(channel_->CanInsertDtmf()); |
solenberg | 1d63dd0 | 2015-12-02 12:35:09 -0800 | [diff] [blame] | 200 | EXPECT_FALSE(channel_->InsertDtmf(ssrc, 1, 111)); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 201 | send_parameters_.codecs.push_back(kTelephoneEventCodec); |
| 202 | EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 203 | EXPECT_TRUE(channel_->CanInsertDtmf()); |
wu@webrtc.org | cadf904 | 2013-08-30 21:24:16 +0000 | [diff] [blame] | 204 | |
| 205 | if (!caller) { |
solenberg | 0a617e2 | 2015-10-20 15:49:38 -0700 | [diff] [blame] | 206 | // If this is callee, there's no active send channel yet. |
solenberg | 1d63dd0 | 2015-12-02 12:35:09 -0800 | [diff] [blame] | 207 | EXPECT_FALSE(channel_->InsertDtmf(ssrc, 2, 123)); |
wu@webrtc.org | cadf904 | 2013-08-30 21:24:16 +0000 | [diff] [blame] | 208 | EXPECT_TRUE(channel_->AddSendStream( |
| 209 | cricket::StreamParams::CreateLegacy(kSsrc1))); |
| 210 | } |
| 211 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 212 | // Check we fail if the ssrc is invalid. |
solenberg | 1d63dd0 | 2015-12-02 12:35:09 -0800 | [diff] [blame] | 213 | EXPECT_FALSE(channel_->InsertDtmf(-1, 1, 111)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 214 | |
Fredrik Solenberg | b572768 | 2015-12-04 15:22:19 +0100 | [diff] [blame] | 215 | // Test send. |
| 216 | cricket::FakeAudioSendStream::TelephoneEvent telephone_event = |
| 217 | GetSendStream(kSsrc1).GetLatestTelephoneEvent(); |
| 218 | EXPECT_EQ(-1, telephone_event.payload_type); |
solenberg | 1d63dd0 | 2015-12-02 12:35:09 -0800 | [diff] [blame] | 219 | EXPECT_TRUE(channel_->InsertDtmf(ssrc, 2, 123)); |
Fredrik Solenberg | b572768 | 2015-12-04 15:22:19 +0100 | [diff] [blame] | 220 | telephone_event = GetSendStream(kSsrc1).GetLatestTelephoneEvent(); |
| 221 | EXPECT_EQ(kTelephoneEventCodec.id, telephone_event.payload_type); |
| 222 | EXPECT_EQ(2, telephone_event.event_code); |
| 223 | EXPECT_EQ(123, telephone_event.duration_ms); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 224 | } |
| 225 | |
| 226 | // Test that send bandwidth is set correctly. |
| 227 | // |codec| is the codec under test. |
sergeyu@chromium.org | 4b26e2e | 2014-01-15 23:15:54 +0000 | [diff] [blame] | 228 | // |max_bitrate| is a parameter to set to SetMaxSendBandwidth(). |
| 229 | // |expected_result| is the expected result from SetMaxSendBandwidth(). |
| 230 | // |expected_bitrate| is the expected audio bitrate afterward. |
deadbeef | 8034614 | 2016-04-27 14:17:10 -0700 | [diff] [blame] | 231 | void TestMaxSendBandwidth(const cricket::AudioCodec& codec, |
| 232 | int max_bitrate, |
| 233 | bool expected_result, |
| 234 | int expected_bitrate) { |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 235 | cricket::AudioSendParameters parameters; |
| 236 | parameters.codecs.push_back(codec); |
| 237 | parameters.max_bandwidth_bps = max_bitrate; |
| 238 | EXPECT_EQ(expected_result, channel_->SetSendParameters(parameters)); |
| 239 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 240 | int channel_num = voe_.GetLastChannel(); |
wu@webrtc.org | 1d1ffc9 | 2013-10-16 18:12:02 +0000 | [diff] [blame] | 241 | webrtc::CodecInst temp_codec; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 242 | EXPECT_FALSE(voe_.GetSendCodec(channel_num, temp_codec)); |
sergeyu@chromium.org | 4b26e2e | 2014-01-15 23:15:54 +0000 | [diff] [blame] | 243 | EXPECT_EQ(expected_bitrate, temp_codec.rate); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 244 | } |
| 245 | |
skvlad | e0d4637 | 2016-04-07 22:59:22 -0700 | [diff] [blame] | 246 | // Sets the per-stream maximum bitrate limit for the specified SSRC. |
| 247 | bool SetMaxBitrateForStream(int32_t ssrc, int bitrate) { |
Taylor Brandstetter | db0cd9e | 2016-05-16 11:40:30 -0700 | [diff] [blame] | 248 | webrtc::RtpParameters parameters = channel_->GetRtpSendParameters(ssrc); |
skvlad | e0d4637 | 2016-04-07 22:59:22 -0700 | [diff] [blame] | 249 | EXPECT_EQ(1UL, parameters.encodings.size()); |
| 250 | |
| 251 | parameters.encodings[0].max_bitrate_bps = bitrate; |
Taylor Brandstetter | db0cd9e | 2016-05-16 11:40:30 -0700 | [diff] [blame] | 252 | return channel_->SetRtpSendParameters(ssrc, parameters); |
skvlad | e0d4637 | 2016-04-07 22:59:22 -0700 | [diff] [blame] | 253 | } |
| 254 | |
| 255 | bool SetGlobalMaxBitrate(const cricket::AudioCodec& codec, int bitrate) { |
| 256 | cricket::AudioSendParameters send_parameters; |
| 257 | send_parameters.codecs.push_back(codec); |
| 258 | send_parameters.max_bandwidth_bps = bitrate; |
| 259 | return channel_->SetSendParameters(send_parameters); |
| 260 | } |
| 261 | |
| 262 | int GetCodecBitrate(int32_t ssrc) { |
| 263 | cricket::WebRtcVoiceMediaChannel* media_channel = |
| 264 | static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_); |
| 265 | int channel = media_channel->GetSendChannelId(ssrc); |
| 266 | EXPECT_NE(-1, channel); |
| 267 | webrtc::CodecInst codec; |
| 268 | EXPECT_FALSE(voe_.GetSendCodec(channel, codec)); |
| 269 | return codec.rate; |
| 270 | } |
| 271 | |
| 272 | void SetAndExpectMaxBitrate(const cricket::AudioCodec& codec, |
| 273 | int global_max, |
| 274 | int stream_max, |
| 275 | bool expected_result, |
| 276 | int expected_codec_bitrate) { |
| 277 | // Clear the bitrate limit from the previous test case. |
| 278 | EXPECT_TRUE(SetMaxBitrateForStream(kSsrc1, -1)); |
| 279 | |
| 280 | // Attempt to set the requested bitrate limits. |
| 281 | EXPECT_TRUE(SetGlobalMaxBitrate(codec, global_max)); |
| 282 | EXPECT_EQ(expected_result, SetMaxBitrateForStream(kSsrc1, stream_max)); |
| 283 | |
| 284 | // Verify that reading back the parameters gives results |
| 285 | // consistent with the Set() result. |
| 286 | webrtc::RtpParameters resulting_parameters = |
Taylor Brandstetter | db0cd9e | 2016-05-16 11:40:30 -0700 | [diff] [blame] | 287 | channel_->GetRtpSendParameters(kSsrc1); |
skvlad | e0d4637 | 2016-04-07 22:59:22 -0700 | [diff] [blame] | 288 | EXPECT_EQ(1UL, resulting_parameters.encodings.size()); |
| 289 | EXPECT_EQ(expected_result ? stream_max : -1, |
| 290 | resulting_parameters.encodings[0].max_bitrate_bps); |
| 291 | |
| 292 | // Verify that the codec settings have the expected bitrate. |
| 293 | EXPECT_EQ(expected_codec_bitrate, GetCodecBitrate(kSsrc1)); |
| 294 | } |
| 295 | |
buildbot@webrtc.org | 150835e | 2014-05-06 15:54:38 +0000 | [diff] [blame] | 296 | void TestSetSendRtpHeaderExtensions(const std::string& ext) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 297 | EXPECT_TRUE(SetupSendStream()); |
wu@webrtc.org | 9dba525 | 2013-08-05 20:36:57 +0000 | [diff] [blame] | 298 | |
henrike@webrtc.org | 79047f9 | 2014-03-06 23:46:59 +0000 | [diff] [blame] | 299 | // Ensure extensions are off by default. |
solenberg | 3a94154 | 2015-11-16 07:34:50 -0800 | [diff] [blame] | 300 | EXPECT_EQ(0u, GetSendStreamConfig(kSsrc1).rtp.extensions.size()); |
wu@webrtc.org | 9dba525 | 2013-08-05 20:36:57 +0000 | [diff] [blame] | 301 | |
| 302 | // Ensure unknown extensions won't cause an error. |
isheriff | 6f8d686 | 2016-05-26 11:24:55 -0700 | [diff] [blame] | 303 | send_parameters_.extensions.push_back( |
| 304 | webrtc::RtpExtension("urn:ietf:params:unknownextention", 1)); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 305 | EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); |
solenberg | 3a94154 | 2015-11-16 07:34:50 -0800 | [diff] [blame] | 306 | EXPECT_EQ(0u, GetSendStreamConfig(kSsrc1).rtp.extensions.size()); |
wu@webrtc.org | 9dba525 | 2013-08-05 20:36:57 +0000 | [diff] [blame] | 307 | |
henrike@webrtc.org | 79047f9 | 2014-03-06 23:46:59 +0000 | [diff] [blame] | 308 | // Ensure extensions stay off with an empty list of headers. |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 309 | send_parameters_.extensions.clear(); |
| 310 | EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); |
solenberg | 3a94154 | 2015-11-16 07:34:50 -0800 | [diff] [blame] | 311 | EXPECT_EQ(0u, GetSendStreamConfig(kSsrc1).rtp.extensions.size()); |
wu@webrtc.org | 9dba525 | 2013-08-05 20:36:57 +0000 | [diff] [blame] | 312 | |
buildbot@webrtc.org | 150835e | 2014-05-06 15:54:38 +0000 | [diff] [blame] | 313 | // Ensure extension is set properly. |
| 314 | const int id = 1; |
isheriff | 6f8d686 | 2016-05-26 11:24:55 -0700 | [diff] [blame] | 315 | send_parameters_.extensions.push_back(webrtc::RtpExtension(ext, id)); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 316 | EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); |
solenberg | 3a94154 | 2015-11-16 07:34:50 -0800 | [diff] [blame] | 317 | EXPECT_EQ(1u, GetSendStreamConfig(kSsrc1).rtp.extensions.size()); |
isheriff | 6f8d686 | 2016-05-26 11:24:55 -0700 | [diff] [blame] | 318 | EXPECT_EQ(ext, GetSendStreamConfig(kSsrc1).rtp.extensions[0].uri); |
solenberg | 3a94154 | 2015-11-16 07:34:50 -0800 | [diff] [blame] | 319 | EXPECT_EQ(id, GetSendStreamConfig(kSsrc1).rtp.extensions[0].id); |
wu@webrtc.org | 9dba525 | 2013-08-05 20:36:57 +0000 | [diff] [blame] | 320 | |
solenberg | 7add058 | 2015-11-20 09:59:34 -0800 | [diff] [blame] | 321 | // Ensure extension is set properly on new stream. |
buildbot@webrtc.org | 150835e | 2014-05-06 15:54:38 +0000 | [diff] [blame] | 322 | EXPECT_TRUE(channel_->AddSendStream( |
solenberg | 0a617e2 | 2015-10-20 15:49:38 -0700 | [diff] [blame] | 323 | cricket::StreamParams::CreateLegacy(kSsrc2))); |
solenberg | 3a94154 | 2015-11-16 07:34:50 -0800 | [diff] [blame] | 324 | EXPECT_NE(call_.GetAudioSendStream(kSsrc1), |
| 325 | call_.GetAudioSendStream(kSsrc2)); |
| 326 | EXPECT_EQ(1u, GetSendStreamConfig(kSsrc2).rtp.extensions.size()); |
isheriff | 6f8d686 | 2016-05-26 11:24:55 -0700 | [diff] [blame] | 327 | EXPECT_EQ(ext, GetSendStreamConfig(kSsrc2).rtp.extensions[0].uri); |
solenberg | 3a94154 | 2015-11-16 07:34:50 -0800 | [diff] [blame] | 328 | EXPECT_EQ(id, GetSendStreamConfig(kSsrc2).rtp.extensions[0].id); |
henrike@webrtc.org | 79047f9 | 2014-03-06 23:46:59 +0000 | [diff] [blame] | 329 | |
| 330 | // Ensure all extensions go back off with an empty list. |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 331 | send_parameters_.codecs.push_back(kPcmuCodec); |
| 332 | send_parameters_.extensions.clear(); |
| 333 | EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); |
solenberg | 3a94154 | 2015-11-16 07:34:50 -0800 | [diff] [blame] | 334 | EXPECT_EQ(0u, GetSendStreamConfig(kSsrc1).rtp.extensions.size()); |
| 335 | EXPECT_EQ(0u, GetSendStreamConfig(kSsrc2).rtp.extensions.size()); |
henrike@webrtc.org | 79047f9 | 2014-03-06 23:46:59 +0000 | [diff] [blame] | 336 | } |
| 337 | |
buildbot@webrtc.org | 150835e | 2014-05-06 15:54:38 +0000 | [diff] [blame] | 338 | void TestSetRecvRtpHeaderExtensions(const std::string& ext) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 339 | EXPECT_TRUE(SetupRecvStream()); |
henrike@webrtc.org | 79047f9 | 2014-03-06 23:46:59 +0000 | [diff] [blame] | 340 | |
henrike@webrtc.org | 79047f9 | 2014-03-06 23:46:59 +0000 | [diff] [blame] | 341 | // Ensure extensions are off by default. |
solenberg | 7add058 | 2015-11-20 09:59:34 -0800 | [diff] [blame] | 342 | EXPECT_EQ(0u, GetRecvStreamConfig(kSsrc1).rtp.extensions.size()); |
henrike@webrtc.org | 79047f9 | 2014-03-06 23:46:59 +0000 | [diff] [blame] | 343 | |
| 344 | // Ensure unknown extensions won't cause an error. |
isheriff | 6f8d686 | 2016-05-26 11:24:55 -0700 | [diff] [blame] | 345 | recv_parameters_.extensions.push_back( |
| 346 | webrtc::RtpExtension("urn:ietf:params:unknownextention", 1)); |
solenberg | 7add058 | 2015-11-20 09:59:34 -0800 | [diff] [blame] | 347 | EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_)); |
| 348 | EXPECT_EQ(0u, GetRecvStreamConfig(kSsrc1).rtp.extensions.size()); |
henrike@webrtc.org | 79047f9 | 2014-03-06 23:46:59 +0000 | [diff] [blame] | 349 | |
buildbot@webrtc.org | 150835e | 2014-05-06 15:54:38 +0000 | [diff] [blame] | 350 | // Ensure extensions stay off with an empty list of headers. |
solenberg | 7add058 | 2015-11-20 09:59:34 -0800 | [diff] [blame] | 351 | recv_parameters_.extensions.clear(); |
| 352 | EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_)); |
| 353 | EXPECT_EQ(0u, GetRecvStreamConfig(kSsrc1).rtp.extensions.size()); |
henrike@webrtc.org | 79047f9 | 2014-03-06 23:46:59 +0000 | [diff] [blame] | 354 | |
buildbot@webrtc.org | 150835e | 2014-05-06 15:54:38 +0000 | [diff] [blame] | 355 | // Ensure extension is set properly. |
| 356 | const int id = 2; |
isheriff | 6f8d686 | 2016-05-26 11:24:55 -0700 | [diff] [blame] | 357 | recv_parameters_.extensions.push_back(webrtc::RtpExtension(ext, id)); |
solenberg | 7add058 | 2015-11-20 09:59:34 -0800 | [diff] [blame] | 358 | EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_)); |
| 359 | EXPECT_EQ(1u, GetRecvStreamConfig(kSsrc1).rtp.extensions.size()); |
isheriff | 6f8d686 | 2016-05-26 11:24:55 -0700 | [diff] [blame] | 360 | EXPECT_EQ(ext, GetRecvStreamConfig(kSsrc1).rtp.extensions[0].uri); |
solenberg | 7add058 | 2015-11-20 09:59:34 -0800 | [diff] [blame] | 361 | EXPECT_EQ(id, GetRecvStreamConfig(kSsrc1).rtp.extensions[0].id); |
henrike@webrtc.org | 79047f9 | 2014-03-06 23:46:59 +0000 | [diff] [blame] | 362 | |
solenberg | 7add058 | 2015-11-20 09:59:34 -0800 | [diff] [blame] | 363 | // Ensure extension is set properly on new stream. |
solenberg | 8189b02 | 2016-06-14 12:13:00 -0700 | [diff] [blame] | 364 | EXPECT_TRUE(AddRecvStream(kSsrc2)); |
solenberg | 7add058 | 2015-11-20 09:59:34 -0800 | [diff] [blame] | 365 | EXPECT_NE(call_.GetAudioReceiveStream(kSsrc1), |
| 366 | call_.GetAudioReceiveStream(kSsrc2)); |
| 367 | EXPECT_EQ(1u, GetRecvStreamConfig(kSsrc2).rtp.extensions.size()); |
isheriff | 6f8d686 | 2016-05-26 11:24:55 -0700 | [diff] [blame] | 368 | EXPECT_EQ(ext, GetRecvStreamConfig(kSsrc2).rtp.extensions[0].uri); |
solenberg | 7add058 | 2015-11-20 09:59:34 -0800 | [diff] [blame] | 369 | EXPECT_EQ(id, GetRecvStreamConfig(kSsrc2).rtp.extensions[0].id); |
buildbot@webrtc.org | 150835e | 2014-05-06 15:54:38 +0000 | [diff] [blame] | 370 | |
| 371 | // Ensure all extensions go back off with an empty list. |
solenberg | 7add058 | 2015-11-20 09:59:34 -0800 | [diff] [blame] | 372 | recv_parameters_.extensions.clear(); |
| 373 | EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_)); |
| 374 | EXPECT_EQ(0u, GetRecvStreamConfig(kSsrc1).rtp.extensions.size()); |
| 375 | EXPECT_EQ(0u, GetRecvStreamConfig(kSsrc2).rtp.extensions.size()); |
wu@webrtc.org | 9dba525 | 2013-08-05 20:36:57 +0000 | [diff] [blame] | 376 | } |
| 377 | |
solenberg | 85a0496 | 2015-10-27 03:35:21 -0700 | [diff] [blame] | 378 | webrtc::AudioSendStream::Stats GetAudioSendStreamStats() const { |
| 379 | webrtc::AudioSendStream::Stats stats; |
| 380 | stats.local_ssrc = 12; |
| 381 | stats.bytes_sent = 345; |
| 382 | stats.packets_sent = 678; |
| 383 | stats.packets_lost = 9012; |
| 384 | stats.fraction_lost = 34.56f; |
| 385 | stats.codec_name = "codec_name_send"; |
| 386 | stats.ext_seqnum = 789; |
| 387 | stats.jitter_ms = 12; |
| 388 | stats.rtt_ms = 345; |
| 389 | stats.audio_level = 678; |
| 390 | stats.aec_quality_min = 9.01f; |
| 391 | stats.echo_delay_median_ms = 234; |
| 392 | stats.echo_delay_std_ms = 567; |
| 393 | stats.echo_return_loss = 890; |
| 394 | stats.echo_return_loss_enhancement = 1234; |
| 395 | stats.typing_noise_detected = true; |
| 396 | return stats; |
| 397 | } |
| 398 | void SetAudioSendStreamStats() { |
| 399 | for (auto* s : call_.GetAudioSendStreams()) { |
| 400 | s->SetStats(GetAudioSendStreamStats()); |
Fredrik Solenberg | 4f4ec0a | 2015-10-22 10:49:27 +0200 | [diff] [blame] | 401 | } |
solenberg | 85a0496 | 2015-10-27 03:35:21 -0700 | [diff] [blame] | 402 | } |
solenberg | 566ef24 | 2015-11-06 15:34:49 -0800 | [diff] [blame] | 403 | void VerifyVoiceSenderInfo(const cricket::VoiceSenderInfo& info, |
| 404 | bool is_sending) { |
solenberg | 85a0496 | 2015-10-27 03:35:21 -0700 | [diff] [blame] | 405 | const auto stats = GetAudioSendStreamStats(); |
| 406 | EXPECT_EQ(info.ssrc(), stats.local_ssrc); |
| 407 | EXPECT_EQ(info.bytes_sent, stats.bytes_sent); |
| 408 | EXPECT_EQ(info.packets_sent, stats.packets_sent); |
| 409 | EXPECT_EQ(info.packets_lost, stats.packets_lost); |
| 410 | EXPECT_EQ(info.fraction_lost, stats.fraction_lost); |
| 411 | EXPECT_EQ(info.codec_name, stats.codec_name); |
| 412 | EXPECT_EQ(info.ext_seqnum, stats.ext_seqnum); |
| 413 | EXPECT_EQ(info.jitter_ms, stats.jitter_ms); |
| 414 | EXPECT_EQ(info.rtt_ms, stats.rtt_ms); |
| 415 | EXPECT_EQ(info.audio_level, stats.audio_level); |
| 416 | EXPECT_EQ(info.aec_quality_min, stats.aec_quality_min); |
| 417 | EXPECT_EQ(info.echo_delay_median_ms, stats.echo_delay_median_ms); |
| 418 | EXPECT_EQ(info.echo_delay_std_ms, stats.echo_delay_std_ms); |
| 419 | EXPECT_EQ(info.echo_return_loss, stats.echo_return_loss); |
| 420 | EXPECT_EQ(info.echo_return_loss_enhancement, |
| 421 | stats.echo_return_loss_enhancement); |
solenberg | 566ef24 | 2015-11-06 15:34:49 -0800 | [diff] [blame] | 422 | EXPECT_EQ(info.typing_noise_detected, |
| 423 | stats.typing_noise_detected && is_sending); |
solenberg | 85a0496 | 2015-10-27 03:35:21 -0700 | [diff] [blame] | 424 | } |
| 425 | |
| 426 | webrtc::AudioReceiveStream::Stats GetAudioReceiveStreamStats() const { |
| 427 | webrtc::AudioReceiveStream::Stats stats; |
| 428 | stats.remote_ssrc = 123; |
| 429 | stats.bytes_rcvd = 456; |
| 430 | stats.packets_rcvd = 768; |
| 431 | stats.packets_lost = 101; |
| 432 | stats.fraction_lost = 23.45f; |
| 433 | stats.codec_name = "codec_name_recv"; |
| 434 | stats.ext_seqnum = 678; |
| 435 | stats.jitter_ms = 901; |
| 436 | stats.jitter_buffer_ms = 234; |
| 437 | stats.jitter_buffer_preferred_ms = 567; |
| 438 | stats.delay_estimate_ms = 890; |
| 439 | stats.audio_level = 1234; |
| 440 | stats.expand_rate = 5.67f; |
| 441 | stats.speech_expand_rate = 8.90f; |
| 442 | stats.secondary_decoded_rate = 1.23f; |
| 443 | stats.accelerate_rate = 4.56f; |
| 444 | stats.preemptive_expand_rate = 7.89f; |
| 445 | stats.decoding_calls_to_silence_generator = 12; |
| 446 | stats.decoding_calls_to_neteq = 345; |
| 447 | stats.decoding_normal = 67890; |
| 448 | stats.decoding_plc = 1234; |
| 449 | stats.decoding_cng = 5678; |
| 450 | stats.decoding_plc_cng = 9012; |
| 451 | stats.capture_start_ntp_time_ms = 3456; |
Fredrik Solenberg | 4f4ec0a | 2015-10-22 10:49:27 +0200 | [diff] [blame] | 452 | return stats; |
| 453 | } |
| 454 | void SetAudioReceiveStreamStats() { |
| 455 | for (auto* s : call_.GetAudioReceiveStreams()) { |
| 456 | s->SetStats(GetAudioReceiveStreamStats()); |
| 457 | } |
| 458 | } |
| 459 | void VerifyVoiceReceiverInfo(const cricket::VoiceReceiverInfo& info) { |
solenberg | 85a0496 | 2015-10-27 03:35:21 -0700 | [diff] [blame] | 460 | const auto stats = GetAudioReceiveStreamStats(); |
| 461 | EXPECT_EQ(info.ssrc(), stats.remote_ssrc); |
| 462 | EXPECT_EQ(info.bytes_rcvd, stats.bytes_rcvd); |
| 463 | EXPECT_EQ(info.packets_rcvd, stats.packets_rcvd); |
| 464 | EXPECT_EQ(info.packets_lost, stats.packets_lost); |
| 465 | EXPECT_EQ(info.fraction_lost, stats.fraction_lost); |
| 466 | EXPECT_EQ(info.codec_name, stats.codec_name); |
| 467 | EXPECT_EQ(info.ext_seqnum, stats.ext_seqnum); |
| 468 | EXPECT_EQ(info.jitter_ms, stats.jitter_ms); |
| 469 | EXPECT_EQ(info.jitter_buffer_ms, stats.jitter_buffer_ms); |
Fredrik Solenberg | 4f4ec0a | 2015-10-22 10:49:27 +0200 | [diff] [blame] | 470 | EXPECT_EQ(info.jitter_buffer_preferred_ms, |
solenberg | 85a0496 | 2015-10-27 03:35:21 -0700 | [diff] [blame] | 471 | stats.jitter_buffer_preferred_ms); |
| 472 | EXPECT_EQ(info.delay_estimate_ms, stats.delay_estimate_ms); |
| 473 | EXPECT_EQ(info.audio_level, stats.audio_level); |
| 474 | EXPECT_EQ(info.expand_rate, stats.expand_rate); |
| 475 | EXPECT_EQ(info.speech_expand_rate, stats.speech_expand_rate); |
| 476 | EXPECT_EQ(info.secondary_decoded_rate, stats.secondary_decoded_rate); |
| 477 | EXPECT_EQ(info.accelerate_rate, stats.accelerate_rate); |
| 478 | EXPECT_EQ(info.preemptive_expand_rate, stats.preemptive_expand_rate); |
Fredrik Solenberg | 4f4ec0a | 2015-10-22 10:49:27 +0200 | [diff] [blame] | 479 | EXPECT_EQ(info.decoding_calls_to_silence_generator, |
solenberg | 85a0496 | 2015-10-27 03:35:21 -0700 | [diff] [blame] | 480 | stats.decoding_calls_to_silence_generator); |
| 481 | EXPECT_EQ(info.decoding_calls_to_neteq, stats.decoding_calls_to_neteq); |
| 482 | EXPECT_EQ(info.decoding_normal, stats.decoding_normal); |
| 483 | EXPECT_EQ(info.decoding_plc, stats.decoding_plc); |
| 484 | EXPECT_EQ(info.decoding_cng, stats.decoding_cng); |
| 485 | EXPECT_EQ(info.decoding_plc_cng, stats.decoding_plc_cng); |
| 486 | EXPECT_EQ(info.capture_start_ntp_time_ms, stats.capture_start_ntp_time_ms); |
Fredrik Solenberg | 4f4ec0a | 2015-10-22 10:49:27 +0200 | [diff] [blame] | 487 | } |
| 488 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 489 | protected: |
solenberg | bc37fc8 | 2016-04-04 09:54:44 -0700 | [diff] [blame] | 490 | StrictMock<webrtc::test::MockAudioDeviceModule> adm_; |
Fredrik Solenberg | 709ed67 | 2015-09-15 12:26:33 +0200 | [diff] [blame] | 491 | cricket::FakeCall call_; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 492 | cricket::FakeWebRtcVoiceEngine voe_; |
solenberg | bc37fc8 | 2016-04-04 09:54:44 -0700 | [diff] [blame] | 493 | std::unique_ptr<cricket::WebRtcVoiceEngine> engine_; |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 494 | cricket::VoiceMediaChannel* channel_ = nullptr; |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 495 | cricket::AudioSendParameters send_parameters_; |
| 496 | cricket::AudioRecvParameters recv_parameters_; |
Taylor Brandstetter | 1a018dc | 2016-03-08 12:37:39 -0800 | [diff] [blame] | 497 | FakeAudioSource fake_source_; |
stefan | ba4c0e4 | 2016-02-04 04:12:24 -0800 | [diff] [blame] | 498 | private: |
| 499 | webrtc::test::ScopedFieldTrials override_field_trials_; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 500 | }; |
| 501 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 502 | // Tests that we can create and destroy a channel. |
| 503 | TEST_F(WebRtcVoiceEngineTestFake, CreateChannel) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 504 | EXPECT_TRUE(SetupChannel()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 505 | } |
| 506 | |
solenberg | 31fec40 | 2016-05-06 02:13:12 -0700 | [diff] [blame] | 507 | // Test that we can add a send stream and that it has the correct defaults. |
| 508 | TEST_F(WebRtcVoiceEngineTestFake, CreateSendStream) { |
| 509 | EXPECT_TRUE(SetupChannel()); |
| 510 | EXPECT_TRUE( |
| 511 | channel_->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc1))); |
| 512 | const webrtc::AudioSendStream::Config& config = GetSendStreamConfig(kSsrc1); |
| 513 | EXPECT_EQ(kSsrc1, config.rtp.ssrc); |
| 514 | EXPECT_EQ("", config.rtp.c_name); |
| 515 | EXPECT_EQ(0u, config.rtp.extensions.size()); |
| 516 | EXPECT_EQ(static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_), |
| 517 | config.send_transport); |
| 518 | } |
| 519 | |
| 520 | // Test that we can add a receive stream and that it has the correct defaults. |
| 521 | TEST_F(WebRtcVoiceEngineTestFake, CreateRecvStream) { |
| 522 | EXPECT_TRUE(SetupChannel()); |
solenberg | 8189b02 | 2016-06-14 12:13:00 -0700 | [diff] [blame] | 523 | EXPECT_TRUE(AddRecvStream(kSsrc1)); |
solenberg | 31fec40 | 2016-05-06 02:13:12 -0700 | [diff] [blame] | 524 | const webrtc::AudioReceiveStream::Config& config = |
| 525 | GetRecvStreamConfig(kSsrc1); |
| 526 | EXPECT_EQ(kSsrc1, config.rtp.remote_ssrc); |
| 527 | EXPECT_EQ(0xFA17FA17, config.rtp.local_ssrc); |
| 528 | EXPECT_FALSE(config.rtp.transport_cc); |
| 529 | EXPECT_EQ(0u, config.rtp.extensions.size()); |
| 530 | EXPECT_EQ(static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_), |
| 531 | config.rtcp_send_transport); |
| 532 | EXPECT_EQ("", config.sync_group); |
| 533 | } |
| 534 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 535 | // Tests that the list of supported codecs is created properly and ordered |
deadbeef | 67cf2c1 | 2016-04-13 10:07:16 -0700 | [diff] [blame] | 536 | // correctly (such that opus appears first). |
ossu | dedfd28 | 2016-06-14 07:12:39 -0700 | [diff] [blame] | 537 | // TODO(ossu): This test should move into a separate builtin audio codecs |
| 538 | // module. |
deadbeef | 67cf2c1 | 2016-04-13 10:07:16 -0700 | [diff] [blame] | 539 | TEST_F(WebRtcVoiceEngineTestFake, CodecOrder) { |
ossu | dedfd28 | 2016-06-14 07:12:39 -0700 | [diff] [blame] | 540 | const std::vector<cricket::AudioCodec>& codecs = engine_->send_codecs(); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 541 | ASSERT_FALSE(codecs.empty()); |
| 542 | EXPECT_STRCASEEQ("opus", codecs[0].name.c_str()); |
| 543 | EXPECT_EQ(48000, codecs[0].clockrate); |
| 544 | EXPECT_EQ(2, codecs[0].channels); |
| 545 | EXPECT_EQ(64000, codecs[0].bitrate); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 546 | } |
| 547 | |
stefan | ba4c0e4 | 2016-02-04 04:12:24 -0800 | [diff] [blame] | 548 | TEST_F(WebRtcVoiceEngineTestFake, OpusSupportsTransportCc) { |
ossu | dedfd28 | 2016-06-14 07:12:39 -0700 | [diff] [blame] | 549 | const std::vector<cricket::AudioCodec>& codecs = engine_->send_codecs(); |
stefan | ba4c0e4 | 2016-02-04 04:12:24 -0800 | [diff] [blame] | 550 | bool opus_found = false; |
| 551 | for (cricket::AudioCodec codec : codecs) { |
| 552 | if (codec.name == "opus") { |
| 553 | EXPECT_TRUE(HasTransportCc(codec)); |
| 554 | opus_found = true; |
| 555 | } |
| 556 | } |
| 557 | EXPECT_TRUE(opus_found); |
| 558 | } |
| 559 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 560 | // Tests that we can find codecs by name or id, and that we interpret the |
| 561 | // clockrate and bitrate fields properly. |
| 562 | TEST_F(WebRtcVoiceEngineTestFake, FindCodec) { |
| 563 | cricket::AudioCodec codec; |
| 564 | webrtc::CodecInst codec_inst; |
| 565 | // Find PCMU with explicit clockrate and bitrate. |
solenberg | 26c8c91 | 2015-11-27 04:00:25 -0800 | [diff] [blame] | 566 | EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(kPcmuCodec, &codec_inst)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 567 | // Find ISAC with explicit clockrate and 0 bitrate. |
solenberg | 26c8c91 | 2015-11-27 04:00:25 -0800 | [diff] [blame] | 568 | EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(kIsacCodec, &codec_inst)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 569 | // Find telephone-event with explicit clockrate and 0 bitrate. |
solenberg | 26c8c91 | 2015-11-27 04:00:25 -0800 | [diff] [blame] | 570 | EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(kTelephoneEventCodec, |
| 571 | &codec_inst)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 572 | // Find ISAC with a different payload id. |
| 573 | codec = kIsacCodec; |
| 574 | codec.id = 127; |
solenberg | 26c8c91 | 2015-11-27 04:00:25 -0800 | [diff] [blame] | 575 | EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(codec, &codec_inst)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 576 | EXPECT_EQ(codec.id, codec_inst.pltype); |
| 577 | // Find PCMU with a 0 clockrate. |
| 578 | codec = kPcmuCodec; |
| 579 | codec.clockrate = 0; |
solenberg | 26c8c91 | 2015-11-27 04:00:25 -0800 | [diff] [blame] | 580 | EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(codec, &codec_inst)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 581 | EXPECT_EQ(codec.id, codec_inst.pltype); |
| 582 | EXPECT_EQ(8000, codec_inst.plfreq); |
| 583 | // Find PCMU with a 0 bitrate. |
| 584 | codec = kPcmuCodec; |
| 585 | codec.bitrate = 0; |
solenberg | 26c8c91 | 2015-11-27 04:00:25 -0800 | [diff] [blame] | 586 | EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(codec, &codec_inst)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 587 | EXPECT_EQ(codec.id, codec_inst.pltype); |
| 588 | EXPECT_EQ(64000, codec_inst.rate); |
| 589 | // Find ISAC with an explicit bitrate. |
| 590 | codec = kIsacCodec; |
| 591 | codec.bitrate = 32000; |
solenberg | 26c8c91 | 2015-11-27 04:00:25 -0800 | [diff] [blame] | 592 | EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(codec, &codec_inst)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 593 | EXPECT_EQ(codec.id, codec_inst.pltype); |
| 594 | EXPECT_EQ(32000, codec_inst.rate); |
| 595 | } |
| 596 | |
| 597 | // Test that we set our inbound codecs properly, including changing PT. |
| 598 | TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecs) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 599 | EXPECT_TRUE(SetupChannel()); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 600 | cricket::AudioRecvParameters parameters; |
| 601 | parameters.codecs.push_back(kIsacCodec); |
| 602 | parameters.codecs.push_back(kPcmuCodec); |
| 603 | parameters.codecs.push_back(kTelephoneEventCodec); |
| 604 | parameters.codecs[0].id = 106; // collide with existing telephone-event |
| 605 | parameters.codecs[2].id = 126; |
| 606 | EXPECT_TRUE(channel_->SetRecvParameters(parameters)); |
solenberg | 8189b02 | 2016-06-14 12:13:00 -0700 | [diff] [blame] | 607 | EXPECT_TRUE(AddRecvStream(kSsrc1)); |
solenberg | 1ac5614 | 2015-10-13 03:58:19 -0700 | [diff] [blame] | 608 | int channel_num = voe_.GetLastChannel(); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 609 | webrtc::CodecInst gcodec; |
tfarina | 5237aaf | 2015-11-10 23:44:30 -0800 | [diff] [blame] | 610 | rtc::strcpyn(gcodec.plname, arraysize(gcodec.plname), "ISAC"); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 611 | gcodec.plfreq = 16000; |
| 612 | gcodec.channels = 1; |
| 613 | EXPECT_EQ(0, voe_.GetRecPayloadType(channel_num, gcodec)); |
| 614 | EXPECT_EQ(106, gcodec.pltype); |
| 615 | EXPECT_STREQ("ISAC", gcodec.plname); |
tfarina | 5237aaf | 2015-11-10 23:44:30 -0800 | [diff] [blame] | 616 | rtc::strcpyn(gcodec.plname, arraysize(gcodec.plname), "telephone-event"); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 617 | gcodec.plfreq = 8000; |
| 618 | EXPECT_EQ(0, voe_.GetRecPayloadType(channel_num, gcodec)); |
| 619 | EXPECT_EQ(126, gcodec.pltype); |
| 620 | EXPECT_STREQ("telephone-event", gcodec.plname); |
| 621 | } |
| 622 | |
| 623 | // Test that we fail to set an unknown inbound codec. |
| 624 | TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecsUnsupportedCodec) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 625 | EXPECT_TRUE(SetupChannel()); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 626 | cricket::AudioRecvParameters parameters; |
| 627 | parameters.codecs.push_back(kIsacCodec); |
deadbeef | 67cf2c1 | 2016-04-13 10:07:16 -0700 | [diff] [blame] | 628 | parameters.codecs.push_back(cricket::AudioCodec(127, "XYZ", 32000, 0, 1)); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 629 | EXPECT_FALSE(channel_->SetRecvParameters(parameters)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 630 | } |
| 631 | |
| 632 | // Test that we fail if we have duplicate types in the inbound list. |
| 633 | TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecsDuplicatePayloadType) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 634 | EXPECT_TRUE(SetupChannel()); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 635 | cricket::AudioRecvParameters parameters; |
| 636 | parameters.codecs.push_back(kIsacCodec); |
| 637 | parameters.codecs.push_back(kCn16000Codec); |
| 638 | parameters.codecs[1].id = kIsacCodec.id; |
| 639 | EXPECT_FALSE(channel_->SetRecvParameters(parameters)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 640 | } |
| 641 | |
| 642 | // Test that we can decode OPUS without stereo parameters. |
| 643 | TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecsWithOpusNoStereo) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 644 | EXPECT_TRUE(SetupChannel()); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 645 | cricket::AudioRecvParameters parameters; |
| 646 | parameters.codecs.push_back(kIsacCodec); |
| 647 | parameters.codecs.push_back(kPcmuCodec); |
| 648 | parameters.codecs.push_back(kOpusCodec); |
| 649 | EXPECT_TRUE(channel_->SetRecvParameters(parameters)); |
solenberg | 8189b02 | 2016-06-14 12:13:00 -0700 | [diff] [blame] | 650 | EXPECT_TRUE(AddRecvStream(kSsrc1)); |
solenberg | 1ac5614 | 2015-10-13 03:58:19 -0700 | [diff] [blame] | 651 | int channel_num = voe_.GetLastChannel(); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 652 | webrtc::CodecInst opus; |
solenberg | 26c8c91 | 2015-11-27 04:00:25 -0800 | [diff] [blame] | 653 | cricket::WebRtcVoiceEngine::ToCodecInst(kOpusCodec, &opus); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 654 | // Even without stereo parameters, recv codecs still specify channels = 2. |
| 655 | EXPECT_EQ(2, opus.channels); |
| 656 | EXPECT_EQ(111, opus.pltype); |
| 657 | EXPECT_STREQ("opus", opus.plname); |
| 658 | opus.pltype = 0; |
solenberg | 1ac5614 | 2015-10-13 03:58:19 -0700 | [diff] [blame] | 659 | EXPECT_EQ(0, voe_.GetRecPayloadType(channel_num, opus)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 660 | EXPECT_EQ(111, opus.pltype); |
| 661 | } |
| 662 | |
| 663 | // Test that we can decode OPUS with stereo = 0. |
| 664 | TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecsWithOpus0Stereo) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 665 | EXPECT_TRUE(SetupChannel()); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 666 | cricket::AudioRecvParameters parameters; |
| 667 | parameters.codecs.push_back(kIsacCodec); |
| 668 | parameters.codecs.push_back(kPcmuCodec); |
| 669 | parameters.codecs.push_back(kOpusCodec); |
| 670 | parameters.codecs[2].params["stereo"] = "0"; |
| 671 | EXPECT_TRUE(channel_->SetRecvParameters(parameters)); |
solenberg | 8189b02 | 2016-06-14 12:13:00 -0700 | [diff] [blame] | 672 | EXPECT_TRUE(AddRecvStream(kSsrc1)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 673 | int channel_num2 = voe_.GetLastChannel(); |
| 674 | webrtc::CodecInst opus; |
solenberg | 26c8c91 | 2015-11-27 04:00:25 -0800 | [diff] [blame] | 675 | cricket::WebRtcVoiceEngine::ToCodecInst(kOpusCodec, &opus); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 676 | // Even when stereo is off, recv codecs still specify channels = 2. |
| 677 | EXPECT_EQ(2, opus.channels); |
| 678 | EXPECT_EQ(111, opus.pltype); |
| 679 | EXPECT_STREQ("opus", opus.plname); |
| 680 | opus.pltype = 0; |
| 681 | EXPECT_EQ(0, voe_.GetRecPayloadType(channel_num2, opus)); |
| 682 | EXPECT_EQ(111, opus.pltype); |
| 683 | } |
| 684 | |
| 685 | // Test that we can decode OPUS with stereo = 1. |
| 686 | TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecsWithOpus1Stereo) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 687 | EXPECT_TRUE(SetupChannel()); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 688 | cricket::AudioRecvParameters parameters; |
| 689 | parameters.codecs.push_back(kIsacCodec); |
| 690 | parameters.codecs.push_back(kPcmuCodec); |
| 691 | parameters.codecs.push_back(kOpusCodec); |
| 692 | parameters.codecs[2].params["stereo"] = "1"; |
| 693 | EXPECT_TRUE(channel_->SetRecvParameters(parameters)); |
solenberg | 8189b02 | 2016-06-14 12:13:00 -0700 | [diff] [blame] | 694 | EXPECT_TRUE(AddRecvStream(kSsrc1)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 695 | int channel_num2 = voe_.GetLastChannel(); |
| 696 | webrtc::CodecInst opus; |
solenberg | 26c8c91 | 2015-11-27 04:00:25 -0800 | [diff] [blame] | 697 | cricket::WebRtcVoiceEngine::ToCodecInst(kOpusCodec, &opus); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 698 | EXPECT_EQ(2, opus.channels); |
| 699 | EXPECT_EQ(111, opus.pltype); |
| 700 | EXPECT_STREQ("opus", opus.plname); |
| 701 | opus.pltype = 0; |
| 702 | EXPECT_EQ(0, voe_.GetRecPayloadType(channel_num2, opus)); |
| 703 | EXPECT_EQ(111, opus.pltype); |
| 704 | } |
| 705 | |
| 706 | // Test that changes to recv codecs are applied to all streams. |
| 707 | TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecsWithMultipleStreams) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 708 | EXPECT_TRUE(SetupChannel()); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 709 | cricket::AudioRecvParameters parameters; |
| 710 | parameters.codecs.push_back(kIsacCodec); |
| 711 | parameters.codecs.push_back(kPcmuCodec); |
| 712 | parameters.codecs.push_back(kTelephoneEventCodec); |
| 713 | parameters.codecs[0].id = 106; // collide with existing telephone-event |
| 714 | parameters.codecs[2].id = 126; |
| 715 | EXPECT_TRUE(channel_->SetRecvParameters(parameters)); |
solenberg | 8189b02 | 2016-06-14 12:13:00 -0700 | [diff] [blame] | 716 | EXPECT_TRUE(AddRecvStream(kSsrc1)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 717 | int channel_num2 = voe_.GetLastChannel(); |
| 718 | webrtc::CodecInst gcodec; |
tfarina | 5237aaf | 2015-11-10 23:44:30 -0800 | [diff] [blame] | 719 | rtc::strcpyn(gcodec.plname, arraysize(gcodec.plname), "ISAC"); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 720 | gcodec.plfreq = 16000; |
| 721 | gcodec.channels = 1; |
| 722 | EXPECT_EQ(0, voe_.GetRecPayloadType(channel_num2, gcodec)); |
| 723 | EXPECT_EQ(106, gcodec.pltype); |
| 724 | EXPECT_STREQ("ISAC", gcodec.plname); |
tfarina | 5237aaf | 2015-11-10 23:44:30 -0800 | [diff] [blame] | 725 | rtc::strcpyn(gcodec.plname, arraysize(gcodec.plname), "telephone-event"); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 726 | gcodec.plfreq = 8000; |
| 727 | gcodec.channels = 1; |
| 728 | EXPECT_EQ(0, voe_.GetRecPayloadType(channel_num2, gcodec)); |
| 729 | EXPECT_EQ(126, gcodec.pltype); |
| 730 | EXPECT_STREQ("telephone-event", gcodec.plname); |
| 731 | } |
| 732 | |
| 733 | TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecsAfterAddingStreams) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 734 | EXPECT_TRUE(SetupRecvStream()); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 735 | cricket::AudioRecvParameters parameters; |
| 736 | parameters.codecs.push_back(kIsacCodec); |
| 737 | parameters.codecs[0].id = 106; // collide with existing telephone-event |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 738 | EXPECT_TRUE(channel_->SetRecvParameters(parameters)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 739 | |
| 740 | int channel_num2 = voe_.GetLastChannel(); |
| 741 | webrtc::CodecInst gcodec; |
tfarina | 5237aaf | 2015-11-10 23:44:30 -0800 | [diff] [blame] | 742 | rtc::strcpyn(gcodec.plname, arraysize(gcodec.plname), "ISAC"); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 743 | gcodec.plfreq = 16000; |
| 744 | gcodec.channels = 1; |
| 745 | EXPECT_EQ(0, voe_.GetRecPayloadType(channel_num2, gcodec)); |
| 746 | EXPECT_EQ(106, gcodec.pltype); |
| 747 | EXPECT_STREQ("ISAC", gcodec.plname); |
| 748 | } |
| 749 | |
| 750 | // Test that we can apply the same set of codecs again while playing. |
| 751 | TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecsWhilePlaying) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 752 | EXPECT_TRUE(SetupRecvStream()); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 753 | cricket::AudioRecvParameters parameters; |
| 754 | parameters.codecs.push_back(kIsacCodec); |
| 755 | parameters.codecs.push_back(kCn16000Codec); |
| 756 | EXPECT_TRUE(channel_->SetRecvParameters(parameters)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 757 | EXPECT_TRUE(channel_->SetPlayout(true)); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 758 | EXPECT_TRUE(channel_->SetRecvParameters(parameters)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 759 | |
| 760 | // Changing the payload type of a codec should fail. |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 761 | parameters.codecs[0].id = 127; |
| 762 | EXPECT_FALSE(channel_->SetRecvParameters(parameters)); |
| 763 | int channel_num = voe_.GetLastChannel(); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 764 | EXPECT_TRUE(voe_.GetPlayout(channel_num)); |
| 765 | } |
| 766 | |
| 767 | // Test that we can add a codec while playing. |
| 768 | TEST_F(WebRtcVoiceEngineTestFake, AddRecvCodecsWhilePlaying) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 769 | EXPECT_TRUE(SetupRecvStream()); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 770 | cricket::AudioRecvParameters parameters; |
| 771 | parameters.codecs.push_back(kIsacCodec); |
| 772 | parameters.codecs.push_back(kCn16000Codec); |
| 773 | EXPECT_TRUE(channel_->SetRecvParameters(parameters)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 774 | EXPECT_TRUE(channel_->SetPlayout(true)); |
| 775 | |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 776 | parameters.codecs.push_back(kOpusCodec); |
| 777 | EXPECT_TRUE(channel_->SetRecvParameters(parameters)); |
| 778 | int channel_num = voe_.GetLastChannel(); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 779 | EXPECT_TRUE(voe_.GetPlayout(channel_num)); |
| 780 | webrtc::CodecInst gcodec; |
solenberg | 26c8c91 | 2015-11-27 04:00:25 -0800 | [diff] [blame] | 781 | EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(kOpusCodec, &gcodec)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 782 | EXPECT_EQ(kOpusCodec.id, gcodec.pltype); |
| 783 | } |
| 784 | |
| 785 | TEST_F(WebRtcVoiceEngineTestFake, SetSendBandwidthAuto) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 786 | EXPECT_TRUE(SetupSendStream()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 787 | |
sergeyu@chromium.org | 4b26e2e | 2014-01-15 23:15:54 +0000 | [diff] [blame] | 788 | // Test that when autobw is enabled, bitrate is kept as the default |
| 789 | // value. autobw is enabled for the following tests because the target |
| 790 | // bitrate is <= 0. |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 791 | |
| 792 | // ISAC, default bitrate == 32000. |
deadbeef | 8034614 | 2016-04-27 14:17:10 -0700 | [diff] [blame] | 793 | TestMaxSendBandwidth(kIsacCodec, 0, true, 32000); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 794 | |
| 795 | // PCMU, default bitrate == 64000. |
deadbeef | 8034614 | 2016-04-27 14:17:10 -0700 | [diff] [blame] | 796 | TestMaxSendBandwidth(kPcmuCodec, -1, true, 64000); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 797 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 798 | // opus, default bitrate == 64000. |
deadbeef | 8034614 | 2016-04-27 14:17:10 -0700 | [diff] [blame] | 799 | TestMaxSendBandwidth(kOpusCodec, -1, true, 64000); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 800 | } |
| 801 | |
sergeyu@chromium.org | 4b26e2e | 2014-01-15 23:15:54 +0000 | [diff] [blame] | 802 | TEST_F(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthMultiRateAsCaller) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 803 | EXPECT_TRUE(SetupSendStream()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 804 | |
sergeyu@chromium.org | 4b26e2e | 2014-01-15 23:15:54 +0000 | [diff] [blame] | 805 | // Test that the bitrate of a multi-rate codec is always the maximum. |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 806 | |
| 807 | // ISAC, default bitrate == 32000. |
deadbeef | 8034614 | 2016-04-27 14:17:10 -0700 | [diff] [blame] | 808 | TestMaxSendBandwidth(kIsacCodec, 40000, true, 40000); |
| 809 | TestMaxSendBandwidth(kIsacCodec, 16000, true, 16000); |
| 810 | // Rates above the max (56000) should be capped. |
| 811 | TestMaxSendBandwidth(kIsacCodec, 100000, true, 56000); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 812 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 813 | // opus, default bitrate == 64000. |
deadbeef | 8034614 | 2016-04-27 14:17:10 -0700 | [diff] [blame] | 814 | TestMaxSendBandwidth(kOpusCodec, 96000, true, 96000); |
| 815 | TestMaxSendBandwidth(kOpusCodec, 48000, true, 48000); |
| 816 | // Rates above the max (510000) should be capped. |
| 817 | TestMaxSendBandwidth(kOpusCodec, 600000, true, 510000); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 818 | } |
| 819 | |
sergeyu@chromium.org | 4b26e2e | 2014-01-15 23:15:54 +0000 | [diff] [blame] | 820 | TEST_F(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthFixedRateAsCaller) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 821 | EXPECT_TRUE(SetupSendStream()); |
sergeyu@chromium.org | 4b26e2e | 2014-01-15 23:15:54 +0000 | [diff] [blame] | 822 | |
| 823 | // Test that we can only set a maximum bitrate for a fixed-rate codec |
| 824 | // if it's bigger than the fixed rate. |
| 825 | |
| 826 | // PCMU, fixed bitrate == 64000. |
deadbeef | 8034614 | 2016-04-27 14:17:10 -0700 | [diff] [blame] | 827 | TestMaxSendBandwidth(kPcmuCodec, 0, true, 64000); |
| 828 | TestMaxSendBandwidth(kPcmuCodec, 1, false, 64000); |
| 829 | TestMaxSendBandwidth(kPcmuCodec, 128000, true, 64000); |
| 830 | TestMaxSendBandwidth(kPcmuCodec, 32000, false, 64000); |
| 831 | TestMaxSendBandwidth(kPcmuCodec, 64000, true, 64000); |
| 832 | TestMaxSendBandwidth(kPcmuCodec, 63999, false, 64000); |
| 833 | TestMaxSendBandwidth(kPcmuCodec, 64001, true, 64000); |
sergeyu@chromium.org | 4b26e2e | 2014-01-15 23:15:54 +0000 | [diff] [blame] | 834 | } |
| 835 | |
| 836 | TEST_F(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthMultiRateAsCallee) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 837 | EXPECT_TRUE(SetupChannel()); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 838 | const int kDesiredBitrate = 128000; |
| 839 | cricket::AudioSendParameters parameters; |
ossu | dedfd28 | 2016-06-14 07:12:39 -0700 | [diff] [blame] | 840 | parameters.codecs = engine_->send_codecs(); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 841 | parameters.max_bandwidth_bps = kDesiredBitrate; |
| 842 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
wu@webrtc.org | 1d1ffc9 | 2013-10-16 18:12:02 +0000 | [diff] [blame] | 843 | |
| 844 | EXPECT_TRUE(channel_->AddSendStream( |
| 845 | cricket::StreamParams::CreateLegacy(kSsrc1))); |
| 846 | |
| 847 | int channel_num = voe_.GetLastChannel(); |
| 848 | webrtc::CodecInst codec; |
| 849 | EXPECT_EQ(0, voe_.GetSendCodec(channel_num, codec)); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 850 | EXPECT_EQ(kDesiredBitrate, codec.rate); |
wu@webrtc.org | 1d1ffc9 | 2013-10-16 18:12:02 +0000 | [diff] [blame] | 851 | } |
| 852 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 853 | // Test that bitrate cannot be set for CBR codecs. |
| 854 | // Bitrate is ignored if it is higher than the fixed bitrate. |
| 855 | // Bitrate less then the fixed bitrate is an error. |
sergeyu@chromium.org | 4b26e2e | 2014-01-15 23:15:54 +0000 | [diff] [blame] | 856 | TEST_F(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthCbr) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 857 | EXPECT_TRUE(SetupSendStream()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 858 | |
| 859 | // PCMU, default bitrate == 64000. |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 860 | EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); |
| 861 | int channel_num = voe_.GetLastChannel(); |
| 862 | webrtc::CodecInst codec; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 863 | EXPECT_EQ(0, voe_.GetSendCodec(channel_num, codec)); |
| 864 | EXPECT_EQ(64000, codec.rate); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 865 | |
| 866 | send_parameters_.max_bandwidth_bps = 128000; |
| 867 | EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 868 | EXPECT_EQ(0, voe_.GetSendCodec(channel_num, codec)); |
| 869 | EXPECT_EQ(64000, codec.rate); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 870 | |
| 871 | send_parameters_.max_bandwidth_bps = 128; |
| 872 | EXPECT_FALSE(channel_->SetSendParameters(send_parameters_)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 873 | EXPECT_EQ(0, voe_.GetSendCodec(channel_num, codec)); |
| 874 | EXPECT_EQ(64000, codec.rate); |
| 875 | } |
| 876 | |
skvlad | e0d4637 | 2016-04-07 22:59:22 -0700 | [diff] [blame] | 877 | // Test that the per-stream bitrate limit and the global |
| 878 | // bitrate limit both apply. |
| 879 | TEST_F(WebRtcVoiceEngineTestFake, SetMaxBitratePerStream) { |
| 880 | EXPECT_TRUE(SetupSendStream()); |
| 881 | |
| 882 | // opus, default bitrate == 64000. |
| 883 | SetAndExpectMaxBitrate(kOpusCodec, 0, 0, true, 64000); |
| 884 | SetAndExpectMaxBitrate(kOpusCodec, 48000, 0, true, 48000); |
| 885 | SetAndExpectMaxBitrate(kOpusCodec, 48000, 64000, true, 48000); |
| 886 | SetAndExpectMaxBitrate(kOpusCodec, 64000, 48000, true, 48000); |
| 887 | |
| 888 | // CBR codecs allow both maximums to exceed the bitrate. |
| 889 | SetAndExpectMaxBitrate(kPcmuCodec, 0, 0, true, 64000); |
| 890 | SetAndExpectMaxBitrate(kPcmuCodec, 64001, 0, true, 64000); |
| 891 | SetAndExpectMaxBitrate(kPcmuCodec, 0, 64001, true, 64000); |
| 892 | SetAndExpectMaxBitrate(kPcmuCodec, 64001, 64001, true, 64000); |
| 893 | |
| 894 | // CBR codecs don't allow per stream maximums to be too low. |
| 895 | SetAndExpectMaxBitrate(kPcmuCodec, 0, 63999, false, 64000); |
| 896 | SetAndExpectMaxBitrate(kPcmuCodec, 64001, 63999, false, 64000); |
| 897 | } |
| 898 | |
| 899 | // Test that an attempt to set RtpParameters for a stream that does not exist |
| 900 | // fails. |
| 901 | TEST_F(WebRtcVoiceEngineTestFake, CannotSetMaxBitrateForNonexistentStream) { |
| 902 | EXPECT_TRUE(SetupChannel()); |
| 903 | webrtc::RtpParameters nonexistent_parameters = |
Taylor Brandstetter | db0cd9e | 2016-05-16 11:40:30 -0700 | [diff] [blame] | 904 | channel_->GetRtpSendParameters(kSsrc1); |
skvlad | e0d4637 | 2016-04-07 22:59:22 -0700 | [diff] [blame] | 905 | EXPECT_EQ(0, nonexistent_parameters.encodings.size()); |
| 906 | |
| 907 | nonexistent_parameters.encodings.push_back(webrtc::RtpEncodingParameters()); |
Taylor Brandstetter | db0cd9e | 2016-05-16 11:40:30 -0700 | [diff] [blame] | 908 | EXPECT_FALSE(channel_->SetRtpSendParameters(kSsrc1, nonexistent_parameters)); |
skvlad | e0d4637 | 2016-04-07 22:59:22 -0700 | [diff] [blame] | 909 | } |
| 910 | |
| 911 | TEST_F(WebRtcVoiceEngineTestFake, |
Taylor Brandstetter | db0cd9e | 2016-05-16 11:40:30 -0700 | [diff] [blame] | 912 | CannotSetRtpSendParametersWithIncorrectNumberOfEncodings) { |
skvlad | e0d4637 | 2016-04-07 22:59:22 -0700 | [diff] [blame] | 913 | // This test verifies that setting RtpParameters succeeds only if |
| 914 | // the structure contains exactly one encoding. |
| 915 | // TODO(skvlad): Update this test when we start supporting setting parameters |
| 916 | // for each encoding individually. |
| 917 | |
| 918 | EXPECT_TRUE(SetupSendStream()); |
| 919 | // Setting RtpParameters with no encoding is expected to fail. |
| 920 | webrtc::RtpParameters parameters; |
Taylor Brandstetter | db0cd9e | 2016-05-16 11:40:30 -0700 | [diff] [blame] | 921 | EXPECT_FALSE(channel_->SetRtpSendParameters(kSsrc1, parameters)); |
skvlad | e0d4637 | 2016-04-07 22:59:22 -0700 | [diff] [blame] | 922 | // Setting RtpParameters with exactly one encoding should succeed. |
| 923 | parameters.encodings.push_back(webrtc::RtpEncodingParameters()); |
Taylor Brandstetter | db0cd9e | 2016-05-16 11:40:30 -0700 | [diff] [blame] | 924 | EXPECT_TRUE(channel_->SetRtpSendParameters(kSsrc1, parameters)); |
skvlad | e0d4637 | 2016-04-07 22:59:22 -0700 | [diff] [blame] | 925 | // Two or more encodings should result in failure. |
| 926 | parameters.encodings.push_back(webrtc::RtpEncodingParameters()); |
Taylor Brandstetter | db0cd9e | 2016-05-16 11:40:30 -0700 | [diff] [blame] | 927 | EXPECT_FALSE(channel_->SetRtpSendParameters(kSsrc1, parameters)); |
skvlad | e0d4637 | 2016-04-07 22:59:22 -0700 | [diff] [blame] | 928 | } |
| 929 | |
Taylor Brandstetter | 55dd708 | 2016-05-03 13:50:11 -0700 | [diff] [blame] | 930 | // Test that a stream will not be sending if its encoding is made |
Taylor Brandstetter | db0cd9e | 2016-05-16 11:40:30 -0700 | [diff] [blame] | 931 | // inactive through SetRtpSendParameters. |
Taylor Brandstetter | 55dd708 | 2016-05-03 13:50:11 -0700 | [diff] [blame] | 932 | TEST_F(WebRtcVoiceEngineTestFake, SetRtpParametersEncodingsActive) { |
| 933 | EXPECT_TRUE(SetupSendStream()); |
| 934 | SetSend(channel_, true); |
| 935 | EXPECT_TRUE(GetSendStream(kSsrc1).IsSending()); |
| 936 | // Get current parameters and change "active" to false. |
Taylor Brandstetter | db0cd9e | 2016-05-16 11:40:30 -0700 | [diff] [blame] | 937 | webrtc::RtpParameters parameters = channel_->GetRtpSendParameters(kSsrc1); |
Taylor Brandstetter | 55dd708 | 2016-05-03 13:50:11 -0700 | [diff] [blame] | 938 | ASSERT_EQ(1u, parameters.encodings.size()); |
| 939 | ASSERT_TRUE(parameters.encodings[0].active); |
| 940 | parameters.encodings[0].active = false; |
Taylor Brandstetter | db0cd9e | 2016-05-16 11:40:30 -0700 | [diff] [blame] | 941 | EXPECT_TRUE(channel_->SetRtpSendParameters(kSsrc1, parameters)); |
Taylor Brandstetter | 55dd708 | 2016-05-03 13:50:11 -0700 | [diff] [blame] | 942 | EXPECT_FALSE(GetSendStream(kSsrc1).IsSending()); |
| 943 | |
| 944 | // Now change it back to active and verify we resume sending. |
| 945 | parameters.encodings[0].active = true; |
Taylor Brandstetter | db0cd9e | 2016-05-16 11:40:30 -0700 | [diff] [blame] | 946 | EXPECT_TRUE(channel_->SetRtpSendParameters(kSsrc1, parameters)); |
Taylor Brandstetter | 55dd708 | 2016-05-03 13:50:11 -0700 | [diff] [blame] | 947 | EXPECT_TRUE(GetSendStream(kSsrc1).IsSending()); |
| 948 | } |
| 949 | |
Taylor Brandstetter | db0cd9e | 2016-05-16 11:40:30 -0700 | [diff] [blame] | 950 | // Test that SetRtpSendParameters configures the correct encoding channel for |
| 951 | // each SSRC. |
skvlad | e0d4637 | 2016-04-07 22:59:22 -0700 | [diff] [blame] | 952 | TEST_F(WebRtcVoiceEngineTestFake, RtpParametersArePerStream) { |
| 953 | SetupForMultiSendStream(); |
| 954 | // Create send streams. |
| 955 | for (uint32_t ssrc : kSsrcs4) { |
| 956 | EXPECT_TRUE( |
| 957 | channel_->AddSendStream(cricket::StreamParams::CreateLegacy(ssrc))); |
| 958 | } |
| 959 | // Configure one stream to be limited by the stream config, another to be |
| 960 | // limited by the global max, and the third one with no per-stream limit |
| 961 | // (still subject to the global limit). |
| 962 | EXPECT_TRUE(SetGlobalMaxBitrate(kOpusCodec, 64000)); |
| 963 | EXPECT_TRUE(SetMaxBitrateForStream(kSsrcs4[0], 48000)); |
| 964 | EXPECT_TRUE(SetMaxBitrateForStream(kSsrcs4[1], 96000)); |
| 965 | EXPECT_TRUE(SetMaxBitrateForStream(kSsrcs4[2], -1)); |
| 966 | |
| 967 | EXPECT_EQ(48000, GetCodecBitrate(kSsrcs4[0])); |
| 968 | EXPECT_EQ(64000, GetCodecBitrate(kSsrcs4[1])); |
| 969 | EXPECT_EQ(64000, GetCodecBitrate(kSsrcs4[2])); |
| 970 | |
| 971 | // Remove the global cap; the streams should switch to their respective |
| 972 | // maximums (or remain unchanged if there was no other limit on them.) |
| 973 | EXPECT_TRUE(SetGlobalMaxBitrate(kOpusCodec, -1)); |
| 974 | EXPECT_EQ(48000, GetCodecBitrate(kSsrcs4[0])); |
| 975 | EXPECT_EQ(96000, GetCodecBitrate(kSsrcs4[1])); |
| 976 | EXPECT_EQ(64000, GetCodecBitrate(kSsrcs4[2])); |
| 977 | } |
| 978 | |
Taylor Brandstetter | db0cd9e | 2016-05-16 11:40:30 -0700 | [diff] [blame] | 979 | // Test that GetRtpSendParameters returns the currently configured codecs. |
| 980 | TEST_F(WebRtcVoiceEngineTestFake, GetRtpSendParametersCodecs) { |
Taylor Brandstetter | 0cd086b | 2016-04-20 16:23:10 -0700 | [diff] [blame] | 981 | EXPECT_TRUE(SetupSendStream()); |
| 982 | cricket::AudioSendParameters parameters; |
| 983 | parameters.codecs.push_back(kIsacCodec); |
| 984 | parameters.codecs.push_back(kPcmuCodec); |
| 985 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
| 986 | |
Taylor Brandstetter | db0cd9e | 2016-05-16 11:40:30 -0700 | [diff] [blame] | 987 | webrtc::RtpParameters rtp_parameters = channel_->GetRtpSendParameters(kSsrc1); |
Taylor Brandstetter | 0cd086b | 2016-04-20 16:23:10 -0700 | [diff] [blame] | 988 | ASSERT_EQ(2u, rtp_parameters.codecs.size()); |
Taylor Brandstetter | db0cd9e | 2016-05-16 11:40:30 -0700 | [diff] [blame] | 989 | EXPECT_EQ(kIsacCodec.ToCodecParameters(), rtp_parameters.codecs[0]); |
| 990 | EXPECT_EQ(kPcmuCodec.ToCodecParameters(), rtp_parameters.codecs[1]); |
Taylor Brandstetter | 0cd086b | 2016-04-20 16:23:10 -0700 | [diff] [blame] | 991 | } |
| 992 | |
| 993 | // Test that if we set/get parameters multiple times, we get the same results. |
Taylor Brandstetter | db0cd9e | 2016-05-16 11:40:30 -0700 | [diff] [blame] | 994 | TEST_F(WebRtcVoiceEngineTestFake, SetAndGetRtpSendParameters) { |
Taylor Brandstetter | 0cd086b | 2016-04-20 16:23:10 -0700 | [diff] [blame] | 995 | EXPECT_TRUE(SetupSendStream()); |
| 996 | cricket::AudioSendParameters parameters; |
| 997 | parameters.codecs.push_back(kIsacCodec); |
| 998 | parameters.codecs.push_back(kPcmuCodec); |
| 999 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
| 1000 | |
Taylor Brandstetter | db0cd9e | 2016-05-16 11:40:30 -0700 | [diff] [blame] | 1001 | webrtc::RtpParameters initial_params = channel_->GetRtpSendParameters(kSsrc1); |
Taylor Brandstetter | 0cd086b | 2016-04-20 16:23:10 -0700 | [diff] [blame] | 1002 | |
| 1003 | // We should be able to set the params we just got. |
Taylor Brandstetter | db0cd9e | 2016-05-16 11:40:30 -0700 | [diff] [blame] | 1004 | EXPECT_TRUE(channel_->SetRtpSendParameters(kSsrc1, initial_params)); |
Taylor Brandstetter | 0cd086b | 2016-04-20 16:23:10 -0700 | [diff] [blame] | 1005 | |
Taylor Brandstetter | db0cd9e | 2016-05-16 11:40:30 -0700 | [diff] [blame] | 1006 | // ... And this shouldn't change the params returned by GetRtpSendParameters. |
| 1007 | webrtc::RtpParameters new_params = channel_->GetRtpSendParameters(kSsrc1); |
| 1008 | EXPECT_EQ(initial_params, channel_->GetRtpSendParameters(kSsrc1)); |
| 1009 | } |
| 1010 | |
| 1011 | // Test that GetRtpReceiveParameters returns the currently configured codecs. |
| 1012 | TEST_F(WebRtcVoiceEngineTestFake, GetRtpReceiveParametersCodecs) { |
| 1013 | EXPECT_TRUE(SetupRecvStream()); |
| 1014 | cricket::AudioRecvParameters parameters; |
| 1015 | parameters.codecs.push_back(kIsacCodec); |
| 1016 | parameters.codecs.push_back(kPcmuCodec); |
| 1017 | EXPECT_TRUE(channel_->SetRecvParameters(parameters)); |
| 1018 | |
| 1019 | webrtc::RtpParameters rtp_parameters = |
| 1020 | channel_->GetRtpReceiveParameters(kSsrc1); |
| 1021 | ASSERT_EQ(2u, rtp_parameters.codecs.size()); |
| 1022 | EXPECT_EQ(kIsacCodec.ToCodecParameters(), rtp_parameters.codecs[0]); |
| 1023 | EXPECT_EQ(kPcmuCodec.ToCodecParameters(), rtp_parameters.codecs[1]); |
| 1024 | } |
| 1025 | |
| 1026 | // Test that if we set/get parameters multiple times, we get the same results. |
| 1027 | TEST_F(WebRtcVoiceEngineTestFake, SetAndGetRtpReceiveParameters) { |
| 1028 | EXPECT_TRUE(SetupRecvStream()); |
| 1029 | cricket::AudioRecvParameters parameters; |
| 1030 | parameters.codecs.push_back(kIsacCodec); |
| 1031 | parameters.codecs.push_back(kPcmuCodec); |
| 1032 | EXPECT_TRUE(channel_->SetRecvParameters(parameters)); |
| 1033 | |
| 1034 | webrtc::RtpParameters initial_params = |
| 1035 | channel_->GetRtpReceiveParameters(kSsrc1); |
| 1036 | |
| 1037 | // We should be able to set the params we just got. |
| 1038 | EXPECT_TRUE(channel_->SetRtpReceiveParameters(kSsrc1, initial_params)); |
| 1039 | |
| 1040 | // ... And this shouldn't change the params returned by |
| 1041 | // GetRtpReceiveParameters. |
| 1042 | webrtc::RtpParameters new_params = channel_->GetRtpReceiveParameters(kSsrc1); |
| 1043 | EXPECT_EQ(initial_params, channel_->GetRtpReceiveParameters(kSsrc1)); |
Taylor Brandstetter | 0cd086b | 2016-04-20 16:23:10 -0700 | [diff] [blame] | 1044 | } |
| 1045 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1046 | // Test that we apply codecs properly. |
| 1047 | TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecs) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 1048 | EXPECT_TRUE(SetupSendStream()); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1049 | cricket::AudioSendParameters parameters; |
| 1050 | parameters.codecs.push_back(kIsacCodec); |
| 1051 | parameters.codecs.push_back(kPcmuCodec); |
kwiberg | 6806136 | 2016-06-14 08:04:47 -0700 | [diff] [blame] | 1052 | parameters.codecs.push_back(kCn8000Codec); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1053 | parameters.codecs[0].id = 96; |
| 1054 | parameters.codecs[0].bitrate = 48000; |
| 1055 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
wu@webrtc.org | 05e7b44 | 2014-04-01 17:44:24 +0000 | [diff] [blame] | 1056 | EXPECT_EQ(1, voe_.GetNumSetSendCodecs()); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1057 | int channel_num = voe_.GetLastChannel(); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1058 | webrtc::CodecInst gcodec; |
| 1059 | EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); |
| 1060 | EXPECT_EQ(96, gcodec.pltype); |
| 1061 | EXPECT_EQ(48000, gcodec.rate); |
| 1062 | EXPECT_STREQ("ISAC", gcodec.plname); |
| 1063 | EXPECT_FALSE(voe_.GetVAD(channel_num)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1064 | EXPECT_EQ(13, voe_.GetSendCNPayloadType(channel_num, false)); |
| 1065 | EXPECT_EQ(105, voe_.GetSendCNPayloadType(channel_num, true)); |
Fredrik Solenberg | b572768 | 2015-12-04 15:22:19 +0100 | [diff] [blame] | 1066 | EXPECT_FALSE(channel_->CanInsertDtmf()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1067 | } |
| 1068 | |
wu@webrtc.org | 05e7b44 | 2014-04-01 17:44:24 +0000 | [diff] [blame] | 1069 | // Test that VoE Channel doesn't call SetSendCodec again if same codec is tried |
| 1070 | // to apply. |
| 1071 | TEST_F(WebRtcVoiceEngineTestFake, DontResetSetSendCodec) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 1072 | EXPECT_TRUE(SetupSendStream()); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1073 | cricket::AudioSendParameters parameters; |
| 1074 | parameters.codecs.push_back(kIsacCodec); |
| 1075 | parameters.codecs.push_back(kPcmuCodec); |
kwiberg | 6806136 | 2016-06-14 08:04:47 -0700 | [diff] [blame] | 1076 | parameters.codecs.push_back(kCn8000Codec); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1077 | parameters.codecs[0].id = 96; |
| 1078 | parameters.codecs[0].bitrate = 48000; |
| 1079 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
wu@webrtc.org | 05e7b44 | 2014-04-01 17:44:24 +0000 | [diff] [blame] | 1080 | EXPECT_EQ(1, voe_.GetNumSetSendCodecs()); |
| 1081 | // Calling SetSendCodec again with same codec which is already set. |
| 1082 | // In this case media channel shouldn't send codec to VoE. |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1083 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
wu@webrtc.org | 05e7b44 | 2014-04-01 17:44:24 +0000 | [diff] [blame] | 1084 | EXPECT_EQ(1, voe_.GetNumSetSendCodecs()); |
| 1085 | } |
| 1086 | |
henrik.lundin@webrtc.org | f85dbce | 2014-11-07 12:25:00 +0000 | [diff] [blame] | 1087 | // Verify that G722 is set with 16000 samples per second to WebRTC. |
| 1088 | TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecG722) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 1089 | EXPECT_TRUE(SetupSendStream()); |
henrik.lundin@webrtc.org | f85dbce | 2014-11-07 12:25:00 +0000 | [diff] [blame] | 1090 | int channel_num = voe_.GetLastChannel(); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1091 | cricket::AudioSendParameters parameters; |
| 1092 | parameters.codecs.push_back(kG722CodecSdp); |
| 1093 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
henrik.lundin@webrtc.org | f85dbce | 2014-11-07 12:25:00 +0000 | [diff] [blame] | 1094 | webrtc::CodecInst gcodec; |
| 1095 | EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); |
| 1096 | EXPECT_STREQ("G722", gcodec.plname); |
| 1097 | EXPECT_EQ(1, gcodec.channels); |
| 1098 | EXPECT_EQ(16000, gcodec.plfreq); |
| 1099 | } |
| 1100 | |
henrike@webrtc.org | 704bf9e | 2014-02-27 17:52:04 +0000 | [diff] [blame] | 1101 | // Test that if clockrate is not 48000 for opus, we fail. |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1102 | TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusBadClockrate) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 1103 | EXPECT_TRUE(SetupSendStream()); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1104 | cricket::AudioSendParameters parameters; |
| 1105 | parameters.codecs.push_back(kOpusCodec); |
| 1106 | parameters.codecs[0].bitrate = 0; |
| 1107 | parameters.codecs[0].clockrate = 50000; |
| 1108 | EXPECT_FALSE(channel_->SetSendParameters(parameters)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1109 | } |
| 1110 | |
henrike@webrtc.org | 704bf9e | 2014-02-27 17:52:04 +0000 | [diff] [blame] | 1111 | // Test that if channels=0 for opus, we fail. |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1112 | TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusBad0ChannelsNoStereo) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 1113 | EXPECT_TRUE(SetupSendStream()); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1114 | cricket::AudioSendParameters parameters; |
| 1115 | parameters.codecs.push_back(kOpusCodec); |
| 1116 | parameters.codecs[0].bitrate = 0; |
| 1117 | parameters.codecs[0].channels = 0; |
| 1118 | EXPECT_FALSE(channel_->SetSendParameters(parameters)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1119 | } |
| 1120 | |
henrike@webrtc.org | 704bf9e | 2014-02-27 17:52:04 +0000 | [diff] [blame] | 1121 | // Test that if channels=0 for opus, we fail. |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1122 | TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusBad0Channels1Stereo) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 1123 | EXPECT_TRUE(SetupSendStream()); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1124 | cricket::AudioSendParameters parameters; |
| 1125 | parameters.codecs.push_back(kOpusCodec); |
| 1126 | parameters.codecs[0].bitrate = 0; |
| 1127 | parameters.codecs[0].channels = 0; |
| 1128 | parameters.codecs[0].params["stereo"] = "1"; |
| 1129 | EXPECT_FALSE(channel_->SetSendParameters(parameters)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1130 | } |
| 1131 | |
| 1132 | // Test that if channel is 1 for opus and there's no stereo, we fail. |
| 1133 | TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpus1ChannelNoStereo) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 1134 | EXPECT_TRUE(SetupSendStream()); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1135 | cricket::AudioSendParameters parameters; |
| 1136 | parameters.codecs.push_back(kOpusCodec); |
| 1137 | parameters.codecs[0].bitrate = 0; |
| 1138 | parameters.codecs[0].channels = 1; |
| 1139 | EXPECT_FALSE(channel_->SetSendParameters(parameters)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1140 | } |
| 1141 | |
| 1142 | // Test that if channel is 1 for opus and stereo=0, we fail. |
| 1143 | TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusBad1Channel0Stereo) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 1144 | EXPECT_TRUE(SetupSendStream()); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1145 | cricket::AudioSendParameters parameters; |
| 1146 | parameters.codecs.push_back(kOpusCodec); |
| 1147 | parameters.codecs[0].bitrate = 0; |
| 1148 | parameters.codecs[0].channels = 1; |
| 1149 | parameters.codecs[0].params["stereo"] = "0"; |
| 1150 | EXPECT_FALSE(channel_->SetSendParameters(parameters)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1151 | } |
| 1152 | |
| 1153 | // Test that if channel is 1 for opus and stereo=1, we fail. |
| 1154 | TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusBad1Channel1Stereo) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 1155 | EXPECT_TRUE(SetupSendStream()); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1156 | cricket::AudioSendParameters parameters; |
| 1157 | parameters.codecs.push_back(kOpusCodec); |
| 1158 | parameters.codecs[0].bitrate = 0; |
| 1159 | parameters.codecs[0].channels = 1; |
| 1160 | parameters.codecs[0].params["stereo"] = "1"; |
| 1161 | EXPECT_FALSE(channel_->SetSendParameters(parameters)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1162 | } |
| 1163 | |
| 1164 | // Test that with bitrate=0 and no stereo, |
| 1165 | // channels and bitrate are 1 and 32000. |
| 1166 | TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGood0BitrateNoStereo) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 1167 | EXPECT_TRUE(SetupSendStream()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1168 | int channel_num = voe_.GetLastChannel(); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1169 | cricket::AudioSendParameters parameters; |
| 1170 | parameters.codecs.push_back(kOpusCodec); |
| 1171 | parameters.codecs[0].bitrate = 0; |
| 1172 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1173 | webrtc::CodecInst gcodec; |
| 1174 | EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); |
| 1175 | EXPECT_STREQ("opus", gcodec.plname); |
| 1176 | EXPECT_EQ(1, gcodec.channels); |
| 1177 | EXPECT_EQ(32000, gcodec.rate); |
| 1178 | } |
| 1179 | |
| 1180 | // Test that with bitrate=0 and stereo=0, |
| 1181 | // channels and bitrate are 1 and 32000. |
| 1182 | TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGood0Bitrate0Stereo) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 1183 | EXPECT_TRUE(SetupSendStream()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1184 | int channel_num = voe_.GetLastChannel(); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1185 | cricket::AudioSendParameters parameters; |
| 1186 | parameters.codecs.push_back(kOpusCodec); |
| 1187 | parameters.codecs[0].bitrate = 0; |
| 1188 | parameters.codecs[0].params["stereo"] = "0"; |
| 1189 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1190 | webrtc::CodecInst gcodec; |
| 1191 | EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); |
| 1192 | EXPECT_STREQ("opus", gcodec.plname); |
| 1193 | EXPECT_EQ(1, gcodec.channels); |
| 1194 | EXPECT_EQ(32000, gcodec.rate); |
| 1195 | } |
| 1196 | |
henrike@webrtc.org | 1e09a71 | 2013-07-26 19:17:59 +0000 | [diff] [blame] | 1197 | // Test that with bitrate=invalid and stereo=0, |
| 1198 | // channels and bitrate are 1 and 32000. |
| 1199 | TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodXBitrate0Stereo) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 1200 | EXPECT_TRUE(SetupSendStream()); |
henrike@webrtc.org | 1e09a71 | 2013-07-26 19:17:59 +0000 | [diff] [blame] | 1201 | int channel_num = voe_.GetLastChannel(); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1202 | cricket::AudioSendParameters parameters; |
| 1203 | parameters.codecs.push_back(kOpusCodec); |
| 1204 | parameters.codecs[0].params["stereo"] = "0"; |
henrike@webrtc.org | 1e09a71 | 2013-07-26 19:17:59 +0000 | [diff] [blame] | 1205 | webrtc::CodecInst gcodec; |
| 1206 | |
buildbot@webrtc.org | 9d446f2 | 2014-10-23 12:22:06 +0000 | [diff] [blame] | 1207 | // bitrate that's out of the range between 6000 and 510000 will be clamped. |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1208 | parameters.codecs[0].bitrate = 5999; |
| 1209 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
henrike@webrtc.org | 1e09a71 | 2013-07-26 19:17:59 +0000 | [diff] [blame] | 1210 | EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); |
| 1211 | EXPECT_STREQ("opus", gcodec.plname); |
| 1212 | EXPECT_EQ(1, gcodec.channels); |
buildbot@webrtc.org | 9d446f2 | 2014-10-23 12:22:06 +0000 | [diff] [blame] | 1213 | EXPECT_EQ(6000, gcodec.rate); |
henrike@webrtc.org | 1e09a71 | 2013-07-26 19:17:59 +0000 | [diff] [blame] | 1214 | |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1215 | parameters.codecs[0].bitrate = 510001; |
| 1216 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
henrike@webrtc.org | 1e09a71 | 2013-07-26 19:17:59 +0000 | [diff] [blame] | 1217 | EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); |
| 1218 | EXPECT_STREQ("opus", gcodec.plname); |
| 1219 | EXPECT_EQ(1, gcodec.channels); |
buildbot@webrtc.org | 9d446f2 | 2014-10-23 12:22:06 +0000 | [diff] [blame] | 1220 | EXPECT_EQ(510000, gcodec.rate); |
henrike@webrtc.org | 1e09a71 | 2013-07-26 19:17:59 +0000 | [diff] [blame] | 1221 | } |
| 1222 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1223 | // Test that with bitrate=0 and stereo=1, |
| 1224 | // channels and bitrate are 2 and 64000. |
| 1225 | TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGood0Bitrate1Stereo) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 1226 | EXPECT_TRUE(SetupSendStream()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1227 | int channel_num = voe_.GetLastChannel(); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1228 | cricket::AudioSendParameters parameters; |
| 1229 | parameters.codecs.push_back(kOpusCodec); |
| 1230 | parameters.codecs[0].bitrate = 0; |
| 1231 | parameters.codecs[0].params["stereo"] = "1"; |
| 1232 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1233 | webrtc::CodecInst gcodec; |
| 1234 | EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); |
| 1235 | EXPECT_STREQ("opus", gcodec.plname); |
| 1236 | EXPECT_EQ(2, gcodec.channels); |
| 1237 | EXPECT_EQ(64000, gcodec.rate); |
| 1238 | } |
| 1239 | |
henrike@webrtc.org | 1e09a71 | 2013-07-26 19:17:59 +0000 | [diff] [blame] | 1240 | // Test that with bitrate=invalid and stereo=1, |
| 1241 | // channels and bitrate are 2 and 64000. |
| 1242 | TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodXBitrate1Stereo) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 1243 | EXPECT_TRUE(SetupSendStream()); |
henrike@webrtc.org | 1e09a71 | 2013-07-26 19:17:59 +0000 | [diff] [blame] | 1244 | int channel_num = voe_.GetLastChannel(); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1245 | cricket::AudioSendParameters parameters; |
| 1246 | parameters.codecs.push_back(kOpusCodec); |
| 1247 | parameters.codecs[0].params["stereo"] = "1"; |
henrike@webrtc.org | 1e09a71 | 2013-07-26 19:17:59 +0000 | [diff] [blame] | 1248 | webrtc::CodecInst gcodec; |
| 1249 | |
buildbot@webrtc.org | 9d446f2 | 2014-10-23 12:22:06 +0000 | [diff] [blame] | 1250 | // bitrate that's out of the range between 6000 and 510000 will be clamped. |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1251 | parameters.codecs[0].bitrate = 5999; |
| 1252 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
henrike@webrtc.org | 1e09a71 | 2013-07-26 19:17:59 +0000 | [diff] [blame] | 1253 | EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); |
| 1254 | EXPECT_STREQ("opus", gcodec.plname); |
| 1255 | EXPECT_EQ(2, gcodec.channels); |
buildbot@webrtc.org | 9d446f2 | 2014-10-23 12:22:06 +0000 | [diff] [blame] | 1256 | EXPECT_EQ(6000, gcodec.rate); |
henrike@webrtc.org | 1e09a71 | 2013-07-26 19:17:59 +0000 | [diff] [blame] | 1257 | |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1258 | parameters.codecs[0].bitrate = 510001; |
| 1259 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
henrike@webrtc.org | 1e09a71 | 2013-07-26 19:17:59 +0000 | [diff] [blame] | 1260 | EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); |
| 1261 | EXPECT_STREQ("opus", gcodec.plname); |
| 1262 | EXPECT_EQ(2, gcodec.channels); |
buildbot@webrtc.org | 9d446f2 | 2014-10-23 12:22:06 +0000 | [diff] [blame] | 1263 | EXPECT_EQ(510000, gcodec.rate); |
henrike@webrtc.org | 1e09a71 | 2013-07-26 19:17:59 +0000 | [diff] [blame] | 1264 | } |
| 1265 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1266 | // Test that with bitrate=N and stereo unset, |
| 1267 | // channels and bitrate are 1 and N. |
| 1268 | TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrateNoStereo) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 1269 | EXPECT_TRUE(SetupSendStream()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1270 | int channel_num = voe_.GetLastChannel(); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1271 | cricket::AudioSendParameters parameters; |
| 1272 | parameters.codecs.push_back(kOpusCodec); |
| 1273 | parameters.codecs[0].bitrate = 96000; |
| 1274 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1275 | webrtc::CodecInst gcodec; |
| 1276 | EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); |
| 1277 | EXPECT_EQ(111, gcodec.pltype); |
| 1278 | EXPECT_EQ(96000, gcodec.rate); |
| 1279 | EXPECT_STREQ("opus", gcodec.plname); |
| 1280 | EXPECT_EQ(1, gcodec.channels); |
| 1281 | EXPECT_EQ(48000, gcodec.plfreq); |
| 1282 | } |
| 1283 | |
| 1284 | // Test that with bitrate=N and stereo=0, |
| 1285 | // channels and bitrate are 1 and N. |
| 1286 | TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrate0Stereo) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 1287 | EXPECT_TRUE(SetupSendStream()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1288 | int channel_num = voe_.GetLastChannel(); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1289 | cricket::AudioSendParameters parameters; |
| 1290 | parameters.codecs.push_back(kOpusCodec); |
| 1291 | parameters.codecs[0].bitrate = 30000; |
| 1292 | parameters.codecs[0].params["stereo"] = "0"; |
| 1293 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1294 | webrtc::CodecInst gcodec; |
| 1295 | EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); |
| 1296 | EXPECT_EQ(1, gcodec.channels); |
| 1297 | EXPECT_EQ(30000, gcodec.rate); |
| 1298 | EXPECT_STREQ("opus", gcodec.plname); |
| 1299 | } |
| 1300 | |
| 1301 | // Test that with bitrate=N and without any parameters, |
| 1302 | // channels and bitrate are 1 and N. |
| 1303 | TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrateNoParameters) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 1304 | EXPECT_TRUE(SetupSendStream()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1305 | int channel_num = voe_.GetLastChannel(); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1306 | cricket::AudioSendParameters parameters; |
| 1307 | parameters.codecs.push_back(kOpusCodec); |
| 1308 | parameters.codecs[0].bitrate = 30000; |
| 1309 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1310 | webrtc::CodecInst gcodec; |
| 1311 | EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); |
| 1312 | EXPECT_EQ(1, gcodec.channels); |
| 1313 | EXPECT_EQ(30000, gcodec.rate); |
| 1314 | EXPECT_STREQ("opus", gcodec.plname); |
| 1315 | } |
| 1316 | |
| 1317 | // Test that with bitrate=N and stereo=1, |
| 1318 | // channels and bitrate are 2 and N. |
| 1319 | TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrate1Stereo) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 1320 | EXPECT_TRUE(SetupSendStream()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1321 | int channel_num = voe_.GetLastChannel(); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1322 | cricket::AudioSendParameters parameters; |
| 1323 | parameters.codecs.push_back(kOpusCodec); |
| 1324 | parameters.codecs[0].bitrate = 30000; |
| 1325 | parameters.codecs[0].params["stereo"] = "1"; |
| 1326 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1327 | webrtc::CodecInst gcodec; |
| 1328 | EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); |
| 1329 | EXPECT_EQ(2, gcodec.channels); |
| 1330 | EXPECT_EQ(30000, gcodec.rate); |
| 1331 | EXPECT_STREQ("opus", gcodec.plname); |
| 1332 | } |
| 1333 | |
henrike@webrtc.org | 1e09a71 | 2013-07-26 19:17:59 +0000 | [diff] [blame] | 1334 | // Test that bitrate will be overridden by the "maxaveragebitrate" parameter. |
| 1335 | // Also test that the "maxaveragebitrate" can't be set to values outside the |
| 1336 | // range of 6000 and 510000 |
| 1337 | TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusMaxAverageBitrate) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 1338 | EXPECT_TRUE(SetupSendStream()); |
henrike@webrtc.org | 1e09a71 | 2013-07-26 19:17:59 +0000 | [diff] [blame] | 1339 | int channel_num = voe_.GetLastChannel(); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1340 | cricket::AudioSendParameters parameters; |
| 1341 | parameters.codecs.push_back(kOpusCodec); |
| 1342 | parameters.codecs[0].bitrate = 30000; |
henrike@webrtc.org | 1e09a71 | 2013-07-26 19:17:59 +0000 | [diff] [blame] | 1343 | webrtc::CodecInst gcodec; |
| 1344 | |
| 1345 | // Ignore if less than 6000. |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1346 | parameters.codecs[0].params["maxaveragebitrate"] = "5999"; |
| 1347 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
henrike@webrtc.org | 1e09a71 | 2013-07-26 19:17:59 +0000 | [diff] [blame] | 1348 | EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); |
buildbot@webrtc.org | 9d446f2 | 2014-10-23 12:22:06 +0000 | [diff] [blame] | 1349 | EXPECT_EQ(6000, gcodec.rate); |
henrike@webrtc.org | 1e09a71 | 2013-07-26 19:17:59 +0000 | [diff] [blame] | 1350 | |
| 1351 | // Ignore if larger than 510000. |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1352 | parameters.codecs[0].params["maxaveragebitrate"] = "510001"; |
| 1353 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
henrike@webrtc.org | 1e09a71 | 2013-07-26 19:17:59 +0000 | [diff] [blame] | 1354 | EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); |
buildbot@webrtc.org | 9d446f2 | 2014-10-23 12:22:06 +0000 | [diff] [blame] | 1355 | EXPECT_EQ(510000, gcodec.rate); |
henrike@webrtc.org | 1e09a71 | 2013-07-26 19:17:59 +0000 | [diff] [blame] | 1356 | |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1357 | parameters.codecs[0].params["maxaveragebitrate"] = "200000"; |
| 1358 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
henrike@webrtc.org | 1e09a71 | 2013-07-26 19:17:59 +0000 | [diff] [blame] | 1359 | EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); |
| 1360 | EXPECT_EQ(200000, gcodec.rate); |
| 1361 | } |
| 1362 | |
wu@webrtc.org | cadf904 | 2013-08-30 21:24:16 +0000 | [diff] [blame] | 1363 | // Test that we can enable NACK with opus as caller. |
| 1364 | TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecEnableNackAsCaller) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 1365 | EXPECT_TRUE(SetupSendStream()); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1366 | cricket::AudioSendParameters parameters; |
| 1367 | parameters.codecs.push_back(kOpusCodec); |
| 1368 | parameters.codecs[0].AddFeedbackParam( |
| 1369 | cricket::FeedbackParam(cricket::kRtcpFbParamNack, |
| 1370 | cricket::kParamValueEmpty)); |
solenberg | 971cab0 | 2016-06-14 10:02:41 -0700 | [diff] [blame] | 1371 | EXPECT_EQ(0, GetSendStreamConfig(kSsrc1).rtp.nack.rtp_history_ms); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1372 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
solenberg | 971cab0 | 2016-06-14 10:02:41 -0700 | [diff] [blame] | 1373 | EXPECT_EQ(kRtpHistoryMs, GetSendStreamConfig(kSsrc1).rtp.nack.rtp_history_ms); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1374 | } |
| 1375 | |
wu@webrtc.org | cadf904 | 2013-08-30 21:24:16 +0000 | [diff] [blame] | 1376 | // Test that we can enable NACK with opus as callee. |
| 1377 | TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecEnableNackAsCallee) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 1378 | EXPECT_TRUE(SetupRecvStream()); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1379 | cricket::AudioSendParameters parameters; |
| 1380 | parameters.codecs.push_back(kOpusCodec); |
| 1381 | parameters.codecs[0].AddFeedbackParam( |
| 1382 | cricket::FeedbackParam(cricket::kRtcpFbParamNack, |
| 1383 | cricket::kParamValueEmpty)); |
solenberg | 8189b02 | 2016-06-14 12:13:00 -0700 | [diff] [blame] | 1384 | EXPECT_EQ(0, GetRecvStreamConfig(kSsrc1).rtp.nack.rtp_history_ms); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1385 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
deadbeef | b56069e | 2016-05-06 04:57:03 -0700 | [diff] [blame] | 1386 | // NACK should be enabled even with no send stream. |
solenberg | 8189b02 | 2016-06-14 12:13:00 -0700 | [diff] [blame] | 1387 | EXPECT_EQ(kRtpHistoryMs, GetRecvStreamConfig(kSsrc1).rtp.nack.rtp_history_ms); |
wu@webrtc.org | cadf904 | 2013-08-30 21:24:16 +0000 | [diff] [blame] | 1388 | |
| 1389 | EXPECT_TRUE(channel_->AddSendStream( |
| 1390 | cricket::StreamParams::CreateLegacy(kSsrc1))); |
solenberg | 971cab0 | 2016-06-14 10:02:41 -0700 | [diff] [blame] | 1391 | EXPECT_EQ(kRtpHistoryMs, GetSendStreamConfig(kSsrc1).rtp.nack.rtp_history_ms); |
wu@webrtc.org | cadf904 | 2013-08-30 21:24:16 +0000 | [diff] [blame] | 1392 | } |
| 1393 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1394 | // Test that we can enable NACK on receive streams. |
| 1395 | TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecEnableNackRecvStreams) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 1396 | EXPECT_TRUE(SetupSendStream()); |
solenberg | 8189b02 | 2016-06-14 12:13:00 -0700 | [diff] [blame] | 1397 | EXPECT_TRUE(AddRecvStream(kSsrc2)); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1398 | cricket::AudioSendParameters parameters; |
| 1399 | parameters.codecs.push_back(kOpusCodec); |
| 1400 | parameters.codecs[0].AddFeedbackParam( |
| 1401 | cricket::FeedbackParam(cricket::kRtcpFbParamNack, |
| 1402 | cricket::kParamValueEmpty)); |
solenberg | 971cab0 | 2016-06-14 10:02:41 -0700 | [diff] [blame] | 1403 | EXPECT_EQ(0, GetSendStreamConfig(kSsrc1).rtp.nack.rtp_history_ms); |
solenberg | 8189b02 | 2016-06-14 12:13:00 -0700 | [diff] [blame] | 1404 | EXPECT_EQ(0, GetRecvStreamConfig(kSsrc2).rtp.nack.rtp_history_ms); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1405 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
solenberg | 971cab0 | 2016-06-14 10:02:41 -0700 | [diff] [blame] | 1406 | EXPECT_EQ(kRtpHistoryMs, GetSendStreamConfig(kSsrc1).rtp.nack.rtp_history_ms); |
solenberg | 8189b02 | 2016-06-14 12:13:00 -0700 | [diff] [blame] | 1407 | EXPECT_EQ(kRtpHistoryMs, GetRecvStreamConfig(kSsrc2).rtp.nack.rtp_history_ms); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1408 | } |
| 1409 | |
| 1410 | // Test that we can disable NACK. |
| 1411 | TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecDisableNack) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 1412 | EXPECT_TRUE(SetupSendStream()); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1413 | cricket::AudioSendParameters parameters; |
| 1414 | parameters.codecs.push_back(kOpusCodec); |
| 1415 | parameters.codecs[0].AddFeedbackParam( |
| 1416 | cricket::FeedbackParam(cricket::kRtcpFbParamNack, |
| 1417 | cricket::kParamValueEmpty)); |
| 1418 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
solenberg | 971cab0 | 2016-06-14 10:02:41 -0700 | [diff] [blame] | 1419 | EXPECT_EQ(kRtpHistoryMs, GetSendStreamConfig(kSsrc1).rtp.nack.rtp_history_ms); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1420 | |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1421 | parameters.codecs.clear(); |
| 1422 | parameters.codecs.push_back(kOpusCodec); |
| 1423 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
solenberg | 971cab0 | 2016-06-14 10:02:41 -0700 | [diff] [blame] | 1424 | EXPECT_EQ(0, GetSendStreamConfig(kSsrc1).rtp.nack.rtp_history_ms); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1425 | } |
| 1426 | |
| 1427 | // Test that we can disable NACK on receive streams. |
| 1428 | TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecDisableNackRecvStreams) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 1429 | EXPECT_TRUE(SetupSendStream()); |
solenberg | 8189b02 | 2016-06-14 12:13:00 -0700 | [diff] [blame] | 1430 | EXPECT_TRUE(AddRecvStream(kSsrc2)); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1431 | cricket::AudioSendParameters parameters; |
| 1432 | parameters.codecs.push_back(kOpusCodec); |
| 1433 | parameters.codecs[0].AddFeedbackParam( |
| 1434 | cricket::FeedbackParam(cricket::kRtcpFbParamNack, |
| 1435 | cricket::kParamValueEmpty)); |
| 1436 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
solenberg | 971cab0 | 2016-06-14 10:02:41 -0700 | [diff] [blame] | 1437 | EXPECT_EQ(kRtpHistoryMs, GetSendStreamConfig(kSsrc1).rtp.nack.rtp_history_ms); |
solenberg | 8189b02 | 2016-06-14 12:13:00 -0700 | [diff] [blame] | 1438 | EXPECT_EQ(kRtpHistoryMs, GetRecvStreamConfig(kSsrc2).rtp.nack.rtp_history_ms); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1439 | |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1440 | parameters.codecs.clear(); |
| 1441 | parameters.codecs.push_back(kOpusCodec); |
| 1442 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
solenberg | 971cab0 | 2016-06-14 10:02:41 -0700 | [diff] [blame] | 1443 | EXPECT_EQ(0, GetSendStreamConfig(kSsrc1).rtp.nack.rtp_history_ms); |
solenberg | 8189b02 | 2016-06-14 12:13:00 -0700 | [diff] [blame] | 1444 | EXPECT_EQ(0, GetRecvStreamConfig(kSsrc2).rtp.nack.rtp_history_ms); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1445 | } |
| 1446 | |
| 1447 | // Test that NACK is enabled on a new receive stream. |
| 1448 | TEST_F(WebRtcVoiceEngineTestFake, AddRecvStreamEnableNack) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 1449 | EXPECT_TRUE(SetupSendStream()); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1450 | cricket::AudioSendParameters parameters; |
| 1451 | parameters.codecs.push_back(kIsacCodec); |
| 1452 | parameters.codecs.push_back(kCn16000Codec); |
| 1453 | parameters.codecs[0].AddFeedbackParam( |
| 1454 | cricket::FeedbackParam(cricket::kRtcpFbParamNack, |
| 1455 | cricket::kParamValueEmpty)); |
| 1456 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
solenberg | 971cab0 | 2016-06-14 10:02:41 -0700 | [diff] [blame] | 1457 | EXPECT_EQ(kRtpHistoryMs, GetSendStreamConfig(kSsrc1).rtp.nack.rtp_history_ms); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1458 | |
solenberg | 8189b02 | 2016-06-14 12:13:00 -0700 | [diff] [blame] | 1459 | EXPECT_TRUE(AddRecvStream(kSsrc2)); |
| 1460 | EXPECT_EQ(kRtpHistoryMs, GetRecvStreamConfig(kSsrc2).rtp.nack.rtp_history_ms); |
| 1461 | EXPECT_TRUE(AddRecvStream(kSsrc3)); |
| 1462 | EXPECT_EQ(kRtpHistoryMs, GetRecvStreamConfig(kSsrc3).rtp.nack.rtp_history_ms); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1463 | } |
| 1464 | |
buildbot@webrtc.org | ae740dd | 2014-06-17 10:56:41 +0000 | [diff] [blame] | 1465 | // Test that without useinbandfec, Opus FEC is off. |
buildbot@webrtc.org | d27d9ae | 2014-06-19 01:56:46 +0000 | [diff] [blame] | 1466 | TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecNoOpusFec) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 1467 | EXPECT_TRUE(SetupSendStream()); |
buildbot@webrtc.org | ae740dd | 2014-06-17 10:56:41 +0000 | [diff] [blame] | 1468 | int channel_num = voe_.GetLastChannel(); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1469 | cricket::AudioSendParameters parameters; |
| 1470 | parameters.codecs.push_back(kOpusCodec); |
| 1471 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
buildbot@webrtc.org | ae740dd | 2014-06-17 10:56:41 +0000 | [diff] [blame] | 1472 | EXPECT_FALSE(voe_.GetCodecFEC(channel_num)); |
| 1473 | } |
| 1474 | |
| 1475 | // Test that with useinbandfec=0, Opus FEC is off. |
buildbot@webrtc.org | d27d9ae | 2014-06-19 01:56:46 +0000 | [diff] [blame] | 1476 | TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusDisableFec) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 1477 | EXPECT_TRUE(SetupSendStream()); |
buildbot@webrtc.org | ae740dd | 2014-06-17 10:56:41 +0000 | [diff] [blame] | 1478 | int channel_num = voe_.GetLastChannel(); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1479 | cricket::AudioSendParameters parameters; |
| 1480 | parameters.codecs.push_back(kOpusCodec); |
| 1481 | parameters.codecs[0].bitrate = 0; |
| 1482 | parameters.codecs[0].params["useinbandfec"] = "0"; |
| 1483 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
buildbot@webrtc.org | ae740dd | 2014-06-17 10:56:41 +0000 | [diff] [blame] | 1484 | EXPECT_FALSE(voe_.GetCodecFEC(channel_num)); |
| 1485 | webrtc::CodecInst gcodec; |
| 1486 | EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); |
| 1487 | EXPECT_STREQ("opus", gcodec.plname); |
| 1488 | EXPECT_EQ(1, gcodec.channels); |
| 1489 | EXPECT_EQ(32000, gcodec.rate); |
| 1490 | } |
| 1491 | |
| 1492 | // Test that with useinbandfec=1, Opus FEC is on. |
buildbot@webrtc.org | d27d9ae | 2014-06-19 01:56:46 +0000 | [diff] [blame] | 1493 | TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusEnableFec) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 1494 | EXPECT_TRUE(SetupSendStream()); |
buildbot@webrtc.org | ae740dd | 2014-06-17 10:56:41 +0000 | [diff] [blame] | 1495 | int channel_num = voe_.GetLastChannel(); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1496 | cricket::AudioSendParameters parameters; |
| 1497 | parameters.codecs.push_back(kOpusCodec); |
| 1498 | parameters.codecs[0].bitrate = 0; |
| 1499 | parameters.codecs[0].params["useinbandfec"] = "1"; |
| 1500 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
buildbot@webrtc.org | ae740dd | 2014-06-17 10:56:41 +0000 | [diff] [blame] | 1501 | EXPECT_TRUE(voe_.GetCodecFEC(channel_num)); |
| 1502 | webrtc::CodecInst gcodec; |
| 1503 | EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); |
| 1504 | EXPECT_STREQ("opus", gcodec.plname); |
| 1505 | EXPECT_EQ(1, gcodec.channels); |
| 1506 | EXPECT_EQ(32000, gcodec.rate); |
| 1507 | } |
| 1508 | |
| 1509 | // Test that with useinbandfec=1, stereo=1, Opus FEC is on. |
buildbot@webrtc.org | d27d9ae | 2014-06-19 01:56:46 +0000 | [diff] [blame] | 1510 | TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusEnableFecStereo) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 1511 | EXPECT_TRUE(SetupSendStream()); |
buildbot@webrtc.org | ae740dd | 2014-06-17 10:56:41 +0000 | [diff] [blame] | 1512 | int channel_num = voe_.GetLastChannel(); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1513 | cricket::AudioSendParameters parameters; |
| 1514 | parameters.codecs.push_back(kOpusCodec); |
| 1515 | parameters.codecs[0].bitrate = 0; |
| 1516 | parameters.codecs[0].params["stereo"] = "1"; |
| 1517 | parameters.codecs[0].params["useinbandfec"] = "1"; |
| 1518 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
buildbot@webrtc.org | ae740dd | 2014-06-17 10:56:41 +0000 | [diff] [blame] | 1519 | EXPECT_TRUE(voe_.GetCodecFEC(channel_num)); |
| 1520 | webrtc::CodecInst gcodec; |
| 1521 | EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); |
| 1522 | EXPECT_STREQ("opus", gcodec.plname); |
| 1523 | EXPECT_EQ(2, gcodec.channels); |
| 1524 | EXPECT_EQ(64000, gcodec.rate); |
| 1525 | } |
| 1526 | |
| 1527 | // Test that with non-Opus, codec FEC is off. |
buildbot@webrtc.org | d27d9ae | 2014-06-19 01:56:46 +0000 | [diff] [blame] | 1528 | TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecIsacNoFec) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 1529 | EXPECT_TRUE(SetupSendStream()); |
buildbot@webrtc.org | ae740dd | 2014-06-17 10:56:41 +0000 | [diff] [blame] | 1530 | int channel_num = voe_.GetLastChannel(); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1531 | cricket::AudioSendParameters parameters; |
| 1532 | parameters.codecs.push_back(kIsacCodec); |
| 1533 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
buildbot@webrtc.org | ae740dd | 2014-06-17 10:56:41 +0000 | [diff] [blame] | 1534 | EXPECT_FALSE(voe_.GetCodecFEC(channel_num)); |
| 1535 | } |
buildbot@webrtc.org | 3ffa1f9 | 2014-07-02 19:51:26 +0000 | [diff] [blame] | 1536 | |
| 1537 | // Test the with non-Opus, even if useinbandfec=1, FEC is off. |
| 1538 | TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecIsacWithParamNoFec) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 1539 | EXPECT_TRUE(SetupSendStream()); |
buildbot@webrtc.org | 3ffa1f9 | 2014-07-02 19:51:26 +0000 | [diff] [blame] | 1540 | int channel_num = voe_.GetLastChannel(); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1541 | cricket::AudioSendParameters parameters; |
| 1542 | parameters.codecs.push_back(kIsacCodec); |
| 1543 | parameters.codecs[0].params["useinbandfec"] = "1"; |
| 1544 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
buildbot@webrtc.org | 3ffa1f9 | 2014-07-02 19:51:26 +0000 | [diff] [blame] | 1545 | EXPECT_FALSE(voe_.GetCodecFEC(channel_num)); |
| 1546 | } |
buildbot@webrtc.org | 5d639b3 | 2014-09-10 07:57:12 +0000 | [diff] [blame] | 1547 | |
| 1548 | // Test that Opus FEC status can be changed. |
| 1549 | TEST_F(WebRtcVoiceEngineTestFake, ChangeOpusFecStatus) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 1550 | EXPECT_TRUE(SetupSendStream()); |
buildbot@webrtc.org | 5d639b3 | 2014-09-10 07:57:12 +0000 | [diff] [blame] | 1551 | int channel_num = voe_.GetLastChannel(); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1552 | cricket::AudioSendParameters parameters; |
| 1553 | parameters.codecs.push_back(kOpusCodec); |
| 1554 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
buildbot@webrtc.org | 5d639b3 | 2014-09-10 07:57:12 +0000 | [diff] [blame] | 1555 | EXPECT_FALSE(voe_.GetCodecFEC(channel_num)); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1556 | parameters.codecs[0].params["useinbandfec"] = "1"; |
| 1557 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
buildbot@webrtc.org | 5d639b3 | 2014-09-10 07:57:12 +0000 | [diff] [blame] | 1558 | EXPECT_TRUE(voe_.GetCodecFEC(channel_num)); |
| 1559 | } |
| 1560 | |
stefan | ba4c0e4 | 2016-02-04 04:12:24 -0800 | [diff] [blame] | 1561 | TEST_F(WebRtcVoiceEngineTestFake, TransportCcCanBeEnabledAndDisabled) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 1562 | EXPECT_TRUE(SetupChannel()); |
stefan | ba4c0e4 | 2016-02-04 04:12:24 -0800 | [diff] [blame] | 1563 | cricket::AudioSendParameters send_parameters; |
| 1564 | send_parameters.codecs.push_back(kOpusCodec); |
| 1565 | EXPECT_TRUE(send_parameters.codecs[0].feedback_params.params().empty()); |
| 1566 | EXPECT_TRUE(channel_->SetSendParameters(send_parameters)); |
| 1567 | |
| 1568 | cricket::AudioRecvParameters recv_parameters; |
| 1569 | recv_parameters.codecs.push_back(kIsacCodec); |
| 1570 | EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters)); |
solenberg | 8189b02 | 2016-06-14 12:13:00 -0700 | [diff] [blame] | 1571 | EXPECT_TRUE(AddRecvStream(kSsrc1)); |
stefan | ba4c0e4 | 2016-02-04 04:12:24 -0800 | [diff] [blame] | 1572 | ASSERT_TRUE(call_.GetAudioReceiveStream(kSsrc1) != nullptr); |
| 1573 | EXPECT_FALSE( |
| 1574 | call_.GetAudioReceiveStream(kSsrc1)->GetConfig().rtp.transport_cc); |
| 1575 | |
ossu | dedfd28 | 2016-06-14 07:12:39 -0700 | [diff] [blame] | 1576 | send_parameters.codecs = engine_->send_codecs(); |
stefan | ba4c0e4 | 2016-02-04 04:12:24 -0800 | [diff] [blame] | 1577 | EXPECT_TRUE(channel_->SetSendParameters(send_parameters)); |
| 1578 | ASSERT_TRUE(call_.GetAudioReceiveStream(kSsrc1) != nullptr); |
| 1579 | EXPECT_TRUE( |
| 1580 | call_.GetAudioReceiveStream(kSsrc1)->GetConfig().rtp.transport_cc); |
| 1581 | } |
| 1582 | |
buildbot@webrtc.org | 5d639b3 | 2014-09-10 07:57:12 +0000 | [diff] [blame] | 1583 | // Test maxplaybackrate <= 8000 triggers Opus narrow band mode. |
| 1584 | TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateNb) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 1585 | EXPECT_TRUE(SetupSendStream()); |
buildbot@webrtc.org | 5d639b3 | 2014-09-10 07:57:12 +0000 | [diff] [blame] | 1586 | int channel_num = voe_.GetLastChannel(); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1587 | cricket::AudioSendParameters parameters; |
| 1588 | parameters.codecs.push_back(kOpusCodec); |
| 1589 | parameters.codecs[0].bitrate = 0; |
| 1590 | parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 8000); |
| 1591 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
buildbot@webrtc.org | 5d639b3 | 2014-09-10 07:57:12 +0000 | [diff] [blame] | 1592 | EXPECT_EQ(cricket::kOpusBandwidthNb, |
| 1593 | voe_.GetMaxEncodingBandwidth(channel_num)); |
| 1594 | webrtc::CodecInst gcodec; |
| 1595 | EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); |
| 1596 | EXPECT_STREQ("opus", gcodec.plname); |
minyue@webrtc.org | 2dc6f31 | 2014-10-31 05:33:10 +0000 | [diff] [blame] | 1597 | |
| 1598 | EXPECT_EQ(12000, gcodec.rate); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1599 | parameters.codecs[0].SetParam(cricket::kCodecParamStereo, "1"); |
| 1600 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
minyue@webrtc.org | 2dc6f31 | 2014-10-31 05:33:10 +0000 | [diff] [blame] | 1601 | EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); |
| 1602 | EXPECT_EQ(24000, gcodec.rate); |
buildbot@webrtc.org | 5d639b3 | 2014-09-10 07:57:12 +0000 | [diff] [blame] | 1603 | } |
| 1604 | |
| 1605 | // Test 8000 < maxplaybackrate <= 12000 triggers Opus medium band mode. |
| 1606 | TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateMb) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 1607 | EXPECT_TRUE(SetupSendStream()); |
buildbot@webrtc.org | 5d639b3 | 2014-09-10 07:57:12 +0000 | [diff] [blame] | 1608 | int channel_num = voe_.GetLastChannel(); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1609 | cricket::AudioSendParameters parameters; |
| 1610 | parameters.codecs.push_back(kOpusCodec); |
| 1611 | parameters.codecs[0].bitrate = 0; |
| 1612 | parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 8001); |
| 1613 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
buildbot@webrtc.org | 5d639b3 | 2014-09-10 07:57:12 +0000 | [diff] [blame] | 1614 | EXPECT_EQ(cricket::kOpusBandwidthMb, |
| 1615 | voe_.GetMaxEncodingBandwidth(channel_num)); |
| 1616 | webrtc::CodecInst gcodec; |
| 1617 | EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); |
| 1618 | EXPECT_STREQ("opus", gcodec.plname); |
minyue@webrtc.org | 2dc6f31 | 2014-10-31 05:33:10 +0000 | [diff] [blame] | 1619 | |
| 1620 | EXPECT_EQ(20000, gcodec.rate); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1621 | parameters.codecs[0].SetParam(cricket::kCodecParamStereo, "1"); |
| 1622 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
minyue@webrtc.org | 2dc6f31 | 2014-10-31 05:33:10 +0000 | [diff] [blame] | 1623 | EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); |
| 1624 | EXPECT_EQ(40000, gcodec.rate); |
buildbot@webrtc.org | 5d639b3 | 2014-09-10 07:57:12 +0000 | [diff] [blame] | 1625 | } |
| 1626 | |
| 1627 | // Test 12000 < maxplaybackrate <= 16000 triggers Opus wide band mode. |
| 1628 | TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateWb) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 1629 | EXPECT_TRUE(SetupSendStream()); |
buildbot@webrtc.org | 5d639b3 | 2014-09-10 07:57:12 +0000 | [diff] [blame] | 1630 | int channel_num = voe_.GetLastChannel(); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1631 | cricket::AudioSendParameters parameters; |
| 1632 | parameters.codecs.push_back(kOpusCodec); |
| 1633 | parameters.codecs[0].bitrate = 0; |
| 1634 | parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 12001); |
| 1635 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
buildbot@webrtc.org | 5d639b3 | 2014-09-10 07:57:12 +0000 | [diff] [blame] | 1636 | EXPECT_EQ(cricket::kOpusBandwidthWb, |
| 1637 | voe_.GetMaxEncodingBandwidth(channel_num)); |
| 1638 | webrtc::CodecInst gcodec; |
| 1639 | EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); |
| 1640 | EXPECT_STREQ("opus", gcodec.plname); |
minyue@webrtc.org | 2dc6f31 | 2014-10-31 05:33:10 +0000 | [diff] [blame] | 1641 | |
| 1642 | EXPECT_EQ(20000, gcodec.rate); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1643 | parameters.codecs[0].SetParam(cricket::kCodecParamStereo, "1"); |
| 1644 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
minyue@webrtc.org | 2dc6f31 | 2014-10-31 05:33:10 +0000 | [diff] [blame] | 1645 | EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); |
| 1646 | EXPECT_EQ(40000, gcodec.rate); |
buildbot@webrtc.org | 5d639b3 | 2014-09-10 07:57:12 +0000 | [diff] [blame] | 1647 | } |
| 1648 | |
| 1649 | // Test 16000 < maxplaybackrate <= 24000 triggers Opus super wide band mode. |
| 1650 | TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateSwb) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 1651 | EXPECT_TRUE(SetupSendStream()); |
buildbot@webrtc.org | 5d639b3 | 2014-09-10 07:57:12 +0000 | [diff] [blame] | 1652 | int channel_num = voe_.GetLastChannel(); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1653 | cricket::AudioSendParameters parameters; |
| 1654 | parameters.codecs.push_back(kOpusCodec); |
| 1655 | parameters.codecs[0].bitrate = 0; |
| 1656 | parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 16001); |
| 1657 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
buildbot@webrtc.org | 5d639b3 | 2014-09-10 07:57:12 +0000 | [diff] [blame] | 1658 | EXPECT_EQ(cricket::kOpusBandwidthSwb, |
| 1659 | voe_.GetMaxEncodingBandwidth(channel_num)); |
| 1660 | webrtc::CodecInst gcodec; |
| 1661 | EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); |
| 1662 | EXPECT_STREQ("opus", gcodec.plname); |
minyue@webrtc.org | 2dc6f31 | 2014-10-31 05:33:10 +0000 | [diff] [blame] | 1663 | |
buildbot@webrtc.org | 5d639b3 | 2014-09-10 07:57:12 +0000 | [diff] [blame] | 1664 | EXPECT_EQ(32000, gcodec.rate); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1665 | parameters.codecs[0].SetParam(cricket::kCodecParamStereo, "1"); |
| 1666 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
minyue@webrtc.org | 2dc6f31 | 2014-10-31 05:33:10 +0000 | [diff] [blame] | 1667 | EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); |
| 1668 | EXPECT_EQ(64000, gcodec.rate); |
buildbot@webrtc.org | 5d639b3 | 2014-09-10 07:57:12 +0000 | [diff] [blame] | 1669 | } |
| 1670 | |
| 1671 | // Test 24000 < maxplaybackrate triggers Opus full band mode. |
| 1672 | TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateFb) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 1673 | EXPECT_TRUE(SetupSendStream()); |
buildbot@webrtc.org | 5d639b3 | 2014-09-10 07:57:12 +0000 | [diff] [blame] | 1674 | int channel_num = voe_.GetLastChannel(); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1675 | cricket::AudioSendParameters parameters; |
| 1676 | parameters.codecs.push_back(kOpusCodec); |
| 1677 | parameters.codecs[0].bitrate = 0; |
| 1678 | parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 24001); |
| 1679 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
buildbot@webrtc.org | 5d639b3 | 2014-09-10 07:57:12 +0000 | [diff] [blame] | 1680 | EXPECT_EQ(cricket::kOpusBandwidthFb, |
| 1681 | voe_.GetMaxEncodingBandwidth(channel_num)); |
| 1682 | webrtc::CodecInst gcodec; |
| 1683 | EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); |
| 1684 | EXPECT_STREQ("opus", gcodec.plname); |
minyue@webrtc.org | 2dc6f31 | 2014-10-31 05:33:10 +0000 | [diff] [blame] | 1685 | |
buildbot@webrtc.org | 5d639b3 | 2014-09-10 07:57:12 +0000 | [diff] [blame] | 1686 | EXPECT_EQ(32000, gcodec.rate); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1687 | parameters.codecs[0].SetParam(cricket::kCodecParamStereo, "1"); |
| 1688 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
minyue@webrtc.org | 2dc6f31 | 2014-10-31 05:33:10 +0000 | [diff] [blame] | 1689 | EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); |
| 1690 | EXPECT_EQ(64000, gcodec.rate); |
buildbot@webrtc.org | 5d639b3 | 2014-09-10 07:57:12 +0000 | [diff] [blame] | 1691 | } |
| 1692 | |
| 1693 | // Test Opus that without maxplaybackrate, default playback rate is used. |
| 1694 | TEST_F(WebRtcVoiceEngineTestFake, DefaultOpusMaxPlaybackRate) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 1695 | EXPECT_TRUE(SetupSendStream()); |
buildbot@webrtc.org | 5d639b3 | 2014-09-10 07:57:12 +0000 | [diff] [blame] | 1696 | int channel_num = voe_.GetLastChannel(); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1697 | cricket::AudioSendParameters parameters; |
| 1698 | parameters.codecs.push_back(kOpusCodec); |
| 1699 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
buildbot@webrtc.org | 5d639b3 | 2014-09-10 07:57:12 +0000 | [diff] [blame] | 1700 | EXPECT_EQ(cricket::kOpusBandwidthFb, |
| 1701 | voe_.GetMaxEncodingBandwidth(channel_num)); |
| 1702 | } |
| 1703 | |
| 1704 | // Test the with non-Opus, maxplaybackrate has no effect. |
| 1705 | TEST_F(WebRtcVoiceEngineTestFake, SetNonOpusMaxPlaybackRate) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 1706 | EXPECT_TRUE(SetupSendStream()); |
buildbot@webrtc.org | 5d639b3 | 2014-09-10 07:57:12 +0000 | [diff] [blame] | 1707 | int channel_num = voe_.GetLastChannel(); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1708 | cricket::AudioSendParameters parameters; |
| 1709 | parameters.codecs.push_back(kIsacCodec); |
| 1710 | parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 32000); |
| 1711 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
buildbot@webrtc.org | 5d639b3 | 2014-09-10 07:57:12 +0000 | [diff] [blame] | 1712 | EXPECT_EQ(0, voe_.GetMaxEncodingBandwidth(channel_num)); |
| 1713 | } |
| 1714 | |
| 1715 | // Test maxplaybackrate can be set on two streams. |
| 1716 | TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateOnTwoStreams) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 1717 | EXPECT_TRUE(SetupSendStream()); |
buildbot@webrtc.org | 5d639b3 | 2014-09-10 07:57:12 +0000 | [diff] [blame] | 1718 | int channel_num = voe_.GetLastChannel(); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1719 | cricket::AudioSendParameters parameters; |
| 1720 | parameters.codecs.push_back(kOpusCodec); |
| 1721 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
buildbot@webrtc.org | 5d639b3 | 2014-09-10 07:57:12 +0000 | [diff] [blame] | 1722 | // Default bandwidth is 24000. |
| 1723 | EXPECT_EQ(cricket::kOpusBandwidthFb, |
| 1724 | voe_.GetMaxEncodingBandwidth(channel_num)); |
| 1725 | |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1726 | parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 8000); |
buildbot@webrtc.org | 5d639b3 | 2014-09-10 07:57:12 +0000 | [diff] [blame] | 1727 | |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1728 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
buildbot@webrtc.org | 5d639b3 | 2014-09-10 07:57:12 +0000 | [diff] [blame] | 1729 | EXPECT_EQ(cricket::kOpusBandwidthNb, |
| 1730 | voe_.GetMaxEncodingBandwidth(channel_num)); |
| 1731 | |
| 1732 | channel_->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc2)); |
| 1733 | channel_num = voe_.GetLastChannel(); |
| 1734 | EXPECT_EQ(cricket::kOpusBandwidthNb, |
| 1735 | voe_.GetMaxEncodingBandwidth(channel_num)); |
| 1736 | } |
buildbot@webrtc.org | ae740dd | 2014-06-17 10:56:41 +0000 | [diff] [blame] | 1737 | |
Minyue Li | 7100dcd | 2015-03-27 05:05:59 +0100 | [diff] [blame] | 1738 | // Test that with usedtx=0, Opus DTX is off. |
| 1739 | TEST_F(WebRtcVoiceEngineTestFake, DisableOpusDtxOnOpus) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 1740 | EXPECT_TRUE(SetupSendStream()); |
Minyue Li | 7100dcd | 2015-03-27 05:05:59 +0100 | [diff] [blame] | 1741 | int channel_num = voe_.GetLastChannel(); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1742 | cricket::AudioSendParameters parameters; |
| 1743 | parameters.codecs.push_back(kOpusCodec); |
| 1744 | parameters.codecs[0].params["usedtx"] = "0"; |
| 1745 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
Minyue Li | 7100dcd | 2015-03-27 05:05:59 +0100 | [diff] [blame] | 1746 | EXPECT_FALSE(voe_.GetOpusDtx(channel_num)); |
| 1747 | } |
| 1748 | |
| 1749 | // Test that with usedtx=1, Opus DTX is on. |
| 1750 | TEST_F(WebRtcVoiceEngineTestFake, EnableOpusDtxOnOpus) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 1751 | EXPECT_TRUE(SetupSendStream()); |
Minyue Li | 7100dcd | 2015-03-27 05:05:59 +0100 | [diff] [blame] | 1752 | int channel_num = voe_.GetLastChannel(); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1753 | cricket::AudioSendParameters parameters; |
| 1754 | parameters.codecs.push_back(kOpusCodec); |
| 1755 | parameters.codecs[0].params["usedtx"] = "1"; |
| 1756 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
Minyue Li | 7100dcd | 2015-03-27 05:05:59 +0100 | [diff] [blame] | 1757 | EXPECT_TRUE(voe_.GetOpusDtx(channel_num)); |
| 1758 | EXPECT_FALSE(voe_.GetVAD(channel_num)); // Opus DTX should not affect VAD. |
| 1759 | } |
| 1760 | |
| 1761 | // Test that usedtx=1 works with stereo Opus. |
| 1762 | TEST_F(WebRtcVoiceEngineTestFake, EnableOpusDtxOnOpusStereo) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 1763 | EXPECT_TRUE(SetupSendStream()); |
Minyue Li | 7100dcd | 2015-03-27 05:05:59 +0100 | [diff] [blame] | 1764 | int channel_num = voe_.GetLastChannel(); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1765 | cricket::AudioSendParameters parameters; |
| 1766 | parameters.codecs.push_back(kOpusCodec); |
| 1767 | parameters.codecs[0].params["usedtx"] = "1"; |
| 1768 | parameters.codecs[0].params["stereo"] = "1"; |
| 1769 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
Minyue Li | 7100dcd | 2015-03-27 05:05:59 +0100 | [diff] [blame] | 1770 | EXPECT_TRUE(voe_.GetOpusDtx(channel_num)); |
| 1771 | EXPECT_FALSE(voe_.GetVAD(channel_num)); // Opus DTX should not affect VAD. |
| 1772 | } |
| 1773 | |
| 1774 | // Test that usedtx=1 does not work with non Opus. |
| 1775 | TEST_F(WebRtcVoiceEngineTestFake, CannotEnableOpusDtxOnNonOpus) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 1776 | EXPECT_TRUE(SetupSendStream()); |
Minyue Li | 7100dcd | 2015-03-27 05:05:59 +0100 | [diff] [blame] | 1777 | int channel_num = voe_.GetLastChannel(); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1778 | cricket::AudioSendParameters parameters; |
| 1779 | parameters.codecs.push_back(kIsacCodec); |
| 1780 | parameters.codecs[0].params["usedtx"] = "1"; |
| 1781 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
Minyue Li | 7100dcd | 2015-03-27 05:05:59 +0100 | [diff] [blame] | 1782 | EXPECT_FALSE(voe_.GetOpusDtx(channel_num)); |
| 1783 | } |
| 1784 | |
minyue@webrtc.org | f9b5c1b | 2015-02-17 12:36:41 +0000 | [diff] [blame] | 1785 | // Test that we can switch back and forth between Opus and ISAC with CN. |
| 1786 | TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsIsacOpusSwitching) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 1787 | EXPECT_TRUE(SetupSendStream()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1788 | int channel_num = voe_.GetLastChannel(); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1789 | cricket::AudioSendParameters opus_parameters; |
| 1790 | opus_parameters.codecs.push_back(kOpusCodec); |
| 1791 | EXPECT_TRUE(channel_->SetSendParameters(opus_parameters)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1792 | webrtc::CodecInst gcodec; |
| 1793 | EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); |
minyue@webrtc.org | f9b5c1b | 2015-02-17 12:36:41 +0000 | [diff] [blame] | 1794 | EXPECT_EQ(111, gcodec.pltype); |
| 1795 | EXPECT_STREQ("opus", gcodec.plname); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1796 | |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1797 | cricket::AudioSendParameters isac_parameters; |
| 1798 | isac_parameters.codecs.push_back(kIsacCodec); |
| 1799 | isac_parameters.codecs.push_back(kCn16000Codec); |
| 1800 | isac_parameters.codecs.push_back(kOpusCodec); |
| 1801 | EXPECT_TRUE(channel_->SetSendParameters(isac_parameters)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1802 | EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); |
| 1803 | EXPECT_EQ(103, gcodec.pltype); |
| 1804 | EXPECT_STREQ("ISAC", gcodec.plname); |
| 1805 | |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1806 | EXPECT_TRUE(channel_->SetSendParameters(opus_parameters)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1807 | EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); |
minyue@webrtc.org | f9b5c1b | 2015-02-17 12:36:41 +0000 | [diff] [blame] | 1808 | EXPECT_EQ(111, gcodec.pltype); |
| 1809 | EXPECT_STREQ("opus", gcodec.plname); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1810 | } |
| 1811 | |
| 1812 | // Test that we handle various ways of specifying bitrate. |
| 1813 | TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsBitrate) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 1814 | EXPECT_TRUE(SetupSendStream()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1815 | int channel_num = voe_.GetLastChannel(); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1816 | cricket::AudioSendParameters parameters; |
| 1817 | parameters.codecs.push_back(kIsacCodec); // bitrate == 32000 |
| 1818 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1819 | webrtc::CodecInst gcodec; |
| 1820 | EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); |
| 1821 | EXPECT_EQ(103, gcodec.pltype); |
| 1822 | EXPECT_STREQ("ISAC", gcodec.plname); |
| 1823 | EXPECT_EQ(32000, gcodec.rate); |
| 1824 | |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1825 | parameters.codecs[0].bitrate = 0; // bitrate == default |
| 1826 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1827 | EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); |
| 1828 | EXPECT_EQ(103, gcodec.pltype); |
| 1829 | EXPECT_STREQ("ISAC", gcodec.plname); |
| 1830 | EXPECT_EQ(-1, gcodec.rate); |
| 1831 | |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1832 | parameters.codecs[0].bitrate = 28000; // bitrate == 28000 |
| 1833 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1834 | EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); |
| 1835 | EXPECT_EQ(103, gcodec.pltype); |
| 1836 | EXPECT_STREQ("ISAC", gcodec.plname); |
| 1837 | EXPECT_EQ(28000, gcodec.rate); |
| 1838 | |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1839 | parameters.codecs[0] = kPcmuCodec; // bitrate == 64000 |
| 1840 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1841 | EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); |
| 1842 | EXPECT_EQ(0, gcodec.pltype); |
| 1843 | EXPECT_STREQ("PCMU", gcodec.plname); |
| 1844 | EXPECT_EQ(64000, gcodec.rate); |
| 1845 | |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1846 | parameters.codecs[0].bitrate = 0; // bitrate == default |
| 1847 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1848 | EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); |
| 1849 | EXPECT_EQ(0, gcodec.pltype); |
| 1850 | EXPECT_STREQ("PCMU", gcodec.plname); |
| 1851 | EXPECT_EQ(64000, gcodec.rate); |
| 1852 | |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1853 | parameters.codecs[0] = kOpusCodec; |
| 1854 | parameters.codecs[0].bitrate = 0; // bitrate == default |
| 1855 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1856 | EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); |
| 1857 | EXPECT_EQ(111, gcodec.pltype); |
| 1858 | EXPECT_STREQ("opus", gcodec.plname); |
| 1859 | EXPECT_EQ(32000, gcodec.rate); |
| 1860 | } |
| 1861 | |
Brave Yao | 5225dd8 | 2015-03-26 07:39:19 +0800 | [diff] [blame] | 1862 | // Test that we could set packet size specified in kCodecParamPTime. |
| 1863 | TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsPTimeAsPacketSize) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 1864 | EXPECT_TRUE(SetupSendStream()); |
Brave Yao | 5225dd8 | 2015-03-26 07:39:19 +0800 | [diff] [blame] | 1865 | int channel_num = voe_.GetLastChannel(); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1866 | cricket::AudioSendParameters parameters; |
| 1867 | parameters.codecs.push_back(kOpusCodec); |
| 1868 | parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 40); // Within range. |
| 1869 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
Brave Yao | 5225dd8 | 2015-03-26 07:39:19 +0800 | [diff] [blame] | 1870 | webrtc::CodecInst gcodec; |
| 1871 | EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); |
| 1872 | EXPECT_EQ(1920, gcodec.pacsize); // Opus gets 40ms. |
| 1873 | |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1874 | parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 5); // Below range. |
| 1875 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
Brave Yao | 5225dd8 | 2015-03-26 07:39:19 +0800 | [diff] [blame] | 1876 | EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); |
| 1877 | EXPECT_EQ(480, gcodec.pacsize); // Opus gets 10ms. |
| 1878 | |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1879 | parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 80); // Beyond range. |
| 1880 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
Brave Yao | 5225dd8 | 2015-03-26 07:39:19 +0800 | [diff] [blame] | 1881 | EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); |
| 1882 | EXPECT_EQ(2880, gcodec.pacsize); // Opus gets 60ms. |
| 1883 | |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1884 | parameters.codecs[0] = kIsacCodec; // Also try Isac, with unsupported size. |
| 1885 | parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 40); // Within range. |
| 1886 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
Brave Yao | 5225dd8 | 2015-03-26 07:39:19 +0800 | [diff] [blame] | 1887 | EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); |
| 1888 | EXPECT_EQ(480, gcodec.pacsize); // Isac gets 30ms as the next smallest value. |
| 1889 | |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1890 | parameters.codecs[0] = kG722CodecSdp; // Try G722 @8kHz as negotiated in SDP. |
| 1891 | parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 40); |
| 1892 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
Brave Yao | 5225dd8 | 2015-03-26 07:39:19 +0800 | [diff] [blame] | 1893 | EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); |
| 1894 | EXPECT_EQ(640, gcodec.pacsize); // G722 gets 40ms @16kHz as defined in VoE. |
| 1895 | } |
| 1896 | |
henrike@webrtc.org | 704bf9e | 2014-02-27 17:52:04 +0000 | [diff] [blame] | 1897 | // Test that we fail if no codecs are specified. |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1898 | TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsNoCodecs) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 1899 | EXPECT_TRUE(SetupSendStream()); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1900 | cricket::AudioSendParameters parameters; |
| 1901 | EXPECT_FALSE(channel_->SetSendParameters(parameters)); |
henrike@webrtc.org | 704bf9e | 2014-02-27 17:52:04 +0000 | [diff] [blame] | 1902 | } |
| 1903 | |
| 1904 | // Test that we can set send codecs even with telephone-event codec as the first |
| 1905 | // one on the list. |
| 1906 | TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsDTMFOnTop) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 1907 | EXPECT_TRUE(SetupSendStream()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1908 | int channel_num = voe_.GetLastChannel(); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1909 | cricket::AudioSendParameters parameters; |
| 1910 | parameters.codecs.push_back(kTelephoneEventCodec); |
| 1911 | parameters.codecs.push_back(kIsacCodec); |
| 1912 | parameters.codecs.push_back(kPcmuCodec); |
| 1913 | parameters.codecs[0].id = 98; // DTMF |
| 1914 | parameters.codecs[1].id = 96; |
| 1915 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1916 | webrtc::CodecInst gcodec; |
| 1917 | EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); |
henrike@webrtc.org | 704bf9e | 2014-02-27 17:52:04 +0000 | [diff] [blame] | 1918 | EXPECT_EQ(96, gcodec.pltype); |
| 1919 | EXPECT_STREQ("ISAC", gcodec.plname); |
Fredrik Solenberg | b572768 | 2015-12-04 15:22:19 +0100 | [diff] [blame] | 1920 | EXPECT_TRUE(channel_->CanInsertDtmf()); |
henrike@webrtc.org | 704bf9e | 2014-02-27 17:52:04 +0000 | [diff] [blame] | 1921 | } |
| 1922 | |
solenberg | 31642aa | 2016-03-14 08:00:37 -0700 | [diff] [blame] | 1923 | // Test that payload type range is limited for telephone-event codec. |
| 1924 | TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsDTMFPayloadTypeOutOfRange) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 1925 | EXPECT_TRUE(SetupSendStream()); |
solenberg | 31642aa | 2016-03-14 08:00:37 -0700 | [diff] [blame] | 1926 | cricket::AudioSendParameters parameters; |
| 1927 | parameters.codecs.push_back(kTelephoneEventCodec); |
| 1928 | parameters.codecs.push_back(kIsacCodec); |
| 1929 | parameters.codecs[0].id = 0; // DTMF |
| 1930 | parameters.codecs[1].id = 96; |
| 1931 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
| 1932 | EXPECT_TRUE(channel_->CanInsertDtmf()); |
| 1933 | parameters.codecs[0].id = 128; // DTMF |
| 1934 | EXPECT_FALSE(channel_->SetSendParameters(parameters)); |
| 1935 | EXPECT_FALSE(channel_->CanInsertDtmf()); |
| 1936 | parameters.codecs[0].id = 127; |
| 1937 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
| 1938 | EXPECT_TRUE(channel_->CanInsertDtmf()); |
| 1939 | parameters.codecs[0].id = -1; // DTMF |
| 1940 | EXPECT_FALSE(channel_->SetSendParameters(parameters)); |
| 1941 | EXPECT_FALSE(channel_->CanInsertDtmf()); |
| 1942 | } |
| 1943 | |
henrike@webrtc.org | 704bf9e | 2014-02-27 17:52:04 +0000 | [diff] [blame] | 1944 | // Test that we can set send codecs even with CN codec as the first |
| 1945 | // one on the list. |
| 1946 | TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNOnTop) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 1947 | EXPECT_TRUE(SetupSendStream()); |
henrike@webrtc.org | 704bf9e | 2014-02-27 17:52:04 +0000 | [diff] [blame] | 1948 | int channel_num = voe_.GetLastChannel(); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1949 | cricket::AudioSendParameters parameters; |
| 1950 | parameters.codecs.push_back(kCn16000Codec); |
| 1951 | parameters.codecs.push_back(kIsacCodec); |
| 1952 | parameters.codecs.push_back(kPcmuCodec); |
| 1953 | parameters.codecs[0].id = 98; // wideband CN |
| 1954 | parameters.codecs[1].id = 96; |
| 1955 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
henrike@webrtc.org | 704bf9e | 2014-02-27 17:52:04 +0000 | [diff] [blame] | 1956 | webrtc::CodecInst gcodec; |
| 1957 | EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); |
| 1958 | EXPECT_EQ(96, gcodec.pltype); |
| 1959 | EXPECT_STREQ("ISAC", gcodec.plname); |
| 1960 | EXPECT_EQ(98, voe_.GetSendCNPayloadType(channel_num, true)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1961 | } |
| 1962 | |
wu@webrtc.org | cadf904 | 2013-08-30 21:24:16 +0000 | [diff] [blame] | 1963 | // Test that we set VAD and DTMF types correctly as caller. |
| 1964 | TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNandDTMFAsCaller) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 1965 | EXPECT_TRUE(SetupSendStream()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1966 | int channel_num = voe_.GetLastChannel(); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1967 | cricket::AudioSendParameters parameters; |
| 1968 | parameters.codecs.push_back(kIsacCodec); |
| 1969 | parameters.codecs.push_back(kPcmuCodec); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1970 | // TODO(juberti): cn 32000 |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1971 | parameters.codecs.push_back(kCn16000Codec); |
| 1972 | parameters.codecs.push_back(kCn8000Codec); |
| 1973 | parameters.codecs.push_back(kTelephoneEventCodec); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1974 | parameters.codecs[0].id = 96; |
| 1975 | parameters.codecs[2].id = 97; // wideband CN |
| 1976 | parameters.codecs[4].id = 98; // DTMF |
| 1977 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1978 | webrtc::CodecInst gcodec; |
| 1979 | EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); |
| 1980 | EXPECT_EQ(96, gcodec.pltype); |
| 1981 | EXPECT_STREQ("ISAC", gcodec.plname); |
| 1982 | EXPECT_TRUE(voe_.GetVAD(channel_num)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1983 | EXPECT_EQ(13, voe_.GetSendCNPayloadType(channel_num, false)); |
| 1984 | EXPECT_EQ(97, voe_.GetSendCNPayloadType(channel_num, true)); |
Fredrik Solenberg | b572768 | 2015-12-04 15:22:19 +0100 | [diff] [blame] | 1985 | EXPECT_TRUE(channel_->CanInsertDtmf()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1986 | } |
| 1987 | |
wu@webrtc.org | cadf904 | 2013-08-30 21:24:16 +0000 | [diff] [blame] | 1988 | // Test that we set VAD and DTMF types correctly as callee. |
| 1989 | TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNandDTMFAsCallee) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 1990 | EXPECT_TRUE(SetupChannel()); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1991 | cricket::AudioSendParameters parameters; |
| 1992 | parameters.codecs.push_back(kIsacCodec); |
| 1993 | parameters.codecs.push_back(kPcmuCodec); |
wu@webrtc.org | cadf904 | 2013-08-30 21:24:16 +0000 | [diff] [blame] | 1994 | // TODO(juberti): cn 32000 |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1995 | parameters.codecs.push_back(kCn16000Codec); |
| 1996 | parameters.codecs.push_back(kCn8000Codec); |
| 1997 | parameters.codecs.push_back(kTelephoneEventCodec); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 1998 | parameters.codecs[0].id = 96; |
| 1999 | parameters.codecs[2].id = 97; // wideband CN |
| 2000 | parameters.codecs[4].id = 98; // DTMF |
| 2001 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
wu@webrtc.org | cadf904 | 2013-08-30 21:24:16 +0000 | [diff] [blame] | 2002 | EXPECT_TRUE(channel_->AddSendStream( |
| 2003 | cricket::StreamParams::CreateLegacy(kSsrc1))); |
solenberg | 0a617e2 | 2015-10-20 15:49:38 -0700 | [diff] [blame] | 2004 | int channel_num = voe_.GetLastChannel(); |
wu@webrtc.org | cadf904 | 2013-08-30 21:24:16 +0000 | [diff] [blame] | 2005 | |
| 2006 | webrtc::CodecInst gcodec; |
| 2007 | EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); |
| 2008 | EXPECT_EQ(96, gcodec.pltype); |
| 2009 | EXPECT_STREQ("ISAC", gcodec.plname); |
| 2010 | EXPECT_TRUE(voe_.GetVAD(channel_num)); |
wu@webrtc.org | cadf904 | 2013-08-30 21:24:16 +0000 | [diff] [blame] | 2011 | EXPECT_EQ(13, voe_.GetSendCNPayloadType(channel_num, false)); |
| 2012 | EXPECT_EQ(97, voe_.GetSendCNPayloadType(channel_num, true)); |
Fredrik Solenberg | b572768 | 2015-12-04 15:22:19 +0100 | [diff] [blame] | 2013 | EXPECT_TRUE(channel_->CanInsertDtmf()); |
wu@webrtc.org | cadf904 | 2013-08-30 21:24:16 +0000 | [diff] [blame] | 2014 | } |
| 2015 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2016 | // Test that we only apply VAD if we have a CN codec that matches the |
| 2017 | // send codec clockrate. |
| 2018 | TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNNoMatch) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 2019 | EXPECT_TRUE(SetupSendStream()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2020 | int channel_num = voe_.GetLastChannel(); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 2021 | cricket::AudioSendParameters parameters; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2022 | // Set ISAC(16K) and CN(16K). VAD should be activated. |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 2023 | parameters.codecs.push_back(kIsacCodec); |
| 2024 | parameters.codecs.push_back(kCn16000Codec); |
| 2025 | parameters.codecs[1].id = 97; |
| 2026 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2027 | webrtc::CodecInst gcodec; |
| 2028 | EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); |
| 2029 | EXPECT_STREQ("ISAC", gcodec.plname); |
| 2030 | EXPECT_TRUE(voe_.GetVAD(channel_num)); |
| 2031 | EXPECT_EQ(97, voe_.GetSendCNPayloadType(channel_num, true)); |
| 2032 | // Set PCMU(8K) and CN(16K). VAD should not be activated. |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 2033 | parameters.codecs[0] = kPcmuCodec; |
| 2034 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2035 | EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); |
| 2036 | EXPECT_STREQ("PCMU", gcodec.plname); |
| 2037 | EXPECT_FALSE(voe_.GetVAD(channel_num)); |
| 2038 | // Set PCMU(8K) and CN(8K). VAD should be activated. |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 2039 | parameters.codecs[1] = kCn8000Codec; |
| 2040 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2041 | EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); |
| 2042 | EXPECT_STREQ("PCMU", gcodec.plname); |
| 2043 | EXPECT_TRUE(voe_.GetVAD(channel_num)); |
| 2044 | EXPECT_EQ(13, voe_.GetSendCNPayloadType(channel_num, false)); |
Brave Yao | 5225dd8 | 2015-03-26 07:39:19 +0800 | [diff] [blame] | 2045 | // Set ISAC(16K) and CN(8K). VAD should not be activated. |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 2046 | parameters.codecs[0] = kIsacCodec; |
| 2047 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2048 | EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); |
| 2049 | EXPECT_STREQ("ISAC", gcodec.plname); |
| 2050 | EXPECT_FALSE(voe_.GetVAD(channel_num)); |
| 2051 | } |
| 2052 | |
| 2053 | // Test that we perform case-insensitive matching of codec names. |
| 2054 | TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCaseInsensitive) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 2055 | EXPECT_TRUE(SetupSendStream()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2056 | int channel_num = voe_.GetLastChannel(); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 2057 | cricket::AudioSendParameters parameters; |
| 2058 | parameters.codecs.push_back(kIsacCodec); |
| 2059 | parameters.codecs.push_back(kPcmuCodec); |
| 2060 | parameters.codecs.push_back(kCn16000Codec); |
| 2061 | parameters.codecs.push_back(kCn8000Codec); |
| 2062 | parameters.codecs.push_back(kTelephoneEventCodec); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 2063 | parameters.codecs[0].name = "iSaC"; |
| 2064 | parameters.codecs[0].id = 96; |
| 2065 | parameters.codecs[2].id = 97; // wideband CN |
| 2066 | parameters.codecs[4].id = 98; // DTMF |
| 2067 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2068 | webrtc::CodecInst gcodec; |
| 2069 | EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); |
| 2070 | EXPECT_EQ(96, gcodec.pltype); |
| 2071 | EXPECT_STREQ("ISAC", gcodec.plname); |
| 2072 | EXPECT_TRUE(voe_.GetVAD(channel_num)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2073 | EXPECT_EQ(13, voe_.GetSendCNPayloadType(channel_num, false)); |
| 2074 | EXPECT_EQ(97, voe_.GetSendCNPayloadType(channel_num, true)); |
Fredrik Solenberg | b572768 | 2015-12-04 15:22:19 +0100 | [diff] [blame] | 2075 | EXPECT_TRUE(channel_->CanInsertDtmf()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2076 | } |
| 2077 | |
stefan | ba4c0e4 | 2016-02-04 04:12:24 -0800 | [diff] [blame] | 2078 | class WebRtcVoiceEngineWithSendSideBweTest : public WebRtcVoiceEngineTestFake { |
| 2079 | public: |
| 2080 | WebRtcVoiceEngineWithSendSideBweTest() |
| 2081 | : WebRtcVoiceEngineTestFake("WebRTC-Audio-SendSideBwe/Enabled/") {} |
| 2082 | }; |
| 2083 | |
| 2084 | TEST_F(WebRtcVoiceEngineWithSendSideBweTest, |
| 2085 | SupportsTransportSequenceNumberHeaderExtension) { |
solenberg | bc37fc8 | 2016-04-04 09:54:44 -0700 | [diff] [blame] | 2086 | cricket::RtpCapabilities capabilities = engine_->GetCapabilities(); |
stefan | ba4c0e4 | 2016-02-04 04:12:24 -0800 | [diff] [blame] | 2087 | ASSERT_FALSE(capabilities.header_extensions.empty()); |
isheriff | 6f8d686 | 2016-05-26 11:24:55 -0700 | [diff] [blame] | 2088 | for (const webrtc::RtpExtension& extension : capabilities.header_extensions) { |
| 2089 | if (extension.uri == webrtc::RtpExtension::kTransportSequenceNumberUri) { |
| 2090 | EXPECT_EQ(webrtc::RtpExtension::kTransportSequenceNumberDefaultId, |
stefan | ba4c0e4 | 2016-02-04 04:12:24 -0800 | [diff] [blame] | 2091 | extension.id); |
| 2092 | return; |
| 2093 | } |
| 2094 | } |
| 2095 | FAIL() << "Transport sequence number extension not in header-extension list."; |
| 2096 | } |
| 2097 | |
buildbot@webrtc.org | 150835e | 2014-05-06 15:54:38 +0000 | [diff] [blame] | 2098 | // Test support for audio level header extension. |
| 2099 | TEST_F(WebRtcVoiceEngineTestFake, SendAudioLevelHeaderExtensions) { |
isheriff | 6f8d686 | 2016-05-26 11:24:55 -0700 | [diff] [blame] | 2100 | TestSetSendRtpHeaderExtensions(webrtc::RtpExtension::kAudioLevelUri); |
henrike@webrtc.org | 79047f9 | 2014-03-06 23:46:59 +0000 | [diff] [blame] | 2101 | } |
buildbot@webrtc.org | 150835e | 2014-05-06 15:54:38 +0000 | [diff] [blame] | 2102 | TEST_F(WebRtcVoiceEngineTestFake, RecvAudioLevelHeaderExtensions) { |
isheriff | 6f8d686 | 2016-05-26 11:24:55 -0700 | [diff] [blame] | 2103 | TestSetRecvRtpHeaderExtensions(webrtc::RtpExtension::kAudioLevelUri); |
buildbot@webrtc.org | 150835e | 2014-05-06 15:54:38 +0000 | [diff] [blame] | 2104 | } |
henrike@webrtc.org | 79047f9 | 2014-03-06 23:46:59 +0000 | [diff] [blame] | 2105 | |
buildbot@webrtc.org | 150835e | 2014-05-06 15:54:38 +0000 | [diff] [blame] | 2106 | // Test support for absolute send time header extension. |
| 2107 | TEST_F(WebRtcVoiceEngineTestFake, SendAbsoluteSendTimeHeaderExtensions) { |
isheriff | 6f8d686 | 2016-05-26 11:24:55 -0700 | [diff] [blame] | 2108 | TestSetSendRtpHeaderExtensions(webrtc::RtpExtension::kAbsSendTimeUri); |
buildbot@webrtc.org | 150835e | 2014-05-06 15:54:38 +0000 | [diff] [blame] | 2109 | } |
| 2110 | TEST_F(WebRtcVoiceEngineTestFake, RecvAbsoluteSendTimeHeaderExtensions) { |
isheriff | 6f8d686 | 2016-05-26 11:24:55 -0700 | [diff] [blame] | 2111 | TestSetRecvRtpHeaderExtensions(webrtc::RtpExtension::kAbsSendTimeUri); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2112 | } |
| 2113 | |
solenberg | 1ac5614 | 2015-10-13 03:58:19 -0700 | [diff] [blame] | 2114 | // Test that we can create a channel and start sending on it. |
| 2115 | TEST_F(WebRtcVoiceEngineTestFake, Send) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 2116 | EXPECT_TRUE(SetupSendStream()); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 2117 | EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); |
solenberg | d53a3f9 | 2016-04-14 13:56:37 -0700 | [diff] [blame] | 2118 | SetSend(channel_, true); |
Taylor Brandstetter | 1a018dc | 2016-03-08 12:37:39 -0800 | [diff] [blame] | 2119 | EXPECT_TRUE(GetSendStream(kSsrc1).IsSending()); |
solenberg | d53a3f9 | 2016-04-14 13:56:37 -0700 | [diff] [blame] | 2120 | SetSend(channel_, false); |
Taylor Brandstetter | 1a018dc | 2016-03-08 12:37:39 -0800 | [diff] [blame] | 2121 | EXPECT_FALSE(GetSendStream(kSsrc1).IsSending()); |
| 2122 | } |
| 2123 | |
| 2124 | // Test that a channel will send if and only if it has a source and is enabled |
| 2125 | // for sending. |
| 2126 | TEST_F(WebRtcVoiceEngineTestFake, SendStateWithAndWithoutSource) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 2127 | EXPECT_TRUE(SetupSendStream()); |
Taylor Brandstetter | 1a018dc | 2016-03-08 12:37:39 -0800 | [diff] [blame] | 2128 | EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); |
| 2129 | EXPECT_TRUE(channel_->SetAudioSend(kSsrc1, true, nullptr, nullptr)); |
solenberg | d53a3f9 | 2016-04-14 13:56:37 -0700 | [diff] [blame] | 2130 | SetSend(channel_, true); |
Taylor Brandstetter | 1a018dc | 2016-03-08 12:37:39 -0800 | [diff] [blame] | 2131 | EXPECT_FALSE(GetSendStream(kSsrc1).IsSending()); |
| 2132 | EXPECT_TRUE(channel_->SetAudioSend(kSsrc1, true, nullptr, &fake_source_)); |
| 2133 | EXPECT_TRUE(GetSendStream(kSsrc1).IsSending()); |
| 2134 | EXPECT_TRUE(channel_->SetAudioSend(kSsrc1, true, nullptr, nullptr)); |
| 2135 | EXPECT_FALSE(GetSendStream(kSsrc1).IsSending()); |
solenberg | 1ac5614 | 2015-10-13 03:58:19 -0700 | [diff] [blame] | 2136 | } |
| 2137 | |
solenberg | 9421853 | 2016-06-16 10:53:22 -0700 | [diff] [blame^] | 2138 | // Test that a channel is muted/unmuted. |
| 2139 | TEST_F(WebRtcVoiceEngineTestFake, SendStateMuteUnmute) { |
| 2140 | EXPECT_TRUE(SetupSendStream()); |
| 2141 | EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); |
| 2142 | EXPECT_FALSE(GetSendStream(kSsrc1).muted()); |
| 2143 | EXPECT_TRUE(channel_->SetAudioSend(kSsrc1, true, nullptr, nullptr)); |
| 2144 | EXPECT_FALSE(GetSendStream(kSsrc1).muted()); |
| 2145 | EXPECT_TRUE(channel_->SetAudioSend(kSsrc1, false, nullptr, nullptr)); |
| 2146 | EXPECT_TRUE(GetSendStream(kSsrc1).muted()); |
| 2147 | } |
| 2148 | |
solenberg | 6d6e7c5 | 2016-04-13 09:07:30 -0700 | [diff] [blame] | 2149 | // Test that SetSendParameters() does not alter a stream's send state. |
| 2150 | TEST_F(WebRtcVoiceEngineTestFake, SendStateWhenStreamsAreRecreated) { |
| 2151 | EXPECT_TRUE(SetupSendStream()); |
| 2152 | EXPECT_FALSE(GetSendStream(kSsrc1).IsSending()); |
| 2153 | |
| 2154 | // Turn on sending. |
solenberg | d53a3f9 | 2016-04-14 13:56:37 -0700 | [diff] [blame] | 2155 | SetSend(channel_, true); |
solenberg | 6d6e7c5 | 2016-04-13 09:07:30 -0700 | [diff] [blame] | 2156 | EXPECT_TRUE(GetSendStream(kSsrc1).IsSending()); |
| 2157 | |
| 2158 | // Changing RTP header extensions will recreate the AudioSendStream. |
| 2159 | send_parameters_.extensions.push_back( |
isheriff | 6f8d686 | 2016-05-26 11:24:55 -0700 | [diff] [blame] | 2160 | webrtc::RtpExtension(webrtc::RtpExtension::kAudioLevelUri, 12)); |
solenberg | 6d6e7c5 | 2016-04-13 09:07:30 -0700 | [diff] [blame] | 2161 | EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); |
| 2162 | EXPECT_TRUE(GetSendStream(kSsrc1).IsSending()); |
| 2163 | |
| 2164 | // Turn off sending. |
solenberg | d53a3f9 | 2016-04-14 13:56:37 -0700 | [diff] [blame] | 2165 | SetSend(channel_, false); |
solenberg | 6d6e7c5 | 2016-04-13 09:07:30 -0700 | [diff] [blame] | 2166 | EXPECT_FALSE(GetSendStream(kSsrc1).IsSending()); |
| 2167 | |
| 2168 | // Changing RTP header extensions will recreate the AudioSendStream. |
| 2169 | send_parameters_.extensions.clear(); |
| 2170 | EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); |
| 2171 | EXPECT_FALSE(GetSendStream(kSsrc1).IsSending()); |
| 2172 | } |
| 2173 | |
solenberg | 1ac5614 | 2015-10-13 03:58:19 -0700 | [diff] [blame] | 2174 | // Test that we can create a channel and start playing out on it. |
| 2175 | TEST_F(WebRtcVoiceEngineTestFake, Playout) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 2176 | EXPECT_TRUE(SetupRecvStream()); |
solenberg | 1ac5614 | 2015-10-13 03:58:19 -0700 | [diff] [blame] | 2177 | int channel_num = voe_.GetLastChannel(); |
| 2178 | EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_)); |
| 2179 | EXPECT_TRUE(channel_->SetPlayout(true)); |
| 2180 | EXPECT_TRUE(voe_.GetPlayout(channel_num)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2181 | EXPECT_TRUE(channel_->SetPlayout(false)); |
| 2182 | EXPECT_FALSE(voe_.GetPlayout(channel_num)); |
| 2183 | } |
| 2184 | |
wu@webrtc.org | 9dba525 | 2013-08-05 20:36:57 +0000 | [diff] [blame] | 2185 | // Test that we can add and remove send streams. |
| 2186 | TEST_F(WebRtcVoiceEngineTestFake, CreateAndDeleteMultipleSendStreams) { |
| 2187 | SetupForMultiSendStream(); |
| 2188 | |
wu@webrtc.org | 9dba525 | 2013-08-05 20:36:57 +0000 | [diff] [blame] | 2189 | // Set the global state for sending. |
solenberg | d53a3f9 | 2016-04-14 13:56:37 -0700 | [diff] [blame] | 2190 | SetSend(channel_, true); |
wu@webrtc.org | 9dba525 | 2013-08-05 20:36:57 +0000 | [diff] [blame] | 2191 | |
solenberg | c96df77 | 2015-10-21 13:01:53 -0700 | [diff] [blame] | 2192 | for (uint32_t ssrc : kSsrcs4) { |
wu@webrtc.org | 9dba525 | 2013-08-05 20:36:57 +0000 | [diff] [blame] | 2193 | EXPECT_TRUE(channel_->AddSendStream( |
solenberg | c96df77 | 2015-10-21 13:01:53 -0700 | [diff] [blame] | 2194 | cricket::StreamParams::CreateLegacy(ssrc))); |
Taylor Brandstetter | 1a018dc | 2016-03-08 12:37:39 -0800 | [diff] [blame] | 2195 | EXPECT_TRUE(channel_->SetAudioSend(ssrc, true, nullptr, &fake_source_)); |
wu@webrtc.org | 9dba525 | 2013-08-05 20:36:57 +0000 | [diff] [blame] | 2196 | // Verify that we are in a sending state for all the created streams. |
Taylor Brandstetter | 1a018dc | 2016-03-08 12:37:39 -0800 | [diff] [blame] | 2197 | EXPECT_TRUE(GetSendStream(ssrc).IsSending()); |
wu@webrtc.org | 9dba525 | 2013-08-05 20:36:57 +0000 | [diff] [blame] | 2198 | } |
tfarina | 5237aaf | 2015-11-10 23:44:30 -0800 | [diff] [blame] | 2199 | EXPECT_EQ(arraysize(kSsrcs4), call_.GetAudioSendStreams().size()); |
wu@webrtc.org | 9dba525 | 2013-08-05 20:36:57 +0000 | [diff] [blame] | 2200 | |
solenberg | c96df77 | 2015-10-21 13:01:53 -0700 | [diff] [blame] | 2201 | // Delete the send streams. |
| 2202 | for (uint32_t ssrc : kSsrcs4) { |
| 2203 | EXPECT_TRUE(channel_->RemoveSendStream(ssrc)); |
solenberg | 3a94154 | 2015-11-16 07:34:50 -0800 | [diff] [blame] | 2204 | EXPECT_FALSE(call_.GetAudioSendStream(ssrc)); |
solenberg | c96df77 | 2015-10-21 13:01:53 -0700 | [diff] [blame] | 2205 | EXPECT_FALSE(channel_->RemoveSendStream(ssrc)); |
wu@webrtc.org | 9dba525 | 2013-08-05 20:36:57 +0000 | [diff] [blame] | 2206 | } |
solenberg | c96df77 | 2015-10-21 13:01:53 -0700 | [diff] [blame] | 2207 | EXPECT_EQ(0u, call_.GetAudioSendStreams().size()); |
wu@webrtc.org | 9dba525 | 2013-08-05 20:36:57 +0000 | [diff] [blame] | 2208 | } |
| 2209 | |
| 2210 | // Test SetSendCodecs correctly configure the codecs in all send streams. |
| 2211 | TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsWithMultipleSendStreams) { |
| 2212 | SetupForMultiSendStream(); |
| 2213 | |
wu@webrtc.org | 9dba525 | 2013-08-05 20:36:57 +0000 | [diff] [blame] | 2214 | // Create send streams. |
solenberg | c96df77 | 2015-10-21 13:01:53 -0700 | [diff] [blame] | 2215 | for (uint32_t ssrc : kSsrcs4) { |
wu@webrtc.org | 9dba525 | 2013-08-05 20:36:57 +0000 | [diff] [blame] | 2216 | EXPECT_TRUE(channel_->AddSendStream( |
solenberg | c96df77 | 2015-10-21 13:01:53 -0700 | [diff] [blame] | 2217 | cricket::StreamParams::CreateLegacy(ssrc))); |
wu@webrtc.org | 9dba525 | 2013-08-05 20:36:57 +0000 | [diff] [blame] | 2218 | } |
| 2219 | |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 2220 | cricket::AudioSendParameters parameters; |
wu@webrtc.org | 9dba525 | 2013-08-05 20:36:57 +0000 | [diff] [blame] | 2221 | // Set ISAC(16K) and CN(16K). VAD should be activated. |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 2222 | parameters.codecs.push_back(kIsacCodec); |
| 2223 | parameters.codecs.push_back(kCn16000Codec); |
| 2224 | parameters.codecs[1].id = 97; |
| 2225 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
wu@webrtc.org | 9dba525 | 2013-08-05 20:36:57 +0000 | [diff] [blame] | 2226 | |
| 2227 | // Verify ISAC and VAD are corrected configured on all send channels. |
| 2228 | webrtc::CodecInst gcodec; |
solenberg | c96df77 | 2015-10-21 13:01:53 -0700 | [diff] [blame] | 2229 | for (uint32_t ssrc : kSsrcs4) { |
solenberg | 3a94154 | 2015-11-16 07:34:50 -0800 | [diff] [blame] | 2230 | int channel_num = GetSendStreamConfig(ssrc).voe_channel_id; |
wu@webrtc.org | 9dba525 | 2013-08-05 20:36:57 +0000 | [diff] [blame] | 2231 | EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); |
| 2232 | EXPECT_STREQ("ISAC", gcodec.plname); |
| 2233 | EXPECT_TRUE(voe_.GetVAD(channel_num)); |
| 2234 | EXPECT_EQ(97, voe_.GetSendCNPayloadType(channel_num, true)); |
| 2235 | } |
| 2236 | |
| 2237 | // Change to PCMU(8K) and CN(16K). VAD should not be activated. |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 2238 | parameters.codecs[0] = kPcmuCodec; |
| 2239 | EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
solenberg | c96df77 | 2015-10-21 13:01:53 -0700 | [diff] [blame] | 2240 | for (uint32_t ssrc : kSsrcs4) { |
solenberg | 3a94154 | 2015-11-16 07:34:50 -0800 | [diff] [blame] | 2241 | int channel_num = GetSendStreamConfig(ssrc).voe_channel_id; |
wu@webrtc.org | 9dba525 | 2013-08-05 20:36:57 +0000 | [diff] [blame] | 2242 | EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); |
| 2243 | EXPECT_STREQ("PCMU", gcodec.plname); |
| 2244 | EXPECT_FALSE(voe_.GetVAD(channel_num)); |
| 2245 | } |
| 2246 | } |
| 2247 | |
| 2248 | // Test we can SetSend on all send streams correctly. |
| 2249 | TEST_F(WebRtcVoiceEngineTestFake, SetSendWithMultipleSendStreams) { |
| 2250 | SetupForMultiSendStream(); |
| 2251 | |
Taylor Brandstetter | 1a018dc | 2016-03-08 12:37:39 -0800 | [diff] [blame] | 2252 | // Create the send channels and they should be a "not sending" date. |
solenberg | c96df77 | 2015-10-21 13:01:53 -0700 | [diff] [blame] | 2253 | for (uint32_t ssrc : kSsrcs4) { |
wu@webrtc.org | 9dba525 | 2013-08-05 20:36:57 +0000 | [diff] [blame] | 2254 | EXPECT_TRUE(channel_->AddSendStream( |
solenberg | c96df77 | 2015-10-21 13:01:53 -0700 | [diff] [blame] | 2255 | cricket::StreamParams::CreateLegacy(ssrc))); |
Taylor Brandstetter | 1a018dc | 2016-03-08 12:37:39 -0800 | [diff] [blame] | 2256 | EXPECT_TRUE(channel_->SetAudioSend(ssrc, true, nullptr, &fake_source_)); |
| 2257 | EXPECT_FALSE(GetSendStream(ssrc).IsSending()); |
wu@webrtc.org | 9dba525 | 2013-08-05 20:36:57 +0000 | [diff] [blame] | 2258 | } |
| 2259 | |
| 2260 | // Set the global state for starting sending. |
solenberg | d53a3f9 | 2016-04-14 13:56:37 -0700 | [diff] [blame] | 2261 | SetSend(channel_, true); |
solenberg | c96df77 | 2015-10-21 13:01:53 -0700 | [diff] [blame] | 2262 | for (uint32_t ssrc : kSsrcs4) { |
wu@webrtc.org | 9dba525 | 2013-08-05 20:36:57 +0000 | [diff] [blame] | 2263 | // Verify that we are in a sending state for all the send streams. |
Taylor Brandstetter | 1a018dc | 2016-03-08 12:37:39 -0800 | [diff] [blame] | 2264 | EXPECT_TRUE(GetSendStream(ssrc).IsSending()); |
wu@webrtc.org | 9dba525 | 2013-08-05 20:36:57 +0000 | [diff] [blame] | 2265 | } |
| 2266 | |
| 2267 | // Set the global state for stopping sending. |
solenberg | d53a3f9 | 2016-04-14 13:56:37 -0700 | [diff] [blame] | 2268 | SetSend(channel_, false); |
solenberg | c96df77 | 2015-10-21 13:01:53 -0700 | [diff] [blame] | 2269 | for (uint32_t ssrc : kSsrcs4) { |
wu@webrtc.org | 9dba525 | 2013-08-05 20:36:57 +0000 | [diff] [blame] | 2270 | // Verify that we are in a stop state for all the send streams. |
Taylor Brandstetter | 1a018dc | 2016-03-08 12:37:39 -0800 | [diff] [blame] | 2271 | EXPECT_FALSE(GetSendStream(ssrc).IsSending()); |
wu@webrtc.org | 9dba525 | 2013-08-05 20:36:57 +0000 | [diff] [blame] | 2272 | } |
| 2273 | } |
| 2274 | |
| 2275 | // Test we can set the correct statistics on all send streams. |
| 2276 | TEST_F(WebRtcVoiceEngineTestFake, GetStatsWithMultipleSendStreams) { |
| 2277 | SetupForMultiSendStream(); |
| 2278 | |
wu@webrtc.org | 9dba525 | 2013-08-05 20:36:57 +0000 | [diff] [blame] | 2279 | // Create send streams. |
solenberg | c96df77 | 2015-10-21 13:01:53 -0700 | [diff] [blame] | 2280 | for (uint32_t ssrc : kSsrcs4) { |
wu@webrtc.org | 9dba525 | 2013-08-05 20:36:57 +0000 | [diff] [blame] | 2281 | EXPECT_TRUE(channel_->AddSendStream( |
solenberg | c96df77 | 2015-10-21 13:01:53 -0700 | [diff] [blame] | 2282 | cricket::StreamParams::CreateLegacy(ssrc))); |
wu@webrtc.org | 9dba525 | 2013-08-05 20:36:57 +0000 | [diff] [blame] | 2283 | } |
solenberg | 85a0496 | 2015-10-27 03:35:21 -0700 | [diff] [blame] | 2284 | |
buildbot@webrtc.org | 7e71b77 | 2014-06-13 01:14:01 +0000 | [diff] [blame] | 2285 | // Create a receive stream to check that none of the send streams end up in |
| 2286 | // the receive stream stats. |
solenberg | 8189b02 | 2016-06-14 12:13:00 -0700 | [diff] [blame] | 2287 | EXPECT_TRUE(AddRecvStream(kSsrc2)); |
solenberg | 971cab0 | 2016-06-14 10:02:41 -0700 | [diff] [blame] | 2288 | |
wu@webrtc.org | 9dba525 | 2013-08-05 20:36:57 +0000 | [diff] [blame] | 2289 | // We need send codec to be set to get all stats. |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 2290 | EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); |
| 2291 | EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_)); |
solenberg | 971cab0 | 2016-06-14 10:02:41 -0700 | [diff] [blame] | 2292 | SetAudioSendStreamStats(); |
wu@webrtc.org | 9dba525 | 2013-08-05 20:36:57 +0000 | [diff] [blame] | 2293 | |
solenberg | 85a0496 | 2015-10-27 03:35:21 -0700 | [diff] [blame] | 2294 | // Check stats for the added streams. |
| 2295 | { |
| 2296 | cricket::VoiceMediaInfo info; |
| 2297 | EXPECT_EQ(true, channel_->GetStats(&info)); |
wu@webrtc.org | 9dba525 | 2013-08-05 20:36:57 +0000 | [diff] [blame] | 2298 | |
solenberg | 85a0496 | 2015-10-27 03:35:21 -0700 | [diff] [blame] | 2299 | // We have added 4 send streams. We should see empty stats for all. |
tfarina | 5237aaf | 2015-11-10 23:44:30 -0800 | [diff] [blame] | 2300 | EXPECT_EQ(static_cast<size_t>(arraysize(kSsrcs4)), info.senders.size()); |
solenberg | 85a0496 | 2015-10-27 03:35:21 -0700 | [diff] [blame] | 2301 | for (const auto& sender : info.senders) { |
solenberg | 566ef24 | 2015-11-06 15:34:49 -0800 | [diff] [blame] | 2302 | VerifyVoiceSenderInfo(sender, false); |
solenberg | 85a0496 | 2015-10-27 03:35:21 -0700 | [diff] [blame] | 2303 | } |
| 2304 | |
| 2305 | // We have added one receive stream. We should see empty stats. |
| 2306 | EXPECT_EQ(info.receivers.size(), 1u); |
| 2307 | EXPECT_EQ(info.receivers[0].ssrc(), 0); |
wu@webrtc.org | 9dba525 | 2013-08-05 20:36:57 +0000 | [diff] [blame] | 2308 | } |
solenberg | 1ac5614 | 2015-10-13 03:58:19 -0700 | [diff] [blame] | 2309 | |
Fredrik Solenberg | 4f4ec0a | 2015-10-22 10:49:27 +0200 | [diff] [blame] | 2310 | // Remove the kSsrc2 stream. No receiver stats. |
solenberg | 85a0496 | 2015-10-27 03:35:21 -0700 | [diff] [blame] | 2311 | { |
| 2312 | cricket::VoiceMediaInfo info; |
| 2313 | EXPECT_TRUE(channel_->RemoveRecvStream(kSsrc2)); |
| 2314 | EXPECT_EQ(true, channel_->GetStats(&info)); |
tfarina | 5237aaf | 2015-11-10 23:44:30 -0800 | [diff] [blame] | 2315 | EXPECT_EQ(static_cast<size_t>(arraysize(kSsrcs4)), info.senders.size()); |
solenberg | 85a0496 | 2015-10-27 03:35:21 -0700 | [diff] [blame] | 2316 | EXPECT_EQ(0u, info.receivers.size()); |
| 2317 | } |
buildbot@webrtc.org | 7e71b77 | 2014-06-13 01:14:01 +0000 | [diff] [blame] | 2318 | |
Fredrik Solenberg | 4f4ec0a | 2015-10-22 10:49:27 +0200 | [diff] [blame] | 2319 | // Deliver a new packet - a default receive stream should be created and we |
| 2320 | // should see stats again. |
solenberg | 85a0496 | 2015-10-27 03:35:21 -0700 | [diff] [blame] | 2321 | { |
| 2322 | cricket::VoiceMediaInfo info; |
| 2323 | DeliverPacket(kPcmuFrame, sizeof(kPcmuFrame)); |
| 2324 | SetAudioReceiveStreamStats(); |
| 2325 | EXPECT_EQ(true, channel_->GetStats(&info)); |
tfarina | 5237aaf | 2015-11-10 23:44:30 -0800 | [diff] [blame] | 2326 | EXPECT_EQ(static_cast<size_t>(arraysize(kSsrcs4)), info.senders.size()); |
solenberg | 85a0496 | 2015-10-27 03:35:21 -0700 | [diff] [blame] | 2327 | EXPECT_EQ(1u, info.receivers.size()); |
| 2328 | VerifyVoiceReceiverInfo(info.receivers[0]); |
| 2329 | } |
wu@webrtc.org | 9dba525 | 2013-08-05 20:36:57 +0000 | [diff] [blame] | 2330 | } |
| 2331 | |
wu@webrtc.org | 9dba525 | 2013-08-05 20:36:57 +0000 | [diff] [blame] | 2332 | // Test that we can add and remove receive streams, and do proper send/playout. |
| 2333 | // We can receive on multiple streams while sending one stream. |
| 2334 | TEST_F(WebRtcVoiceEngineTestFake, PlayoutWithMultipleStreams) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 2335 | EXPECT_TRUE(SetupSendStream()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2336 | int channel_num1 = voe_.GetLastChannel(); |
| 2337 | |
solenberg | 1ac5614 | 2015-10-13 03:58:19 -0700 | [diff] [blame] | 2338 | // Start playout without a receive stream. |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 2339 | EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2340 | EXPECT_TRUE(channel_->SetPlayout(true)); |
solenberg | 1ac5614 | 2015-10-13 03:58:19 -0700 | [diff] [blame] | 2341 | EXPECT_FALSE(voe_.GetPlayout(channel_num1)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2342 | |
solenberg | 1ac5614 | 2015-10-13 03:58:19 -0700 | [diff] [blame] | 2343 | // Adding another stream should enable playout on the new stream only. |
solenberg | 8189b02 | 2016-06-14 12:13:00 -0700 | [diff] [blame] | 2344 | EXPECT_TRUE(AddRecvStream(kSsrc2)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2345 | int channel_num2 = voe_.GetLastChannel(); |
solenberg | d53a3f9 | 2016-04-14 13:56:37 -0700 | [diff] [blame] | 2346 | SetSend(channel_, true); |
Taylor Brandstetter | 1a018dc | 2016-03-08 12:37:39 -0800 | [diff] [blame] | 2347 | EXPECT_TRUE(GetSendStream(kSsrc1).IsSending()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2348 | |
solenberg | 1ac5614 | 2015-10-13 03:58:19 -0700 | [diff] [blame] | 2349 | // Make sure only the new stream is played out. |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2350 | EXPECT_FALSE(voe_.GetPlayout(channel_num1)); |
| 2351 | EXPECT_TRUE(voe_.GetPlayout(channel_num2)); |
| 2352 | |
| 2353 | // Adding yet another stream should have stream 2 and 3 enabled for playout. |
solenberg | 8189b02 | 2016-06-14 12:13:00 -0700 | [diff] [blame] | 2354 | EXPECT_TRUE(AddRecvStream(kSsrc3)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2355 | int channel_num3 = voe_.GetLastChannel(); |
| 2356 | EXPECT_FALSE(voe_.GetPlayout(channel_num1)); |
| 2357 | EXPECT_TRUE(voe_.GetPlayout(channel_num2)); |
| 2358 | EXPECT_TRUE(voe_.GetPlayout(channel_num3)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2359 | |
| 2360 | // Stop sending. |
solenberg | d53a3f9 | 2016-04-14 13:56:37 -0700 | [diff] [blame] | 2361 | SetSend(channel_, false); |
Taylor Brandstetter | 1a018dc | 2016-03-08 12:37:39 -0800 | [diff] [blame] | 2362 | EXPECT_FALSE(GetSendStream(kSsrc1).IsSending()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2363 | |
| 2364 | // Stop playout. |
| 2365 | EXPECT_TRUE(channel_->SetPlayout(false)); |
| 2366 | EXPECT_FALSE(voe_.GetPlayout(channel_num1)); |
| 2367 | EXPECT_FALSE(voe_.GetPlayout(channel_num2)); |
| 2368 | EXPECT_FALSE(voe_.GetPlayout(channel_num3)); |
| 2369 | |
solenberg | 1ac5614 | 2015-10-13 03:58:19 -0700 | [diff] [blame] | 2370 | // Restart playout and make sure only recv streams are played out. |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2371 | EXPECT_TRUE(channel_->SetPlayout(true)); |
| 2372 | EXPECT_FALSE(voe_.GetPlayout(channel_num1)); |
| 2373 | EXPECT_TRUE(voe_.GetPlayout(channel_num2)); |
| 2374 | EXPECT_TRUE(voe_.GetPlayout(channel_num3)); |
| 2375 | |
solenberg | 1ac5614 | 2015-10-13 03:58:19 -0700 | [diff] [blame] | 2376 | // Now remove the recv streams and verify that the send stream doesn't play. |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2377 | EXPECT_TRUE(channel_->RemoveRecvStream(3)); |
| 2378 | EXPECT_TRUE(channel_->RemoveRecvStream(2)); |
solenberg | 1ac5614 | 2015-10-13 03:58:19 -0700 | [diff] [blame] | 2379 | EXPECT_FALSE(voe_.GetPlayout(channel_num1)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2380 | } |
| 2381 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2382 | // Test that we can create a channel configured for Codian bridges, |
solenberg | 1ac5614 | 2015-10-13 03:58:19 -0700 | [diff] [blame] | 2383 | // and start sending on it. |
| 2384 | TEST_F(WebRtcVoiceEngineTestFake, CodianSend) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 2385 | EXPECT_TRUE(SetupSendStream()); |
solenberg | 246b817 | 2015-12-08 09:50:23 -0800 | [diff] [blame] | 2386 | cricket::AudioOptions options_adjust_agc; |
| 2387 | options_adjust_agc.adjust_agc_delta = rtc::Optional<int>(-10); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2388 | webrtc::AgcConfig agc_config; |
| 2389 | EXPECT_EQ(0, voe_.GetAgcConfig(agc_config)); |
| 2390 | EXPECT_EQ(0, agc_config.targetLeveldBOv); |
solenberg | 246b817 | 2015-12-08 09:50:23 -0800 | [diff] [blame] | 2391 | send_parameters_.options = options_adjust_agc; |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 2392 | EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); |
solenberg | d53a3f9 | 2016-04-14 13:56:37 -0700 | [diff] [blame] | 2393 | SetSend(channel_, true); |
Taylor Brandstetter | 1a018dc | 2016-03-08 12:37:39 -0800 | [diff] [blame] | 2394 | EXPECT_TRUE(GetSendStream(kSsrc1).IsSending()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2395 | EXPECT_EQ(0, voe_.GetAgcConfig(agc_config)); |
| 2396 | EXPECT_EQ(agc_config.targetLeveldBOv, 10); // level was attenuated |
solenberg | d53a3f9 | 2016-04-14 13:56:37 -0700 | [diff] [blame] | 2397 | SetSend(channel_, false); |
Taylor Brandstetter | 1a018dc | 2016-03-08 12:37:39 -0800 | [diff] [blame] | 2398 | EXPECT_FALSE(GetSendStream(kSsrc1).IsSending()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2399 | EXPECT_EQ(0, voe_.GetAgcConfig(agc_config)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2400 | } |
| 2401 | |
wu@webrtc.org | 97077a3 | 2013-10-25 21:18:33 +0000 | [diff] [blame] | 2402 | TEST_F(WebRtcVoiceEngineTestFake, TxAgcConfigViaOptions) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 2403 | EXPECT_TRUE(SetupSendStream()); |
solenberg | 5b5129a | 2016-04-08 05:35:48 -0700 | [diff] [blame] | 2404 | EXPECT_CALL(adm_, |
| 2405 | BuiltInAGCIsAvailable()).Times(2).WillRepeatedly(Return(false)); |
wu@webrtc.org | 97077a3 | 2013-10-25 21:18:33 +0000 | [diff] [blame] | 2406 | webrtc::AgcConfig agc_config; |
| 2407 | EXPECT_EQ(0, voe_.GetAgcConfig(agc_config)); |
| 2408 | EXPECT_EQ(0, agc_config.targetLeveldBOv); |
solenberg | 246b817 | 2015-12-08 09:50:23 -0800 | [diff] [blame] | 2409 | send_parameters_.options.tx_agc_target_dbov = rtc::Optional<uint16_t>(3); |
| 2410 | send_parameters_.options.tx_agc_digital_compression_gain = |
| 2411 | rtc::Optional<uint16_t>(9); |
| 2412 | send_parameters_.options.tx_agc_limiter = rtc::Optional<bool>(true); |
| 2413 | send_parameters_.options.auto_gain_control = rtc::Optional<bool>(true); |
| 2414 | EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); |
wu@webrtc.org | 97077a3 | 2013-10-25 21:18:33 +0000 | [diff] [blame] | 2415 | EXPECT_EQ(0, voe_.GetAgcConfig(agc_config)); |
| 2416 | EXPECT_EQ(3, agc_config.targetLeveldBOv); |
| 2417 | EXPECT_EQ(9, agc_config.digitalCompressionGaindB); |
| 2418 | EXPECT_TRUE(agc_config.limiterEnable); |
| 2419 | |
| 2420 | // Check interaction with adjust_agc_delta. Both should be respected, for |
| 2421 | // backwards compatibility. |
solenberg | 246b817 | 2015-12-08 09:50:23 -0800 | [diff] [blame] | 2422 | send_parameters_.options.adjust_agc_delta = rtc::Optional<int>(-10); |
| 2423 | EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); |
wu@webrtc.org | 97077a3 | 2013-10-25 21:18:33 +0000 | [diff] [blame] | 2424 | EXPECT_EQ(0, voe_.GetAgcConfig(agc_config)); |
| 2425 | EXPECT_EQ(13, agc_config.targetLeveldBOv); |
| 2426 | } |
| 2427 | |
wu@webrtc.org | 97077a3 | 2013-10-25 21:18:33 +0000 | [diff] [blame] | 2428 | TEST_F(WebRtcVoiceEngineTestFake, SampleRatesViaOptions) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 2429 | EXPECT_TRUE(SetupSendStream()); |
solenberg | 5b5129a | 2016-04-08 05:35:48 -0700 | [diff] [blame] | 2430 | EXPECT_CALL(adm_, SetRecordingSampleRate(48000)).WillOnce(Return(0)); |
| 2431 | EXPECT_CALL(adm_, SetPlayoutSampleRate(44100)).WillOnce(Return(0)); |
solenberg | 246b817 | 2015-12-08 09:50:23 -0800 | [diff] [blame] | 2432 | send_parameters_.options.recording_sample_rate = |
| 2433 | rtc::Optional<uint32_t>(48000); |
| 2434 | send_parameters_.options.playout_sample_rate = rtc::Optional<uint32_t>(44100); |
| 2435 | EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); |
wu@webrtc.org | 97077a3 | 2013-10-25 21:18:33 +0000 | [diff] [blame] | 2436 | } |
| 2437 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2438 | // Test that we can set the outgoing SSRC properly. |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 2439 | // SSRC is set in SetupSendStream() by calling AddSendStream. |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2440 | TEST_F(WebRtcVoiceEngineTestFake, SetSendSsrc) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 2441 | EXPECT_TRUE(SetupSendStream()); |
solenberg | 3a94154 | 2015-11-16 07:34:50 -0800 | [diff] [blame] | 2442 | EXPECT_TRUE(call_.GetAudioSendStream(kSsrc1)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2443 | } |
| 2444 | |
| 2445 | TEST_F(WebRtcVoiceEngineTestFake, GetStats) { |
| 2446 | // Setup. We need send codec to be set to get all stats. |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 2447 | EXPECT_TRUE(SetupSendStream()); |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 2448 | // SetupSendStream adds a send stream with kSsrc1, so the receive |
solenberg | 1ac5614 | 2015-10-13 03:58:19 -0700 | [diff] [blame] | 2449 | // stream has to use a different SSRC. |
solenberg | 8189b02 | 2016-06-14 12:13:00 -0700 | [diff] [blame] | 2450 | EXPECT_TRUE(AddRecvStream(kSsrc2)); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 2451 | EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); |
| 2452 | EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_)); |
solenberg | 971cab0 | 2016-06-14 10:02:41 -0700 | [diff] [blame] | 2453 | SetAudioSendStreamStats(); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2454 | |
solenberg | 85a0496 | 2015-10-27 03:35:21 -0700 | [diff] [blame] | 2455 | // Check stats for the added streams. |
| 2456 | { |
| 2457 | cricket::VoiceMediaInfo info; |
| 2458 | EXPECT_EQ(true, channel_->GetStats(&info)); |
| 2459 | |
| 2460 | // We have added one send stream. We should see the stats we've set. |
| 2461 | EXPECT_EQ(1u, info.senders.size()); |
solenberg | 566ef24 | 2015-11-06 15:34:49 -0800 | [diff] [blame] | 2462 | VerifyVoiceSenderInfo(info.senders[0], false); |
solenberg | 85a0496 | 2015-10-27 03:35:21 -0700 | [diff] [blame] | 2463 | // We have added one receive stream. We should see empty stats. |
| 2464 | EXPECT_EQ(info.receivers.size(), 1u); |
| 2465 | EXPECT_EQ(info.receivers[0].ssrc(), 0); |
| 2466 | } |
solenberg | 1ac5614 | 2015-10-13 03:58:19 -0700 | [diff] [blame] | 2467 | |
solenberg | 566ef24 | 2015-11-06 15:34:49 -0800 | [diff] [blame] | 2468 | // Start sending - this affects some reported stats. |
| 2469 | { |
| 2470 | cricket::VoiceMediaInfo info; |
solenberg | d53a3f9 | 2016-04-14 13:56:37 -0700 | [diff] [blame] | 2471 | SetSend(channel_, true); |
solenberg | 566ef24 | 2015-11-06 15:34:49 -0800 | [diff] [blame] | 2472 | EXPECT_EQ(true, channel_->GetStats(&info)); |
| 2473 | VerifyVoiceSenderInfo(info.senders[0], true); |
| 2474 | } |
| 2475 | |
Fredrik Solenberg | 4f4ec0a | 2015-10-22 10:49:27 +0200 | [diff] [blame] | 2476 | // Remove the kSsrc2 stream. No receiver stats. |
solenberg | 85a0496 | 2015-10-27 03:35:21 -0700 | [diff] [blame] | 2477 | { |
| 2478 | cricket::VoiceMediaInfo info; |
| 2479 | EXPECT_TRUE(channel_->RemoveRecvStream(kSsrc2)); |
| 2480 | EXPECT_EQ(true, channel_->GetStats(&info)); |
| 2481 | EXPECT_EQ(1u, info.senders.size()); |
| 2482 | EXPECT_EQ(0u, info.receivers.size()); |
| 2483 | } |
solenberg | 1ac5614 | 2015-10-13 03:58:19 -0700 | [diff] [blame] | 2484 | |
Fredrik Solenberg | 4f4ec0a | 2015-10-22 10:49:27 +0200 | [diff] [blame] | 2485 | // Deliver a new packet - a default receive stream should be created and we |
| 2486 | // should see stats again. |
solenberg | 85a0496 | 2015-10-27 03:35:21 -0700 | [diff] [blame] | 2487 | { |
| 2488 | cricket::VoiceMediaInfo info; |
| 2489 | DeliverPacket(kPcmuFrame, sizeof(kPcmuFrame)); |
| 2490 | SetAudioReceiveStreamStats(); |
| 2491 | EXPECT_EQ(true, channel_->GetStats(&info)); |
| 2492 | EXPECT_EQ(1u, info.senders.size()); |
| 2493 | EXPECT_EQ(1u, info.receivers.size()); |
| 2494 | VerifyVoiceReceiverInfo(info.receivers[0]); |
| 2495 | } |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2496 | } |
| 2497 | |
| 2498 | // Test that we can set the outgoing SSRC properly with multiple streams. |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 2499 | // SSRC is set in SetupSendStream() by calling AddSendStream. |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2500 | TEST_F(WebRtcVoiceEngineTestFake, SetSendSsrcWithMultipleStreams) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 2501 | EXPECT_TRUE(SetupSendStream()); |
solenberg | 3a94154 | 2015-11-16 07:34:50 -0800 | [diff] [blame] | 2502 | EXPECT_TRUE(call_.GetAudioSendStream(kSsrc1)); |
solenberg | 8189b02 | 2016-06-14 12:13:00 -0700 | [diff] [blame] | 2503 | EXPECT_TRUE(AddRecvStream(kSsrc2)); |
solenberg | 7add058 | 2015-11-20 09:59:34 -0800 | [diff] [blame] | 2504 | EXPECT_EQ(kSsrc1, GetRecvStreamConfig(kSsrc2).rtp.local_ssrc); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2505 | } |
| 2506 | |
| 2507 | // Test that the local SSRC is the same on sending and receiving channels if the |
| 2508 | // receive channel is created before the send channel. |
| 2509 | TEST_F(WebRtcVoiceEngineTestFake, SetSendSsrcAfterCreatingReceiveChannel) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 2510 | EXPECT_TRUE(SetupChannel()); |
solenberg | 8189b02 | 2016-06-14 12:13:00 -0700 | [diff] [blame] | 2511 | EXPECT_TRUE(AddRecvStream(1)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2512 | int receive_channel_num = voe_.GetLastChannel(); |
| 2513 | EXPECT_TRUE(channel_->AddSendStream( |
| 2514 | cricket::StreamParams::CreateLegacy(1234))); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2515 | |
solenberg | 3a94154 | 2015-11-16 07:34:50 -0800 | [diff] [blame] | 2516 | EXPECT_TRUE(call_.GetAudioSendStream(1234)); |
solenberg | 85a0496 | 2015-10-27 03:35:21 -0700 | [diff] [blame] | 2517 | EXPECT_EQ(1234U, voe_.GetLocalSSRC(receive_channel_num)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2518 | } |
| 2519 | |
| 2520 | // Test that we can properly receive packets. |
| 2521 | TEST_F(WebRtcVoiceEngineTestFake, Recv) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 2522 | EXPECT_TRUE(SetupChannel()); |
solenberg | 8189b02 | 2016-06-14 12:13:00 -0700 | [diff] [blame] | 2523 | EXPECT_TRUE(AddRecvStream(1)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2524 | DeliverPacket(kPcmuFrame, sizeof(kPcmuFrame)); |
mflodman | 3d7db26 | 2016-04-29 00:57:13 -0700 | [diff] [blame] | 2525 | |
| 2526 | EXPECT_TRUE(GetRecvStream(1).VerifyLastPacket(kPcmuFrame, |
| 2527 | sizeof(kPcmuFrame))); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2528 | } |
| 2529 | |
| 2530 | // Test that we can properly receive packets on multiple streams. |
| 2531 | TEST_F(WebRtcVoiceEngineTestFake, RecvWithMultipleStreams) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 2532 | EXPECT_TRUE(SetupChannel()); |
mflodman | 3d7db26 | 2016-04-29 00:57:13 -0700 | [diff] [blame] | 2533 | const uint32_t ssrc1 = 1; |
| 2534 | const uint32_t ssrc2 = 2; |
| 2535 | const uint32_t ssrc3 = 3; |
solenberg | 8189b02 | 2016-06-14 12:13:00 -0700 | [diff] [blame] | 2536 | EXPECT_TRUE(AddRecvStream(ssrc1)); |
| 2537 | EXPECT_TRUE(AddRecvStream(ssrc2)); |
| 2538 | EXPECT_TRUE(AddRecvStream(ssrc3)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2539 | // Create packets with the right SSRCs. |
mflodman | 3d7db26 | 2016-04-29 00:57:13 -0700 | [diff] [blame] | 2540 | unsigned char packets[4][sizeof(kPcmuFrame)]; |
tfarina | 5237aaf | 2015-11-10 23:44:30 -0800 | [diff] [blame] | 2541 | for (size_t i = 0; i < arraysize(packets); ++i) { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2542 | memcpy(packets[i], kPcmuFrame, sizeof(kPcmuFrame)); |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 2543 | rtc::SetBE32(packets[i] + 8, static_cast<uint32_t>(i)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2544 | } |
mflodman | 3d7db26 | 2016-04-29 00:57:13 -0700 | [diff] [blame] | 2545 | |
| 2546 | const cricket::FakeAudioReceiveStream& s1 = GetRecvStream(ssrc1); |
| 2547 | const cricket::FakeAudioReceiveStream& s2 = GetRecvStream(ssrc2); |
| 2548 | const cricket::FakeAudioReceiveStream& s3 = GetRecvStream(ssrc3); |
| 2549 | |
| 2550 | EXPECT_EQ(s1.received_packets(), 0); |
| 2551 | EXPECT_EQ(s2.received_packets(), 0); |
| 2552 | EXPECT_EQ(s3.received_packets(), 0); |
solenberg | 7e63ef0 | 2015-11-20 00:19:43 -0800 | [diff] [blame] | 2553 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2554 | DeliverPacket(packets[0], sizeof(packets[0])); |
mflodman | 3d7db26 | 2016-04-29 00:57:13 -0700 | [diff] [blame] | 2555 | EXPECT_EQ(s1.received_packets(), 0); |
| 2556 | EXPECT_EQ(s2.received_packets(), 0); |
| 2557 | EXPECT_EQ(s3.received_packets(), 0); |
solenberg | 7e63ef0 | 2015-11-20 00:19:43 -0800 | [diff] [blame] | 2558 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2559 | DeliverPacket(packets[1], sizeof(packets[1])); |
mflodman | 3d7db26 | 2016-04-29 00:57:13 -0700 | [diff] [blame] | 2560 | EXPECT_EQ(s1.received_packets(), 1); |
| 2561 | EXPECT_TRUE(s1.VerifyLastPacket(packets[1], sizeof(packets[1]))); |
| 2562 | EXPECT_EQ(s2.received_packets(), 0); |
| 2563 | EXPECT_EQ(s3.received_packets(), 0); |
solenberg | 7e63ef0 | 2015-11-20 00:19:43 -0800 | [diff] [blame] | 2564 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2565 | DeliverPacket(packets[2], sizeof(packets[2])); |
mflodman | 3d7db26 | 2016-04-29 00:57:13 -0700 | [diff] [blame] | 2566 | EXPECT_EQ(s1.received_packets(), 1); |
| 2567 | EXPECT_EQ(s2.received_packets(), 1); |
| 2568 | EXPECT_TRUE(s2.VerifyLastPacket(packets[2], sizeof(packets[2]))); |
| 2569 | EXPECT_EQ(s3.received_packets(), 0); |
solenberg | 7e63ef0 | 2015-11-20 00:19:43 -0800 | [diff] [blame] | 2570 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2571 | DeliverPacket(packets[3], sizeof(packets[3])); |
mflodman | 3d7db26 | 2016-04-29 00:57:13 -0700 | [diff] [blame] | 2572 | EXPECT_EQ(s1.received_packets(), 1); |
| 2573 | EXPECT_EQ(s2.received_packets(), 1); |
| 2574 | EXPECT_EQ(s3.received_packets(), 1); |
| 2575 | EXPECT_TRUE(s3.VerifyLastPacket(packets[3], sizeof(packets[3]))); |
solenberg | 7e63ef0 | 2015-11-20 00:19:43 -0800 | [diff] [blame] | 2576 | |
mflodman | 3d7db26 | 2016-04-29 00:57:13 -0700 | [diff] [blame] | 2577 | EXPECT_TRUE(channel_->RemoveRecvStream(ssrc3)); |
| 2578 | EXPECT_TRUE(channel_->RemoveRecvStream(ssrc2)); |
| 2579 | EXPECT_TRUE(channel_->RemoveRecvStream(ssrc1)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2580 | } |
| 2581 | |
solenberg | 7e63ef0 | 2015-11-20 00:19:43 -0800 | [diff] [blame] | 2582 | // Test that receiving on an unsignalled stream works (default channel will be |
| 2583 | // created). |
| 2584 | TEST_F(WebRtcVoiceEngineTestFake, RecvUnsignalled) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 2585 | EXPECT_TRUE(SetupChannel()); |
mflodman | 3d7db26 | 2016-04-29 00:57:13 -0700 | [diff] [blame] | 2586 | EXPECT_EQ(0, call_.GetAudioReceiveStreams().size()); |
| 2587 | |
solenberg | 7e63ef0 | 2015-11-20 00:19:43 -0800 | [diff] [blame] | 2588 | DeliverPacket(kPcmuFrame, sizeof(kPcmuFrame)); |
mflodman | 3d7db26 | 2016-04-29 00:57:13 -0700 | [diff] [blame] | 2589 | |
| 2590 | EXPECT_EQ(1, call_.GetAudioReceiveStreams().size()); |
| 2591 | EXPECT_TRUE(GetRecvStream(1).VerifyLastPacket(kPcmuFrame, |
| 2592 | sizeof(kPcmuFrame))); |
solenberg | 7e63ef0 | 2015-11-20 00:19:43 -0800 | [diff] [blame] | 2593 | } |
| 2594 | |
| 2595 | // Test that receiving on an unsignalled stream works (default channel will be |
| 2596 | // created), and that packets will be forwarded to the default channel |
| 2597 | // regardless of their SSRCs. |
| 2598 | TEST_F(WebRtcVoiceEngineTestFake, RecvUnsignalledWithSsrcSwitch) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 2599 | EXPECT_TRUE(SetupChannel()); |
mflodman | 3d7db26 | 2016-04-29 00:57:13 -0700 | [diff] [blame] | 2600 | unsigned char packet[sizeof(kPcmuFrame)]; |
solenberg | 7e63ef0 | 2015-11-20 00:19:43 -0800 | [diff] [blame] | 2601 | memcpy(packet, kPcmuFrame, sizeof(kPcmuFrame)); |
| 2602 | |
mflodman | 3d7db26 | 2016-04-29 00:57:13 -0700 | [diff] [blame] | 2603 | // Note that ssrc = 0 is not supported. |
| 2604 | uint32_t ssrc = 1; |
| 2605 | for (; ssrc < 10; ++ssrc) { |
solenberg | 7e63ef0 | 2015-11-20 00:19:43 -0800 | [diff] [blame] | 2606 | rtc::SetBE32(&packet[8], ssrc); |
| 2607 | DeliverPacket(packet, sizeof(packet)); |
mflodman | 3d7db26 | 2016-04-29 00:57:13 -0700 | [diff] [blame] | 2608 | |
| 2609 | // Verify we only have one default stream. |
| 2610 | EXPECT_EQ(1, call_.GetAudioReceiveStreams().size()); |
| 2611 | EXPECT_EQ(1, GetRecvStream(ssrc).received_packets()); |
| 2612 | EXPECT_TRUE(GetRecvStream(ssrc).VerifyLastPacket(packet, sizeof(packet))); |
solenberg | 7e63ef0 | 2015-11-20 00:19:43 -0800 | [diff] [blame] | 2613 | } |
mflodman | 3d7db26 | 2016-04-29 00:57:13 -0700 | [diff] [blame] | 2614 | |
| 2615 | // Sending the same ssrc again should not create a new stream. |
| 2616 | --ssrc; |
| 2617 | DeliverPacket(packet, sizeof(packet)); |
| 2618 | EXPECT_EQ(1, call_.GetAudioReceiveStreams().size()); |
| 2619 | EXPECT_EQ(2, GetRecvStream(ssrc).received_packets()); |
| 2620 | EXPECT_TRUE(GetRecvStream(ssrc).VerifyLastPacket(packet, sizeof(packet))); |
solenberg | 7e63ef0 | 2015-11-20 00:19:43 -0800 | [diff] [blame] | 2621 | } |
| 2622 | |
| 2623 | // Test that a default channel is created even after a signalled stream has been |
| 2624 | // added, and that this stream will get any packets for unknown SSRCs. |
| 2625 | TEST_F(WebRtcVoiceEngineTestFake, RecvUnsignalledAfterSignalled) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 2626 | EXPECT_TRUE(SetupChannel()); |
mflodman | 3d7db26 | 2016-04-29 00:57:13 -0700 | [diff] [blame] | 2627 | unsigned char packet[sizeof(kPcmuFrame)]; |
solenberg | 7e63ef0 | 2015-11-20 00:19:43 -0800 | [diff] [blame] | 2628 | memcpy(packet, kPcmuFrame, sizeof(kPcmuFrame)); |
| 2629 | |
| 2630 | // Add a known stream, send packet and verify we got it. |
mflodman | 3d7db26 | 2016-04-29 00:57:13 -0700 | [diff] [blame] | 2631 | const uint32_t signaled_ssrc = 1; |
| 2632 | rtc::SetBE32(&packet[8], signaled_ssrc); |
solenberg | 8189b02 | 2016-06-14 12:13:00 -0700 | [diff] [blame] | 2633 | EXPECT_TRUE(AddRecvStream(signaled_ssrc)); |
solenberg | 7e63ef0 | 2015-11-20 00:19:43 -0800 | [diff] [blame] | 2634 | DeliverPacket(packet, sizeof(packet)); |
mflodman | 3d7db26 | 2016-04-29 00:57:13 -0700 | [diff] [blame] | 2635 | EXPECT_TRUE(GetRecvStream(signaled_ssrc).VerifyLastPacket( |
| 2636 | packet, sizeof(packet))); |
solenberg | 7e63ef0 | 2015-11-20 00:19:43 -0800 | [diff] [blame] | 2637 | |
| 2638 | // Note that the first unknown SSRC cannot be 0, because we only support |
| 2639 | // creating receive streams for SSRC!=0. |
mflodman | 3d7db26 | 2016-04-29 00:57:13 -0700 | [diff] [blame] | 2640 | const uint32_t unsignaled_ssrc = 7011; |
| 2641 | rtc::SetBE32(&packet[8], unsignaled_ssrc); |
solenberg | 7e63ef0 | 2015-11-20 00:19:43 -0800 | [diff] [blame] | 2642 | DeliverPacket(packet, sizeof(packet)); |
mflodman | 3d7db26 | 2016-04-29 00:57:13 -0700 | [diff] [blame] | 2643 | EXPECT_TRUE(GetRecvStream(unsignaled_ssrc).VerifyLastPacket( |
| 2644 | packet, sizeof(packet))); |
| 2645 | EXPECT_EQ(2, call_.GetAudioReceiveStreams().size()); |
| 2646 | |
| 2647 | DeliverPacket(packet, sizeof(packet)); |
| 2648 | EXPECT_EQ(2, GetRecvStream(unsignaled_ssrc).received_packets()); |
| 2649 | |
| 2650 | rtc::SetBE32(&packet[8], signaled_ssrc); |
| 2651 | DeliverPacket(packet, sizeof(packet)); |
| 2652 | EXPECT_EQ(2, GetRecvStream(signaled_ssrc).received_packets()); |
| 2653 | EXPECT_EQ(2, call_.GetAudioReceiveStreams().size()); |
solenberg | 7e63ef0 | 2015-11-20 00:19:43 -0800 | [diff] [blame] | 2654 | } |
| 2655 | |
solenberg | 0a617e2 | 2015-10-20 15:49:38 -0700 | [diff] [blame] | 2656 | // Test that we properly handle failures to add a receive stream. |
| 2657 | TEST_F(WebRtcVoiceEngineTestFake, AddRecvStreamFail) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 2658 | EXPECT_TRUE(SetupChannel()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2659 | voe_.set_fail_create_channel(true); |
solenberg | 8189b02 | 2016-06-14 12:13:00 -0700 | [diff] [blame] | 2660 | EXPECT_FALSE(AddRecvStream(2)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2661 | } |
| 2662 | |
solenberg | 0a617e2 | 2015-10-20 15:49:38 -0700 | [diff] [blame] | 2663 | // Test that we properly handle failures to add a send stream. |
| 2664 | TEST_F(WebRtcVoiceEngineTestFake, AddSendStreamFail) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 2665 | EXPECT_TRUE(SetupChannel()); |
solenberg | 0a617e2 | 2015-10-20 15:49:38 -0700 | [diff] [blame] | 2666 | voe_.set_fail_create_channel(true); |
| 2667 | EXPECT_FALSE(channel_->AddSendStream(cricket::StreamParams::CreateLegacy(2))); |
| 2668 | } |
| 2669 | |
solenberg | 1ac5614 | 2015-10-13 03:58:19 -0700 | [diff] [blame] | 2670 | // Test that AddRecvStream creates new stream. |
| 2671 | TEST_F(WebRtcVoiceEngineTestFake, AddRecvStream) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 2672 | EXPECT_TRUE(SetupRecvStream()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2673 | int channel_num = voe_.GetLastChannel(); |
solenberg | 8189b02 | 2016-06-14 12:13:00 -0700 | [diff] [blame] | 2674 | EXPECT_TRUE(AddRecvStream(1)); |
solenberg | 1ac5614 | 2015-10-13 03:58:19 -0700 | [diff] [blame] | 2675 | EXPECT_NE(channel_num, voe_.GetLastChannel()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2676 | } |
| 2677 | |
| 2678 | // Test that after adding a recv stream, we do not decode more codecs than |
| 2679 | // those previously passed into SetRecvCodecs. |
| 2680 | TEST_F(WebRtcVoiceEngineTestFake, AddRecvStreamUnsupportedCodec) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 2681 | EXPECT_TRUE(SetupSendStream()); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 2682 | cricket::AudioRecvParameters parameters; |
| 2683 | parameters.codecs.push_back(kIsacCodec); |
| 2684 | parameters.codecs.push_back(kPcmuCodec); |
| 2685 | EXPECT_TRUE(channel_->SetRecvParameters(parameters)); |
solenberg | 8189b02 | 2016-06-14 12:13:00 -0700 | [diff] [blame] | 2686 | EXPECT_TRUE(AddRecvStream(kSsrc1)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2687 | int channel_num2 = voe_.GetLastChannel(); |
| 2688 | webrtc::CodecInst gcodec; |
tfarina | 5237aaf | 2015-11-10 23:44:30 -0800 | [diff] [blame] | 2689 | rtc::strcpyn(gcodec.plname, arraysize(gcodec.plname), "opus"); |
minyue@webrtc.org | f9b5c1b | 2015-02-17 12:36:41 +0000 | [diff] [blame] | 2690 | gcodec.plfreq = 48000; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2691 | gcodec.channels = 2; |
| 2692 | EXPECT_EQ(-1, voe_.GetRecPayloadType(channel_num2, gcodec)); |
| 2693 | } |
| 2694 | |
| 2695 | // Test that we properly clean up any streams that were added, even if |
| 2696 | // not explicitly removed. |
| 2697 | TEST_F(WebRtcVoiceEngineTestFake, StreamCleanup) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 2698 | EXPECT_TRUE(SetupSendStream()); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 2699 | EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); |
solenberg | 8189b02 | 2016-06-14 12:13:00 -0700 | [diff] [blame] | 2700 | EXPECT_TRUE(AddRecvStream(1)); |
| 2701 | EXPECT_TRUE(AddRecvStream(2)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2702 | EXPECT_EQ(3, voe_.GetNumChannels()); // default channel + 2 added |
| 2703 | delete channel_; |
| 2704 | channel_ = NULL; |
| 2705 | EXPECT_EQ(0, voe_.GetNumChannels()); |
| 2706 | } |
| 2707 | |
wu@webrtc.org | 7818752 | 2013-10-07 23:32:02 +0000 | [diff] [blame] | 2708 | TEST_F(WebRtcVoiceEngineTestFake, TestAddRecvStreamFailWithZeroSsrc) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 2709 | EXPECT_TRUE(SetupSendStream()); |
solenberg | 8189b02 | 2016-06-14 12:13:00 -0700 | [diff] [blame] | 2710 | EXPECT_FALSE(AddRecvStream(0)); |
wu@webrtc.org | 7818752 | 2013-10-07 23:32:02 +0000 | [diff] [blame] | 2711 | } |
| 2712 | |
| 2713 | TEST_F(WebRtcVoiceEngineTestFake, TestNoLeakingWhenAddRecvStreamFail) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 2714 | EXPECT_TRUE(SetupChannel()); |
solenberg | 8189b02 | 2016-06-14 12:13:00 -0700 | [diff] [blame] | 2715 | EXPECT_TRUE(AddRecvStream(1)); |
solenberg | 1ac5614 | 2015-10-13 03:58:19 -0700 | [diff] [blame] | 2716 | // Manually delete channel to simulate a failure. |
| 2717 | int channel = voe_.GetLastChannel(); |
| 2718 | EXPECT_EQ(0, voe_.DeleteChannel(channel)); |
| 2719 | // Add recv stream 2 should work. |
solenberg | 8189b02 | 2016-06-14 12:13:00 -0700 | [diff] [blame] | 2720 | EXPECT_TRUE(AddRecvStream(2)); |
wu@webrtc.org | 7818752 | 2013-10-07 23:32:02 +0000 | [diff] [blame] | 2721 | int new_channel = voe_.GetLastChannel(); |
solenberg | 1ac5614 | 2015-10-13 03:58:19 -0700 | [diff] [blame] | 2722 | EXPECT_NE(channel, new_channel); |
| 2723 | // The last created channel is deleted too. |
| 2724 | EXPECT_EQ(0, voe_.DeleteChannel(new_channel)); |
wu@webrtc.org | 7818752 | 2013-10-07 23:32:02 +0000 | [diff] [blame] | 2725 | } |
| 2726 | |
wu@webrtc.org | cadf904 | 2013-08-30 21:24:16 +0000 | [diff] [blame] | 2727 | // Test the InsertDtmf on default send stream as caller. |
| 2728 | TEST_F(WebRtcVoiceEngineTestFake, InsertDtmfOnDefaultSendStreamAsCaller) { |
| 2729 | TestInsertDtmf(0, true); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2730 | } |
| 2731 | |
wu@webrtc.org | cadf904 | 2013-08-30 21:24:16 +0000 | [diff] [blame] | 2732 | // Test the InsertDtmf on default send stream as callee |
| 2733 | TEST_F(WebRtcVoiceEngineTestFake, InsertDtmfOnDefaultSendStreamAsCallee) { |
| 2734 | TestInsertDtmf(0, false); |
| 2735 | } |
| 2736 | |
| 2737 | // Test the InsertDtmf on specified send stream as caller. |
| 2738 | TEST_F(WebRtcVoiceEngineTestFake, InsertDtmfOnSendStreamAsCaller) { |
| 2739 | TestInsertDtmf(kSsrc1, true); |
| 2740 | } |
| 2741 | |
| 2742 | // Test the InsertDtmf on specified send stream as callee. |
| 2743 | TEST_F(WebRtcVoiceEngineTestFake, InsertDtmfOnSendStreamAsCallee) { |
| 2744 | TestInsertDtmf(kSsrc1, false); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2745 | } |
| 2746 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2747 | TEST_F(WebRtcVoiceEngineTestFake, TestSetPlayoutError) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 2748 | EXPECT_TRUE(SetupSendStream()); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 2749 | EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); |
solenberg | d53a3f9 | 2016-04-14 13:56:37 -0700 | [diff] [blame] | 2750 | SetSend(channel_, true); |
solenberg | 8189b02 | 2016-06-14 12:13:00 -0700 | [diff] [blame] | 2751 | EXPECT_TRUE(AddRecvStream(2)); |
| 2752 | EXPECT_TRUE(AddRecvStream(3)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2753 | EXPECT_TRUE(channel_->SetPlayout(true)); |
| 2754 | voe_.set_playout_fail_channel(voe_.GetLastChannel() - 1); |
| 2755 | EXPECT_TRUE(channel_->SetPlayout(false)); |
| 2756 | EXPECT_FALSE(channel_->SetPlayout(true)); |
| 2757 | } |
| 2758 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2759 | TEST_F(WebRtcVoiceEngineTestFake, SetAudioOptions) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 2760 | EXPECT_TRUE(SetupSendStream()); |
solenberg | 5b5129a | 2016-04-08 05:35:48 -0700 | [diff] [blame] | 2761 | EXPECT_CALL(adm_, |
| 2762 | BuiltInAECIsAvailable()).Times(9).WillRepeatedly(Return(false)); |
| 2763 | EXPECT_CALL(adm_, |
| 2764 | BuiltInAGCIsAvailable()).Times(4).WillRepeatedly(Return(false)); |
| 2765 | EXPECT_CALL(adm_, |
| 2766 | BuiltInNSIsAvailable()).Times(2).WillRepeatedly(Return(false)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2767 | bool ec_enabled; |
| 2768 | webrtc::EcModes ec_mode; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2769 | webrtc::AecmModes aecm_mode; |
| 2770 | bool cng_enabled; |
| 2771 | bool agc_enabled; |
| 2772 | webrtc::AgcModes agc_mode; |
| 2773 | webrtc::AgcConfig agc_config; |
| 2774 | bool ns_enabled; |
| 2775 | webrtc::NsModes ns_mode; |
| 2776 | bool highpass_filter_enabled; |
| 2777 | bool stereo_swapping_enabled; |
| 2778 | bool typing_detection_enabled; |
| 2779 | voe_.GetEcStatus(ec_enabled, ec_mode); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2780 | voe_.GetAecmMode(aecm_mode, cng_enabled); |
| 2781 | voe_.GetAgcStatus(agc_enabled, agc_mode); |
| 2782 | voe_.GetAgcConfig(agc_config); |
| 2783 | voe_.GetNsStatus(ns_enabled, ns_mode); |
| 2784 | highpass_filter_enabled = voe_.IsHighPassFilterEnabled(); |
| 2785 | stereo_swapping_enabled = voe_.IsStereoChannelSwappingEnabled(); |
| 2786 | voe_.GetTypingDetectionStatus(typing_detection_enabled); |
| 2787 | EXPECT_TRUE(ec_enabled); |
solenberg | 85a0496 | 2015-10-27 03:35:21 -0700 | [diff] [blame] | 2788 | EXPECT_TRUE(voe_.ec_metrics_enabled()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2789 | EXPECT_FALSE(cng_enabled); |
| 2790 | EXPECT_TRUE(agc_enabled); |
| 2791 | EXPECT_EQ(0, agc_config.targetLeveldBOv); |
| 2792 | EXPECT_TRUE(ns_enabled); |
| 2793 | EXPECT_TRUE(highpass_filter_enabled); |
| 2794 | EXPECT_FALSE(stereo_swapping_enabled); |
| 2795 | EXPECT_TRUE(typing_detection_enabled); |
| 2796 | EXPECT_EQ(ec_mode, webrtc::kEcConference); |
| 2797 | EXPECT_EQ(ns_mode, webrtc::kNsHighSuppression); |
solenberg | 246b817 | 2015-12-08 09:50:23 -0800 | [diff] [blame] | 2798 | EXPECT_EQ(50, voe_.GetNetEqCapacity()); |
| 2799 | EXPECT_FALSE(voe_.GetNetEqFastAccelerate()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2800 | |
solenberg | 246b817 | 2015-12-08 09:50:23 -0800 | [diff] [blame] | 2801 | // Nothing set in AudioOptions, so everything should be as default. |
| 2802 | send_parameters_.options = cricket::AudioOptions(); |
| 2803 | EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2804 | voe_.GetEcStatus(ec_enabled, ec_mode); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2805 | voe_.GetAecmMode(aecm_mode, cng_enabled); |
| 2806 | voe_.GetAgcStatus(agc_enabled, agc_mode); |
| 2807 | voe_.GetAgcConfig(agc_config); |
| 2808 | voe_.GetNsStatus(ns_enabled, ns_mode); |
| 2809 | highpass_filter_enabled = voe_.IsHighPassFilterEnabled(); |
| 2810 | stereo_swapping_enabled = voe_.IsStereoChannelSwappingEnabled(); |
| 2811 | voe_.GetTypingDetectionStatus(typing_detection_enabled); |
| 2812 | EXPECT_TRUE(ec_enabled); |
solenberg | 85a0496 | 2015-10-27 03:35:21 -0700 | [diff] [blame] | 2813 | EXPECT_TRUE(voe_.ec_metrics_enabled()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2814 | EXPECT_FALSE(cng_enabled); |
| 2815 | EXPECT_TRUE(agc_enabled); |
| 2816 | EXPECT_EQ(0, agc_config.targetLeveldBOv); |
| 2817 | EXPECT_TRUE(ns_enabled); |
| 2818 | EXPECT_TRUE(highpass_filter_enabled); |
| 2819 | EXPECT_FALSE(stereo_swapping_enabled); |
| 2820 | EXPECT_TRUE(typing_detection_enabled); |
| 2821 | EXPECT_EQ(ec_mode, webrtc::kEcConference); |
| 2822 | EXPECT_EQ(ns_mode, webrtc::kNsHighSuppression); |
solenberg | 246b817 | 2015-12-08 09:50:23 -0800 | [diff] [blame] | 2823 | EXPECT_EQ(50, voe_.GetNetEqCapacity()); |
| 2824 | EXPECT_FALSE(voe_.GetNetEqFastAccelerate()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2825 | |
| 2826 | // Turn echo cancellation off |
solenberg | 246b817 | 2015-12-08 09:50:23 -0800 | [diff] [blame] | 2827 | send_parameters_.options.echo_cancellation = rtc::Optional<bool>(false); |
| 2828 | EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2829 | voe_.GetEcStatus(ec_enabled, ec_mode); |
| 2830 | EXPECT_FALSE(ec_enabled); |
| 2831 | |
| 2832 | // Turn echo cancellation back on, with settings, and make sure |
| 2833 | // nothing else changed. |
solenberg | 246b817 | 2015-12-08 09:50:23 -0800 | [diff] [blame] | 2834 | send_parameters_.options.echo_cancellation = rtc::Optional<bool>(true); |
| 2835 | EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2836 | voe_.GetEcStatus(ec_enabled, ec_mode); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2837 | voe_.GetAecmMode(aecm_mode, cng_enabled); |
| 2838 | voe_.GetAgcStatus(agc_enabled, agc_mode); |
| 2839 | voe_.GetAgcConfig(agc_config); |
| 2840 | voe_.GetNsStatus(ns_enabled, ns_mode); |
| 2841 | highpass_filter_enabled = voe_.IsHighPassFilterEnabled(); |
| 2842 | stereo_swapping_enabled = voe_.IsStereoChannelSwappingEnabled(); |
| 2843 | voe_.GetTypingDetectionStatus(typing_detection_enabled); |
| 2844 | EXPECT_TRUE(ec_enabled); |
solenberg | 85a0496 | 2015-10-27 03:35:21 -0700 | [diff] [blame] | 2845 | EXPECT_TRUE(voe_.ec_metrics_enabled()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2846 | EXPECT_TRUE(agc_enabled); |
| 2847 | EXPECT_EQ(0, agc_config.targetLeveldBOv); |
| 2848 | EXPECT_TRUE(ns_enabled); |
| 2849 | EXPECT_TRUE(highpass_filter_enabled); |
| 2850 | EXPECT_FALSE(stereo_swapping_enabled); |
| 2851 | EXPECT_TRUE(typing_detection_enabled); |
| 2852 | EXPECT_EQ(ec_mode, webrtc::kEcConference); |
| 2853 | EXPECT_EQ(ns_mode, webrtc::kNsHighSuppression); |
| 2854 | |
Bjorn Volcker | bf395c1 | 2015-03-25 22:45:56 +0100 | [diff] [blame] | 2855 | // Turn on delay agnostic aec and make sure nothing change w.r.t. echo |
| 2856 | // control. |
solenberg | 246b817 | 2015-12-08 09:50:23 -0800 | [diff] [blame] | 2857 | send_parameters_.options.delay_agnostic_aec = rtc::Optional<bool>(true); |
| 2858 | EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); |
Bjorn Volcker | bf395c1 | 2015-03-25 22:45:56 +0100 | [diff] [blame] | 2859 | voe_.GetEcStatus(ec_enabled, ec_mode); |
Bjorn Volcker | bf395c1 | 2015-03-25 22:45:56 +0100 | [diff] [blame] | 2860 | voe_.GetAecmMode(aecm_mode, cng_enabled); |
| 2861 | EXPECT_TRUE(ec_enabled); |
solenberg | 85a0496 | 2015-10-27 03:35:21 -0700 | [diff] [blame] | 2862 | EXPECT_TRUE(voe_.ec_metrics_enabled()); |
Bjorn Volcker | bf395c1 | 2015-03-25 22:45:56 +0100 | [diff] [blame] | 2863 | EXPECT_EQ(ec_mode, webrtc::kEcConference); |
| 2864 | |
| 2865 | // Turn off echo cancellation and delay agnostic aec. |
solenberg | 246b817 | 2015-12-08 09:50:23 -0800 | [diff] [blame] | 2866 | send_parameters_.options.delay_agnostic_aec = rtc::Optional<bool>(false); |
| 2867 | send_parameters_.options.extended_filter_aec = rtc::Optional<bool>(false); |
| 2868 | send_parameters_.options.echo_cancellation = rtc::Optional<bool>(false); |
| 2869 | EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); |
Bjorn Volcker | bf395c1 | 2015-03-25 22:45:56 +0100 | [diff] [blame] | 2870 | voe_.GetEcStatus(ec_enabled, ec_mode); |
| 2871 | EXPECT_FALSE(ec_enabled); |
| 2872 | // Turning delay agnostic aec back on should also turn on echo cancellation. |
solenberg | 246b817 | 2015-12-08 09:50:23 -0800 | [diff] [blame] | 2873 | send_parameters_.options.delay_agnostic_aec = rtc::Optional<bool>(true); |
| 2874 | EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); |
Bjorn Volcker | bf395c1 | 2015-03-25 22:45:56 +0100 | [diff] [blame] | 2875 | voe_.GetEcStatus(ec_enabled, ec_mode); |
Bjorn Volcker | bf395c1 | 2015-03-25 22:45:56 +0100 | [diff] [blame] | 2876 | EXPECT_TRUE(ec_enabled); |
solenberg | 85a0496 | 2015-10-27 03:35:21 -0700 | [diff] [blame] | 2877 | EXPECT_TRUE(voe_.ec_metrics_enabled()); |
Bjorn Volcker | bf395c1 | 2015-03-25 22:45:56 +0100 | [diff] [blame] | 2878 | EXPECT_EQ(ec_mode, webrtc::kEcConference); |
| 2879 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2880 | // Turn off AGC |
solenberg | 246b817 | 2015-12-08 09:50:23 -0800 | [diff] [blame] | 2881 | send_parameters_.options.auto_gain_control = rtc::Optional<bool>(false); |
| 2882 | EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2883 | voe_.GetAgcStatus(agc_enabled, agc_mode); |
| 2884 | EXPECT_FALSE(agc_enabled); |
| 2885 | |
| 2886 | // Turn AGC back on |
solenberg | 246b817 | 2015-12-08 09:50:23 -0800 | [diff] [blame] | 2887 | send_parameters_.options.auto_gain_control = rtc::Optional<bool>(true); |
| 2888 | send_parameters_.options.adjust_agc_delta = rtc::Optional<int>(); |
| 2889 | EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2890 | voe_.GetAgcStatus(agc_enabled, agc_mode); |
| 2891 | EXPECT_TRUE(agc_enabled); |
| 2892 | voe_.GetAgcConfig(agc_config); |
| 2893 | EXPECT_EQ(0, agc_config.targetLeveldBOv); |
| 2894 | |
| 2895 | // Turn off other options (and stereo swapping on). |
solenberg | 246b817 | 2015-12-08 09:50:23 -0800 | [diff] [blame] | 2896 | send_parameters_.options.noise_suppression = rtc::Optional<bool>(false); |
| 2897 | send_parameters_.options.highpass_filter = rtc::Optional<bool>(false); |
| 2898 | send_parameters_.options.typing_detection = rtc::Optional<bool>(false); |
| 2899 | send_parameters_.options.stereo_swapping = rtc::Optional<bool>(true); |
| 2900 | EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2901 | voe_.GetNsStatus(ns_enabled, ns_mode); |
| 2902 | highpass_filter_enabled = voe_.IsHighPassFilterEnabled(); |
| 2903 | stereo_swapping_enabled = voe_.IsStereoChannelSwappingEnabled(); |
| 2904 | voe_.GetTypingDetectionStatus(typing_detection_enabled); |
| 2905 | EXPECT_FALSE(ns_enabled); |
| 2906 | EXPECT_FALSE(highpass_filter_enabled); |
| 2907 | EXPECT_FALSE(typing_detection_enabled); |
| 2908 | EXPECT_TRUE(stereo_swapping_enabled); |
| 2909 | |
solenberg | 1ac5614 | 2015-10-13 03:58:19 -0700 | [diff] [blame] | 2910 | // Set options again to ensure it has no impact. |
solenberg | 246b817 | 2015-12-08 09:50:23 -0800 | [diff] [blame] | 2911 | EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2912 | voe_.GetEcStatus(ec_enabled, ec_mode); |
| 2913 | voe_.GetNsStatus(ns_enabled, ns_mode); |
| 2914 | EXPECT_TRUE(ec_enabled); |
| 2915 | EXPECT_EQ(webrtc::kEcConference, ec_mode); |
| 2916 | EXPECT_FALSE(ns_enabled); |
| 2917 | EXPECT_EQ(webrtc::kNsHighSuppression, ns_mode); |
| 2918 | } |
| 2919 | |
mallinath@webrtc.org | a27be8e | 2013-09-27 23:04:10 +0000 | [diff] [blame] | 2920 | TEST_F(WebRtcVoiceEngineTestFake, DefaultOptions) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 2921 | EXPECT_TRUE(SetupSendStream()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2922 | |
| 2923 | bool ec_enabled; |
| 2924 | webrtc::EcModes ec_mode; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2925 | bool agc_enabled; |
| 2926 | webrtc::AgcModes agc_mode; |
| 2927 | bool ns_enabled; |
| 2928 | webrtc::NsModes ns_mode; |
| 2929 | bool highpass_filter_enabled; |
| 2930 | bool stereo_swapping_enabled; |
| 2931 | bool typing_detection_enabled; |
| 2932 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2933 | voe_.GetEcStatus(ec_enabled, ec_mode); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2934 | voe_.GetAgcStatus(agc_enabled, agc_mode); |
| 2935 | voe_.GetNsStatus(ns_enabled, ns_mode); |
| 2936 | highpass_filter_enabled = voe_.IsHighPassFilterEnabled(); |
| 2937 | stereo_swapping_enabled = voe_.IsStereoChannelSwappingEnabled(); |
| 2938 | voe_.GetTypingDetectionStatus(typing_detection_enabled); |
| 2939 | EXPECT_TRUE(ec_enabled); |
| 2940 | EXPECT_TRUE(agc_enabled); |
| 2941 | EXPECT_TRUE(ns_enabled); |
| 2942 | EXPECT_TRUE(highpass_filter_enabled); |
mallinath@webrtc.org | a27be8e | 2013-09-27 23:04:10 +0000 | [diff] [blame] | 2943 | EXPECT_TRUE(typing_detection_enabled); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2944 | EXPECT_FALSE(stereo_swapping_enabled); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2945 | } |
| 2946 | |
| 2947 | TEST_F(WebRtcVoiceEngineTestFake, InitDoesNotOverwriteDefaultAgcConfig) { |
| 2948 | webrtc::AgcConfig set_config = {0}; |
| 2949 | set_config.targetLeveldBOv = 3; |
| 2950 | set_config.digitalCompressionGaindB = 9; |
| 2951 | set_config.limiterEnable = true; |
| 2952 | EXPECT_EQ(0, voe_.SetAgcConfig(set_config)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2953 | |
| 2954 | webrtc::AgcConfig config = {0}; |
| 2955 | EXPECT_EQ(0, voe_.GetAgcConfig(config)); |
| 2956 | EXPECT_EQ(set_config.targetLeveldBOv, config.targetLeveldBOv); |
| 2957 | EXPECT_EQ(set_config.digitalCompressionGaindB, |
| 2958 | config.digitalCompressionGaindB); |
| 2959 | EXPECT_EQ(set_config.limiterEnable, config.limiterEnable); |
| 2960 | } |
| 2961 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2962 | TEST_F(WebRtcVoiceEngineTestFake, SetOptionOverridesViaChannels) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 2963 | EXPECT_TRUE(SetupSendStream()); |
solenberg | 5b5129a | 2016-04-08 05:35:48 -0700 | [diff] [blame] | 2964 | EXPECT_CALL(adm_, |
| 2965 | BuiltInAECIsAvailable()).Times(9).WillRepeatedly(Return(false)); |
| 2966 | EXPECT_CALL(adm_, |
| 2967 | BuiltInAGCIsAvailable()).Times(9).WillRepeatedly(Return(false)); |
| 2968 | EXPECT_CALL(adm_, |
| 2969 | BuiltInNSIsAvailable()).Times(9).WillRepeatedly(Return(false)); |
| 2970 | |
kwiberg | 686a8ef | 2016-02-26 03:00:35 -0800 | [diff] [blame] | 2971 | std::unique_ptr<cricket::WebRtcVoiceMediaChannel> channel1( |
solenberg | bc37fc8 | 2016-04-04 09:54:44 -0700 | [diff] [blame] | 2972 | static_cast<cricket::WebRtcVoiceMediaChannel*>(engine_->CreateChannel( |
nisse | 51542be | 2016-02-12 02:27:06 -0800 | [diff] [blame] | 2973 | &call_, cricket::MediaConfig(), cricket::AudioOptions()))); |
kwiberg | 686a8ef | 2016-02-26 03:00:35 -0800 | [diff] [blame] | 2974 | std::unique_ptr<cricket::WebRtcVoiceMediaChannel> channel2( |
solenberg | bc37fc8 | 2016-04-04 09:54:44 -0700 | [diff] [blame] | 2975 | static_cast<cricket::WebRtcVoiceMediaChannel*>(engine_->CreateChannel( |
nisse | 51542be | 2016-02-12 02:27:06 -0800 | [diff] [blame] | 2976 | &call_, cricket::MediaConfig(), cricket::AudioOptions()))); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2977 | |
| 2978 | // Have to add a stream to make SetSend work. |
| 2979 | cricket::StreamParams stream1; |
| 2980 | stream1.ssrcs.push_back(1); |
| 2981 | channel1->AddSendStream(stream1); |
| 2982 | cricket::StreamParams stream2; |
| 2983 | stream2.ssrcs.push_back(2); |
| 2984 | channel2->AddSendStream(stream2); |
| 2985 | |
| 2986 | // AEC and AGC and NS |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 2987 | cricket::AudioSendParameters parameters_options_all = send_parameters_; |
Karl Wiberg | be57983 | 2015-11-10 22:34:18 +0100 | [diff] [blame] | 2988 | parameters_options_all.options.echo_cancellation = rtc::Optional<bool>(true); |
| 2989 | parameters_options_all.options.auto_gain_control = rtc::Optional<bool>(true); |
| 2990 | parameters_options_all.options.noise_suppression = rtc::Optional<bool>(true); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 2991 | ASSERT_TRUE(channel1->SetSendParameters(parameters_options_all)); |
| 2992 | EXPECT_EQ(parameters_options_all.options, channel1->options()); |
| 2993 | ASSERT_TRUE(channel2->SetSendParameters(parameters_options_all)); |
| 2994 | EXPECT_EQ(parameters_options_all.options, channel2->options()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2995 | |
| 2996 | // unset NS |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 2997 | cricket::AudioSendParameters parameters_options_no_ns = send_parameters_; |
Karl Wiberg | be57983 | 2015-11-10 22:34:18 +0100 | [diff] [blame] | 2998 | parameters_options_no_ns.options.noise_suppression = |
| 2999 | rtc::Optional<bool>(false); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 3000 | ASSERT_TRUE(channel1->SetSendParameters(parameters_options_no_ns)); |
| 3001 | cricket::AudioOptions expected_options = parameters_options_all.options; |
Karl Wiberg | be57983 | 2015-11-10 22:34:18 +0100 | [diff] [blame] | 3002 | expected_options.echo_cancellation = rtc::Optional<bool>(true); |
| 3003 | expected_options.auto_gain_control = rtc::Optional<bool>(true); |
| 3004 | expected_options.noise_suppression = rtc::Optional<bool>(false); |
solenberg | 66f4339 | 2015-09-09 01:36:22 -0700 | [diff] [blame] | 3005 | EXPECT_EQ(expected_options, channel1->options()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 3006 | |
| 3007 | // unset AGC |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 3008 | cricket::AudioSendParameters parameters_options_no_agc = send_parameters_; |
Karl Wiberg | be57983 | 2015-11-10 22:34:18 +0100 | [diff] [blame] | 3009 | parameters_options_no_agc.options.auto_gain_control = |
| 3010 | rtc::Optional<bool>(false); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 3011 | ASSERT_TRUE(channel2->SetSendParameters(parameters_options_no_agc)); |
Karl Wiberg | be57983 | 2015-11-10 22:34:18 +0100 | [diff] [blame] | 3012 | expected_options.echo_cancellation = rtc::Optional<bool>(true); |
| 3013 | expected_options.auto_gain_control = rtc::Optional<bool>(false); |
| 3014 | expected_options.noise_suppression = rtc::Optional<bool>(true); |
solenberg | 66f4339 | 2015-09-09 01:36:22 -0700 | [diff] [blame] | 3015 | EXPECT_EQ(expected_options, channel2->options()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 3016 | |
solenberg | 246b817 | 2015-12-08 09:50:23 -0800 | [diff] [blame] | 3017 | ASSERT_TRUE(channel_->SetSendParameters(parameters_options_all)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 3018 | bool ec_enabled; |
| 3019 | webrtc::EcModes ec_mode; |
| 3020 | bool agc_enabled; |
| 3021 | webrtc::AgcModes agc_mode; |
| 3022 | bool ns_enabled; |
| 3023 | webrtc::NsModes ns_mode; |
| 3024 | voe_.GetEcStatus(ec_enabled, ec_mode); |
| 3025 | voe_.GetAgcStatus(agc_enabled, agc_mode); |
| 3026 | voe_.GetNsStatus(ns_enabled, ns_mode); |
| 3027 | EXPECT_TRUE(ec_enabled); |
| 3028 | EXPECT_TRUE(agc_enabled); |
| 3029 | EXPECT_TRUE(ns_enabled); |
| 3030 | |
solenberg | d53a3f9 | 2016-04-14 13:56:37 -0700 | [diff] [blame] | 3031 | SetSend(channel1.get(), true); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 3032 | voe_.GetEcStatus(ec_enabled, ec_mode); |
| 3033 | voe_.GetAgcStatus(agc_enabled, agc_mode); |
| 3034 | voe_.GetNsStatus(ns_enabled, ns_mode); |
| 3035 | EXPECT_TRUE(ec_enabled); |
| 3036 | EXPECT_TRUE(agc_enabled); |
| 3037 | EXPECT_FALSE(ns_enabled); |
| 3038 | |
solenberg | d53a3f9 | 2016-04-14 13:56:37 -0700 | [diff] [blame] | 3039 | SetSend(channel2.get(), true); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 3040 | voe_.GetEcStatus(ec_enabled, ec_mode); |
| 3041 | voe_.GetAgcStatus(agc_enabled, agc_mode); |
| 3042 | voe_.GetNsStatus(ns_enabled, ns_mode); |
| 3043 | EXPECT_TRUE(ec_enabled); |
| 3044 | EXPECT_FALSE(agc_enabled); |
| 3045 | EXPECT_TRUE(ns_enabled); |
| 3046 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 3047 | // Make sure settings take effect while we are sending. |
solenberg | 246b817 | 2015-12-08 09:50:23 -0800 | [diff] [blame] | 3048 | ASSERT_TRUE(channel_->SetSendParameters(parameters_options_all)); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 3049 | cricket::AudioSendParameters parameters_options_no_agc_nor_ns = |
| 3050 | send_parameters_; |
kwiberg | 102c6a6 | 2015-10-30 02:47:38 -0700 | [diff] [blame] | 3051 | parameters_options_no_agc_nor_ns.options.auto_gain_control = |
Karl Wiberg | be57983 | 2015-11-10 22:34:18 +0100 | [diff] [blame] | 3052 | rtc::Optional<bool>(false); |
kwiberg | 102c6a6 | 2015-10-30 02:47:38 -0700 | [diff] [blame] | 3053 | parameters_options_no_agc_nor_ns.options.noise_suppression = |
Karl Wiberg | be57983 | 2015-11-10 22:34:18 +0100 | [diff] [blame] | 3054 | rtc::Optional<bool>(false); |
Taylor Brandstetter | 1a018dc | 2016-03-08 12:37:39 -0800 | [diff] [blame] | 3055 | channel2->SetSend(true); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 3056 | channel2->SetSendParameters(parameters_options_no_agc_nor_ns); |
Karl Wiberg | be57983 | 2015-11-10 22:34:18 +0100 | [diff] [blame] | 3057 | expected_options.echo_cancellation = rtc::Optional<bool>(true); |
| 3058 | expected_options.auto_gain_control = rtc::Optional<bool>(false); |
| 3059 | expected_options.noise_suppression = rtc::Optional<bool>(false); |
solenberg | 66f4339 | 2015-09-09 01:36:22 -0700 | [diff] [blame] | 3060 | EXPECT_EQ(expected_options, channel2->options()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 3061 | voe_.GetEcStatus(ec_enabled, ec_mode); |
| 3062 | voe_.GetAgcStatus(agc_enabled, agc_mode); |
| 3063 | voe_.GetNsStatus(ns_enabled, ns_mode); |
| 3064 | EXPECT_TRUE(ec_enabled); |
| 3065 | EXPECT_FALSE(agc_enabled); |
| 3066 | EXPECT_FALSE(ns_enabled); |
| 3067 | } |
| 3068 | |
wu@webrtc.org | de30501 | 2013-10-31 15:40:38 +0000 | [diff] [blame] | 3069 | // This test verifies DSCP settings are properly applied on voice media channel. |
| 3070 | TEST_F(WebRtcVoiceEngineTestFake, TestSetDscpOptions) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 3071 | EXPECT_TRUE(SetupSendStream()); |
nisse | 51542be | 2016-02-12 02:27:06 -0800 | [diff] [blame] | 3072 | cricket::FakeNetworkInterface network_interface; |
| 3073 | cricket::MediaConfig config; |
kwiberg | 686a8ef | 2016-02-26 03:00:35 -0800 | [diff] [blame] | 3074 | std::unique_ptr<cricket::VoiceMediaChannel> channel; |
nisse | 51542be | 2016-02-12 02:27:06 -0800 | [diff] [blame] | 3075 | |
solenberg | bc37fc8 | 2016-04-04 09:54:44 -0700 | [diff] [blame] | 3076 | channel.reset( |
| 3077 | engine_->CreateChannel(&call_, config, cricket::AudioOptions())); |
nisse | 51542be | 2016-02-12 02:27:06 -0800 | [diff] [blame] | 3078 | channel->SetInterface(&network_interface); |
| 3079 | // Default value when DSCP is disabled should be DSCP_DEFAULT. |
| 3080 | EXPECT_EQ(rtc::DSCP_DEFAULT, network_interface.dscp()); |
| 3081 | |
| 3082 | config.enable_dscp = true; |
solenberg | bc37fc8 | 2016-04-04 09:54:44 -0700 | [diff] [blame] | 3083 | channel.reset( |
| 3084 | engine_->CreateChannel(&call_, config, cricket::AudioOptions())); |
nisse | 51542be | 2016-02-12 02:27:06 -0800 | [diff] [blame] | 3085 | channel->SetInterface(&network_interface); |
| 3086 | EXPECT_EQ(rtc::DSCP_EF, network_interface.dscp()); |
| 3087 | |
| 3088 | // Verify that setting the option to false resets the |
| 3089 | // DiffServCodePoint. |
| 3090 | config.enable_dscp = false; |
solenberg | bc37fc8 | 2016-04-04 09:54:44 -0700 | [diff] [blame] | 3091 | channel.reset( |
| 3092 | engine_->CreateChannel(&call_, config, cricket::AudioOptions())); |
nisse | 51542be | 2016-02-12 02:27:06 -0800 | [diff] [blame] | 3093 | channel->SetInterface(&network_interface); |
| 3094 | // Default value when DSCP is disabled should be DSCP_DEFAULT. |
| 3095 | EXPECT_EQ(rtc::DSCP_DEFAULT, network_interface.dscp()); |
| 3096 | |
| 3097 | channel->SetInterface(nullptr); |
wu@webrtc.org | de30501 | 2013-10-31 15:40:38 +0000 | [diff] [blame] | 3098 | } |
| 3099 | |
solenberg | 1ac5614 | 2015-10-13 03:58:19 -0700 | [diff] [blame] | 3100 | TEST_F(WebRtcVoiceEngineTestFake, TestGetReceiveChannelId) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 3101 | EXPECT_TRUE(SetupChannel()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 3102 | cricket::WebRtcVoiceMediaChannel* media_channel = |
| 3103 | static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_); |
solenberg | 1ac5614 | 2015-10-13 03:58:19 -0700 | [diff] [blame] | 3104 | EXPECT_EQ(-1, media_channel->GetReceiveChannelId(0)); |
solenberg | 8189b02 | 2016-06-14 12:13:00 -0700 | [diff] [blame] | 3105 | EXPECT_TRUE(AddRecvStream(kSsrc1)); |
solenberg | 1ac5614 | 2015-10-13 03:58:19 -0700 | [diff] [blame] | 3106 | int channel_id = voe_.GetLastChannel(); |
| 3107 | EXPECT_EQ(channel_id, media_channel->GetReceiveChannelId(kSsrc1)); |
| 3108 | EXPECT_EQ(-1, media_channel->GetReceiveChannelId(kSsrc2)); |
solenberg | 8189b02 | 2016-06-14 12:13:00 -0700 | [diff] [blame] | 3109 | EXPECT_TRUE(AddRecvStream(kSsrc2)); |
solenberg | 1ac5614 | 2015-10-13 03:58:19 -0700 | [diff] [blame] | 3110 | int channel_id2 = voe_.GetLastChannel(); |
| 3111 | EXPECT_EQ(channel_id2, media_channel->GetReceiveChannelId(kSsrc2)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 3112 | } |
| 3113 | |
solenberg | 1ac5614 | 2015-10-13 03:58:19 -0700 | [diff] [blame] | 3114 | TEST_F(WebRtcVoiceEngineTestFake, TestGetSendChannelId) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 3115 | EXPECT_TRUE(SetupChannel()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 3116 | cricket::WebRtcVoiceMediaChannel* media_channel = |
solenberg | 1ac5614 | 2015-10-13 03:58:19 -0700 | [diff] [blame] | 3117 | static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_); |
| 3118 | EXPECT_EQ(-1, media_channel->GetSendChannelId(0)); |
| 3119 | EXPECT_TRUE(channel_->AddSendStream( |
| 3120 | cricket::StreamParams::CreateLegacy(kSsrc1))); |
| 3121 | int channel_id = voe_.GetLastChannel(); |
| 3122 | EXPECT_EQ(channel_id, media_channel->GetSendChannelId(kSsrc1)); |
| 3123 | EXPECT_EQ(-1, media_channel->GetSendChannelId(kSsrc2)); |
| 3124 | EXPECT_TRUE(channel_->AddSendStream( |
| 3125 | cricket::StreamParams::CreateLegacy(kSsrc2))); |
| 3126 | int channel_id2 = voe_.GetLastChannel(); |
| 3127 | EXPECT_EQ(channel_id2, media_channel->GetSendChannelId(kSsrc2)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 3128 | } |
| 3129 | |
solenberg | 4bac9c5 | 2015-10-09 02:32:53 -0700 | [diff] [blame] | 3130 | TEST_F(WebRtcVoiceEngineTestFake, SetOutputVolume) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 3131 | EXPECT_TRUE(SetupChannel()); |
solenberg | 4bac9c5 | 2015-10-09 02:32:53 -0700 | [diff] [blame] | 3132 | EXPECT_FALSE(channel_->SetOutputVolume(kSsrc2, 0.5)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 3133 | cricket::StreamParams stream; |
| 3134 | stream.ssrcs.push_back(kSsrc2); |
| 3135 | EXPECT_TRUE(channel_->AddRecvStream(stream)); |
solenberg | 1ac5614 | 2015-10-13 03:58:19 -0700 | [diff] [blame] | 3136 | int channel_id = voe_.GetLastChannel(); |
solenberg | 4bac9c5 | 2015-10-09 02:32:53 -0700 | [diff] [blame] | 3137 | EXPECT_TRUE(channel_->SetOutputVolume(kSsrc2, 3)); |
solenberg | 1ac5614 | 2015-10-13 03:58:19 -0700 | [diff] [blame] | 3138 | float scale = 0; |
| 3139 | EXPECT_EQ(0, voe_.GetChannelOutputVolumeScaling(channel_id, scale)); |
| 3140 | EXPECT_DOUBLE_EQ(3, scale); |
| 3141 | } |
| 3142 | |
| 3143 | TEST_F(WebRtcVoiceEngineTestFake, SetOutputVolumeDefaultRecvStream) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 3144 | EXPECT_TRUE(SetupChannel()); |
solenberg | 1ac5614 | 2015-10-13 03:58:19 -0700 | [diff] [blame] | 3145 | EXPECT_TRUE(channel_->SetOutputVolume(0, 2)); |
| 3146 | DeliverPacket(kPcmuFrame, sizeof(kPcmuFrame)); |
| 3147 | int channel_id = voe_.GetLastChannel(); |
| 3148 | float scale = 0; |
| 3149 | EXPECT_EQ(0, voe_.GetChannelOutputVolumeScaling(channel_id, scale)); |
| 3150 | EXPECT_DOUBLE_EQ(2, scale); |
| 3151 | EXPECT_TRUE(channel_->SetOutputVolume(0, 3)); |
solenberg | bb741b3 | 2015-09-07 03:56:38 -0700 | [diff] [blame] | 3152 | EXPECT_EQ(0, voe_.GetChannelOutputVolumeScaling(channel_id, scale)); |
solenberg | 4bac9c5 | 2015-10-09 02:32:53 -0700 | [diff] [blame] | 3153 | EXPECT_DOUBLE_EQ(3, scale); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 3154 | } |
| 3155 | |
pbos | 8fc7fa7 | 2015-07-15 08:02:58 -0700 | [diff] [blame] | 3156 | TEST_F(WebRtcVoiceEngineTestFake, SetsSyncGroupFromSyncLabel) { |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 3157 | const uint32_t kAudioSsrc = 123; |
pbos | 8fc7fa7 | 2015-07-15 08:02:58 -0700 | [diff] [blame] | 3158 | const std::string kSyncLabel = "AvSyncLabel"; |
| 3159 | |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 3160 | EXPECT_TRUE(SetupSendStream()); |
pbos | 8fc7fa7 | 2015-07-15 08:02:58 -0700 | [diff] [blame] | 3161 | cricket::StreamParams sp = cricket::StreamParams::CreateLegacy(kAudioSsrc); |
| 3162 | sp.sync_label = kSyncLabel; |
| 3163 | // Creating two channels to make sure that sync label is set properly for both |
| 3164 | // the default voice channel and following ones. |
| 3165 | EXPECT_TRUE(channel_->AddRecvStream(sp)); |
| 3166 | sp.ssrcs[0] += 1; |
| 3167 | EXPECT_TRUE(channel_->AddRecvStream(sp)); |
| 3168 | |
Fredrik Solenberg | 709ed67 | 2015-09-15 12:26:33 +0200 | [diff] [blame] | 3169 | ASSERT_EQ(2, call_.GetAudioReceiveStreams().size()); |
pbos | 8fc7fa7 | 2015-07-15 08:02:58 -0700 | [diff] [blame] | 3170 | EXPECT_EQ(kSyncLabel, |
Fredrik Solenberg | 709ed67 | 2015-09-15 12:26:33 +0200 | [diff] [blame] | 3171 | call_.GetAudioReceiveStream(kAudioSsrc)->GetConfig().sync_group) |
pbos | 8fc7fa7 | 2015-07-15 08:02:58 -0700 | [diff] [blame] | 3172 | << "SyncGroup should be set based on sync_label"; |
| 3173 | EXPECT_EQ(kSyncLabel, |
Fredrik Solenberg | 709ed67 | 2015-09-15 12:26:33 +0200 | [diff] [blame] | 3174 | call_.GetAudioReceiveStream(kAudioSsrc + 1)->GetConfig().sync_group) |
pbos | 8fc7fa7 | 2015-07-15 08:02:58 -0700 | [diff] [blame] | 3175 | << "SyncGroup should be set based on sync_label"; |
pbos | 8fc7fa7 | 2015-07-15 08:02:58 -0700 | [diff] [blame] | 3176 | } |
| 3177 | |
solenberg | 3a94154 | 2015-11-16 07:34:50 -0800 | [diff] [blame] | 3178 | // TODO(solenberg): Remove, once recv streams are configured through Call. |
| 3179 | // (This is then covered by TestSetRecvRtpHeaderExtensions.) |
pbos | 6bb1b6e | 2015-07-24 07:10:18 -0700 | [diff] [blame] | 3180 | TEST_F(WebRtcVoiceEngineTestFake, ConfiguresAudioReceiveStreamRtpExtensions) { |
Fredrik Solenberg | 4b60c73 | 2015-05-07 14:07:48 +0200 | [diff] [blame] | 3181 | // Test that setting the header extensions results in the expected state |
| 3182 | // changes on an associated Call. |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 3183 | std::vector<uint32_t> ssrcs; |
Fredrik Solenberg | 4b60c73 | 2015-05-07 14:07:48 +0200 | [diff] [blame] | 3184 | ssrcs.push_back(223); |
| 3185 | ssrcs.push_back(224); |
| 3186 | |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 3187 | EXPECT_TRUE(SetupSendStream()); |
Fredrik Solenberg | 4b60c73 | 2015-05-07 14:07:48 +0200 | [diff] [blame] | 3188 | cricket::WebRtcVoiceMediaChannel* media_channel = |
| 3189 | static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 3190 | EXPECT_TRUE(media_channel->SetSendParameters(send_parameters_)); |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 3191 | for (uint32_t ssrc : ssrcs) { |
Fredrik Solenberg | 4b60c73 | 2015-05-07 14:07:48 +0200 | [diff] [blame] | 3192 | EXPECT_TRUE(media_channel->AddRecvStream( |
| 3193 | cricket::StreamParams::CreateLegacy(ssrc))); |
| 3194 | } |
| 3195 | |
Fredrik Solenberg | 709ed67 | 2015-09-15 12:26:33 +0200 | [diff] [blame] | 3196 | EXPECT_EQ(2, call_.GetAudioReceiveStreams().size()); |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 3197 | for (uint32_t ssrc : ssrcs) { |
Fredrik Solenberg | 709ed67 | 2015-09-15 12:26:33 +0200 | [diff] [blame] | 3198 | const auto* s = call_.GetAudioReceiveStream(ssrc); |
Fredrik Solenberg | 4b60c73 | 2015-05-07 14:07:48 +0200 | [diff] [blame] | 3199 | EXPECT_NE(nullptr, s); |
| 3200 | EXPECT_EQ(0, s->GetConfig().rtp.extensions.size()); |
| 3201 | } |
| 3202 | |
| 3203 | // Set up receive extensions. |
solenberg | bc37fc8 | 2016-04-04 09:54:44 -0700 | [diff] [blame] | 3204 | cricket::RtpCapabilities capabilities = engine_->GetCapabilities(); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 3205 | cricket::AudioRecvParameters recv_parameters; |
Stefan Holmer | 9d69c3f | 2015-12-07 10:45:43 +0100 | [diff] [blame] | 3206 | recv_parameters.extensions = capabilities.header_extensions; |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 3207 | channel_->SetRecvParameters(recv_parameters); |
Fredrik Solenberg | 709ed67 | 2015-09-15 12:26:33 +0200 | [diff] [blame] | 3208 | EXPECT_EQ(2, call_.GetAudioReceiveStreams().size()); |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 3209 | for (uint32_t ssrc : ssrcs) { |
Fredrik Solenberg | 709ed67 | 2015-09-15 12:26:33 +0200 | [diff] [blame] | 3210 | const auto* s = call_.GetAudioReceiveStream(ssrc); |
Fredrik Solenberg | 4b60c73 | 2015-05-07 14:07:48 +0200 | [diff] [blame] | 3211 | EXPECT_NE(nullptr, s); |
| 3212 | const auto& s_exts = s->GetConfig().rtp.extensions; |
Stefan Holmer | 9d69c3f | 2015-12-07 10:45:43 +0100 | [diff] [blame] | 3213 | EXPECT_EQ(capabilities.header_extensions.size(), s_exts.size()); |
| 3214 | for (const auto& e_ext : capabilities.header_extensions) { |
Fredrik Solenberg | 4b60c73 | 2015-05-07 14:07:48 +0200 | [diff] [blame] | 3215 | for (const auto& s_ext : s_exts) { |
| 3216 | if (e_ext.id == s_ext.id) { |
isheriff | 6f8d686 | 2016-05-26 11:24:55 -0700 | [diff] [blame] | 3217 | EXPECT_EQ(e_ext.uri, s_ext.uri); |
Fredrik Solenberg | 4b60c73 | 2015-05-07 14:07:48 +0200 | [diff] [blame] | 3218 | } |
| 3219 | } |
| 3220 | } |
| 3221 | } |
| 3222 | |
| 3223 | // Disable receive extensions. |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 3224 | channel_->SetRecvParameters(cricket::AudioRecvParameters()); |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 3225 | for (uint32_t ssrc : ssrcs) { |
Fredrik Solenberg | 709ed67 | 2015-09-15 12:26:33 +0200 | [diff] [blame] | 3226 | const auto* s = call_.GetAudioReceiveStream(ssrc); |
Fredrik Solenberg | 4b60c73 | 2015-05-07 14:07:48 +0200 | [diff] [blame] | 3227 | EXPECT_NE(nullptr, s); |
| 3228 | EXPECT_EQ(0, s->GetConfig().rtp.extensions.size()); |
| 3229 | } |
Fredrik Solenberg | 4b60c73 | 2015-05-07 14:07:48 +0200 | [diff] [blame] | 3230 | } |
| 3231 | |
| 3232 | TEST_F(WebRtcVoiceEngineTestFake, DeliverAudioPacket_Call) { |
| 3233 | // Test that packets are forwarded to the Call when configured accordingly. |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 3234 | const uint32_t kAudioSsrc = 1; |
jbauch | eec21bd | 2016-03-20 06:15:43 -0700 | [diff] [blame] | 3235 | rtc::CopyOnWriteBuffer kPcmuPacket(kPcmuFrame, sizeof(kPcmuFrame)); |
Fredrik Solenberg | 4b60c73 | 2015-05-07 14:07:48 +0200 | [diff] [blame] | 3236 | static const unsigned char kRtcp[] = { |
| 3237 | 0x80, 0xc9, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, |
| 3238 | 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, |
| 3239 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
| 3240 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 |
| 3241 | }; |
jbauch | eec21bd | 2016-03-20 06:15:43 -0700 | [diff] [blame] | 3242 | rtc::CopyOnWriteBuffer kRtcpPacket(kRtcp, sizeof(kRtcp)); |
Fredrik Solenberg | 4b60c73 | 2015-05-07 14:07:48 +0200 | [diff] [blame] | 3243 | |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 3244 | EXPECT_TRUE(SetupSendStream()); |
Fredrik Solenberg | 4b60c73 | 2015-05-07 14:07:48 +0200 | [diff] [blame] | 3245 | cricket::WebRtcVoiceMediaChannel* media_channel = |
| 3246 | static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 3247 | EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); |
Fredrik Solenberg | 4b60c73 | 2015-05-07 14:07:48 +0200 | [diff] [blame] | 3248 | EXPECT_TRUE(media_channel->AddRecvStream( |
| 3249 | cricket::StreamParams::CreateLegacy(kAudioSsrc))); |
| 3250 | |
Fredrik Solenberg | 709ed67 | 2015-09-15 12:26:33 +0200 | [diff] [blame] | 3251 | EXPECT_EQ(1, call_.GetAudioReceiveStreams().size()); |
Fredrik Solenberg | 4b60c73 | 2015-05-07 14:07:48 +0200 | [diff] [blame] | 3252 | const cricket::FakeAudioReceiveStream* s = |
Fredrik Solenberg | 709ed67 | 2015-09-15 12:26:33 +0200 | [diff] [blame] | 3253 | call_.GetAudioReceiveStream(kAudioSsrc); |
Fredrik Solenberg | 4b60c73 | 2015-05-07 14:07:48 +0200 | [diff] [blame] | 3254 | EXPECT_EQ(0, s->received_packets()); |
| 3255 | channel_->OnPacketReceived(&kPcmuPacket, rtc::PacketTime()); |
| 3256 | EXPECT_EQ(1, s->received_packets()); |
| 3257 | channel_->OnRtcpReceived(&kRtcpPacket, rtc::PacketTime()); |
| 3258 | EXPECT_EQ(2, s->received_packets()); |
Fredrik Solenberg | 4b60c73 | 2015-05-07 14:07:48 +0200 | [diff] [blame] | 3259 | } |
Minyue | 2013aec | 2015-05-13 14:14:42 +0200 | [diff] [blame] | 3260 | |
solenberg | 0a617e2 | 2015-10-20 15:49:38 -0700 | [diff] [blame] | 3261 | // All receive channels should be associated with the first send channel, |
solenberg | 1ac5614 | 2015-10-13 03:58:19 -0700 | [diff] [blame] | 3262 | // since they do not send RTCP SR. |
solenberg | 0a617e2 | 2015-10-20 15:49:38 -0700 | [diff] [blame] | 3263 | TEST_F(WebRtcVoiceEngineTestFake, AssociateFirstSendChannel) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 3264 | EXPECT_TRUE(SetupSendStream()); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 3265 | EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); |
solenberg | 8fb30c3 | 2015-10-13 03:06:58 -0700 | [diff] [blame] | 3266 | int default_channel = voe_.GetLastChannel(); |
solenberg | 8189b02 | 2016-06-14 12:13:00 -0700 | [diff] [blame] | 3267 | EXPECT_TRUE(AddRecvStream(1)); |
Minyue | 2013aec | 2015-05-13 14:14:42 +0200 | [diff] [blame] | 3268 | int recv_ch = voe_.GetLastChannel(); |
| 3269 | EXPECT_NE(recv_ch, default_channel); |
| 3270 | EXPECT_EQ(voe_.GetAssociateSendChannel(recv_ch), default_channel); |
| 3271 | EXPECT_TRUE(channel_->AddSendStream(cricket::StreamParams::CreateLegacy(2))); |
| 3272 | EXPECT_EQ(voe_.GetAssociateSendChannel(recv_ch), default_channel); |
solenberg | 8189b02 | 2016-06-14 12:13:00 -0700 | [diff] [blame] | 3273 | EXPECT_TRUE(AddRecvStream(3)); |
solenberg | 1ac5614 | 2015-10-13 03:58:19 -0700 | [diff] [blame] | 3274 | recv_ch = voe_.GetLastChannel(); |
| 3275 | EXPECT_NE(recv_ch, default_channel); |
| 3276 | EXPECT_EQ(voe_.GetAssociateSendChannel(recv_ch), default_channel); |
Minyue | 2013aec | 2015-05-13 14:14:42 +0200 | [diff] [blame] | 3277 | } |
| 3278 | |
| 3279 | TEST_F(WebRtcVoiceEngineTestFake, AssociateChannelResetUponDeleteChannnel) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 3280 | EXPECT_TRUE(SetupSendStream()); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 3281 | EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); |
Minyue | 2013aec | 2015-05-13 14:14:42 +0200 | [diff] [blame] | 3282 | |
solenberg | 8189b02 | 2016-06-14 12:13:00 -0700 | [diff] [blame] | 3283 | EXPECT_TRUE(AddRecvStream(1)); |
Minyue | 2013aec | 2015-05-13 14:14:42 +0200 | [diff] [blame] | 3284 | int recv_ch = voe_.GetLastChannel(); |
| 3285 | |
| 3286 | EXPECT_TRUE(channel_->AddSendStream(cricket::StreamParams::CreateLegacy(2))); |
| 3287 | int send_ch = voe_.GetLastChannel(); |
| 3288 | |
| 3289 | // Manually associate |recv_ch| to |send_ch|. This test is to verify a |
| 3290 | // deleting logic, i.e., deleting |send_ch| will reset the associate send |
| 3291 | // channel of |recv_ch|.This is not a common case, since, normally, only the |
| 3292 | // default channel can be associated. However, the default is not deletable. |
| 3293 | // So we force the |recv_ch| to associate with a non-default channel. |
| 3294 | EXPECT_EQ(0, voe_.AssociateSendChannel(recv_ch, send_ch)); |
| 3295 | EXPECT_EQ(voe_.GetAssociateSendChannel(recv_ch), send_ch); |
| 3296 | |
| 3297 | EXPECT_TRUE(channel_->RemoveSendStream(2)); |
| 3298 | EXPECT_EQ(voe_.GetAssociateSendChannel(recv_ch), -1); |
| 3299 | } |
stefan | 658910c | 2015-09-03 05:48:32 -0700 | [diff] [blame] | 3300 | |
deadbeef | 884f585 | 2016-01-15 09:20:04 -0800 | [diff] [blame] | 3301 | TEST_F(WebRtcVoiceEngineTestFake, SetRawAudioSink) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 3302 | EXPECT_TRUE(SetupChannel()); |
kwiberg | 686a8ef | 2016-02-26 03:00:35 -0800 | [diff] [blame] | 3303 | std::unique_ptr<FakeAudioSink> fake_sink_1(new FakeAudioSink()); |
| 3304 | std::unique_ptr<FakeAudioSink> fake_sink_2(new FakeAudioSink()); |
deadbeef | 884f585 | 2016-01-15 09:20:04 -0800 | [diff] [blame] | 3305 | |
| 3306 | // Setting the sink before a recv stream exists should do nothing. |
| 3307 | channel_->SetRawAudioSink(kSsrc1, std::move(fake_sink_1)); |
solenberg | 8189b02 | 2016-06-14 12:13:00 -0700 | [diff] [blame] | 3308 | EXPECT_TRUE(AddRecvStream(kSsrc1)); |
deadbeef | 884f585 | 2016-01-15 09:20:04 -0800 | [diff] [blame] | 3309 | EXPECT_EQ(nullptr, GetRecvStream(kSsrc1).sink()); |
| 3310 | |
| 3311 | // Now try actually setting the sink. |
| 3312 | channel_->SetRawAudioSink(kSsrc1, std::move(fake_sink_2)); |
| 3313 | EXPECT_NE(nullptr, GetRecvStream(kSsrc1).sink()); |
| 3314 | |
| 3315 | // Now try resetting it. |
| 3316 | channel_->SetRawAudioSink(kSsrc1, nullptr); |
| 3317 | EXPECT_EQ(nullptr, GetRecvStream(kSsrc1).sink()); |
| 3318 | } |
| 3319 | |
| 3320 | TEST_F(WebRtcVoiceEngineTestFake, SetRawAudioSinkDefaultRecvStream) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 3321 | EXPECT_TRUE(SetupChannel()); |
kwiberg | 686a8ef | 2016-02-26 03:00:35 -0800 | [diff] [blame] | 3322 | std::unique_ptr<FakeAudioSink> fake_sink_1(new FakeAudioSink()); |
| 3323 | std::unique_ptr<FakeAudioSink> fake_sink_2(new FakeAudioSink()); |
deadbeef | 884f585 | 2016-01-15 09:20:04 -0800 | [diff] [blame] | 3324 | |
| 3325 | // Should be able to set a default sink even when no stream exists. |
| 3326 | channel_->SetRawAudioSink(0, std::move(fake_sink_1)); |
| 3327 | |
| 3328 | // Create default channel and ensure it's assigned the default sink. |
| 3329 | DeliverPacket(kPcmuFrame, sizeof(kPcmuFrame)); |
| 3330 | EXPECT_NE(nullptr, GetRecvStream(0x01).sink()); |
| 3331 | |
| 3332 | // Try resetting the default sink. |
| 3333 | channel_->SetRawAudioSink(0, nullptr); |
| 3334 | EXPECT_EQ(nullptr, GetRecvStream(0x01).sink()); |
| 3335 | |
| 3336 | // Try setting the default sink while the default stream exists. |
| 3337 | channel_->SetRawAudioSink(0, std::move(fake_sink_2)); |
| 3338 | EXPECT_NE(nullptr, GetRecvStream(0x01).sink()); |
| 3339 | |
| 3340 | // If we remove and add a default stream, it should get the same sink. |
| 3341 | EXPECT_TRUE(channel_->RemoveRecvStream(0x01)); |
| 3342 | DeliverPacket(kPcmuFrame, sizeof(kPcmuFrame)); |
| 3343 | EXPECT_NE(nullptr, GetRecvStream(0x01).sink()); |
| 3344 | } |
| 3345 | |
skvlad | 7a43d25 | 2016-03-22 15:32:27 -0700 | [diff] [blame] | 3346 | // Test that, just like the video channel, the voice channel communicates the |
| 3347 | // network state to the call. |
| 3348 | TEST_F(WebRtcVoiceEngineTestFake, OnReadyToSendSignalsNetworkState) { |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 3349 | EXPECT_TRUE(SetupChannel()); |
skvlad | 7a43d25 | 2016-03-22 15:32:27 -0700 | [diff] [blame] | 3350 | |
| 3351 | EXPECT_EQ(webrtc::kNetworkUp, |
| 3352 | call_.GetNetworkState(webrtc::MediaType::AUDIO)); |
| 3353 | EXPECT_EQ(webrtc::kNetworkUp, |
| 3354 | call_.GetNetworkState(webrtc::MediaType::VIDEO)); |
| 3355 | |
| 3356 | channel_->OnReadyToSend(false); |
| 3357 | EXPECT_EQ(webrtc::kNetworkDown, |
| 3358 | call_.GetNetworkState(webrtc::MediaType::AUDIO)); |
| 3359 | EXPECT_EQ(webrtc::kNetworkUp, |
| 3360 | call_.GetNetworkState(webrtc::MediaType::VIDEO)); |
| 3361 | |
| 3362 | channel_->OnReadyToSend(true); |
| 3363 | EXPECT_EQ(webrtc::kNetworkUp, |
| 3364 | call_.GetNetworkState(webrtc::MediaType::AUDIO)); |
| 3365 | EXPECT_EQ(webrtc::kNetworkUp, |
| 3366 | call_.GetNetworkState(webrtc::MediaType::VIDEO)); |
| 3367 | } |
| 3368 | |
stefan | 658910c | 2015-09-03 05:48:32 -0700 | [diff] [blame] | 3369 | // Tests that the library initializes and shuts down properly. |
| 3370 | TEST(WebRtcVoiceEngineTest, StartupShutdown) { |
ossu | 29b1a8d | 2016-06-13 07:34:51 -0700 | [diff] [blame] | 3371 | using testing::_; |
| 3372 | using testing::AnyNumber; |
| 3373 | |
| 3374 | // If the VoiceEngine wants to gather available codecs early, that's fine but |
| 3375 | // we never want it to create a decoder at this stage. |
| 3376 | rtc::scoped_refptr<webrtc::MockAudioDecoderFactory> factory = |
| 3377 | new rtc::RefCountedObject<webrtc::MockAudioDecoderFactory>; |
| 3378 | ON_CALL(*factory.get(), GetSupportedFormats()) |
| 3379 | .WillByDefault(Return(std::vector<webrtc::SdpAudioFormat>())); |
| 3380 | EXPECT_CALL(*factory.get(), GetSupportedFormats()) |
| 3381 | .Times(AnyNumber()); |
| 3382 | EXPECT_CALL(*factory.get(), MakeAudioDecoderMock(_, _)).Times(0); |
| 3383 | |
| 3384 | cricket::WebRtcVoiceEngine engine(nullptr, factory); |
kwiberg | 686a8ef | 2016-02-26 03:00:35 -0800 | [diff] [blame] | 3385 | std::unique_ptr<webrtc::Call> call( |
Fredrik Solenberg | 709ed67 | 2015-09-15 12:26:33 +0200 | [diff] [blame] | 3386 | webrtc::Call::Create(webrtc::Call::Config())); |
nisse | 51542be | 2016-02-12 02:27:06 -0800 | [diff] [blame] | 3387 | cricket::VoiceMediaChannel* channel = engine.CreateChannel( |
| 3388 | call.get(), cricket::MediaConfig(), cricket::AudioOptions()); |
stefan | 658910c | 2015-09-03 05:48:32 -0700 | [diff] [blame] | 3389 | EXPECT_TRUE(channel != nullptr); |
| 3390 | delete channel; |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 3391 | } |
stefan | 658910c | 2015-09-03 05:48:32 -0700 | [diff] [blame] | 3392 | |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 3393 | // Tests that reference counting on the external ADM is correct. |
solenberg | bc37fc8 | 2016-04-04 09:54:44 -0700 | [diff] [blame] | 3394 | TEST(WebRtcVoiceEngineTest, StartupShutdownWithExternalADM) { |
| 3395 | testing::NiceMock<webrtc::test::MockAudioDeviceModule> adm; |
| 3396 | EXPECT_CALL(adm, AddRef()).Times(3).WillRepeatedly(Return(0)); |
| 3397 | EXPECT_CALL(adm, Release()).Times(3).WillRepeatedly(Return(0)); |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 3398 | { |
ossu | 29b1a8d | 2016-06-13 07:34:51 -0700 | [diff] [blame] | 3399 | cricket::WebRtcVoiceEngine engine(&adm, nullptr); |
solenberg | ff97631 | 2016-03-30 23:28:51 -0700 | [diff] [blame] | 3400 | std::unique_ptr<webrtc::Call> call( |
| 3401 | webrtc::Call::Create(webrtc::Call::Config())); |
| 3402 | cricket::VoiceMediaChannel* channel = engine.CreateChannel( |
| 3403 | call.get(), cricket::MediaConfig(), cricket::AudioOptions()); |
| 3404 | EXPECT_TRUE(channel != nullptr); |
| 3405 | delete channel; |
| 3406 | } |
stefan | 658910c | 2015-09-03 05:48:32 -0700 | [diff] [blame] | 3407 | } |
| 3408 | |
| 3409 | // Tests that the library is configured with the codecs we want. |
ossu | dedfd28 | 2016-06-14 07:12:39 -0700 | [diff] [blame] | 3410 | // TODO(ossu): This test should move into the builtin audio codecs module |
| 3411 | // eventually. |
stefan | 658910c | 2015-09-03 05:48:32 -0700 | [diff] [blame] | 3412 | TEST(WebRtcVoiceEngineTest, HasCorrectCodecs) { |
ossu | 29b1a8d | 2016-06-13 07:34:51 -0700 | [diff] [blame] | 3413 | // TODO(ossu): These tests should move into a future "builtin audio codecs" |
| 3414 | // module. |
| 3415 | |
stefan | 658910c | 2015-09-03 05:48:32 -0700 | [diff] [blame] | 3416 | // Check codecs by name. |
solenberg | 26c8c91 | 2015-11-27 04:00:25 -0800 | [diff] [blame] | 3417 | EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst( |
deadbeef | 67cf2c1 | 2016-04-13 10:07:16 -0700 | [diff] [blame] | 3418 | cricket::AudioCodec(96, "OPUS", 48000, 0, 2), nullptr)); |
solenberg | 26c8c91 | 2015-11-27 04:00:25 -0800 | [diff] [blame] | 3419 | EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst( |
deadbeef | 67cf2c1 | 2016-04-13 10:07:16 -0700 | [diff] [blame] | 3420 | cricket::AudioCodec(96, "ISAC", 16000, 0, 1), nullptr)); |
solenberg | 26c8c91 | 2015-11-27 04:00:25 -0800 | [diff] [blame] | 3421 | EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst( |
deadbeef | 67cf2c1 | 2016-04-13 10:07:16 -0700 | [diff] [blame] | 3422 | cricket::AudioCodec(96, "ISAC", 32000, 0, 1), nullptr)); |
stefan | 658910c | 2015-09-03 05:48:32 -0700 | [diff] [blame] | 3423 | // Check that name matching is case-insensitive. |
solenberg | 26c8c91 | 2015-11-27 04:00:25 -0800 | [diff] [blame] | 3424 | EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst( |
deadbeef | 67cf2c1 | 2016-04-13 10:07:16 -0700 | [diff] [blame] | 3425 | cricket::AudioCodec(96, "ILBC", 8000, 0, 1), nullptr)); |
solenberg | 26c8c91 | 2015-11-27 04:00:25 -0800 | [diff] [blame] | 3426 | EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst( |
deadbeef | 67cf2c1 | 2016-04-13 10:07:16 -0700 | [diff] [blame] | 3427 | cricket::AudioCodec(96, "iLBC", 8000, 0, 1), nullptr)); |
solenberg | 26c8c91 | 2015-11-27 04:00:25 -0800 | [diff] [blame] | 3428 | EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst( |
deadbeef | 67cf2c1 | 2016-04-13 10:07:16 -0700 | [diff] [blame] | 3429 | cricket::AudioCodec(96, "PCMU", 8000, 0, 1), nullptr)); |
solenberg | 26c8c91 | 2015-11-27 04:00:25 -0800 | [diff] [blame] | 3430 | EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst( |
deadbeef | 67cf2c1 | 2016-04-13 10:07:16 -0700 | [diff] [blame] | 3431 | cricket::AudioCodec(96, "PCMA", 8000, 0, 1), nullptr)); |
solenberg | 26c8c91 | 2015-11-27 04:00:25 -0800 | [diff] [blame] | 3432 | EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst( |
deadbeef | 67cf2c1 | 2016-04-13 10:07:16 -0700 | [diff] [blame] | 3433 | cricket::AudioCodec(96, "G722", 8000, 0, 1), nullptr)); |
solenberg | 26c8c91 | 2015-11-27 04:00:25 -0800 | [diff] [blame] | 3434 | EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst( |
deadbeef | 67cf2c1 | 2016-04-13 10:07:16 -0700 | [diff] [blame] | 3435 | cricket::AudioCodec(96, "CN", 32000, 0, 1), nullptr)); |
solenberg | 26c8c91 | 2015-11-27 04:00:25 -0800 | [diff] [blame] | 3436 | EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst( |
deadbeef | 67cf2c1 | 2016-04-13 10:07:16 -0700 | [diff] [blame] | 3437 | cricket::AudioCodec(96, "CN", 16000, 0, 1), nullptr)); |
solenberg | 26c8c91 | 2015-11-27 04:00:25 -0800 | [diff] [blame] | 3438 | EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst( |
deadbeef | 67cf2c1 | 2016-04-13 10:07:16 -0700 | [diff] [blame] | 3439 | cricket::AudioCodec(96, "CN", 8000, 0, 1), nullptr)); |
solenberg | 26c8c91 | 2015-11-27 04:00:25 -0800 | [diff] [blame] | 3440 | EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst( |
deadbeef | 67cf2c1 | 2016-04-13 10:07:16 -0700 | [diff] [blame] | 3441 | cricket::AudioCodec(96, "telephone-event", 8000, 0, 1), nullptr)); |
stefan | 658910c | 2015-09-03 05:48:32 -0700 | [diff] [blame] | 3442 | // Check codecs with an id by id. |
solenberg | 26c8c91 | 2015-11-27 04:00:25 -0800 | [diff] [blame] | 3443 | EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst( |
deadbeef | 67cf2c1 | 2016-04-13 10:07:16 -0700 | [diff] [blame] | 3444 | cricket::AudioCodec(0, "", 8000, 0, 1), nullptr)); // PCMU |
solenberg | 26c8c91 | 2015-11-27 04:00:25 -0800 | [diff] [blame] | 3445 | EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst( |
deadbeef | 67cf2c1 | 2016-04-13 10:07:16 -0700 | [diff] [blame] | 3446 | cricket::AudioCodec(8, "", 8000, 0, 1), nullptr)); // PCMA |
solenberg | 26c8c91 | 2015-11-27 04:00:25 -0800 | [diff] [blame] | 3447 | EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst( |
deadbeef | 67cf2c1 | 2016-04-13 10:07:16 -0700 | [diff] [blame] | 3448 | cricket::AudioCodec(9, "", 8000, 0, 1), nullptr)); // G722 |
solenberg | 26c8c91 | 2015-11-27 04:00:25 -0800 | [diff] [blame] | 3449 | EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst( |
deadbeef | 67cf2c1 | 2016-04-13 10:07:16 -0700 | [diff] [blame] | 3450 | cricket::AudioCodec(13, "", 8000, 0, 1), nullptr)); // CN |
stefan | 658910c | 2015-09-03 05:48:32 -0700 | [diff] [blame] | 3451 | // Check sample/bitrate matching. |
solenberg | 26c8c91 | 2015-11-27 04:00:25 -0800 | [diff] [blame] | 3452 | EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst( |
deadbeef | 67cf2c1 | 2016-04-13 10:07:16 -0700 | [diff] [blame] | 3453 | cricket::AudioCodec(0, "PCMU", 8000, 64000, 1), nullptr)); |
stefan | 658910c | 2015-09-03 05:48:32 -0700 | [diff] [blame] | 3454 | // Check that bad codecs fail. |
solenberg | 26c8c91 | 2015-11-27 04:00:25 -0800 | [diff] [blame] | 3455 | EXPECT_FALSE(cricket::WebRtcVoiceEngine::ToCodecInst( |
deadbeef | 67cf2c1 | 2016-04-13 10:07:16 -0700 | [diff] [blame] | 3456 | cricket::AudioCodec(99, "ABCD", 0, 0, 1), nullptr)); |
solenberg | 26c8c91 | 2015-11-27 04:00:25 -0800 | [diff] [blame] | 3457 | EXPECT_FALSE(cricket::WebRtcVoiceEngine::ToCodecInst( |
deadbeef | 67cf2c1 | 2016-04-13 10:07:16 -0700 | [diff] [blame] | 3458 | cricket::AudioCodec(88, "", 0, 0, 1), nullptr)); |
solenberg | 26c8c91 | 2015-11-27 04:00:25 -0800 | [diff] [blame] | 3459 | EXPECT_FALSE(cricket::WebRtcVoiceEngine::ToCodecInst( |
deadbeef | 67cf2c1 | 2016-04-13 10:07:16 -0700 | [diff] [blame] | 3460 | cricket::AudioCodec(0, "", 0, 0, 2), nullptr)); |
solenberg | 26c8c91 | 2015-11-27 04:00:25 -0800 | [diff] [blame] | 3461 | EXPECT_FALSE(cricket::WebRtcVoiceEngine::ToCodecInst( |
deadbeef | 67cf2c1 | 2016-04-13 10:07:16 -0700 | [diff] [blame] | 3462 | cricket::AudioCodec(0, "", 5000, 0, 1), nullptr)); |
solenberg | 26c8c91 | 2015-11-27 04:00:25 -0800 | [diff] [blame] | 3463 | EXPECT_FALSE(cricket::WebRtcVoiceEngine::ToCodecInst( |
deadbeef | 67cf2c1 | 2016-04-13 10:07:16 -0700 | [diff] [blame] | 3464 | cricket::AudioCodec(0, "", 0, 5000, 1), nullptr)); |
solenberg | 26c8c91 | 2015-11-27 04:00:25 -0800 | [diff] [blame] | 3465 | |
stefan | 658910c | 2015-09-03 05:48:32 -0700 | [diff] [blame] | 3466 | // Verify the payload id of common audio codecs, including CN, ISAC, and G722. |
ossu | 29b1a8d | 2016-06-13 07:34:51 -0700 | [diff] [blame] | 3467 | cricket::WebRtcVoiceEngine engine(nullptr, |
| 3468 | webrtc::CreateBuiltinAudioDecoderFactory()); |
stefan | 658910c | 2015-09-03 05:48:32 -0700 | [diff] [blame] | 3469 | for (std::vector<cricket::AudioCodec>::const_iterator it = |
ossu | dedfd28 | 2016-06-14 07:12:39 -0700 | [diff] [blame] | 3470 | engine.send_codecs().begin(); it != engine.send_codecs().end(); ++it) { |
stefan | 658910c | 2015-09-03 05:48:32 -0700 | [diff] [blame] | 3471 | if (it->name == "CN" && it->clockrate == 16000) { |
| 3472 | EXPECT_EQ(105, it->id); |
| 3473 | } else if (it->name == "CN" && it->clockrate == 32000) { |
| 3474 | EXPECT_EQ(106, it->id); |
| 3475 | } else if (it->name == "ISAC" && it->clockrate == 16000) { |
| 3476 | EXPECT_EQ(103, it->id); |
| 3477 | } else if (it->name == "ISAC" && it->clockrate == 32000) { |
| 3478 | EXPECT_EQ(104, it->id); |
| 3479 | } else if (it->name == "G722" && it->clockrate == 8000) { |
| 3480 | EXPECT_EQ(9, it->id); |
| 3481 | } else if (it->name == "telephone-event") { |
| 3482 | EXPECT_EQ(126, it->id); |
stefan | 658910c | 2015-09-03 05:48:32 -0700 | [diff] [blame] | 3483 | } else if (it->name == "opus") { |
| 3484 | EXPECT_EQ(111, it->id); |
| 3485 | ASSERT_TRUE(it->params.find("minptime") != it->params.end()); |
| 3486 | EXPECT_EQ("10", it->params.find("minptime")->second); |
stefan | 658910c | 2015-09-03 05:48:32 -0700 | [diff] [blame] | 3487 | ASSERT_TRUE(it->params.find("useinbandfec") != it->params.end()); |
| 3488 | EXPECT_EQ("1", it->params.find("useinbandfec")->second); |
| 3489 | } |
| 3490 | } |
stefan | 658910c | 2015-09-03 05:48:32 -0700 | [diff] [blame] | 3491 | } |
| 3492 | |
| 3493 | // Tests that VoE supports at least 32 channels |
| 3494 | TEST(WebRtcVoiceEngineTest, Has32Channels) { |
ossu | 29b1a8d | 2016-06-13 07:34:51 -0700 | [diff] [blame] | 3495 | cricket::WebRtcVoiceEngine engine(nullptr, nullptr); |
kwiberg | 686a8ef | 2016-02-26 03:00:35 -0800 | [diff] [blame] | 3496 | std::unique_ptr<webrtc::Call> call( |
Fredrik Solenberg | 709ed67 | 2015-09-15 12:26:33 +0200 | [diff] [blame] | 3497 | webrtc::Call::Create(webrtc::Call::Config())); |
stefan | 658910c | 2015-09-03 05:48:32 -0700 | [diff] [blame] | 3498 | |
| 3499 | cricket::VoiceMediaChannel* channels[32]; |
| 3500 | int num_channels = 0; |
tfarina | 5237aaf | 2015-11-10 23:44:30 -0800 | [diff] [blame] | 3501 | while (num_channels < arraysize(channels)) { |
nisse | 51542be | 2016-02-12 02:27:06 -0800 | [diff] [blame] | 3502 | cricket::VoiceMediaChannel* channel = engine.CreateChannel( |
| 3503 | call.get(), cricket::MediaConfig(), cricket::AudioOptions()); |
stefan | 658910c | 2015-09-03 05:48:32 -0700 | [diff] [blame] | 3504 | if (!channel) |
| 3505 | break; |
stefan | 658910c | 2015-09-03 05:48:32 -0700 | [diff] [blame] | 3506 | channels[num_channels++] = channel; |
| 3507 | } |
| 3508 | |
tfarina | 5237aaf | 2015-11-10 23:44:30 -0800 | [diff] [blame] | 3509 | int expected = arraysize(channels); |
stefan | 658910c | 2015-09-03 05:48:32 -0700 | [diff] [blame] | 3510 | EXPECT_EQ(expected, num_channels); |
| 3511 | |
| 3512 | while (num_channels > 0) { |
| 3513 | delete channels[--num_channels]; |
| 3514 | } |
stefan | 658910c | 2015-09-03 05:48:32 -0700 | [diff] [blame] | 3515 | } |
| 3516 | |
| 3517 | // Test that we set our preferred codecs properly. |
| 3518 | TEST(WebRtcVoiceEngineTest, SetRecvCodecs) { |
ossu | 29b1a8d | 2016-06-13 07:34:51 -0700 | [diff] [blame] | 3519 | // TODO(ossu): I'm not sure of the intent of this test. It's either: |
| 3520 | // - Check that our builtin codecs are usable by Channel. |
| 3521 | // - The codecs provided by the engine is usable by Channel. |
| 3522 | // It does not check that the codecs in the RecvParameters are actually |
| 3523 | // what we sent in - though it's probably reasonable to expect so, if |
| 3524 | // SetRecvParameters returns true. |
| 3525 | // I think it will become clear once audio decoder injection is completed. |
| 3526 | cricket::WebRtcVoiceEngine engine( |
| 3527 | nullptr, webrtc::CreateBuiltinAudioDecoderFactory()); |
kwiberg | 686a8ef | 2016-02-26 03:00:35 -0800 | [diff] [blame] | 3528 | std::unique_ptr<webrtc::Call> call( |
Fredrik Solenberg | 709ed67 | 2015-09-15 12:26:33 +0200 | [diff] [blame] | 3529 | webrtc::Call::Create(webrtc::Call::Config())); |
nisse | 51542be | 2016-02-12 02:27:06 -0800 | [diff] [blame] | 3530 | cricket::WebRtcVoiceMediaChannel channel(&engine, cricket::MediaConfig(), |
| 3531 | cricket::AudioOptions(), call.get()); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 3532 | cricket::AudioRecvParameters parameters; |
ossu | dedfd28 | 2016-06-14 07:12:39 -0700 | [diff] [blame] | 3533 | parameters.codecs = engine.recv_codecs(); |
Fredrik Solenberg | b071a19 | 2015-09-17 16:42:56 +0200 | [diff] [blame] | 3534 | EXPECT_TRUE(channel.SetRecvParameters(parameters)); |
stefan | 658910c | 2015-09-03 05:48:32 -0700 | [diff] [blame] | 3535 | } |