blob: cbc00071930ee1d9eb8fe2bdb437866098c95ff7 [file] [log] [blame]
henrike@webrtc.org79047f92014-03-06 23:46:59 +00001/*
2 * libjingle
3 * Copyright 2008 Google Inc.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are met:
7 *
8 * 1. Redistributions of source code must retain the above copyright notice,
9 * this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright notice,
11 * this list of conditions and the following disclaimer in the documentation
12 * and/or other materials provided with the distribution.
13 * 3. The name of the author may not be used to endorse or promote products
14 * derived from this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
17 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
18 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
19 * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
20 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
21 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
22 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
23 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
24 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
25 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
henrike@webrtc.org28e20752013-07-10 00:45:36 +000027
28#ifdef WIN32
29#include "talk/base/win32.h"
30#include <objbase.h>
31#endif
32
33#include "talk/base/byteorder.h"
34#include "talk/base/gunit.h"
35#include "talk/media/base/constants.h"
36#include "talk/media/base/fakemediaengine.h"
37#include "talk/media/base/fakemediaprocessor.h"
wu@webrtc.orgde305012013-10-31 15:40:38 +000038#include "talk/media/base/fakenetworkinterface.h"
henrike@webrtc.org28e20752013-07-10 00:45:36 +000039#include "talk/media/base/fakertp.h"
40#include "talk/media/webrtc/fakewebrtcvoiceengine.h"
41#include "talk/media/webrtc/webrtcvoiceengine.h"
42#include "talk/p2p/base/fakesession.h"
43#include "talk/session/media/channel.h"
44
45// Tests for the WebRtcVoiceEngine/VoiceChannel code.
46
buildbot@webrtc.org150835e2014-05-06 15:54:38 +000047using cricket::kRtpAudioLevelHeaderExtension;
48using cricket::kRtpAbsoluteSenderTimeHeaderExtension;
49
henrike@webrtc.org28e20752013-07-10 00:45:36 +000050static const cricket::AudioCodec kPcmuCodec(0, "PCMU", 8000, 64000, 1, 0);
51static const cricket::AudioCodec kIsacCodec(103, "ISAC", 16000, 32000, 1, 0);
52static const cricket::AudioCodec kCeltCodec(110, "CELT", 32000, 64000, 2, 0);
53static const cricket::AudioCodec kOpusCodec(111, "opus", 48000, 64000, 2, 0);
54static const cricket::AudioCodec kRedCodec(117, "red", 8000, 0, 1, 0);
55static const cricket::AudioCodec kCn8000Codec(13, "CN", 8000, 0, 1, 0);
56static const cricket::AudioCodec kCn16000Codec(105, "CN", 16000, 0, 1, 0);
57static const cricket::AudioCodec
58 kTelephoneEventCodec(106, "telephone-event", 8000, 0, 1, 0);
59static const cricket::AudioCodec* const kAudioCodecs[] = {
60 &kPcmuCodec, &kIsacCodec, &kCeltCodec, &kOpusCodec, &kRedCodec,
61 &kCn8000Codec, &kCn16000Codec, &kTelephoneEventCodec,
62};
63const char kRingbackTone[] = "RIFF____WAVE____ABCD1234";
64static uint32 kSsrc1 = 0x99;
65static uint32 kSsrc2 = 0x98;
66
67class FakeVoEWrapper : public cricket::VoEWrapper {
68 public:
69 explicit FakeVoEWrapper(cricket::FakeWebRtcVoiceEngine* engine)
70 : cricket::VoEWrapper(engine, // processing
71 engine, // base
72 engine, // codec
73 engine, // dtmf
74 engine, // file
75 engine, // hw
76 engine, // media
77 engine, // neteq
78 engine, // network
79 engine, // rtp
80 engine, // sync
81 engine) { // volume
82 }
83};
84
wu@webrtc.org97077a32013-10-25 21:18:33 +000085class FakeVoETraceWrapper : public cricket::VoETraceWrapper {
henrike@webrtc.org28e20752013-07-10 00:45:36 +000086 public:
87 virtual int SetTraceFilter(const unsigned int filter) {
wu@webrtc.org97077a32013-10-25 21:18:33 +000088 filter_ = filter;
henrike@webrtc.org28e20752013-07-10 00:45:36 +000089 return 0;
90 }
91 virtual int SetTraceFile(const char* fileNameUTF8) {
92 return 0;
93 }
94 virtual int SetTraceCallback(webrtc::TraceCallback* callback) {
95 return 0;
96 }
wu@webrtc.org97077a32013-10-25 21:18:33 +000097 unsigned int filter_;
henrike@webrtc.org28e20752013-07-10 00:45:36 +000098};
99
100class WebRtcVoiceEngineTestFake : public testing::Test {
101 public:
102 class ChannelErrorListener : public sigslot::has_slots<> {
103 public:
104 explicit ChannelErrorListener(cricket::VoiceMediaChannel* channel)
105 : ssrc_(0), error_(cricket::VoiceMediaChannel::ERROR_NONE) {
106 ASSERT(channel != NULL);
107 channel->SignalMediaError.connect(
108 this, &ChannelErrorListener::OnVoiceChannelError);
109 }
110 void OnVoiceChannelError(uint32 ssrc,
111 cricket::VoiceMediaChannel::Error error) {
112 ssrc_ = ssrc;
113 error_ = error;
114 }
115 void Reset() {
116 ssrc_ = 0;
117 error_ = cricket::VoiceMediaChannel::ERROR_NONE;
118 }
119 uint32 ssrc() const {
120 return ssrc_;
121 }
122 cricket::VoiceMediaChannel::Error error() const {
123 return error_;
124 }
125
126 private:
127 uint32 ssrc_;
128 cricket::VoiceMediaChannel::Error error_;
129 };
130
131 WebRtcVoiceEngineTestFake()
132 : voe_(kAudioCodecs, ARRAY_SIZE(kAudioCodecs)),
133 voe_sc_(kAudioCodecs, ARRAY_SIZE(kAudioCodecs)),
wu@webrtc.org97077a32013-10-25 21:18:33 +0000134 trace_wrapper_(new FakeVoETraceWrapper()),
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000135 engine_(new FakeVoEWrapper(&voe_),
136 new FakeVoEWrapper(&voe_sc_),
wu@webrtc.org97077a32013-10-25 21:18:33 +0000137 trace_wrapper_),
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000138 channel_(NULL), soundclip_(NULL) {
139 options_conference_.conference_mode.Set(true);
140 options_adjust_agc_.adjust_agc_delta.Set(-10);
141 }
buildbot@webrtc.org150835e2014-05-06 15:54:38 +0000142 bool SetupEngineWithoutStream() {
143 if (!engine_.Init(talk_base::Thread::Current())) {
144 return false;
145 }
146 channel_ = engine_.CreateChannel();
147 return (channel_ != NULL);
148 }
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000149 bool SetupEngine() {
buildbot@webrtc.org150835e2014-05-06 15:54:38 +0000150 if (!SetupEngineWithoutStream()) {
151 return false;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000152 }
buildbot@webrtc.org150835e2014-05-06 15:54:38 +0000153 return channel_->AddSendStream(
154 cricket::StreamParams::CreateLegacy(kSsrc1));
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000155 }
wu@webrtc.org9dba5252013-08-05 20:36:57 +0000156 void SetupForMultiSendStream() {
157 EXPECT_TRUE(SetupEngine());
158 // Remove stream added in Setup, which is corresponding to default channel.
159 int default_channel_num = voe_.GetLastChannel();
henrike@webrtc.org7666db72013-08-22 14:45:42 +0000160 uint32 default_send_ssrc = 0u;
wu@webrtc.org9dba5252013-08-05 20:36:57 +0000161 EXPECT_EQ(0, voe_.GetLocalSSRC(default_channel_num, default_send_ssrc));
162 EXPECT_EQ(kSsrc1, default_send_ssrc);
163 EXPECT_TRUE(channel_->RemoveSendStream(default_send_ssrc));
164
165 // Verify the default channel still exists.
166 EXPECT_EQ(0, voe_.GetLocalSSRC(default_channel_num, default_send_ssrc));
167 }
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000168 void DeliverPacket(const void* data, int len) {
169 talk_base::Buffer packet(data, len);
wu@webrtc.orga9890802013-12-13 00:21:03 +0000170 channel_->OnPacketReceived(&packet, talk_base::PacketTime());
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000171 }
172 virtual void TearDown() {
173 delete soundclip_;
174 delete channel_;
175 engine_.Terminate();
176 }
177
wu@webrtc.orgcadf9042013-08-30 21:24:16 +0000178 void TestInsertDtmf(uint32 ssrc, bool caller) {
179 EXPECT_TRUE(engine_.Init(talk_base::Thread::Current()));
180 channel_ = engine_.CreateChannel();
181 EXPECT_TRUE(channel_ != NULL);
182 if (caller) {
183 // if this is a caller, local description will be applied and add the
184 // send stream.
185 EXPECT_TRUE(channel_->AddSendStream(
186 cricket::StreamParams::CreateLegacy(kSsrc1)));
187 }
188 int channel_id = voe_.GetLastChannel();
189
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000190 // Test we can only InsertDtmf when the other side supports telephone-event.
191 std::vector<cricket::AudioCodec> codecs;
192 codecs.push_back(kPcmuCodec);
193 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
194 EXPECT_TRUE(channel_->SetSend(cricket::SEND_MICROPHONE));
195 EXPECT_FALSE(channel_->CanInsertDtmf());
196 EXPECT_FALSE(channel_->InsertDtmf(ssrc, 1, 111, cricket::DF_SEND));
197 codecs.push_back(kTelephoneEventCodec);
198 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
199 EXPECT_TRUE(channel_->CanInsertDtmf());
wu@webrtc.orgcadf9042013-08-30 21:24:16 +0000200
201 if (!caller) {
202 // There's no active send channel yet.
203 EXPECT_FALSE(channel_->InsertDtmf(ssrc, 2, 123, cricket::DF_SEND));
204 EXPECT_TRUE(channel_->AddSendStream(
205 cricket::StreamParams::CreateLegacy(kSsrc1)));
206 }
207
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000208 // Check we fail if the ssrc is invalid.
209 EXPECT_FALSE(channel_->InsertDtmf(-1, 1, 111, cricket::DF_SEND));
210
211 // Test send
212 EXPECT_FALSE(voe_.WasSendTelephoneEventCalled(channel_id, 2, 123));
213 EXPECT_TRUE(channel_->InsertDtmf(ssrc, 2, 123, cricket::DF_SEND));
214 EXPECT_TRUE(voe_.WasSendTelephoneEventCalled(channel_id, 2, 123));
215
216 // Test play
217 EXPECT_FALSE(voe_.WasPlayDtmfToneCalled(3, 134));
218 EXPECT_TRUE(channel_->InsertDtmf(ssrc, 3, 134, cricket::DF_PLAY));
219 EXPECT_TRUE(voe_.WasPlayDtmfToneCalled(3, 134));
220
221 // Test send and play
222 EXPECT_FALSE(voe_.WasSendTelephoneEventCalled(channel_id, 4, 145));
223 EXPECT_FALSE(voe_.WasPlayDtmfToneCalled(4, 145));
224 EXPECT_TRUE(channel_->InsertDtmf(ssrc, 4, 145,
225 cricket::DF_PLAY | cricket::DF_SEND));
226 EXPECT_TRUE(voe_.WasSendTelephoneEventCalled(channel_id, 4, 145));
227 EXPECT_TRUE(voe_.WasPlayDtmfToneCalled(4, 145));
228 }
229
230 // Test that send bandwidth is set correctly.
231 // |codec| is the codec under test.
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +0000232 // |max_bitrate| is a parameter to set to SetMaxSendBandwidth().
233 // |expected_result| is the expected result from SetMaxSendBandwidth().
234 // |expected_bitrate| is the expected audio bitrate afterward.
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000235 void TestSendBandwidth(const cricket::AudioCodec& codec,
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +0000236 int max_bitrate,
237 bool expected_result,
238 int expected_bitrate) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000239 int channel_num = voe_.GetLastChannel();
240 std::vector<cricket::AudioCodec> codecs;
241
242 codecs.push_back(codec);
243 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
244
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +0000245 bool result = channel_->SetMaxSendBandwidth(max_bitrate);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000246 EXPECT_EQ(expected_result, result);
247
wu@webrtc.org1d1ffc92013-10-16 18:12:02 +0000248 webrtc::CodecInst temp_codec;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000249 EXPECT_FALSE(voe_.GetSendCodec(channel_num, temp_codec));
250
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +0000251 EXPECT_EQ(expected_bitrate, temp_codec.rate);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000252 }
253
buildbot@webrtc.org150835e2014-05-06 15:54:38 +0000254 void TestSetSendRtpHeaderExtensions(const std::string& ext) {
255 EXPECT_TRUE(SetupEngineWithoutStream());
256 int channel_num = voe_.GetLastChannel();
wu@webrtc.org9dba5252013-08-05 20:36:57 +0000257
henrike@webrtc.org79047f92014-03-06 23:46:59 +0000258 // Ensure extensions are off by default.
buildbot@webrtc.org150835e2014-05-06 15:54:38 +0000259 EXPECT_EQ(-1, voe_.GetSendRtpExtensionId(channel_num, ext));
wu@webrtc.org9dba5252013-08-05 20:36:57 +0000260
buildbot@webrtc.org150835e2014-05-06 15:54:38 +0000261 std::vector<cricket::RtpHeaderExtension> extensions;
wu@webrtc.org9dba5252013-08-05 20:36:57 +0000262 // Ensure unknown extensions won't cause an error.
263 extensions.push_back(cricket::RtpHeaderExtension(
henrike@webrtc.org79047f92014-03-06 23:46:59 +0000264 "urn:ietf:params:unknownextention", 1));
wu@webrtc.org9dba5252013-08-05 20:36:57 +0000265 EXPECT_TRUE(channel_->SetSendRtpHeaderExtensions(extensions));
buildbot@webrtc.org150835e2014-05-06 15:54:38 +0000266 EXPECT_EQ(-1, voe_.GetSendRtpExtensionId(channel_num, ext));
wu@webrtc.org9dba5252013-08-05 20:36:57 +0000267
henrike@webrtc.org79047f92014-03-06 23:46:59 +0000268 // Ensure extensions stay off with an empty list of headers.
269 extensions.clear();
wu@webrtc.org9dba5252013-08-05 20:36:57 +0000270 EXPECT_TRUE(channel_->SetSendRtpHeaderExtensions(extensions));
buildbot@webrtc.org150835e2014-05-06 15:54:38 +0000271 EXPECT_EQ(-1, voe_.GetSendRtpExtensionId(channel_num, ext));
wu@webrtc.org9dba5252013-08-05 20:36:57 +0000272
buildbot@webrtc.org150835e2014-05-06 15:54:38 +0000273 // Ensure extension is set properly.
274 const int id = 1;
275 extensions.push_back(cricket::RtpHeaderExtension(ext, id));
wu@webrtc.org9dba5252013-08-05 20:36:57 +0000276 EXPECT_TRUE(channel_->SetSendRtpHeaderExtensions(extensions));
buildbot@webrtc.org150835e2014-05-06 15:54:38 +0000277 EXPECT_EQ(id, voe_.GetSendRtpExtensionId(channel_num, ext));
wu@webrtc.org9dba5252013-08-05 20:36:57 +0000278
buildbot@webrtc.org150835e2014-05-06 15:54:38 +0000279 // Ensure extension is set properly on new channel.
280 // The first stream to occupy the default channel.
281 EXPECT_TRUE(channel_->AddSendStream(
282 cricket::StreamParams::CreateLegacy(123)));
283 EXPECT_TRUE(channel_->AddSendStream(
284 cricket::StreamParams::CreateLegacy(234)));
285 int new_channel_num = voe_.GetLastChannel();
286 EXPECT_NE(channel_num, new_channel_num);
287 EXPECT_EQ(id, voe_.GetSendRtpExtensionId(new_channel_num, ext));
henrike@webrtc.org79047f92014-03-06 23:46:59 +0000288
289 // Ensure all extensions go back off with an empty list.
wu@webrtc.org9dba5252013-08-05 20:36:57 +0000290 extensions.clear();
291 EXPECT_TRUE(channel_->SetSendRtpHeaderExtensions(extensions));
buildbot@webrtc.org150835e2014-05-06 15:54:38 +0000292 EXPECT_EQ(-1, voe_.GetSendRtpExtensionId(channel_num, ext));
293 EXPECT_EQ(-1, voe_.GetSendRtpExtensionId(new_channel_num, ext));
henrike@webrtc.org79047f92014-03-06 23:46:59 +0000294 }
295
buildbot@webrtc.org150835e2014-05-06 15:54:38 +0000296 void TestSetRecvRtpHeaderExtensions(const std::string& ext) {
297 EXPECT_TRUE(SetupEngineWithoutStream());
298 int channel_num = voe_.GetLastChannel();
henrike@webrtc.org79047f92014-03-06 23:46:59 +0000299
henrike@webrtc.org79047f92014-03-06 23:46:59 +0000300 // Ensure extensions are off by default.
buildbot@webrtc.org150835e2014-05-06 15:54:38 +0000301 EXPECT_EQ(-1, voe_.GetReceiveRtpExtensionId(channel_num, ext));
henrike@webrtc.org79047f92014-03-06 23:46:59 +0000302
buildbot@webrtc.org150835e2014-05-06 15:54:38 +0000303 std::vector<cricket::RtpHeaderExtension> extensions;
henrike@webrtc.org79047f92014-03-06 23:46:59 +0000304 // Ensure unknown extensions won't cause an error.
305 extensions.push_back(cricket::RtpHeaderExtension(
306 "urn:ietf:params:unknownextention", 1));
307 EXPECT_TRUE(channel_->SetRecvRtpHeaderExtensions(extensions));
buildbot@webrtc.org150835e2014-05-06 15:54:38 +0000308 EXPECT_EQ(-1, voe_.GetReceiveRtpExtensionId(channel_num, ext));
henrike@webrtc.org79047f92014-03-06 23:46:59 +0000309
buildbot@webrtc.org150835e2014-05-06 15:54:38 +0000310 // Ensure extensions stay off with an empty list of headers.
henrike@webrtc.org79047f92014-03-06 23:46:59 +0000311 extensions.clear();
312 EXPECT_TRUE(channel_->SetRecvRtpHeaderExtensions(extensions));
buildbot@webrtc.org150835e2014-05-06 15:54:38 +0000313 EXPECT_EQ(-1, voe_.GetReceiveRtpExtensionId(channel_num, ext));
henrike@webrtc.org79047f92014-03-06 23:46:59 +0000314
buildbot@webrtc.org150835e2014-05-06 15:54:38 +0000315 // Ensure extension is set properly.
316 const int id = 2;
317 extensions.push_back(cricket::RtpHeaderExtension(ext, id));
henrike@webrtc.org79047f92014-03-06 23:46:59 +0000318 EXPECT_TRUE(channel_->SetRecvRtpHeaderExtensions(extensions));
buildbot@webrtc.org150835e2014-05-06 15:54:38 +0000319 EXPECT_EQ(id, voe_.GetReceiveRtpExtensionId(channel_num, ext));
henrike@webrtc.org79047f92014-03-06 23:46:59 +0000320
buildbot@webrtc.org150835e2014-05-06 15:54:38 +0000321 // Ensure extension is set properly on new channel.
322 // The first stream to occupy the default channel.
323 EXPECT_TRUE(channel_->AddRecvStream(
324 cricket::StreamParams::CreateLegacy(345)));
325 EXPECT_TRUE(channel_->AddRecvStream(
326 cricket::StreamParams::CreateLegacy(456)));
327 int new_channel_num = voe_.GetLastChannel();
328 EXPECT_NE(channel_num, new_channel_num);
329 EXPECT_EQ(id, voe_.GetReceiveRtpExtensionId(new_channel_num, ext));
330
331 // Ensure all extensions go back off with an empty list.
henrike@webrtc.org79047f92014-03-06 23:46:59 +0000332 extensions.clear();
333 EXPECT_TRUE(channel_->SetRecvRtpHeaderExtensions(extensions));
buildbot@webrtc.org150835e2014-05-06 15:54:38 +0000334 EXPECT_EQ(-1, voe_.GetReceiveRtpExtensionId(channel_num, ext));
335 EXPECT_EQ(-1, voe_.GetReceiveRtpExtensionId(new_channel_num, ext));
wu@webrtc.org9dba5252013-08-05 20:36:57 +0000336 }
337
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000338 protected:
339 cricket::FakeWebRtcVoiceEngine voe_;
340 cricket::FakeWebRtcVoiceEngine voe_sc_;
wu@webrtc.org97077a32013-10-25 21:18:33 +0000341 FakeVoETraceWrapper* trace_wrapper_;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000342 cricket::WebRtcVoiceEngine engine_;
343 cricket::VoiceMediaChannel* channel_;
344 cricket::SoundclipMedia* soundclip_;
345
346 cricket::AudioOptions options_conference_;
347 cricket::AudioOptions options_adjust_agc_;
348};
349
350// Tests that our stub library "works".
351TEST_F(WebRtcVoiceEngineTestFake, StartupShutdown) {
352 EXPECT_FALSE(voe_.IsInited());
353 EXPECT_FALSE(voe_sc_.IsInited());
354 EXPECT_TRUE(engine_.Init(talk_base::Thread::Current()));
355 EXPECT_TRUE(voe_.IsInited());
wu@webrtc.org4551b792013-10-09 15:37:36 +0000356 // The soundclip engine is lazily initialized.
357 EXPECT_FALSE(voe_sc_.IsInited());
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000358 engine_.Terminate();
359 EXPECT_FALSE(voe_.IsInited());
360 EXPECT_FALSE(voe_sc_.IsInited());
361}
362
363// Tests that we can create and destroy a channel.
364TEST_F(WebRtcVoiceEngineTestFake, CreateChannel) {
365 EXPECT_TRUE(engine_.Init(talk_base::Thread::Current()));
366 channel_ = engine_.CreateChannel();
367 EXPECT_TRUE(channel_ != NULL);
368}
369
370// Tests that we properly handle failures in CreateChannel.
371TEST_F(WebRtcVoiceEngineTestFake, CreateChannelFail) {
372 voe_.set_fail_create_channel(true);
373 EXPECT_TRUE(engine_.Init(talk_base::Thread::Current()));
374 channel_ = engine_.CreateChannel();
375 EXPECT_TRUE(channel_ == NULL);
376}
377
378// Tests that the list of supported codecs is created properly and ordered
379// correctly
380TEST_F(WebRtcVoiceEngineTestFake, CodecPreference) {
381 const std::vector<cricket::AudioCodec>& codecs = engine_.codecs();
382 ASSERT_FALSE(codecs.empty());
383 EXPECT_STRCASEEQ("opus", codecs[0].name.c_str());
384 EXPECT_EQ(48000, codecs[0].clockrate);
385 EXPECT_EQ(2, codecs[0].channels);
386 EXPECT_EQ(64000, codecs[0].bitrate);
387 int pref = codecs[0].preference;
388 for (size_t i = 1; i < codecs.size(); ++i) {
389 EXPECT_GT(pref, codecs[i].preference);
390 pref = codecs[i].preference;
391 }
392}
393
394// Tests that we can find codecs by name or id, and that we interpret the
395// clockrate and bitrate fields properly.
396TEST_F(WebRtcVoiceEngineTestFake, FindCodec) {
397 cricket::AudioCodec codec;
398 webrtc::CodecInst codec_inst;
399 // Find PCMU with explicit clockrate and bitrate.
400 EXPECT_TRUE(engine_.FindWebRtcCodec(kPcmuCodec, &codec_inst));
401 // Find ISAC with explicit clockrate and 0 bitrate.
402 EXPECT_TRUE(engine_.FindWebRtcCodec(kIsacCodec, &codec_inst));
403 // Find telephone-event with explicit clockrate and 0 bitrate.
404 EXPECT_TRUE(engine_.FindWebRtcCodec(kTelephoneEventCodec, &codec_inst));
405 // Find ISAC with a different payload id.
406 codec = kIsacCodec;
407 codec.id = 127;
408 EXPECT_TRUE(engine_.FindWebRtcCodec(codec, &codec_inst));
409 EXPECT_EQ(codec.id, codec_inst.pltype);
410 // Find PCMU with a 0 clockrate.
411 codec = kPcmuCodec;
412 codec.clockrate = 0;
413 EXPECT_TRUE(engine_.FindWebRtcCodec(codec, &codec_inst));
414 EXPECT_EQ(codec.id, codec_inst.pltype);
415 EXPECT_EQ(8000, codec_inst.plfreq);
416 // Find PCMU with a 0 bitrate.
417 codec = kPcmuCodec;
418 codec.bitrate = 0;
419 EXPECT_TRUE(engine_.FindWebRtcCodec(codec, &codec_inst));
420 EXPECT_EQ(codec.id, codec_inst.pltype);
421 EXPECT_EQ(64000, codec_inst.rate);
422 // Find ISAC with an explicit bitrate.
423 codec = kIsacCodec;
424 codec.bitrate = 32000;
425 EXPECT_TRUE(engine_.FindWebRtcCodec(codec, &codec_inst));
426 EXPECT_EQ(codec.id, codec_inst.pltype);
427 EXPECT_EQ(32000, codec_inst.rate);
428}
429
430// Test that we set our inbound codecs properly, including changing PT.
431TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecs) {
432 EXPECT_TRUE(SetupEngine());
433 int channel_num = voe_.GetLastChannel();
434 std::vector<cricket::AudioCodec> codecs;
435 codecs.push_back(kIsacCodec);
436 codecs.push_back(kPcmuCodec);
437 codecs.push_back(kTelephoneEventCodec);
438 codecs[0].id = 106; // collide with existing telephone-event
439 codecs[2].id = 126;
440 EXPECT_TRUE(channel_->SetRecvCodecs(codecs));
441 webrtc::CodecInst gcodec;
442 talk_base::strcpyn(gcodec.plname, ARRAY_SIZE(gcodec.plname), "ISAC");
443 gcodec.plfreq = 16000;
444 gcodec.channels = 1;
445 EXPECT_EQ(0, voe_.GetRecPayloadType(channel_num, gcodec));
446 EXPECT_EQ(106, gcodec.pltype);
447 EXPECT_STREQ("ISAC", gcodec.plname);
448 talk_base::strcpyn(gcodec.plname, ARRAY_SIZE(gcodec.plname),
449 "telephone-event");
450 gcodec.plfreq = 8000;
451 EXPECT_EQ(0, voe_.GetRecPayloadType(channel_num, gcodec));
452 EXPECT_EQ(126, gcodec.pltype);
453 EXPECT_STREQ("telephone-event", gcodec.plname);
454}
455
456// Test that we fail to set an unknown inbound codec.
457TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecsUnsupportedCodec) {
458 EXPECT_TRUE(SetupEngine());
459 std::vector<cricket::AudioCodec> codecs;
460 codecs.push_back(kIsacCodec);
461 codecs.push_back(cricket::AudioCodec(127, "XYZ", 32000, 0, 1, 0));
462 EXPECT_FALSE(channel_->SetRecvCodecs(codecs));
463}
464
465// Test that we fail if we have duplicate types in the inbound list.
466TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecsDuplicatePayloadType) {
467 EXPECT_TRUE(SetupEngine());
468 std::vector<cricket::AudioCodec> codecs;
469 codecs.push_back(kIsacCodec);
470 codecs.push_back(kCn16000Codec);
471 codecs[1].id = kIsacCodec.id;
472 EXPECT_FALSE(channel_->SetRecvCodecs(codecs));
473}
474
475// Test that we can decode OPUS without stereo parameters.
476TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecsWithOpusNoStereo) {
477 EXPECT_TRUE(SetupEngine());
478 EXPECT_TRUE(channel_->SetOptions(options_conference_));
479 std::vector<cricket::AudioCodec> codecs;
480 codecs.push_back(kIsacCodec);
481 codecs.push_back(kPcmuCodec);
482 codecs.push_back(kOpusCodec);
483 EXPECT_TRUE(channel_->SetRecvCodecs(codecs));
484 EXPECT_TRUE(channel_->AddRecvStream(
485 cricket::StreamParams::CreateLegacy(kSsrc1)));
486 int channel_num2 = voe_.GetLastChannel();
487 webrtc::CodecInst opus;
488 engine_.FindWebRtcCodec(kOpusCodec, &opus);
489 // Even without stereo parameters, recv codecs still specify channels = 2.
490 EXPECT_EQ(2, opus.channels);
491 EXPECT_EQ(111, opus.pltype);
492 EXPECT_STREQ("opus", opus.plname);
493 opus.pltype = 0;
494 EXPECT_EQ(0, voe_.GetRecPayloadType(channel_num2, opus));
495 EXPECT_EQ(111, opus.pltype);
496}
497
498// Test that we can decode OPUS with stereo = 0.
499TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecsWithOpus0Stereo) {
500 EXPECT_TRUE(SetupEngine());
501 EXPECT_TRUE(channel_->SetOptions(options_conference_));
502 std::vector<cricket::AudioCodec> codecs;
503 codecs.push_back(kIsacCodec);
504 codecs.push_back(kPcmuCodec);
505 codecs.push_back(kOpusCodec);
506 codecs[2].params["stereo"] = "0";
507 EXPECT_TRUE(channel_->SetRecvCodecs(codecs));
508 EXPECT_TRUE(channel_->AddRecvStream(
509 cricket::StreamParams::CreateLegacy(kSsrc1)));
510 int channel_num2 = voe_.GetLastChannel();
511 webrtc::CodecInst opus;
512 engine_.FindWebRtcCodec(kOpusCodec, &opus);
513 // Even when stereo is off, recv codecs still specify channels = 2.
514 EXPECT_EQ(2, opus.channels);
515 EXPECT_EQ(111, opus.pltype);
516 EXPECT_STREQ("opus", opus.plname);
517 opus.pltype = 0;
518 EXPECT_EQ(0, voe_.GetRecPayloadType(channel_num2, opus));
519 EXPECT_EQ(111, opus.pltype);
520}
521
522// Test that we can decode OPUS with stereo = 1.
523TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecsWithOpus1Stereo) {
524 EXPECT_TRUE(SetupEngine());
525 EXPECT_TRUE(channel_->SetOptions(options_conference_));
526 std::vector<cricket::AudioCodec> codecs;
527 codecs.push_back(kIsacCodec);
528 codecs.push_back(kPcmuCodec);
529 codecs.push_back(kOpusCodec);
530 codecs[2].params["stereo"] = "1";
531 EXPECT_TRUE(channel_->SetRecvCodecs(codecs));
532 EXPECT_TRUE(channel_->AddRecvStream(
533 cricket::StreamParams::CreateLegacy(kSsrc1)));
534 int channel_num2 = voe_.GetLastChannel();
535 webrtc::CodecInst opus;
536 engine_.FindWebRtcCodec(kOpusCodec, &opus);
537 EXPECT_EQ(2, opus.channels);
538 EXPECT_EQ(111, opus.pltype);
539 EXPECT_STREQ("opus", opus.plname);
540 opus.pltype = 0;
541 EXPECT_EQ(0, voe_.GetRecPayloadType(channel_num2, opus));
542 EXPECT_EQ(111, opus.pltype);
543}
544
545// Test that changes to recv codecs are applied to all streams.
546TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecsWithMultipleStreams) {
547 EXPECT_TRUE(SetupEngine());
548 EXPECT_TRUE(channel_->SetOptions(options_conference_));
549 std::vector<cricket::AudioCodec> codecs;
550 codecs.push_back(kIsacCodec);
551 codecs.push_back(kPcmuCodec);
552 codecs.push_back(kTelephoneEventCodec);
553 codecs[0].id = 106; // collide with existing telephone-event
554 codecs[2].id = 126;
555 EXPECT_TRUE(channel_->SetRecvCodecs(codecs));
556 EXPECT_TRUE(channel_->AddRecvStream(
557 cricket::StreamParams::CreateLegacy(kSsrc1)));
558 int channel_num2 = voe_.GetLastChannel();
559 webrtc::CodecInst gcodec;
560 talk_base::strcpyn(gcodec.plname, ARRAY_SIZE(gcodec.plname), "ISAC");
561 gcodec.plfreq = 16000;
562 gcodec.channels = 1;
563 EXPECT_EQ(0, voe_.GetRecPayloadType(channel_num2, gcodec));
564 EXPECT_EQ(106, gcodec.pltype);
565 EXPECT_STREQ("ISAC", gcodec.plname);
566 talk_base::strcpyn(gcodec.plname, ARRAY_SIZE(gcodec.plname),
567 "telephone-event");
568 gcodec.plfreq = 8000;
569 gcodec.channels = 1;
570 EXPECT_EQ(0, voe_.GetRecPayloadType(channel_num2, gcodec));
571 EXPECT_EQ(126, gcodec.pltype);
572 EXPECT_STREQ("telephone-event", gcodec.plname);
573}
574
575TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecsAfterAddingStreams) {
576 EXPECT_TRUE(SetupEngine());
577 EXPECT_TRUE(channel_->SetOptions(options_conference_));
578 std::vector<cricket::AudioCodec> codecs;
579 codecs.push_back(kIsacCodec);
580 codecs[0].id = 106; // collide with existing telephone-event
581
582 EXPECT_TRUE(channel_->AddRecvStream(
583 cricket::StreamParams::CreateLegacy(kSsrc1)));
584 EXPECT_TRUE(channel_->SetRecvCodecs(codecs));
585
586 int channel_num2 = voe_.GetLastChannel();
587 webrtc::CodecInst gcodec;
588 talk_base::strcpyn(gcodec.plname, ARRAY_SIZE(gcodec.plname), "ISAC");
589 gcodec.plfreq = 16000;
590 gcodec.channels = 1;
591 EXPECT_EQ(0, voe_.GetRecPayloadType(channel_num2, gcodec));
592 EXPECT_EQ(106, gcodec.pltype);
593 EXPECT_STREQ("ISAC", gcodec.plname);
594}
595
596// Test that we can apply the same set of codecs again while playing.
597TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecsWhilePlaying) {
598 EXPECT_TRUE(SetupEngine());
599 int channel_num = voe_.GetLastChannel();
600 std::vector<cricket::AudioCodec> codecs;
601 codecs.push_back(kIsacCodec);
602 codecs.push_back(kCn16000Codec);
603 EXPECT_TRUE(channel_->SetRecvCodecs(codecs));
604 EXPECT_TRUE(channel_->SetPlayout(true));
605 EXPECT_TRUE(channel_->SetRecvCodecs(codecs));
606
607 // Changing the payload type of a codec should fail.
608 codecs[0].id = 127;
609 EXPECT_FALSE(channel_->SetRecvCodecs(codecs));
610 EXPECT_TRUE(voe_.GetPlayout(channel_num));
611}
612
613// Test that we can add a codec while playing.
614TEST_F(WebRtcVoiceEngineTestFake, AddRecvCodecsWhilePlaying) {
615 EXPECT_TRUE(SetupEngine());
616 int channel_num = voe_.GetLastChannel();
617 std::vector<cricket::AudioCodec> codecs;
618 codecs.push_back(kIsacCodec);
619 codecs.push_back(kCn16000Codec);
620 EXPECT_TRUE(channel_->SetRecvCodecs(codecs));
621 EXPECT_TRUE(channel_->SetPlayout(true));
622
623 codecs.push_back(kOpusCodec);
624 EXPECT_TRUE(channel_->SetRecvCodecs(codecs));
625 EXPECT_TRUE(voe_.GetPlayout(channel_num));
626 webrtc::CodecInst gcodec;
627 EXPECT_TRUE(engine_.FindWebRtcCodec(kOpusCodec, &gcodec));
628 EXPECT_EQ(kOpusCodec.id, gcodec.pltype);
629}
630
631TEST_F(WebRtcVoiceEngineTestFake, SetSendBandwidthAuto) {
632 EXPECT_TRUE(SetupEngine());
633 EXPECT_TRUE(channel_->SetSendCodecs(engine_.codecs()));
634
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +0000635 // Test that when autobw is enabled, bitrate is kept as the default
636 // value. autobw is enabled for the following tests because the target
637 // bitrate is <= 0.
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000638
639 // ISAC, default bitrate == 32000.
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +0000640 TestSendBandwidth(kIsacCodec, 0, true, 32000);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000641
642 // PCMU, default bitrate == 64000.
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +0000643 TestSendBandwidth(kPcmuCodec, -1, true, 64000);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000644
645 // CELT, default bitrate == 64000.
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +0000646 TestSendBandwidth(kCeltCodec, 0, true, 64000);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000647
648 // opus, default bitrate == 64000.
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +0000649 TestSendBandwidth(kOpusCodec, -1, true, 64000);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000650}
651
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +0000652TEST_F(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthMultiRateAsCaller) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000653 EXPECT_TRUE(SetupEngine());
654 EXPECT_TRUE(channel_->SetSendCodecs(engine_.codecs()));
655
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +0000656 // Test that the bitrate of a multi-rate codec is always the maximum.
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000657
658 // ISAC, default bitrate == 32000.
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +0000659 TestSendBandwidth(kIsacCodec, 128000, true, 128000);
660 TestSendBandwidth(kIsacCodec, 16000, true, 16000);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000661
662 // CELT, default bitrate == 64000.
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +0000663 TestSendBandwidth(kCeltCodec, 96000, true, 96000);
664 TestSendBandwidth(kCeltCodec, 32000, true, 32000);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000665
666 // opus, default bitrate == 64000.
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +0000667 TestSendBandwidth(kOpusCodec, 96000, true, 96000);
668 TestSendBandwidth(kOpusCodec, 48000, true, 48000);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000669}
670
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +0000671TEST_F(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthFixedRateAsCaller) {
672 EXPECT_TRUE(SetupEngine());
673 EXPECT_TRUE(channel_->SetSendCodecs(engine_.codecs()));
674
675 // Test that we can only set a maximum bitrate for a fixed-rate codec
676 // if it's bigger than the fixed rate.
677
678 // PCMU, fixed bitrate == 64000.
679 TestSendBandwidth(kPcmuCodec, 0, true, 64000);
680 TestSendBandwidth(kPcmuCodec, 1, false, 64000);
681 TestSendBandwidth(kPcmuCodec, 128000, true, 64000);
682 TestSendBandwidth(kPcmuCodec, 32000, false, 64000);
683 TestSendBandwidth(kPcmuCodec, 64000, true, 64000);
684 TestSendBandwidth(kPcmuCodec, 63999, false, 64000);
685 TestSendBandwidth(kPcmuCodec, 64001, true, 64000);
686}
687
688TEST_F(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthMultiRateAsCallee) {
wu@webrtc.org1d1ffc92013-10-16 18:12:02 +0000689 EXPECT_TRUE(engine_.Init(talk_base::Thread::Current()));
690 channel_ = engine_.CreateChannel();
691 EXPECT_TRUE(channel_ != NULL);
692 EXPECT_TRUE(channel_->SetSendCodecs(engine_.codecs()));
693
694 int desired_bitrate = 128000;
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +0000695 EXPECT_TRUE(channel_->SetMaxSendBandwidth(desired_bitrate));
wu@webrtc.org1d1ffc92013-10-16 18:12:02 +0000696
697 EXPECT_TRUE(channel_->AddSendStream(
698 cricket::StreamParams::CreateLegacy(kSsrc1)));
699
700 int channel_num = voe_.GetLastChannel();
701 webrtc::CodecInst codec;
702 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, codec));
703 EXPECT_EQ(desired_bitrate, codec.rate);
704}
705
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000706// Test that bitrate cannot be set for CBR codecs.
707// Bitrate is ignored if it is higher than the fixed bitrate.
708// Bitrate less then the fixed bitrate is an error.
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +0000709TEST_F(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthCbr) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000710 EXPECT_TRUE(SetupEngine());
711 EXPECT_TRUE(channel_->SetSendCodecs(engine_.codecs()));
712
713 webrtc::CodecInst codec;
714 int channel_num = voe_.GetLastChannel();
715 std::vector<cricket::AudioCodec> codecs;
716
717 // PCMU, default bitrate == 64000.
718 codecs.push_back(kPcmuCodec);
719 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
720 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, codec));
721 EXPECT_EQ(64000, codec.rate);
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +0000722 EXPECT_TRUE(channel_->SetMaxSendBandwidth(128000));
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000723 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, codec));
724 EXPECT_EQ(64000, codec.rate);
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +0000725 EXPECT_FALSE(channel_->SetMaxSendBandwidth(128));
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000726 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, codec));
727 EXPECT_EQ(64000, codec.rate);
728}
729
730// Test that we apply codecs properly.
731TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecs) {
732 EXPECT_TRUE(SetupEngine());
733 int channel_num = voe_.GetLastChannel();
734 std::vector<cricket::AudioCodec> codecs;
735 codecs.push_back(kIsacCodec);
736 codecs.push_back(kPcmuCodec);
737 codecs.push_back(kRedCodec);
738 codecs[0].id = 96;
739 codecs[0].bitrate = 48000;
740 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
wu@webrtc.org05e7b442014-04-01 17:44:24 +0000741 EXPECT_EQ(1, voe_.GetNumSetSendCodecs());
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000742 webrtc::CodecInst gcodec;
743 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
744 EXPECT_EQ(96, gcodec.pltype);
745 EXPECT_EQ(48000, gcodec.rate);
746 EXPECT_STREQ("ISAC", gcodec.plname);
747 EXPECT_FALSE(voe_.GetVAD(channel_num));
748 EXPECT_FALSE(voe_.GetFEC(channel_num));
749 EXPECT_EQ(13, voe_.GetSendCNPayloadType(channel_num, false));
750 EXPECT_EQ(105, voe_.GetSendCNPayloadType(channel_num, true));
751 EXPECT_EQ(106, voe_.GetSendTelephoneEventPayloadType(channel_num));
752}
753
wu@webrtc.org05e7b442014-04-01 17:44:24 +0000754// Test that VoE Channel doesn't call SetSendCodec again if same codec is tried
755// to apply.
756TEST_F(WebRtcVoiceEngineTestFake, DontResetSetSendCodec) {
757 EXPECT_TRUE(SetupEngine());
758 std::vector<cricket::AudioCodec> codecs;
759 codecs.push_back(kIsacCodec);
760 codecs.push_back(kPcmuCodec);
761 codecs.push_back(kRedCodec);
762 codecs[0].id = 96;
763 codecs[0].bitrate = 48000;
764 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
765 EXPECT_EQ(1, voe_.GetNumSetSendCodecs());
766 // Calling SetSendCodec again with same codec which is already set.
767 // In this case media channel shouldn't send codec to VoE.
768 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
769 EXPECT_EQ(1, voe_.GetNumSetSendCodecs());
770}
771
henrike@webrtc.org704bf9e2014-02-27 17:52:04 +0000772// Test that if clockrate is not 48000 for opus, we fail.
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000773TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusBadClockrate) {
774 EXPECT_TRUE(SetupEngine());
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000775 std::vector<cricket::AudioCodec> codecs;
776 codecs.push_back(kOpusCodec);
777 codecs[0].bitrate = 0;
778 codecs[0].clockrate = 50000;
henrike@webrtc.org704bf9e2014-02-27 17:52:04 +0000779 EXPECT_FALSE(channel_->SetSendCodecs(codecs));
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000780}
781
henrike@webrtc.org704bf9e2014-02-27 17:52:04 +0000782// Test that if channels=0 for opus, we fail.
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000783TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusBad0ChannelsNoStereo) {
784 EXPECT_TRUE(SetupEngine());
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000785 std::vector<cricket::AudioCodec> codecs;
786 codecs.push_back(kOpusCodec);
787 codecs[0].bitrate = 0;
788 codecs[0].channels = 0;
henrike@webrtc.org704bf9e2014-02-27 17:52:04 +0000789 EXPECT_FALSE(channel_->SetSendCodecs(codecs));
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000790}
791
henrike@webrtc.org704bf9e2014-02-27 17:52:04 +0000792// Test that if channels=0 for opus, we fail.
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000793TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusBad0Channels1Stereo) {
794 EXPECT_TRUE(SetupEngine());
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000795 std::vector<cricket::AudioCodec> codecs;
796 codecs.push_back(kOpusCodec);
797 codecs[0].bitrate = 0;
798 codecs[0].channels = 0;
799 codecs[0].params["stereo"] = "1";
henrike@webrtc.org704bf9e2014-02-27 17:52:04 +0000800 EXPECT_FALSE(channel_->SetSendCodecs(codecs));
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000801}
802
803// Test that if channel is 1 for opus and there's no stereo, we fail.
804TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpus1ChannelNoStereo) {
805 EXPECT_TRUE(SetupEngine());
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000806 std::vector<cricket::AudioCodec> codecs;
807 codecs.push_back(kOpusCodec);
808 codecs[0].bitrate = 0;
809 codecs[0].channels = 1;
henrike@webrtc.org704bf9e2014-02-27 17:52:04 +0000810 EXPECT_FALSE(channel_->SetSendCodecs(codecs));
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000811}
812
813// Test that if channel is 1 for opus and stereo=0, we fail.
814TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusBad1Channel0Stereo) {
815 EXPECT_TRUE(SetupEngine());
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000816 std::vector<cricket::AudioCodec> codecs;
817 codecs.push_back(kOpusCodec);
818 codecs[0].bitrate = 0;
819 codecs[0].channels = 1;
820 codecs[0].params["stereo"] = "0";
henrike@webrtc.org704bf9e2014-02-27 17:52:04 +0000821 EXPECT_FALSE(channel_->SetSendCodecs(codecs));
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000822}
823
824// Test that if channel is 1 for opus and stereo=1, we fail.
825TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusBad1Channel1Stereo) {
826 EXPECT_TRUE(SetupEngine());
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000827 std::vector<cricket::AudioCodec> codecs;
828 codecs.push_back(kOpusCodec);
829 codecs[0].bitrate = 0;
830 codecs[0].channels = 1;
831 codecs[0].params["stereo"] = "1";
henrike@webrtc.org704bf9e2014-02-27 17:52:04 +0000832 EXPECT_FALSE(channel_->SetSendCodecs(codecs));
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000833}
834
835// Test that with bitrate=0 and no stereo,
836// channels and bitrate are 1 and 32000.
837TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGood0BitrateNoStereo) {
838 EXPECT_TRUE(SetupEngine());
839 int channel_num = voe_.GetLastChannel();
840 std::vector<cricket::AudioCodec> codecs;
841 codecs.push_back(kOpusCodec);
842 codecs[0].bitrate = 0;
843 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
844 webrtc::CodecInst gcodec;
845 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
846 EXPECT_STREQ("opus", gcodec.plname);
847 EXPECT_EQ(1, gcodec.channels);
848 EXPECT_EQ(32000, gcodec.rate);
849}
850
851// Test that with bitrate=0 and stereo=0,
852// channels and bitrate are 1 and 32000.
853TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGood0Bitrate0Stereo) {
854 EXPECT_TRUE(SetupEngine());
855 int channel_num = voe_.GetLastChannel();
856 std::vector<cricket::AudioCodec> codecs;
857 codecs.push_back(kOpusCodec);
858 codecs[0].bitrate = 0;
859 codecs[0].params["stereo"] = "0";
860 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
861 webrtc::CodecInst gcodec;
862 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
863 EXPECT_STREQ("opus", gcodec.plname);
864 EXPECT_EQ(1, gcodec.channels);
865 EXPECT_EQ(32000, gcodec.rate);
866}
867
henrike@webrtc.org1e09a712013-07-26 19:17:59 +0000868// Test that with bitrate=invalid and stereo=0,
869// channels and bitrate are 1 and 32000.
870TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodXBitrate0Stereo) {
871 EXPECT_TRUE(SetupEngine());
872 int channel_num = voe_.GetLastChannel();
873 std::vector<cricket::AudioCodec> codecs;
874 codecs.push_back(kOpusCodec);
875 codecs[0].params["stereo"] = "0";
876 webrtc::CodecInst gcodec;
877
878 // bitrate that's out of the range between 6000 and 510000 will be considered
879 // as invalid and ignored.
880 codecs[0].bitrate = 5999;
881 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
882 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
883 EXPECT_STREQ("opus", gcodec.plname);
884 EXPECT_EQ(1, gcodec.channels);
885 EXPECT_EQ(32000, gcodec.rate);
886
887 codecs[0].bitrate = 510001;
888 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
889 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
890 EXPECT_STREQ("opus", gcodec.plname);
891 EXPECT_EQ(1, gcodec.channels);
892 EXPECT_EQ(32000, gcodec.rate);
893}
894
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000895// Test that with bitrate=0 and stereo=1,
896// channels and bitrate are 2 and 64000.
897TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGood0Bitrate1Stereo) {
898 EXPECT_TRUE(SetupEngine());
899 int channel_num = voe_.GetLastChannel();
900 std::vector<cricket::AudioCodec> codecs;
901 codecs.push_back(kOpusCodec);
902 codecs[0].bitrate = 0;
903 codecs[0].params["stereo"] = "1";
904 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
905 webrtc::CodecInst gcodec;
906 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
907 EXPECT_STREQ("opus", gcodec.plname);
908 EXPECT_EQ(2, gcodec.channels);
909 EXPECT_EQ(64000, gcodec.rate);
910}
911
henrike@webrtc.org1e09a712013-07-26 19:17:59 +0000912// Test that with bitrate=invalid and stereo=1,
913// channels and bitrate are 2 and 64000.
914TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodXBitrate1Stereo) {
915 EXPECT_TRUE(SetupEngine());
916 int channel_num = voe_.GetLastChannel();
917 std::vector<cricket::AudioCodec> codecs;
918 codecs.push_back(kOpusCodec);
919 codecs[0].params["stereo"] = "1";
920 webrtc::CodecInst gcodec;
921
922 // bitrate that's out of the range between 6000 and 510000 will be considered
923 // as invalid and ignored.
924 codecs[0].bitrate = 5999;
925 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
926 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
927 EXPECT_STREQ("opus", gcodec.plname);
928 EXPECT_EQ(2, gcodec.channels);
929 EXPECT_EQ(64000, gcodec.rate);
930
931 codecs[0].bitrate = 510001;
932 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
933 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
934 EXPECT_STREQ("opus", gcodec.plname);
935 EXPECT_EQ(2, gcodec.channels);
936 EXPECT_EQ(64000, gcodec.rate);
937}
938
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000939// Test that with bitrate=N and stereo unset,
940// channels and bitrate are 1 and N.
941TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrateNoStereo) {
942 EXPECT_TRUE(SetupEngine());
943 int channel_num = voe_.GetLastChannel();
944 std::vector<cricket::AudioCodec> codecs;
945 codecs.push_back(kOpusCodec);
946 codecs[0].bitrate = 96000;
947 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
948 webrtc::CodecInst gcodec;
949 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
950 EXPECT_EQ(111, gcodec.pltype);
951 EXPECT_EQ(96000, gcodec.rate);
952 EXPECT_STREQ("opus", gcodec.plname);
953 EXPECT_EQ(1, gcodec.channels);
954 EXPECT_EQ(48000, gcodec.plfreq);
955}
956
957// Test that with bitrate=N and stereo=0,
958// channels and bitrate are 1 and N.
959TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrate0Stereo) {
960 EXPECT_TRUE(SetupEngine());
961 int channel_num = voe_.GetLastChannel();
962 std::vector<cricket::AudioCodec> codecs;
963 codecs.push_back(kOpusCodec);
964 codecs[0].bitrate = 30000;
965 codecs[0].params["stereo"] = "0";
966 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
967 webrtc::CodecInst gcodec;
968 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
969 EXPECT_EQ(1, gcodec.channels);
970 EXPECT_EQ(30000, gcodec.rate);
971 EXPECT_STREQ("opus", gcodec.plname);
972}
973
974// Test that with bitrate=N and without any parameters,
975// channels and bitrate are 1 and N.
976TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrateNoParameters) {
977 EXPECT_TRUE(SetupEngine());
978 int channel_num = voe_.GetLastChannel();
979 std::vector<cricket::AudioCodec> codecs;
980 codecs.push_back(kOpusCodec);
981 codecs[0].bitrate = 30000;
982 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
983 webrtc::CodecInst gcodec;
984 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
985 EXPECT_EQ(1, gcodec.channels);
986 EXPECT_EQ(30000, gcodec.rate);
987 EXPECT_STREQ("opus", gcodec.plname);
988}
989
990// Test that with bitrate=N and stereo=1,
991// channels and bitrate are 2 and N.
992TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrate1Stereo) {
993 EXPECT_TRUE(SetupEngine());
994 int channel_num = voe_.GetLastChannel();
995 std::vector<cricket::AudioCodec> codecs;
996 codecs.push_back(kOpusCodec);
997 codecs[0].bitrate = 30000;
998 codecs[0].params["stereo"] = "1";
999 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
1000 webrtc::CodecInst gcodec;
1001 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
1002 EXPECT_EQ(2, gcodec.channels);
1003 EXPECT_EQ(30000, gcodec.rate);
1004 EXPECT_STREQ("opus", gcodec.plname);
1005}
1006
henrike@webrtc.org1e09a712013-07-26 19:17:59 +00001007// Test that bitrate will be overridden by the "maxaveragebitrate" parameter.
1008// Also test that the "maxaveragebitrate" can't be set to values outside the
1009// range of 6000 and 510000
1010TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusMaxAverageBitrate) {
1011 EXPECT_TRUE(SetupEngine());
1012 int channel_num = voe_.GetLastChannel();
1013 std::vector<cricket::AudioCodec> codecs;
1014 codecs.push_back(kOpusCodec);
1015 codecs[0].bitrate = 30000;
1016 webrtc::CodecInst gcodec;
1017
1018 // Ignore if less than 6000.
1019 codecs[0].params["maxaveragebitrate"] = "5999";
1020 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
1021 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
1022 EXPECT_EQ(30000, gcodec.rate);
1023
1024 // Ignore if larger than 510000.
1025 codecs[0].params["maxaveragebitrate"] = "510001";
1026 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
1027 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
1028 EXPECT_EQ(30000, gcodec.rate);
1029
1030 codecs[0].params["maxaveragebitrate"] = "200000";
1031 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
1032 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
1033 EXPECT_EQ(200000, gcodec.rate);
1034}
1035
wu@webrtc.orgcadf9042013-08-30 21:24:16 +00001036// Test that we can enable NACK with opus as caller.
1037TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecEnableNackAsCaller) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001038 EXPECT_TRUE(SetupEngine());
1039 int channel_num = voe_.GetLastChannel();
1040 std::vector<cricket::AudioCodec> codecs;
1041 codecs.push_back(kOpusCodec);
1042 codecs[0].AddFeedbackParam(cricket::FeedbackParam(cricket::kRtcpFbParamNack,
1043 cricket::kParamValueEmpty));
1044 EXPECT_FALSE(voe_.GetNACK(channel_num));
1045 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
1046 EXPECT_TRUE(voe_.GetNACK(channel_num));
1047}
1048
wu@webrtc.orgcadf9042013-08-30 21:24:16 +00001049// Test that we can enable NACK with opus as callee.
1050TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecEnableNackAsCallee) {
1051 EXPECT_TRUE(engine_.Init(talk_base::Thread::Current()));
1052 channel_ = engine_.CreateChannel();
1053 EXPECT_TRUE(channel_ != NULL);
1054
1055 int channel_num = voe_.GetLastChannel();
1056 std::vector<cricket::AudioCodec> codecs;
1057 codecs.push_back(kOpusCodec);
1058 codecs[0].AddFeedbackParam(cricket::FeedbackParam(cricket::kRtcpFbParamNack,
1059 cricket::kParamValueEmpty));
1060 EXPECT_FALSE(voe_.GetNACK(channel_num));
1061 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
1062 EXPECT_FALSE(voe_.GetNACK(channel_num));
1063
1064 EXPECT_TRUE(channel_->AddSendStream(
1065 cricket::StreamParams::CreateLegacy(kSsrc1)));
1066 EXPECT_TRUE(voe_.GetNACK(channel_num));
1067}
1068
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001069// Test that we can enable NACK on receive streams.
1070TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecEnableNackRecvStreams) {
1071 EXPECT_TRUE(SetupEngine());
1072 EXPECT_TRUE(channel_->SetOptions(options_conference_));
1073 int channel_num1 = voe_.GetLastChannel();
1074 EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(2)));
1075 int channel_num2 = voe_.GetLastChannel();
1076 std::vector<cricket::AudioCodec> codecs;
1077 codecs.push_back(kOpusCodec);
1078 codecs[0].AddFeedbackParam(cricket::FeedbackParam(cricket::kRtcpFbParamNack,
1079 cricket::kParamValueEmpty));
1080 EXPECT_FALSE(voe_.GetNACK(channel_num1));
1081 EXPECT_FALSE(voe_.GetNACK(channel_num2));
1082 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
1083 EXPECT_TRUE(voe_.GetNACK(channel_num1));
1084 EXPECT_TRUE(voe_.GetNACK(channel_num2));
1085}
1086
1087// Test that we can disable NACK.
1088TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecDisableNack) {
1089 EXPECT_TRUE(SetupEngine());
1090 int channel_num = voe_.GetLastChannel();
1091 std::vector<cricket::AudioCodec> codecs;
1092 codecs.push_back(kOpusCodec);
1093 codecs[0].AddFeedbackParam(cricket::FeedbackParam(cricket::kRtcpFbParamNack,
1094 cricket::kParamValueEmpty));
1095 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
1096 EXPECT_TRUE(voe_.GetNACK(channel_num));
1097
1098 codecs.clear();
1099 codecs.push_back(kOpusCodec);
1100 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
1101 EXPECT_FALSE(voe_.GetNACK(channel_num));
1102}
1103
1104// Test that we can disable NACK on receive streams.
1105TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecDisableNackRecvStreams) {
1106 EXPECT_TRUE(SetupEngine());
1107 EXPECT_TRUE(channel_->SetOptions(options_conference_));
1108 int channel_num1 = voe_.GetLastChannel();
1109 EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(2)));
1110 int channel_num2 = voe_.GetLastChannel();
1111 std::vector<cricket::AudioCodec> codecs;
1112 codecs.push_back(kOpusCodec);
1113 codecs[0].AddFeedbackParam(cricket::FeedbackParam(cricket::kRtcpFbParamNack,
1114 cricket::kParamValueEmpty));
1115 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
1116 EXPECT_TRUE(voe_.GetNACK(channel_num1));
1117 EXPECT_TRUE(voe_.GetNACK(channel_num2));
1118
1119 codecs.clear();
1120 codecs.push_back(kOpusCodec);
1121 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
1122 EXPECT_FALSE(voe_.GetNACK(channel_num1));
1123 EXPECT_FALSE(voe_.GetNACK(channel_num2));
1124}
1125
1126// Test that NACK is enabled on a new receive stream.
1127TEST_F(WebRtcVoiceEngineTestFake, AddRecvStreamEnableNack) {
1128 EXPECT_TRUE(SetupEngine());
1129 EXPECT_TRUE(channel_->SetOptions(options_conference_));
1130 int channel_num = voe_.GetLastChannel();
1131 std::vector<cricket::AudioCodec> codecs;
1132 codecs.push_back(kIsacCodec);
1133 codecs[0].AddFeedbackParam(cricket::FeedbackParam(cricket::kRtcpFbParamNack,
1134 cricket::kParamValueEmpty));
1135 codecs.push_back(kCn16000Codec);
1136 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
1137 EXPECT_TRUE(voe_.GetNACK(channel_num));
1138
1139 EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(2)));
1140 channel_num = voe_.GetLastChannel();
1141 EXPECT_TRUE(voe_.GetNACK(channel_num));
1142 EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(3)));
1143 channel_num = voe_.GetLastChannel();
1144 EXPECT_TRUE(voe_.GetNACK(channel_num));
1145}
1146
1147// Test that we can apply CELT with stereo mode but fail with mono mode.
1148TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCelt) {
1149 EXPECT_TRUE(SetupEngine());
1150 int channel_num = voe_.GetLastChannel();
1151 std::vector<cricket::AudioCodec> codecs;
1152 codecs.push_back(kCeltCodec);
henrike@webrtc.org704bf9e2014-02-27 17:52:04 +00001153 codecs.push_back(kIsacCodec);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001154 codecs[0].id = 96;
1155 codecs[0].channels = 2;
1156 codecs[0].bitrate = 96000;
henrike@webrtc.org704bf9e2014-02-27 17:52:04 +00001157 codecs[1].bitrate = 64000;
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001158 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
1159 webrtc::CodecInst gcodec;
1160 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
1161 EXPECT_EQ(96, gcodec.pltype);
1162 EXPECT_EQ(96000, gcodec.rate);
1163 EXPECT_EQ(2, gcodec.channels);
1164 EXPECT_STREQ("CELT", gcodec.plname);
1165 // Doesn't support mono, expect it to fall back to the next codec in the list.
1166 codecs[0].channels = 1;
1167 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
1168 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
henrike@webrtc.org704bf9e2014-02-27 17:52:04 +00001169 EXPECT_EQ(103, gcodec.pltype);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001170 EXPECT_EQ(1, gcodec.channels);
1171 EXPECT_EQ(64000, gcodec.rate);
henrike@webrtc.org704bf9e2014-02-27 17:52:04 +00001172 EXPECT_STREQ("ISAC", gcodec.plname);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001173}
1174
1175// Test that we can switch back and forth between CELT and ISAC with CN.
1176TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsIsacCeltSwitching) {
1177 EXPECT_TRUE(SetupEngine());
1178 int channel_num = voe_.GetLastChannel();
1179 std::vector<cricket::AudioCodec> celt_codecs;
1180 celt_codecs.push_back(kCeltCodec);
1181 EXPECT_TRUE(channel_->SetSendCodecs(celt_codecs));
1182 webrtc::CodecInst gcodec;
1183 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
1184 EXPECT_EQ(110, gcodec.pltype);
1185 EXPECT_STREQ("CELT", gcodec.plname);
1186
1187 std::vector<cricket::AudioCodec> isac_codecs;
1188 isac_codecs.push_back(kIsacCodec);
1189 isac_codecs.push_back(kCn16000Codec);
1190 isac_codecs.push_back(kCeltCodec);
1191 EXPECT_TRUE(channel_->SetSendCodecs(isac_codecs));
1192 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
1193 EXPECT_EQ(103, gcodec.pltype);
1194 EXPECT_STREQ("ISAC", gcodec.plname);
1195
1196 EXPECT_TRUE(channel_->SetSendCodecs(celt_codecs));
1197 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
1198 EXPECT_EQ(110, gcodec.pltype);
1199 EXPECT_STREQ("CELT", gcodec.plname);
1200}
1201
1202// Test that we handle various ways of specifying bitrate.
1203TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsBitrate) {
1204 EXPECT_TRUE(SetupEngine());
1205 int channel_num = voe_.GetLastChannel();
1206 std::vector<cricket::AudioCodec> codecs;
1207 codecs.push_back(kIsacCodec); // bitrate == 32000
1208 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
1209 webrtc::CodecInst gcodec;
1210 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
1211 EXPECT_EQ(103, gcodec.pltype);
1212 EXPECT_STREQ("ISAC", gcodec.plname);
1213 EXPECT_EQ(32000, gcodec.rate);
1214
1215 codecs[0].bitrate = 0; // bitrate == default
1216 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
1217 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
1218 EXPECT_EQ(103, gcodec.pltype);
1219 EXPECT_STREQ("ISAC", gcodec.plname);
1220 EXPECT_EQ(-1, gcodec.rate);
1221
1222 codecs[0].bitrate = 28000; // bitrate == 28000
1223 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
1224 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
1225 EXPECT_EQ(103, gcodec.pltype);
1226 EXPECT_STREQ("ISAC", gcodec.plname);
1227 EXPECT_EQ(28000, gcodec.rate);
1228
1229 codecs[0] = kPcmuCodec; // bitrate == 64000
1230 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
1231 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
1232 EXPECT_EQ(0, gcodec.pltype);
1233 EXPECT_STREQ("PCMU", gcodec.plname);
1234 EXPECT_EQ(64000, gcodec.rate);
1235
1236 codecs[0].bitrate = 0; // bitrate == default
1237 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
1238 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
1239 EXPECT_EQ(0, gcodec.pltype);
1240 EXPECT_STREQ("PCMU", gcodec.plname);
1241 EXPECT_EQ(64000, gcodec.rate);
1242
1243 codecs[0] = kOpusCodec;
1244 codecs[0].bitrate = 0; // bitrate == default
1245 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
1246 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
1247 EXPECT_EQ(111, gcodec.pltype);
1248 EXPECT_STREQ("opus", gcodec.plname);
1249 EXPECT_EQ(32000, gcodec.rate);
1250}
1251
henrike@webrtc.org704bf9e2014-02-27 17:52:04 +00001252// Test that we fail if no codecs are specified.
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001253TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsNoCodecs) {
1254 EXPECT_TRUE(SetupEngine());
henrike@webrtc.org704bf9e2014-02-27 17:52:04 +00001255 std::vector<cricket::AudioCodec> codecs;
1256 EXPECT_FALSE(channel_->SetSendCodecs(codecs));
1257}
1258
1259// Test that we can set send codecs even with telephone-event codec as the first
1260// one on the list.
1261TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsDTMFOnTop) {
1262 EXPECT_TRUE(SetupEngine());
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001263 int channel_num = voe_.GetLastChannel();
1264 std::vector<cricket::AudioCodec> codecs;
henrike@webrtc.org704bf9e2014-02-27 17:52:04 +00001265 codecs.push_back(kTelephoneEventCodec);
1266 codecs.push_back(kIsacCodec);
1267 codecs.push_back(kPcmuCodec);
1268 codecs[0].id = 98; // DTMF
1269 codecs[1].id = 96;
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001270 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
1271 webrtc::CodecInst gcodec;
1272 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
henrike@webrtc.org704bf9e2014-02-27 17:52:04 +00001273 EXPECT_EQ(96, gcodec.pltype);
1274 EXPECT_STREQ("ISAC", gcodec.plname);
1275 EXPECT_EQ(98, voe_.GetSendTelephoneEventPayloadType(channel_num));
1276}
1277
1278// Test that we can set send codecs even with CN codec as the first
1279// one on the list.
1280TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNOnTop) {
1281 EXPECT_TRUE(SetupEngine());
1282 int channel_num = voe_.GetLastChannel();
1283 std::vector<cricket::AudioCodec> codecs;
1284 codecs.push_back(kCn16000Codec);
1285 codecs.push_back(kIsacCodec);
1286 codecs.push_back(kPcmuCodec);
1287 codecs[0].id = 98; // wideband CN
1288 codecs[1].id = 96;
1289 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
1290 webrtc::CodecInst gcodec;
1291 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
1292 EXPECT_EQ(96, gcodec.pltype);
1293 EXPECT_STREQ("ISAC", gcodec.plname);
1294 EXPECT_EQ(98, voe_.GetSendCNPayloadType(channel_num, true));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001295}
1296
wu@webrtc.orgcadf9042013-08-30 21:24:16 +00001297// Test that we set VAD and DTMF types correctly as caller.
1298TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNandDTMFAsCaller) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001299 EXPECT_TRUE(SetupEngine());
1300 int channel_num = voe_.GetLastChannel();
1301 std::vector<cricket::AudioCodec> codecs;
1302 codecs.push_back(kIsacCodec);
1303 codecs.push_back(kPcmuCodec);
1304 // TODO(juberti): cn 32000
1305 codecs.push_back(kCn16000Codec);
1306 codecs.push_back(kCn8000Codec);
1307 codecs.push_back(kTelephoneEventCodec);
1308 codecs.push_back(kRedCodec);
1309 codecs[0].id = 96;
1310 codecs[2].id = 97; // wideband CN
1311 codecs[4].id = 98; // DTMF
1312 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
1313 webrtc::CodecInst gcodec;
1314 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
1315 EXPECT_EQ(96, gcodec.pltype);
1316 EXPECT_STREQ("ISAC", gcodec.plname);
1317 EXPECT_TRUE(voe_.GetVAD(channel_num));
1318 EXPECT_FALSE(voe_.GetFEC(channel_num));
1319 EXPECT_EQ(13, voe_.GetSendCNPayloadType(channel_num, false));
1320 EXPECT_EQ(97, voe_.GetSendCNPayloadType(channel_num, true));
1321 EXPECT_EQ(98, voe_.GetSendTelephoneEventPayloadType(channel_num));
1322}
1323
wu@webrtc.orgcadf9042013-08-30 21:24:16 +00001324// Test that we set VAD and DTMF types correctly as callee.
1325TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNandDTMFAsCallee) {
1326 EXPECT_TRUE(engine_.Init(talk_base::Thread::Current()));
1327 channel_ = engine_.CreateChannel();
1328 EXPECT_TRUE(channel_ != NULL);
1329
1330 int channel_num = voe_.GetLastChannel();
1331 std::vector<cricket::AudioCodec> codecs;
1332 codecs.push_back(kIsacCodec);
1333 codecs.push_back(kPcmuCodec);
1334 // TODO(juberti): cn 32000
1335 codecs.push_back(kCn16000Codec);
1336 codecs.push_back(kCn8000Codec);
1337 codecs.push_back(kTelephoneEventCodec);
1338 codecs.push_back(kRedCodec);
1339 codecs[0].id = 96;
1340 codecs[2].id = 97; // wideband CN
1341 codecs[4].id = 98; // DTMF
1342 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
1343 EXPECT_TRUE(channel_->AddSendStream(
1344 cricket::StreamParams::CreateLegacy(kSsrc1)));
1345
1346 webrtc::CodecInst gcodec;
1347 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
1348 EXPECT_EQ(96, gcodec.pltype);
1349 EXPECT_STREQ("ISAC", gcodec.plname);
1350 EXPECT_TRUE(voe_.GetVAD(channel_num));
1351 EXPECT_FALSE(voe_.GetFEC(channel_num));
1352 EXPECT_EQ(13, voe_.GetSendCNPayloadType(channel_num, false));
1353 EXPECT_EQ(97, voe_.GetSendCNPayloadType(channel_num, true));
1354 EXPECT_EQ(98, voe_.GetSendTelephoneEventPayloadType(channel_num));
1355}
1356
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001357// Test that we only apply VAD if we have a CN codec that matches the
1358// send codec clockrate.
1359TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNNoMatch) {
1360 EXPECT_TRUE(SetupEngine());
1361 int channel_num = voe_.GetLastChannel();
1362 std::vector<cricket::AudioCodec> codecs;
1363 // Set ISAC(16K) and CN(16K). VAD should be activated.
1364 codecs.push_back(kIsacCodec);
1365 codecs.push_back(kCn16000Codec);
1366 codecs[1].id = 97;
1367 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
1368 webrtc::CodecInst gcodec;
1369 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
1370 EXPECT_STREQ("ISAC", gcodec.plname);
1371 EXPECT_TRUE(voe_.GetVAD(channel_num));
1372 EXPECT_EQ(97, voe_.GetSendCNPayloadType(channel_num, true));
1373 // Set PCMU(8K) and CN(16K). VAD should not be activated.
1374 codecs[0] = kPcmuCodec;
1375 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
1376 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
1377 EXPECT_STREQ("PCMU", gcodec.plname);
1378 EXPECT_FALSE(voe_.GetVAD(channel_num));
1379 // Set PCMU(8K) and CN(8K). VAD should be activated.
1380 codecs[1] = kCn8000Codec;
1381 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
1382 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
1383 EXPECT_STREQ("PCMU", gcodec.plname);
1384 EXPECT_TRUE(voe_.GetVAD(channel_num));
1385 EXPECT_EQ(13, voe_.GetSendCNPayloadType(channel_num, false));
1386 // Set ISAC(16K) and CN(8K). VAD should not be activated.
1387 codecs[0] = kIsacCodec;
1388 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
1389 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
1390 EXPECT_STREQ("ISAC", gcodec.plname);
1391 EXPECT_FALSE(voe_.GetVAD(channel_num));
1392}
1393
1394// Test that we perform case-insensitive matching of codec names.
1395TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCaseInsensitive) {
1396 EXPECT_TRUE(SetupEngine());
1397 int channel_num = voe_.GetLastChannel();
1398 std::vector<cricket::AudioCodec> codecs;
1399 codecs.push_back(kIsacCodec);
1400 codecs.push_back(kPcmuCodec);
1401 codecs.push_back(kCn16000Codec);
1402 codecs.push_back(kCn8000Codec);
1403 codecs.push_back(kTelephoneEventCodec);
1404 codecs.push_back(kRedCodec);
1405 codecs[0].name = "iSaC";
1406 codecs[0].id = 96;
1407 codecs[2].id = 97; // wideband CN
1408 codecs[4].id = 98; // DTMF
1409 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
1410 webrtc::CodecInst gcodec;
1411 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
1412 EXPECT_EQ(96, gcodec.pltype);
1413 EXPECT_STREQ("ISAC", gcodec.plname);
1414 EXPECT_TRUE(voe_.GetVAD(channel_num));
1415 EXPECT_FALSE(voe_.GetFEC(channel_num));
1416 EXPECT_EQ(13, voe_.GetSendCNPayloadType(channel_num, false));
1417 EXPECT_EQ(97, voe_.GetSendCNPayloadType(channel_num, true));
1418 EXPECT_EQ(98, voe_.GetSendTelephoneEventPayloadType(channel_num));
1419}
1420
wu@webrtc.orgcadf9042013-08-30 21:24:16 +00001421// Test that we set up FEC correctly as caller.
1422TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsREDAsCaller) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001423 EXPECT_TRUE(SetupEngine());
1424 int channel_num = voe_.GetLastChannel();
1425 std::vector<cricket::AudioCodec> codecs;
1426 codecs.push_back(kRedCodec);
1427 codecs.push_back(kIsacCodec);
1428 codecs.push_back(kPcmuCodec);
1429 codecs[0].id = 127;
1430 codecs[0].params[""] = "96/96";
1431 codecs[1].id = 96;
1432 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
1433 webrtc::CodecInst gcodec;
1434 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
1435 EXPECT_EQ(96, gcodec.pltype);
1436 EXPECT_STREQ("ISAC", gcodec.plname);
1437 EXPECT_TRUE(voe_.GetFEC(channel_num));
1438 EXPECT_EQ(127, voe_.GetSendFECPayloadType(channel_num));
1439}
1440
wu@webrtc.orgcadf9042013-08-30 21:24:16 +00001441// Test that we set up FEC correctly as callee.
1442TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsREDAsCallee) {
1443 EXPECT_TRUE(engine_.Init(talk_base::Thread::Current()));
1444 channel_ = engine_.CreateChannel();
1445 EXPECT_TRUE(channel_ != NULL);
1446
1447 int channel_num = voe_.GetLastChannel();
1448 std::vector<cricket::AudioCodec> codecs;
1449 codecs.push_back(kRedCodec);
1450 codecs.push_back(kIsacCodec);
1451 codecs.push_back(kPcmuCodec);
1452 codecs[0].id = 127;
1453 codecs[0].params[""] = "96/96";
1454 codecs[1].id = 96;
1455 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
1456 EXPECT_TRUE(channel_->AddSendStream(
1457 cricket::StreamParams::CreateLegacy(kSsrc1)));
1458 webrtc::CodecInst gcodec;
1459 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
1460 EXPECT_EQ(96, gcodec.pltype);
1461 EXPECT_STREQ("ISAC", gcodec.plname);
1462 EXPECT_TRUE(voe_.GetFEC(channel_num));
1463 EXPECT_EQ(127, voe_.GetSendFECPayloadType(channel_num));
1464}
1465
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001466// Test that we set up FEC correctly if params are omitted.
1467TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsREDNoParams) {
1468 EXPECT_TRUE(SetupEngine());
1469 int channel_num = voe_.GetLastChannel();
1470 std::vector<cricket::AudioCodec> codecs;
1471 codecs.push_back(kRedCodec);
1472 codecs.push_back(kIsacCodec);
1473 codecs.push_back(kPcmuCodec);
1474 codecs[0].id = 127;
1475 codecs[1].id = 96;
1476 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
1477 webrtc::CodecInst gcodec;
1478 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
1479 EXPECT_EQ(96, gcodec.pltype);
1480 EXPECT_STREQ("ISAC", gcodec.plname);
1481 EXPECT_TRUE(voe_.GetFEC(channel_num));
1482 EXPECT_EQ(127, voe_.GetSendFECPayloadType(channel_num));
1483}
1484
1485// Test that we ignore RED if the parameters aren't named the way we expect.
1486TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsBadRED1) {
1487 EXPECT_TRUE(SetupEngine());
1488 int channel_num = voe_.GetLastChannel();
1489 std::vector<cricket::AudioCodec> codecs;
1490 codecs.push_back(kRedCodec);
1491 codecs.push_back(kIsacCodec);
1492 codecs.push_back(kPcmuCodec);
1493 codecs[0].id = 127;
1494 codecs[0].params["ABC"] = "96/96";
1495 codecs[1].id = 96;
1496 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
1497 webrtc::CodecInst gcodec;
1498 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
1499 EXPECT_EQ(96, gcodec.pltype);
1500 EXPECT_STREQ("ISAC", gcodec.plname);
1501 EXPECT_FALSE(voe_.GetFEC(channel_num));
1502}
1503
1504// Test that we ignore RED if it uses different primary/secondary encoding.
1505TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsBadRED2) {
1506 EXPECT_TRUE(SetupEngine());
1507 int channel_num = voe_.GetLastChannel();
1508 std::vector<cricket::AudioCodec> codecs;
1509 codecs.push_back(kRedCodec);
1510 codecs.push_back(kIsacCodec);
1511 codecs.push_back(kPcmuCodec);
1512 codecs[0].id = 127;
1513 codecs[0].params[""] = "96/0";
1514 codecs[1].id = 96;
1515 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
1516 webrtc::CodecInst gcodec;
1517 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
1518 EXPECT_EQ(96, gcodec.pltype);
1519 EXPECT_STREQ("ISAC", gcodec.plname);
1520 EXPECT_FALSE(voe_.GetFEC(channel_num));
1521}
1522
1523// Test that we ignore RED if it uses more than 2 encodings.
1524TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsBadRED3) {
1525 EXPECT_TRUE(SetupEngine());
1526 int channel_num = voe_.GetLastChannel();
1527 std::vector<cricket::AudioCodec> codecs;
1528 codecs.push_back(kRedCodec);
1529 codecs.push_back(kIsacCodec);
1530 codecs.push_back(kPcmuCodec);
1531 codecs[0].id = 127;
1532 codecs[0].params[""] = "96/96/96";
1533 codecs[1].id = 96;
1534 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
1535 webrtc::CodecInst gcodec;
1536 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
1537 EXPECT_EQ(96, gcodec.pltype);
1538 EXPECT_STREQ("ISAC", gcodec.plname);
1539 EXPECT_FALSE(voe_.GetFEC(channel_num));
1540}
1541
1542// Test that we ignore RED if it has bogus codec ids.
1543TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsBadRED4) {
1544 EXPECT_TRUE(SetupEngine());
1545 int channel_num = voe_.GetLastChannel();
1546 std::vector<cricket::AudioCodec> codecs;
1547 codecs.push_back(kRedCodec);
1548 codecs.push_back(kIsacCodec);
1549 codecs.push_back(kPcmuCodec);
1550 codecs[0].id = 127;
1551 codecs[0].params[""] = "ABC/ABC";
1552 codecs[1].id = 96;
1553 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
1554 webrtc::CodecInst gcodec;
1555 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
1556 EXPECT_EQ(96, gcodec.pltype);
1557 EXPECT_STREQ("ISAC", gcodec.plname);
1558 EXPECT_FALSE(voe_.GetFEC(channel_num));
1559}
1560
1561// Test that we ignore RED if it refers to a codec that is not present.
1562TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsBadRED5) {
1563 EXPECT_TRUE(SetupEngine());
1564 int channel_num = voe_.GetLastChannel();
1565 std::vector<cricket::AudioCodec> codecs;
1566 codecs.push_back(kRedCodec);
1567 codecs.push_back(kIsacCodec);
1568 codecs.push_back(kPcmuCodec);
1569 codecs[0].id = 127;
1570 codecs[0].params[""] = "97/97";
1571 codecs[1].id = 96;
1572 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
1573 webrtc::CodecInst gcodec;
1574 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
1575 EXPECT_EQ(96, gcodec.pltype);
1576 EXPECT_STREQ("ISAC", gcodec.plname);
1577 EXPECT_FALSE(voe_.GetFEC(channel_num));
1578}
1579
buildbot@webrtc.org150835e2014-05-06 15:54:38 +00001580// Test support for audio level header extension.
1581TEST_F(WebRtcVoiceEngineTestFake, SendAudioLevelHeaderExtensions) {
1582 TestSetSendRtpHeaderExtensions(kRtpAudioLevelHeaderExtension);
henrike@webrtc.org79047f92014-03-06 23:46:59 +00001583}
buildbot@webrtc.org150835e2014-05-06 15:54:38 +00001584#ifdef USE_WEBRTC_DEV_BRANCH
1585TEST_F(WebRtcVoiceEngineTestFake, RecvAudioLevelHeaderExtensions) {
1586 TestSetRecvRtpHeaderExtensions(kRtpAudioLevelHeaderExtension);
1587}
1588#endif // USE_WEBRTC_DEV_BRANCH
henrike@webrtc.org79047f92014-03-06 23:46:59 +00001589
buildbot@webrtc.org150835e2014-05-06 15:54:38 +00001590// Test support for absolute send time header extension.
1591TEST_F(WebRtcVoiceEngineTestFake, SendAbsoluteSendTimeHeaderExtensions) {
1592 TestSetSendRtpHeaderExtensions(kRtpAbsoluteSenderTimeHeaderExtension);
1593}
1594TEST_F(WebRtcVoiceEngineTestFake, RecvAbsoluteSendTimeHeaderExtensions) {
1595 TestSetRecvRtpHeaderExtensions(kRtpAbsoluteSenderTimeHeaderExtension);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001596}
1597
1598// Test that we can create a channel and start sending/playing out on it.
1599TEST_F(WebRtcVoiceEngineTestFake, SendAndPlayout) {
1600 EXPECT_TRUE(SetupEngine());
1601 int channel_num = voe_.GetLastChannel();
1602 std::vector<cricket::AudioCodec> codecs;
1603 codecs.push_back(kPcmuCodec);
1604 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
1605 EXPECT_TRUE(channel_->SetSend(cricket::SEND_MICROPHONE));
1606 EXPECT_TRUE(voe_.GetSend(channel_num));
1607 EXPECT_TRUE(channel_->SetPlayout(true));
1608 EXPECT_TRUE(voe_.GetPlayout(channel_num));
1609 EXPECT_TRUE(channel_->SetSend(cricket::SEND_NOTHING));
1610 EXPECT_FALSE(voe_.GetSend(channel_num));
1611 EXPECT_TRUE(channel_->SetPlayout(false));
1612 EXPECT_FALSE(voe_.GetPlayout(channel_num));
1613}
1614
wu@webrtc.org9dba5252013-08-05 20:36:57 +00001615// Test that we can add and remove send streams.
1616TEST_F(WebRtcVoiceEngineTestFake, CreateAndDeleteMultipleSendStreams) {
1617 SetupForMultiSendStream();
1618
1619 static const uint32 kSsrcs4[] = {1, 2, 3, 4};
1620
1621 // Set the global state for sending.
1622 EXPECT_TRUE(channel_->SetSend(cricket::SEND_MICROPHONE));
1623
1624 for (unsigned int i = 0; i < ARRAY_SIZE(kSsrcs4); ++i) {
1625 EXPECT_TRUE(channel_->AddSendStream(
1626 cricket::StreamParams::CreateLegacy(kSsrcs4[i])));
1627
1628 // Verify that we are in a sending state for all the created streams.
1629 int channel_num = voe_.GetChannelFromLocalSsrc(kSsrcs4[i]);
1630 EXPECT_TRUE(voe_.GetSend(channel_num));
1631 }
1632
1633 // Remove the first send channel, which is the default channel. It will only
1634 // recycle the default channel but not delete it.
1635 EXPECT_TRUE(channel_->RemoveSendStream(kSsrcs4[0]));
1636 // Stream should already be Removed from the send stream list.
1637 EXPECT_FALSE(channel_->RemoveSendStream(kSsrcs4[0]));
1638 // But the default still exists.
1639 EXPECT_EQ(0, voe_.GetChannelFromLocalSsrc(kSsrcs4[0]));
1640
1641 // Delete the rest of send channel streams.
1642 for (unsigned int i = 1; i < ARRAY_SIZE(kSsrcs4); ++i) {
1643 EXPECT_TRUE(channel_->RemoveSendStream(kSsrcs4[i]));
1644 // Stream should already be deleted.
1645 EXPECT_FALSE(channel_->RemoveSendStream(kSsrcs4[i]));
1646 EXPECT_EQ(-1, voe_.GetChannelFromLocalSsrc(kSsrcs4[i]));
1647 }
1648}
1649
1650// Test SetSendCodecs correctly configure the codecs in all send streams.
1651TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsWithMultipleSendStreams) {
1652 SetupForMultiSendStream();
1653
1654 static const uint32 kSsrcs4[] = {1, 2, 3, 4};
1655 // Create send streams.
1656 for (unsigned int i = 0; i < ARRAY_SIZE(kSsrcs4); ++i) {
1657 EXPECT_TRUE(channel_->AddSendStream(
1658 cricket::StreamParams::CreateLegacy(kSsrcs4[i])));
1659 }
1660
1661 std::vector<cricket::AudioCodec> codecs;
1662 // Set ISAC(16K) and CN(16K). VAD should be activated.
1663 codecs.push_back(kIsacCodec);
1664 codecs.push_back(kCn16000Codec);
1665 codecs[1].id = 97;
1666 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
1667
1668 // Verify ISAC and VAD are corrected configured on all send channels.
1669 webrtc::CodecInst gcodec;
1670 for (unsigned int i = 0; i < ARRAY_SIZE(kSsrcs4); ++i) {
1671 int channel_num = voe_.GetChannelFromLocalSsrc(kSsrcs4[i]);
1672 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
1673 EXPECT_STREQ("ISAC", gcodec.plname);
1674 EXPECT_TRUE(voe_.GetVAD(channel_num));
1675 EXPECT_EQ(97, voe_.GetSendCNPayloadType(channel_num, true));
1676 }
1677
1678 // Change to PCMU(8K) and CN(16K). VAD should not be activated.
1679 codecs[0] = kPcmuCodec;
1680 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
1681 for (unsigned int i = 0; i < ARRAY_SIZE(kSsrcs4); ++i) {
1682 int channel_num = voe_.GetChannelFromLocalSsrc(kSsrcs4[i]);
1683 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
1684 EXPECT_STREQ("PCMU", gcodec.plname);
1685 EXPECT_FALSE(voe_.GetVAD(channel_num));
1686 }
1687}
1688
1689// Test we can SetSend on all send streams correctly.
1690TEST_F(WebRtcVoiceEngineTestFake, SetSendWithMultipleSendStreams) {
1691 SetupForMultiSendStream();
1692
1693 static const uint32 kSsrcs4[] = {1, 2, 3, 4};
1694 // Create the send channels and they should be a SEND_NOTHING date.
1695 for (unsigned int i = 0; i < ARRAY_SIZE(kSsrcs4); ++i) {
1696 EXPECT_TRUE(channel_->AddSendStream(
1697 cricket::StreamParams::CreateLegacy(kSsrcs4[i])));
1698 int channel_num = voe_.GetLastChannel();
1699 EXPECT_FALSE(voe_.GetSend(channel_num));
1700 }
1701
1702 // Set the global state for starting sending.
1703 EXPECT_TRUE(channel_->SetSend(cricket::SEND_MICROPHONE));
1704 for (unsigned int i = 0; i < ARRAY_SIZE(kSsrcs4); ++i) {
1705 // Verify that we are in a sending state for all the send streams.
1706 int channel_num = voe_.GetChannelFromLocalSsrc(kSsrcs4[i]);
1707 EXPECT_TRUE(voe_.GetSend(channel_num));
1708 }
1709
1710 // Set the global state for stopping sending.
1711 EXPECT_TRUE(channel_->SetSend(cricket::SEND_NOTHING));
1712 for (unsigned int i = 1; i < ARRAY_SIZE(kSsrcs4); ++i) {
1713 // Verify that we are in a stop state for all the send streams.
1714 int channel_num = voe_.GetChannelFromLocalSsrc(kSsrcs4[i]);
1715 EXPECT_FALSE(voe_.GetSend(channel_num));
1716 }
1717}
1718
1719// Test we can set the correct statistics on all send streams.
1720TEST_F(WebRtcVoiceEngineTestFake, GetStatsWithMultipleSendStreams) {
1721 SetupForMultiSendStream();
1722
1723 static const uint32 kSsrcs4[] = {1, 2, 3, 4};
1724 // Create send streams.
1725 for (unsigned int i = 0; i < ARRAY_SIZE(kSsrcs4); ++i) {
1726 EXPECT_TRUE(channel_->AddSendStream(
1727 cricket::StreamParams::CreateLegacy(kSsrcs4[i])));
1728 }
1729
1730 // We need send codec to be set to get all stats.
1731 std::vector<cricket::AudioCodec> codecs;
1732 codecs.push_back(kPcmuCodec);
1733 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
1734
1735 cricket::VoiceMediaInfo info;
1736 EXPECT_EQ(true, channel_->GetStats(&info));
1737 EXPECT_EQ(static_cast<size_t>(ARRAY_SIZE(kSsrcs4)), info.senders.size());
1738
1739 // Verify the statistic information is correct.
1740 for (unsigned int i = 0; i < ARRAY_SIZE(kSsrcs4); ++i) {
sergeyu@chromium.org5bc25c42013-12-05 00:24:06 +00001741 EXPECT_EQ(kSsrcs4[i], info.senders[i].ssrc());
wu@webrtc.org9dba5252013-08-05 20:36:57 +00001742 EXPECT_EQ(kPcmuCodec.name, info.senders[i].codec_name);
1743 EXPECT_EQ(cricket::kIntStatValue, info.senders[i].bytes_sent);
1744 EXPECT_EQ(cricket::kIntStatValue, info.senders[i].packets_sent);
1745 EXPECT_EQ(cricket::kIntStatValue, info.senders[i].packets_lost);
1746 EXPECT_EQ(cricket::kFractionLostStatValue, info.senders[i].fraction_lost);
1747 EXPECT_EQ(cricket::kIntStatValue, info.senders[i].ext_seqnum);
1748 EXPECT_EQ(cricket::kIntStatValue, info.senders[i].rtt_ms);
1749 EXPECT_EQ(cricket::kIntStatValue, info.senders[i].jitter_ms);
1750 }
1751
1752 EXPECT_EQ(1u, info.receivers.size());
1753}
1754
wu@webrtc.org9dba5252013-08-05 20:36:57 +00001755// Test that we can add and remove receive streams, and do proper send/playout.
1756// We can receive on multiple streams while sending one stream.
1757TEST_F(WebRtcVoiceEngineTestFake, PlayoutWithMultipleStreams) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001758 EXPECT_TRUE(SetupEngine());
1759 int channel_num1 = voe_.GetLastChannel();
1760
1761 // Start playout on the default channel.
1762 EXPECT_TRUE(channel_->SetOptions(options_conference_));
1763 EXPECT_TRUE(channel_->SetPlayout(true));
1764 EXPECT_TRUE(voe_.GetPlayout(channel_num1));
1765
1766 // Adding another stream should disable playout on the default channel.
1767 EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(2)));
1768 int channel_num2 = voe_.GetLastChannel();
1769 std::vector<cricket::AudioCodec> codecs;
1770 codecs.push_back(kPcmuCodec);
1771 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
1772 EXPECT_TRUE(channel_->SetSend(cricket::SEND_MICROPHONE));
1773 EXPECT_TRUE(voe_.GetSend(channel_num1));
1774 EXPECT_FALSE(voe_.GetSend(channel_num2));
1775
1776 // Make sure only the new channel is played out.
1777 EXPECT_FALSE(voe_.GetPlayout(channel_num1));
1778 EXPECT_TRUE(voe_.GetPlayout(channel_num2));
1779
1780 // Adding yet another stream should have stream 2 and 3 enabled for playout.
1781 EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(3)));
1782 int channel_num3 = voe_.GetLastChannel();
1783 EXPECT_FALSE(voe_.GetPlayout(channel_num1));
1784 EXPECT_TRUE(voe_.GetPlayout(channel_num2));
1785 EXPECT_TRUE(voe_.GetPlayout(channel_num3));
1786 EXPECT_FALSE(voe_.GetSend(channel_num3));
1787
1788 // Stop sending.
1789 EXPECT_TRUE(channel_->SetSend(cricket::SEND_NOTHING));
1790 EXPECT_FALSE(voe_.GetSend(channel_num1));
1791 EXPECT_FALSE(voe_.GetSend(channel_num2));
1792 EXPECT_FALSE(voe_.GetSend(channel_num3));
1793
1794 // Stop playout.
1795 EXPECT_TRUE(channel_->SetPlayout(false));
1796 EXPECT_FALSE(voe_.GetPlayout(channel_num1));
1797 EXPECT_FALSE(voe_.GetPlayout(channel_num2));
1798 EXPECT_FALSE(voe_.GetPlayout(channel_num3));
1799
1800 // Restart playout and make sure the default channel still is not played out.
1801 EXPECT_TRUE(channel_->SetPlayout(true));
1802 EXPECT_FALSE(voe_.GetPlayout(channel_num1));
1803 EXPECT_TRUE(voe_.GetPlayout(channel_num2));
1804 EXPECT_TRUE(voe_.GetPlayout(channel_num3));
1805
1806 // Now remove the new streams and verify that the default channel is
1807 // played out again.
1808 EXPECT_TRUE(channel_->RemoveRecvStream(3));
1809 EXPECT_TRUE(channel_->RemoveRecvStream(2));
1810
1811 EXPECT_TRUE(voe_.GetPlayout(channel_num1));
1812}
1813
1814// Test that we can set the devices to use.
1815TEST_F(WebRtcVoiceEngineTestFake, SetDevices) {
1816 EXPECT_TRUE(SetupEngine());
1817 int channel_num = voe_.GetLastChannel();
1818 std::vector<cricket::AudioCodec> codecs;
1819 codecs.push_back(kPcmuCodec);
1820 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
1821
1822 cricket::Device default_dev(cricket::kFakeDefaultDeviceName,
1823 cricket::kFakeDefaultDeviceId);
1824 cricket::Device dev(cricket::kFakeDeviceName,
1825 cricket::kFakeDeviceId);
1826
1827 // Test SetDevices() while not sending or playing.
1828 EXPECT_TRUE(engine_.SetDevices(&default_dev, &default_dev));
1829
1830 // Test SetDevices() while sending and playing.
1831 EXPECT_TRUE(engine_.SetLocalMonitor(true));
1832 EXPECT_TRUE(channel_->SetSend(cricket::SEND_MICROPHONE));
1833 EXPECT_TRUE(channel_->SetPlayout(true));
1834 EXPECT_TRUE(voe_.GetRecordingMicrophone());
1835 EXPECT_TRUE(voe_.GetSend(channel_num));
1836 EXPECT_TRUE(voe_.GetPlayout(channel_num));
1837
1838 EXPECT_TRUE(engine_.SetDevices(&dev, &dev));
1839
1840 EXPECT_TRUE(voe_.GetRecordingMicrophone());
1841 EXPECT_TRUE(voe_.GetSend(channel_num));
1842 EXPECT_TRUE(voe_.GetPlayout(channel_num));
1843
1844 // Test that failure to open newly selected devices does not prevent opening
1845 // ones after that.
1846 voe_.set_fail_start_recording_microphone(true);
1847 voe_.set_playout_fail_channel(channel_num);
1848 voe_.set_send_fail_channel(channel_num);
1849
1850 EXPECT_FALSE(engine_.SetDevices(&default_dev, &default_dev));
1851
1852 EXPECT_FALSE(voe_.GetRecordingMicrophone());
1853 EXPECT_FALSE(voe_.GetSend(channel_num));
1854 EXPECT_FALSE(voe_.GetPlayout(channel_num));
1855
1856 voe_.set_fail_start_recording_microphone(false);
1857 voe_.set_playout_fail_channel(-1);
1858 voe_.set_send_fail_channel(-1);
1859
1860 EXPECT_TRUE(engine_.SetDevices(&dev, &dev));
1861
1862 EXPECT_TRUE(voe_.GetRecordingMicrophone());
1863 EXPECT_TRUE(voe_.GetSend(channel_num));
1864 EXPECT_TRUE(voe_.GetPlayout(channel_num));
1865}
1866
1867// Test that we can set the devices to use even if we failed to
1868// open the initial ones.
1869TEST_F(WebRtcVoiceEngineTestFake, SetDevicesWithInitiallyBadDevices) {
1870 EXPECT_TRUE(SetupEngine());
1871 int channel_num = voe_.GetLastChannel();
1872 std::vector<cricket::AudioCodec> codecs;
1873 codecs.push_back(kPcmuCodec);
1874 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
1875
1876 cricket::Device default_dev(cricket::kFakeDefaultDeviceName,
1877 cricket::kFakeDefaultDeviceId);
1878 cricket::Device dev(cricket::kFakeDeviceName,
1879 cricket::kFakeDeviceId);
1880
1881 // Test that failure to open devices selected before starting
1882 // send/play does not prevent opening newly selected ones after that.
1883 voe_.set_fail_start_recording_microphone(true);
1884 voe_.set_playout_fail_channel(channel_num);
1885 voe_.set_send_fail_channel(channel_num);
1886
1887 EXPECT_TRUE(engine_.SetDevices(&default_dev, &default_dev));
1888
1889 EXPECT_FALSE(engine_.SetLocalMonitor(true));
1890 EXPECT_FALSE(channel_->SetSend(cricket::SEND_MICROPHONE));
1891 EXPECT_FALSE(channel_->SetPlayout(true));
1892 EXPECT_FALSE(voe_.GetRecordingMicrophone());
1893 EXPECT_FALSE(voe_.GetSend(channel_num));
1894 EXPECT_FALSE(voe_.GetPlayout(channel_num));
1895
1896 voe_.set_fail_start_recording_microphone(false);
1897 voe_.set_playout_fail_channel(-1);
1898 voe_.set_send_fail_channel(-1);
1899
1900 EXPECT_TRUE(engine_.SetDevices(&dev, &dev));
1901
1902 EXPECT_TRUE(voe_.GetRecordingMicrophone());
1903 EXPECT_TRUE(voe_.GetSend(channel_num));
1904 EXPECT_TRUE(voe_.GetPlayout(channel_num));
1905}
1906
1907// Test that we can create a channel configured for multi-point conferences,
1908// and start sending/playing out on it.
1909TEST_F(WebRtcVoiceEngineTestFake, ConferenceSendAndPlayout) {
1910 EXPECT_TRUE(SetupEngine());
1911 int channel_num = voe_.GetLastChannel();
1912 EXPECT_TRUE(channel_->SetOptions(options_conference_));
1913 std::vector<cricket::AudioCodec> codecs;
1914 codecs.push_back(kPcmuCodec);
1915 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
1916 EXPECT_TRUE(channel_->SetSend(cricket::SEND_MICROPHONE));
1917 EXPECT_TRUE(voe_.GetSend(channel_num));
1918}
1919
1920// Test that we can create a channel configured for Codian bridges,
1921// and start sending/playing out on it.
1922TEST_F(WebRtcVoiceEngineTestFake, CodianSendAndPlayout) {
1923 EXPECT_TRUE(SetupEngine());
1924 int channel_num = voe_.GetLastChannel();
1925 webrtc::AgcConfig agc_config;
1926 EXPECT_EQ(0, voe_.GetAgcConfig(agc_config));
1927 EXPECT_EQ(0, agc_config.targetLeveldBOv);
1928 EXPECT_TRUE(channel_->SetOptions(options_adjust_agc_));
1929 std::vector<cricket::AudioCodec> codecs;
1930 codecs.push_back(kPcmuCodec);
1931 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
1932 EXPECT_TRUE(channel_->SetSend(cricket::SEND_MICROPHONE));
1933 EXPECT_TRUE(voe_.GetSend(channel_num));
1934 EXPECT_EQ(0, voe_.GetAgcConfig(agc_config));
1935 EXPECT_EQ(agc_config.targetLeveldBOv, 10); // level was attenuated
1936 EXPECT_TRUE(channel_->SetPlayout(true));
1937 EXPECT_TRUE(voe_.GetPlayout(channel_num));
1938 EXPECT_TRUE(channel_->SetSend(cricket::SEND_NOTHING));
1939 EXPECT_FALSE(voe_.GetSend(channel_num));
1940 EXPECT_EQ(0, voe_.GetAgcConfig(agc_config));
1941 EXPECT_EQ(0, agc_config.targetLeveldBOv); // level was restored
1942 EXPECT_TRUE(channel_->SetPlayout(false));
1943 EXPECT_FALSE(voe_.GetPlayout(channel_num));
1944}
1945
wu@webrtc.org97077a32013-10-25 21:18:33 +00001946TEST_F(WebRtcVoiceEngineTestFake, TxAgcConfigViaOptions) {
1947 EXPECT_TRUE(SetupEngine());
1948 webrtc::AgcConfig agc_config;
1949 EXPECT_EQ(0, voe_.GetAgcConfig(agc_config));
1950 EXPECT_EQ(0, agc_config.targetLeveldBOv);
1951
1952 cricket::AudioOptions options;
1953 options.tx_agc_target_dbov.Set(3);
1954 options.tx_agc_digital_compression_gain.Set(9);
1955 options.tx_agc_limiter.Set(true);
1956 options.auto_gain_control.Set(true);
1957 EXPECT_TRUE(engine_.SetOptions(options));
1958
1959 EXPECT_EQ(0, voe_.GetAgcConfig(agc_config));
1960 EXPECT_EQ(3, agc_config.targetLeveldBOv);
1961 EXPECT_EQ(9, agc_config.digitalCompressionGaindB);
1962 EXPECT_TRUE(agc_config.limiterEnable);
1963
1964 // Check interaction with adjust_agc_delta. Both should be respected, for
1965 // backwards compatibility.
1966 options.adjust_agc_delta.Set(-10);
1967 EXPECT_TRUE(engine_.SetOptions(options));
1968
1969 EXPECT_EQ(0, voe_.GetAgcConfig(agc_config));
1970 EXPECT_EQ(13, agc_config.targetLeveldBOv);
1971}
1972
1973TEST_F(WebRtcVoiceEngineTestFake, RxAgcConfigViaOptions) {
1974 EXPECT_TRUE(SetupEngine());
1975 int channel_num = voe_.GetLastChannel();
1976 cricket::AudioOptions options;
1977 options.rx_agc_target_dbov.Set(6);
1978 options.rx_agc_digital_compression_gain.Set(0);
1979 options.rx_agc_limiter.Set(true);
1980 options.rx_auto_gain_control.Set(true);
1981 EXPECT_TRUE(channel_->SetOptions(options));
1982
1983 webrtc::AgcConfig agc_config;
1984 EXPECT_EQ(0, engine_.voe()->processing()->GetRxAgcConfig(
1985 channel_num, agc_config));
1986 EXPECT_EQ(6, agc_config.targetLeveldBOv);
1987 EXPECT_EQ(0, agc_config.digitalCompressionGaindB);
1988 EXPECT_TRUE(agc_config.limiterEnable);
1989}
1990
1991TEST_F(WebRtcVoiceEngineTestFake, SampleRatesViaOptions) {
1992 EXPECT_TRUE(SetupEngine());
1993 cricket::AudioOptions options;
1994 options.recording_sample_rate.Set(48000u);
1995 options.playout_sample_rate.Set(44100u);
1996 EXPECT_TRUE(engine_.SetOptions(options));
1997
1998 unsigned int recording_sample_rate, playout_sample_rate;
1999 EXPECT_EQ(0, voe_.RecordingSampleRate(&recording_sample_rate));
2000 EXPECT_EQ(0, voe_.PlayoutSampleRate(&playout_sample_rate));
2001 EXPECT_EQ(48000u, recording_sample_rate);
2002 EXPECT_EQ(44100u, playout_sample_rate);
2003}
2004
2005TEST_F(WebRtcVoiceEngineTestFake, TraceFilterViaTraceOptions) {
2006 EXPECT_TRUE(SetupEngine());
2007 engine_.SetLogging(talk_base::LS_INFO, "");
2008 EXPECT_EQ(
2009 // Info:
2010 webrtc::kTraceStateInfo | webrtc::kTraceInfo |
2011 // Warning:
2012 webrtc::kTraceTerseInfo | webrtc::kTraceWarning |
2013 // Error:
2014 webrtc::kTraceError | webrtc::kTraceCritical,
2015 static_cast<int>(trace_wrapper_->filter_));
2016 // Now set it explicitly
2017 std::string filter =
2018 "tracefilter " + talk_base::ToString(webrtc::kTraceDefault);
2019 engine_.SetLogging(talk_base::LS_VERBOSE, filter.c_str());
2020 EXPECT_EQ(static_cast<unsigned int>(webrtc::kTraceDefault),
2021 trace_wrapper_->filter_);
2022}
2023
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002024// Test that we can set the outgoing SSRC properly.
2025// SSRC is set in SetupEngine by calling AddSendStream.
2026TEST_F(WebRtcVoiceEngineTestFake, SetSendSsrc) {
2027 EXPECT_TRUE(SetupEngine());
2028 int channel_num = voe_.GetLastChannel();
2029 unsigned int send_ssrc;
2030 EXPECT_EQ(0, voe_.GetLocalSSRC(channel_num, send_ssrc));
2031 EXPECT_NE(0U, send_ssrc);
2032 EXPECT_EQ(0, voe_.GetLocalSSRC(channel_num, send_ssrc));
2033 EXPECT_EQ(kSsrc1, send_ssrc);
2034}
2035
2036TEST_F(WebRtcVoiceEngineTestFake, GetStats) {
2037 // Setup. We need send codec to be set to get all stats.
2038 EXPECT_TRUE(SetupEngine());
2039 std::vector<cricket::AudioCodec> codecs;
2040 codecs.push_back(kPcmuCodec);
2041 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
2042
2043 cricket::VoiceMediaInfo info;
2044 EXPECT_EQ(true, channel_->GetStats(&info));
2045 EXPECT_EQ(1u, info.senders.size());
sergeyu@chromium.org5bc25c42013-12-05 00:24:06 +00002046 EXPECT_EQ(kSsrc1, info.senders[0].ssrc());
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002047 EXPECT_EQ(kPcmuCodec.name, info.senders[0].codec_name);
2048 EXPECT_EQ(cricket::kIntStatValue, info.senders[0].bytes_sent);
2049 EXPECT_EQ(cricket::kIntStatValue, info.senders[0].packets_sent);
2050 EXPECT_EQ(cricket::kIntStatValue, info.senders[0].packets_lost);
2051 EXPECT_EQ(cricket::kFractionLostStatValue, info.senders[0].fraction_lost);
2052 EXPECT_EQ(cricket::kIntStatValue, info.senders[0].ext_seqnum);
2053 EXPECT_EQ(cricket::kIntStatValue, info.senders[0].rtt_ms);
2054 EXPECT_EQ(cricket::kIntStatValue, info.senders[0].jitter_ms);
2055 // TODO(sriniv): Add testing for more fields. These are not populated
2056 // in FakeWebrtcVoiceEngine yet.
2057 // EXPECT_EQ(cricket::kIntStatValue, info.senders[0].audio_level);
2058 // EXPECT_EQ(cricket::kIntStatValue, info.senders[0].echo_delay_median_ms);
2059 // EXPECT_EQ(cricket::kIntStatValue, info.senders[0].echo_delay_std_ms);
2060 // EXPECT_EQ(cricket::kIntStatValue, info.senders[0].echo_return_loss);
2061 // EXPECT_EQ(cricket::kIntStatValue,
2062 // info.senders[0].echo_return_loss_enhancement);
2063
2064 EXPECT_EQ(1u, info.receivers.size());
2065 // TODO(sriniv): Add testing for receiver fields.
2066}
2067
2068// Test that we can set the outgoing SSRC properly with multiple streams.
2069// SSRC is set in SetupEngine by calling AddSendStream.
2070TEST_F(WebRtcVoiceEngineTestFake, SetSendSsrcWithMultipleStreams) {
2071 EXPECT_TRUE(SetupEngine());
2072 EXPECT_TRUE(channel_->SetOptions(options_conference_));
2073 int channel_num1 = voe_.GetLastChannel();
2074 unsigned int send_ssrc;
2075 EXPECT_EQ(0, voe_.GetLocalSSRC(channel_num1, send_ssrc));
2076 EXPECT_EQ(kSsrc1, send_ssrc);
2077
2078 EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(2)));
2079 int channel_num2 = voe_.GetLastChannel();
2080 EXPECT_EQ(0, voe_.GetLocalSSRC(channel_num2, send_ssrc));
2081 EXPECT_EQ(kSsrc1, send_ssrc);
2082}
2083
2084// Test that the local SSRC is the same on sending and receiving channels if the
2085// receive channel is created before the send channel.
2086TEST_F(WebRtcVoiceEngineTestFake, SetSendSsrcAfterCreatingReceiveChannel) {
2087 EXPECT_TRUE(engine_.Init(talk_base::Thread::Current()));
2088 channel_ = engine_.CreateChannel();
2089 EXPECT_TRUE(channel_->SetOptions(options_conference_));
2090
2091 EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1)));
2092 int receive_channel_num = voe_.GetLastChannel();
2093 EXPECT_TRUE(channel_->AddSendStream(
2094 cricket::StreamParams::CreateLegacy(1234)));
2095 int send_channel_num = voe_.GetLastChannel();
2096
2097 unsigned int ssrc = 0;
2098 EXPECT_EQ(0, voe_.GetLocalSSRC(send_channel_num, ssrc));
2099 EXPECT_EQ(1234U, ssrc);
2100 ssrc = 0;
2101 EXPECT_EQ(0, voe_.GetLocalSSRC(receive_channel_num, ssrc));
2102 EXPECT_EQ(1234U, ssrc);
2103}
2104
2105// Test that we can properly receive packets.
2106TEST_F(WebRtcVoiceEngineTestFake, Recv) {
2107 EXPECT_TRUE(SetupEngine());
2108 int channel_num = voe_.GetLastChannel();
2109 DeliverPacket(kPcmuFrame, sizeof(kPcmuFrame));
2110 EXPECT_TRUE(voe_.CheckPacket(channel_num, kPcmuFrame,
2111 sizeof(kPcmuFrame)));
2112}
2113
2114// Test that we can properly receive packets on multiple streams.
2115TEST_F(WebRtcVoiceEngineTestFake, RecvWithMultipleStreams) {
2116 EXPECT_TRUE(SetupEngine());
2117 EXPECT_TRUE(channel_->SetOptions(options_conference_));
2118 EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1)));
2119 int channel_num1 = voe_.GetLastChannel();
2120 EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(2)));
2121 int channel_num2 = voe_.GetLastChannel();
2122 EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(3)));
2123 int channel_num3 = voe_.GetLastChannel();
2124 // Create packets with the right SSRCs.
2125 char packets[4][sizeof(kPcmuFrame)];
2126 for (size_t i = 0; i < ARRAY_SIZE(packets); ++i) {
2127 memcpy(packets[i], kPcmuFrame, sizeof(kPcmuFrame));
wu@webrtc.org9caf2762013-12-11 18:25:07 +00002128 talk_base::SetBE32(packets[i] + 8, static_cast<uint32>(i));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002129 }
2130 EXPECT_TRUE(voe_.CheckNoPacket(channel_num1));
2131 EXPECT_TRUE(voe_.CheckNoPacket(channel_num2));
2132 EXPECT_TRUE(voe_.CheckNoPacket(channel_num3));
2133 DeliverPacket(packets[0], sizeof(packets[0]));
2134 EXPECT_TRUE(voe_.CheckNoPacket(channel_num1));
2135 EXPECT_TRUE(voe_.CheckNoPacket(channel_num2));
2136 EXPECT_TRUE(voe_.CheckNoPacket(channel_num3));
2137 DeliverPacket(packets[1], sizeof(packets[1]));
2138 EXPECT_TRUE(voe_.CheckPacket(channel_num1, packets[1],
2139 sizeof(packets[1])));
2140 EXPECT_TRUE(voe_.CheckNoPacket(channel_num2));
2141 EXPECT_TRUE(voe_.CheckNoPacket(channel_num3));
2142 DeliverPacket(packets[2], sizeof(packets[2]));
2143 EXPECT_TRUE(voe_.CheckNoPacket(channel_num1));
2144 EXPECT_TRUE(voe_.CheckPacket(channel_num2, packets[2],
2145 sizeof(packets[2])));
2146 EXPECT_TRUE(voe_.CheckNoPacket(channel_num3));
2147 DeliverPacket(packets[3], sizeof(packets[3]));
2148 EXPECT_TRUE(voe_.CheckNoPacket(channel_num1));
2149 EXPECT_TRUE(voe_.CheckNoPacket(channel_num2));
2150 EXPECT_TRUE(voe_.CheckPacket(channel_num3, packets[3],
2151 sizeof(packets[3])));
2152 EXPECT_TRUE(channel_->RemoveRecvStream(3));
2153 EXPECT_TRUE(channel_->RemoveRecvStream(2));
2154 EXPECT_TRUE(channel_->RemoveRecvStream(1));
2155}
2156
2157// Test that we properly handle failures to add a stream.
2158TEST_F(WebRtcVoiceEngineTestFake, AddStreamFail) {
2159 EXPECT_TRUE(SetupEngine());
2160 voe_.set_fail_create_channel(true);
2161 EXPECT_TRUE(channel_->SetOptions(options_conference_));
2162 EXPECT_FALSE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(2)));
2163
2164 // In 1:1 call, we should not try to create a new channel.
2165 cricket::AudioOptions options_no_conference_;
2166 options_no_conference_.conference_mode.Set(false);
2167 EXPECT_TRUE(channel_->SetOptions(options_no_conference_));
2168 EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(2)));
2169}
2170
2171// Test that AddRecvStream doesn't create new channel for 1:1 call.
2172TEST_F(WebRtcVoiceEngineTestFake, AddRecvStream1On1) {
2173 EXPECT_TRUE(SetupEngine());
2174 int channel_num = voe_.GetLastChannel();
2175 EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1)));
2176 EXPECT_EQ(channel_num, voe_.GetLastChannel());
2177}
2178
2179// Test that after adding a recv stream, we do not decode more codecs than
2180// those previously passed into SetRecvCodecs.
2181TEST_F(WebRtcVoiceEngineTestFake, AddRecvStreamUnsupportedCodec) {
2182 EXPECT_TRUE(SetupEngine());
2183 EXPECT_TRUE(channel_->SetOptions(options_conference_));
2184 std::vector<cricket::AudioCodec> codecs;
2185 codecs.push_back(kIsacCodec);
2186 codecs.push_back(kPcmuCodec);
2187 EXPECT_TRUE(channel_->SetRecvCodecs(codecs));
2188 EXPECT_TRUE(channel_->AddRecvStream(
2189 cricket::StreamParams::CreateLegacy(kSsrc1)));
2190 int channel_num2 = voe_.GetLastChannel();
2191 webrtc::CodecInst gcodec;
2192 talk_base::strcpyn(gcodec.plname, ARRAY_SIZE(gcodec.plname), "CELT");
2193 gcodec.plfreq = 32000;
2194 gcodec.channels = 2;
2195 EXPECT_EQ(-1, voe_.GetRecPayloadType(channel_num2, gcodec));
2196}
2197
2198// Test that we properly clean up any streams that were added, even if
2199// not explicitly removed.
2200TEST_F(WebRtcVoiceEngineTestFake, StreamCleanup) {
2201 EXPECT_TRUE(SetupEngine());
2202 EXPECT_TRUE(channel_->SetOptions(options_conference_));
2203 EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1)));
2204 EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(2)));
2205 EXPECT_EQ(3, voe_.GetNumChannels()); // default channel + 2 added
2206 delete channel_;
2207 channel_ = NULL;
2208 EXPECT_EQ(0, voe_.GetNumChannels());
2209}
2210
wu@webrtc.org78187522013-10-07 23:32:02 +00002211TEST_F(WebRtcVoiceEngineTestFake, TestAddRecvStreamFailWithZeroSsrc) {
2212 EXPECT_TRUE(SetupEngine());
2213 EXPECT_FALSE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(0)));
2214}
2215
2216TEST_F(WebRtcVoiceEngineTestFake, TestNoLeakingWhenAddRecvStreamFail) {
2217 EXPECT_TRUE(SetupEngine());
2218 // Stream 1 reuses default channel.
2219 EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1)));
2220 // Manually delete default channel to simulate a failure.
2221 int default_channel = voe_.GetLastChannel();
2222 EXPECT_EQ(0, voe_.DeleteChannel(default_channel));
2223 // Add recv stream 2 should fail because default channel is gone.
2224 EXPECT_FALSE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(2)));
2225 int new_channel = voe_.GetLastChannel();
2226 EXPECT_NE(default_channel, new_channel);
2227 // The last created channel should have already been deleted.
2228 EXPECT_EQ(-1, voe_.DeleteChannel(new_channel));
2229}
2230
wu@webrtc.orgcadf9042013-08-30 21:24:16 +00002231// Test the InsertDtmf on default send stream as caller.
2232TEST_F(WebRtcVoiceEngineTestFake, InsertDtmfOnDefaultSendStreamAsCaller) {
2233 TestInsertDtmf(0, true);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002234}
2235
wu@webrtc.orgcadf9042013-08-30 21:24:16 +00002236// Test the InsertDtmf on default send stream as callee
2237TEST_F(WebRtcVoiceEngineTestFake, InsertDtmfOnDefaultSendStreamAsCallee) {
2238 TestInsertDtmf(0, false);
2239}
2240
2241// Test the InsertDtmf on specified send stream as caller.
2242TEST_F(WebRtcVoiceEngineTestFake, InsertDtmfOnSendStreamAsCaller) {
2243 TestInsertDtmf(kSsrc1, true);
2244}
2245
2246// Test the InsertDtmf on specified send stream as callee.
2247TEST_F(WebRtcVoiceEngineTestFake, InsertDtmfOnSendStreamAsCallee) {
2248 TestInsertDtmf(kSsrc1, false);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002249}
2250
2251// Test that we can play a ringback tone properly in a single-stream call.
2252TEST_F(WebRtcVoiceEngineTestFake, PlayRingback) {
2253 EXPECT_TRUE(SetupEngine());
2254 int channel_num = voe_.GetLastChannel();
2255 EXPECT_EQ(0, voe_.IsPlayingFileLocally(channel_num));
2256 // Check we fail if no ringback tone specified.
2257 EXPECT_FALSE(channel_->PlayRingbackTone(0, true, true));
2258 EXPECT_EQ(0, voe_.IsPlayingFileLocally(channel_num));
2259 // Check we can set and play a ringback tone.
wu@webrtc.org9caf2762013-12-11 18:25:07 +00002260 EXPECT_TRUE(channel_->SetRingbackTone(
2261 kRingbackTone, static_cast<int>(strlen(kRingbackTone))));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002262 EXPECT_TRUE(channel_->PlayRingbackTone(0, true, true));
2263 EXPECT_EQ(1, voe_.IsPlayingFileLocally(channel_num));
2264 // Check we can stop the tone manually.
2265 EXPECT_TRUE(channel_->PlayRingbackTone(0, false, false));
2266 EXPECT_EQ(0, voe_.IsPlayingFileLocally(channel_num));
2267 // Check we stop the tone if a packet arrives.
2268 EXPECT_TRUE(channel_->PlayRingbackTone(0, true, true));
2269 EXPECT_EQ(1, voe_.IsPlayingFileLocally(channel_num));
2270 DeliverPacket(kPcmuFrame, sizeof(kPcmuFrame));
2271 EXPECT_EQ(0, voe_.IsPlayingFileLocally(channel_num));
2272}
2273
2274// Test that we can play a ringback tone properly in a multi-stream call.
2275TEST_F(WebRtcVoiceEngineTestFake, PlayRingbackWithMultipleStreams) {
2276 EXPECT_TRUE(SetupEngine());
2277 EXPECT_TRUE(channel_->SetOptions(options_conference_));
2278 EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1)));
2279 EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(2)));
2280 int channel_num = voe_.GetLastChannel();
2281 EXPECT_EQ(0, voe_.IsPlayingFileLocally(channel_num));
2282 // Check we fail if no ringback tone specified.
2283 EXPECT_FALSE(channel_->PlayRingbackTone(2, true, true));
2284 EXPECT_EQ(0, voe_.IsPlayingFileLocally(channel_num));
2285 // Check we can set and play a ringback tone on the correct ssrc.
wu@webrtc.org9caf2762013-12-11 18:25:07 +00002286 EXPECT_TRUE(channel_->SetRingbackTone(
2287 kRingbackTone, static_cast<int>(strlen(kRingbackTone))));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002288 EXPECT_FALSE(channel_->PlayRingbackTone(77, true, true));
2289 EXPECT_TRUE(channel_->PlayRingbackTone(2, true, true));
2290 EXPECT_EQ(1, voe_.IsPlayingFileLocally(channel_num));
2291 // Check we can stop the tone manually.
2292 EXPECT_TRUE(channel_->PlayRingbackTone(2, false, false));
2293 EXPECT_EQ(0, voe_.IsPlayingFileLocally(channel_num));
2294 // Check we stop the tone if a packet arrives, but only with the right SSRC.
2295 EXPECT_TRUE(channel_->PlayRingbackTone(2, true, true));
2296 EXPECT_EQ(1, voe_.IsPlayingFileLocally(channel_num));
2297 // Send a packet with SSRC 1; the tone should not stop.
2298 DeliverPacket(kPcmuFrame, sizeof(kPcmuFrame));
2299 EXPECT_EQ(1, voe_.IsPlayingFileLocally(channel_num));
2300 // Send a packet with SSRC 2; the tone should stop.
2301 char packet[sizeof(kPcmuFrame)];
2302 memcpy(packet, kPcmuFrame, sizeof(kPcmuFrame));
2303 talk_base::SetBE32(packet + 8, 2);
2304 DeliverPacket(packet, sizeof(packet));
2305 EXPECT_EQ(0, voe_.IsPlayingFileLocally(channel_num));
2306}
2307
2308// Tests creating soundclips, and make sure they come from the right engine.
2309TEST_F(WebRtcVoiceEngineTestFake, CreateSoundclip) {
2310 EXPECT_TRUE(engine_.Init(talk_base::Thread::Current()));
wu@webrtc.org4551b792013-10-09 15:37:36 +00002311 EXPECT_FALSE(voe_sc_.IsInited());
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002312 soundclip_ = engine_.CreateSoundclip();
wu@webrtc.org4551b792013-10-09 15:37:36 +00002313 EXPECT_TRUE(voe_sc_.IsInited());
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002314 ASSERT_TRUE(soundclip_ != NULL);
2315 EXPECT_EQ(0, voe_.GetNumChannels());
2316 EXPECT_EQ(1, voe_sc_.GetNumChannels());
2317 int channel_num = voe_sc_.GetLastChannel();
2318 EXPECT_TRUE(voe_sc_.GetPlayout(channel_num));
2319 delete soundclip_;
2320 soundclip_ = NULL;
2321 EXPECT_EQ(0, voe_sc_.GetNumChannels());
wu@webrtc.org4551b792013-10-09 15:37:36 +00002322 // Make sure the soundclip engine is uninitialized on shutdown, now that
2323 // we've initialized it by creating a soundclip.
2324 engine_.Terminate();
2325 EXPECT_FALSE(voe_sc_.IsInited());
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002326}
2327
2328// Tests playing out a fake sound.
2329TEST_F(WebRtcVoiceEngineTestFake, PlaySoundclip) {
2330 static const char kZeroes[16000] = {};
2331 EXPECT_TRUE(engine_.Init(talk_base::Thread::Current()));
2332 soundclip_ = engine_.CreateSoundclip();
2333 ASSERT_TRUE(soundclip_ != NULL);
2334 EXPECT_TRUE(soundclip_->PlaySound(kZeroes, sizeof(kZeroes), 0));
2335}
2336
2337TEST_F(WebRtcVoiceEngineTestFake, MediaEngineCallbackOnError) {
2338 talk_base::scoped_ptr<ChannelErrorListener> listener;
2339 cricket::WebRtcVoiceMediaChannel* media_channel;
2340 unsigned int ssrc = 0;
2341
2342 EXPECT_TRUE(SetupEngine());
2343 EXPECT_TRUE(channel_->SetOptions(options_conference_));
2344 EXPECT_TRUE(channel_->SetSend(cricket::SEND_MICROPHONE));
2345
2346 media_channel = static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_);
2347 listener.reset(new ChannelErrorListener(channel_));
2348
2349 // Test on WebRtc VoE channel.
2350 voe_.TriggerCallbackOnError(media_channel->voe_channel(),
2351 VE_SATURATION_WARNING);
2352 EXPECT_EQ(cricket::VoiceMediaChannel::ERROR_REC_DEVICE_SATURATION,
2353 listener->error());
2354 EXPECT_NE(-1, voe_.GetLocalSSRC(voe_.GetLastChannel(), ssrc));
2355 EXPECT_EQ(ssrc, listener->ssrc());
2356
2357 listener->Reset();
2358 voe_.TriggerCallbackOnError(-1, VE_TYPING_NOISE_WARNING);
2359 EXPECT_EQ(cricket::VoiceMediaChannel::ERROR_REC_TYPING_NOISE_DETECTED,
2360 listener->error());
2361 EXPECT_EQ(0U, listener->ssrc());
2362
2363 // Add another stream and test on that.
2364 ++ssrc;
2365 EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(
2366 ssrc)));
2367 listener->Reset();
2368 voe_.TriggerCallbackOnError(voe_.GetLastChannel(),
2369 VE_SATURATION_WARNING);
2370 EXPECT_EQ(cricket::VoiceMediaChannel::ERROR_REC_DEVICE_SATURATION,
2371 listener->error());
2372 EXPECT_EQ(ssrc, listener->ssrc());
2373
2374 // Testing a non-existing channel.
2375 listener->Reset();
2376 voe_.TriggerCallbackOnError(voe_.GetLastChannel() + 2,
2377 VE_SATURATION_WARNING);
2378 EXPECT_EQ(0, listener->error());
2379}
2380
2381TEST_F(WebRtcVoiceEngineTestFake, TestSetPlayoutError) {
2382 EXPECT_TRUE(SetupEngine());
2383 EXPECT_TRUE(channel_->SetOptions(options_conference_));
2384 std::vector<cricket::AudioCodec> codecs;
2385 codecs.push_back(kPcmuCodec);
2386 EXPECT_TRUE(channel_->SetSendCodecs(codecs));
2387 EXPECT_TRUE(channel_->SetSend(cricket::SEND_MICROPHONE));
2388 EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(2)));
2389 EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(3)));
2390 EXPECT_TRUE(channel_->SetPlayout(true));
2391 voe_.set_playout_fail_channel(voe_.GetLastChannel() - 1);
2392 EXPECT_TRUE(channel_->SetPlayout(false));
2393 EXPECT_FALSE(channel_->SetPlayout(true));
2394}
2395
2396// Test that the Registering/Unregistering with the
2397// webrtcvoiceengine works as expected
2398TEST_F(WebRtcVoiceEngineTestFake, RegisterVoiceProcessor) {
2399 EXPECT_TRUE(SetupEngine());
2400 EXPECT_TRUE(channel_->SetOptions(options_conference_));
2401 EXPECT_TRUE(channel_->AddRecvStream(
2402 cricket::StreamParams::CreateLegacy(kSsrc2)));
2403 cricket::FakeMediaProcessor vp_1;
2404 cricket::FakeMediaProcessor vp_2;
2405
2406 EXPECT_FALSE(engine_.RegisterProcessor(kSsrc2, &vp_1, cricket::MPD_TX));
2407 EXPECT_TRUE(engine_.RegisterProcessor(kSsrc2, &vp_1, cricket::MPD_RX));
2408 EXPECT_TRUE(engine_.RegisterProcessor(kSsrc2, &vp_2, cricket::MPD_RX));
2409 voe_.TriggerProcessPacket(cricket::MPD_RX);
2410 voe_.TriggerProcessPacket(cricket::MPD_TX);
2411
2412 EXPECT_TRUE(voe_.IsExternalMediaProcessorRegistered());
2413 EXPECT_EQ(1, vp_1.voice_frame_count());
2414 EXPECT_EQ(1, vp_2.voice_frame_count());
2415
2416 EXPECT_TRUE(engine_.UnregisterProcessor(kSsrc2,
2417 &vp_2,
2418 cricket::MPD_RX));
2419 voe_.TriggerProcessPacket(cricket::MPD_RX);
2420 EXPECT_TRUE(voe_.IsExternalMediaProcessorRegistered());
2421 EXPECT_EQ(1, vp_2.voice_frame_count());
2422 EXPECT_EQ(2, vp_1.voice_frame_count());
2423
2424 EXPECT_TRUE(engine_.UnregisterProcessor(kSsrc2,
2425 &vp_1,
2426 cricket::MPD_RX));
2427 voe_.TriggerProcessPacket(cricket::MPD_RX);
2428 EXPECT_FALSE(voe_.IsExternalMediaProcessorRegistered());
2429 EXPECT_EQ(2, vp_1.voice_frame_count());
2430
2431 EXPECT_FALSE(engine_.RegisterProcessor(kSsrc1, &vp_1, cricket::MPD_RX));
2432 EXPECT_TRUE(engine_.RegisterProcessor(kSsrc1, &vp_1, cricket::MPD_TX));
2433 voe_.TriggerProcessPacket(cricket::MPD_RX);
2434 voe_.TriggerProcessPacket(cricket::MPD_TX);
2435 EXPECT_TRUE(voe_.IsExternalMediaProcessorRegistered());
2436 EXPECT_EQ(3, vp_1.voice_frame_count());
2437
2438 EXPECT_TRUE(engine_.UnregisterProcessor(kSsrc1,
2439 &vp_1,
2440 cricket::MPD_RX_AND_TX));
2441 voe_.TriggerProcessPacket(cricket::MPD_TX);
2442 EXPECT_FALSE(voe_.IsExternalMediaProcessorRegistered());
2443 EXPECT_EQ(3, vp_1.voice_frame_count());
2444 EXPECT_TRUE(channel_->RemoveRecvStream(kSsrc2));
2445 EXPECT_FALSE(engine_.RegisterProcessor(kSsrc2, &vp_1, cricket::MPD_RX));
2446 EXPECT_FALSE(voe_.IsExternalMediaProcessorRegistered());
2447
2448 // Test that we can register a processor on the receive channel on SSRC 0.
2449 // This tests the 1:1 case when the receive SSRC is unknown.
2450 EXPECT_TRUE(engine_.RegisterProcessor(0, &vp_1, cricket::MPD_RX));
2451 voe_.TriggerProcessPacket(cricket::MPD_RX);
2452 EXPECT_TRUE(voe_.IsExternalMediaProcessorRegistered());
2453 EXPECT_EQ(4, vp_1.voice_frame_count());
2454 EXPECT_TRUE(engine_.UnregisterProcessor(0,
2455 &vp_1,
2456 cricket::MPD_RX));
2457
2458 // The following tests test that FindChannelNumFromSsrc is doing
2459 // what we expect.
2460 // pick an invalid ssrc and make sure we can't register
2461 EXPECT_FALSE(engine_.RegisterProcessor(99,
2462 &vp_1,
2463 cricket::MPD_RX));
2464 EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1)));
2465 EXPECT_TRUE(engine_.RegisterProcessor(1,
2466 &vp_1,
2467 cricket::MPD_RX));
2468 EXPECT_TRUE(engine_.UnregisterProcessor(1,
2469 &vp_1,
2470 cricket::MPD_RX));
2471 EXPECT_FALSE(engine_.RegisterProcessor(1,
2472 &vp_1,
2473 cricket::MPD_TX));
2474 EXPECT_TRUE(channel_->RemoveRecvStream(1));
2475}
2476
2477TEST_F(WebRtcVoiceEngineTestFake, SetAudioOptions) {
2478 EXPECT_TRUE(SetupEngine());
2479
2480 bool ec_enabled;
2481 webrtc::EcModes ec_mode;
2482 bool ec_metrics_enabled;
2483 webrtc::AecmModes aecm_mode;
2484 bool cng_enabled;
2485 bool agc_enabled;
2486 webrtc::AgcModes agc_mode;
2487 webrtc::AgcConfig agc_config;
2488 bool ns_enabled;
2489 webrtc::NsModes ns_mode;
2490 bool highpass_filter_enabled;
2491 bool stereo_swapping_enabled;
2492 bool typing_detection_enabled;
2493 voe_.GetEcStatus(ec_enabled, ec_mode);
2494 voe_.GetEcMetricsStatus(ec_metrics_enabled);
2495 voe_.GetAecmMode(aecm_mode, cng_enabled);
2496 voe_.GetAgcStatus(agc_enabled, agc_mode);
2497 voe_.GetAgcConfig(agc_config);
2498 voe_.GetNsStatus(ns_enabled, ns_mode);
2499 highpass_filter_enabled = voe_.IsHighPassFilterEnabled();
2500 stereo_swapping_enabled = voe_.IsStereoChannelSwappingEnabled();
2501 voe_.GetTypingDetectionStatus(typing_detection_enabled);
2502 EXPECT_TRUE(ec_enabled);
2503 EXPECT_TRUE(ec_metrics_enabled);
2504 EXPECT_FALSE(cng_enabled);
2505 EXPECT_TRUE(agc_enabled);
2506 EXPECT_EQ(0, agc_config.targetLeveldBOv);
2507 EXPECT_TRUE(ns_enabled);
2508 EXPECT_TRUE(highpass_filter_enabled);
2509 EXPECT_FALSE(stereo_swapping_enabled);
2510 EXPECT_TRUE(typing_detection_enabled);
2511 EXPECT_EQ(ec_mode, webrtc::kEcConference);
2512 EXPECT_EQ(ns_mode, webrtc::kNsHighSuppression);
2513
2514 // Nothing set, so all ignored.
2515 cricket::AudioOptions options;
mallinath@webrtc.orga27be8e2013-09-27 23:04:10 +00002516 ASSERT_TRUE(engine_.SetOptions(options));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002517 voe_.GetEcStatus(ec_enabled, ec_mode);
2518 voe_.GetEcMetricsStatus(ec_metrics_enabled);
2519 voe_.GetAecmMode(aecm_mode, cng_enabled);
2520 voe_.GetAgcStatus(agc_enabled, agc_mode);
2521 voe_.GetAgcConfig(agc_config);
2522 voe_.GetNsStatus(ns_enabled, ns_mode);
2523 highpass_filter_enabled = voe_.IsHighPassFilterEnabled();
2524 stereo_swapping_enabled = voe_.IsStereoChannelSwappingEnabled();
2525 voe_.GetTypingDetectionStatus(typing_detection_enabled);
2526 EXPECT_TRUE(ec_enabled);
2527 EXPECT_TRUE(ec_metrics_enabled);
2528 EXPECT_FALSE(cng_enabled);
2529 EXPECT_TRUE(agc_enabled);
2530 EXPECT_EQ(0, agc_config.targetLeveldBOv);
2531 EXPECT_TRUE(ns_enabled);
2532 EXPECT_TRUE(highpass_filter_enabled);
2533 EXPECT_FALSE(stereo_swapping_enabled);
2534 EXPECT_TRUE(typing_detection_enabled);
2535 EXPECT_EQ(ec_mode, webrtc::kEcConference);
2536 EXPECT_EQ(ns_mode, webrtc::kNsHighSuppression);
2537
2538 // Turn echo cancellation off
2539 options.echo_cancellation.Set(false);
mallinath@webrtc.orga27be8e2013-09-27 23:04:10 +00002540 ASSERT_TRUE(engine_.SetOptions(options));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002541 voe_.GetEcStatus(ec_enabled, ec_mode);
2542 EXPECT_FALSE(ec_enabled);
2543
2544 // Turn echo cancellation back on, with settings, and make sure
2545 // nothing else changed.
2546 options.echo_cancellation.Set(true);
mallinath@webrtc.orga27be8e2013-09-27 23:04:10 +00002547 ASSERT_TRUE(engine_.SetOptions(options));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002548 voe_.GetEcStatus(ec_enabled, ec_mode);
2549 voe_.GetEcMetricsStatus(ec_metrics_enabled);
2550 voe_.GetAecmMode(aecm_mode, cng_enabled);
2551 voe_.GetAgcStatus(agc_enabled, agc_mode);
2552 voe_.GetAgcConfig(agc_config);
2553 voe_.GetNsStatus(ns_enabled, ns_mode);
2554 highpass_filter_enabled = voe_.IsHighPassFilterEnabled();
2555 stereo_swapping_enabled = voe_.IsStereoChannelSwappingEnabled();
2556 voe_.GetTypingDetectionStatus(typing_detection_enabled);
2557 EXPECT_TRUE(ec_enabled);
2558 EXPECT_TRUE(ec_metrics_enabled);
2559 EXPECT_TRUE(agc_enabled);
2560 EXPECT_EQ(0, agc_config.targetLeveldBOv);
2561 EXPECT_TRUE(ns_enabled);
2562 EXPECT_TRUE(highpass_filter_enabled);
2563 EXPECT_FALSE(stereo_swapping_enabled);
2564 EXPECT_TRUE(typing_detection_enabled);
2565 EXPECT_EQ(ec_mode, webrtc::kEcConference);
2566 EXPECT_EQ(ns_mode, webrtc::kNsHighSuppression);
2567
2568 // Turn off AGC
2569 options.auto_gain_control.Set(false);
mallinath@webrtc.orga27be8e2013-09-27 23:04:10 +00002570 ASSERT_TRUE(engine_.SetOptions(options));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002571 voe_.GetAgcStatus(agc_enabled, agc_mode);
2572 EXPECT_FALSE(agc_enabled);
2573
2574 // Turn AGC back on
2575 options.auto_gain_control.Set(true);
2576 options.adjust_agc_delta.Clear();
mallinath@webrtc.orga27be8e2013-09-27 23:04:10 +00002577 ASSERT_TRUE(engine_.SetOptions(options));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002578 voe_.GetAgcStatus(agc_enabled, agc_mode);
2579 EXPECT_TRUE(agc_enabled);
2580 voe_.GetAgcConfig(agc_config);
2581 EXPECT_EQ(0, agc_config.targetLeveldBOv);
2582
2583 // Turn off other options (and stereo swapping on).
2584 options.noise_suppression.Set(false);
2585 options.highpass_filter.Set(false);
2586 options.typing_detection.Set(false);
2587 options.stereo_swapping.Set(true);
mallinath@webrtc.orga27be8e2013-09-27 23:04:10 +00002588 ASSERT_TRUE(engine_.SetOptions(options));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002589 voe_.GetNsStatus(ns_enabled, ns_mode);
2590 highpass_filter_enabled = voe_.IsHighPassFilterEnabled();
2591 stereo_swapping_enabled = voe_.IsStereoChannelSwappingEnabled();
2592 voe_.GetTypingDetectionStatus(typing_detection_enabled);
2593 EXPECT_FALSE(ns_enabled);
2594 EXPECT_FALSE(highpass_filter_enabled);
2595 EXPECT_FALSE(typing_detection_enabled);
2596 EXPECT_TRUE(stereo_swapping_enabled);
2597
2598 // Turn on "conference mode" to ensure it has no impact.
2599 options.conference_mode.Set(true);
mallinath@webrtc.orga27be8e2013-09-27 23:04:10 +00002600 ASSERT_TRUE(engine_.SetOptions(options));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002601 voe_.GetEcStatus(ec_enabled, ec_mode);
2602 voe_.GetNsStatus(ns_enabled, ns_mode);
2603 EXPECT_TRUE(ec_enabled);
2604 EXPECT_EQ(webrtc::kEcConference, ec_mode);
2605 EXPECT_FALSE(ns_enabled);
2606 EXPECT_EQ(webrtc::kNsHighSuppression, ns_mode);
2607}
2608
mallinath@webrtc.orga27be8e2013-09-27 23:04:10 +00002609TEST_F(WebRtcVoiceEngineTestFake, DefaultOptions) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002610 EXPECT_TRUE(SetupEngine());
2611
2612 bool ec_enabled;
2613 webrtc::EcModes ec_mode;
2614 bool ec_metrics_enabled;
2615 bool agc_enabled;
2616 webrtc::AgcModes agc_mode;
2617 bool ns_enabled;
2618 webrtc::NsModes ns_mode;
2619 bool highpass_filter_enabled;
2620 bool stereo_swapping_enabled;
2621 bool typing_detection_enabled;
2622
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002623 voe_.GetEcStatus(ec_enabled, ec_mode);
2624 voe_.GetEcMetricsStatus(ec_metrics_enabled);
2625 voe_.GetAgcStatus(agc_enabled, agc_mode);
2626 voe_.GetNsStatus(ns_enabled, ns_mode);
2627 highpass_filter_enabled = voe_.IsHighPassFilterEnabled();
2628 stereo_swapping_enabled = voe_.IsStereoChannelSwappingEnabled();
2629 voe_.GetTypingDetectionStatus(typing_detection_enabled);
2630 EXPECT_TRUE(ec_enabled);
2631 EXPECT_TRUE(agc_enabled);
2632 EXPECT_TRUE(ns_enabled);
2633 EXPECT_TRUE(highpass_filter_enabled);
mallinath@webrtc.orga27be8e2013-09-27 23:04:10 +00002634 EXPECT_TRUE(typing_detection_enabled);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002635 EXPECT_FALSE(stereo_swapping_enabled);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002636}
2637
2638TEST_F(WebRtcVoiceEngineTestFake, InitDoesNotOverwriteDefaultAgcConfig) {
2639 webrtc::AgcConfig set_config = {0};
2640 set_config.targetLeveldBOv = 3;
2641 set_config.digitalCompressionGaindB = 9;
2642 set_config.limiterEnable = true;
2643 EXPECT_EQ(0, voe_.SetAgcConfig(set_config));
2644 EXPECT_TRUE(engine_.Init(talk_base::Thread::Current()));
2645
2646 webrtc::AgcConfig config = {0};
2647 EXPECT_EQ(0, voe_.GetAgcConfig(config));
2648 EXPECT_EQ(set_config.targetLeveldBOv, config.targetLeveldBOv);
2649 EXPECT_EQ(set_config.digitalCompressionGaindB,
2650 config.digitalCompressionGaindB);
2651 EXPECT_EQ(set_config.limiterEnable, config.limiterEnable);
2652}
2653
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002654TEST_F(WebRtcVoiceEngineTestFake, SetOptionOverridesViaChannels) {
2655 EXPECT_TRUE(SetupEngine());
2656 talk_base::scoped_ptr<cricket::VoiceMediaChannel> channel1(
2657 engine_.CreateChannel());
2658 talk_base::scoped_ptr<cricket::VoiceMediaChannel> channel2(
2659 engine_.CreateChannel());
2660
2661 // Have to add a stream to make SetSend work.
2662 cricket::StreamParams stream1;
2663 stream1.ssrcs.push_back(1);
2664 channel1->AddSendStream(stream1);
2665 cricket::StreamParams stream2;
2666 stream2.ssrcs.push_back(2);
2667 channel2->AddSendStream(stream2);
2668
2669 // AEC and AGC and NS
2670 cricket::AudioOptions options_all;
2671 options_all.echo_cancellation.Set(true);
2672 options_all.auto_gain_control.Set(true);
2673 options_all.noise_suppression.Set(true);
2674
2675 ASSERT_TRUE(channel1->SetOptions(options_all));
2676 cricket::AudioOptions expected_options = options_all;
2677 cricket::AudioOptions actual_options;
2678 ASSERT_TRUE(channel1->GetOptions(&actual_options));
2679 EXPECT_EQ(expected_options, actual_options);
2680 ASSERT_TRUE(channel2->SetOptions(options_all));
2681 ASSERT_TRUE(channel2->GetOptions(&actual_options));
2682 EXPECT_EQ(expected_options, actual_options);
2683
2684 // unset NS
2685 cricket::AudioOptions options_no_ns;
2686 options_no_ns.noise_suppression.Set(false);
2687 ASSERT_TRUE(channel1->SetOptions(options_no_ns));
2688
2689 expected_options.echo_cancellation.Set(true);
2690 expected_options.auto_gain_control.Set(true);
2691 expected_options.noise_suppression.Set(false);
2692 ASSERT_TRUE(channel1->GetOptions(&actual_options));
2693 EXPECT_EQ(expected_options, actual_options);
2694
2695 // unset AGC
2696 cricket::AudioOptions options_no_agc;
2697 options_no_agc.auto_gain_control.Set(false);
2698 ASSERT_TRUE(channel2->SetOptions(options_no_agc));
2699
2700 expected_options.echo_cancellation.Set(true);
2701 expected_options.auto_gain_control.Set(false);
2702 expected_options.noise_suppression.Set(true);
2703 ASSERT_TRUE(channel2->GetOptions(&actual_options));
2704 EXPECT_EQ(expected_options, actual_options);
2705
mallinath@webrtc.orga27be8e2013-09-27 23:04:10 +00002706 ASSERT_TRUE(engine_.SetOptions(options_all));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002707 bool ec_enabled;
2708 webrtc::EcModes ec_mode;
2709 bool agc_enabled;
2710 webrtc::AgcModes agc_mode;
2711 bool ns_enabled;
2712 webrtc::NsModes ns_mode;
2713 voe_.GetEcStatus(ec_enabled, ec_mode);
2714 voe_.GetAgcStatus(agc_enabled, agc_mode);
2715 voe_.GetNsStatus(ns_enabled, ns_mode);
2716 EXPECT_TRUE(ec_enabled);
2717 EXPECT_TRUE(agc_enabled);
2718 EXPECT_TRUE(ns_enabled);
2719
2720 channel1->SetSend(cricket::SEND_MICROPHONE);
2721 voe_.GetEcStatus(ec_enabled, ec_mode);
2722 voe_.GetAgcStatus(agc_enabled, agc_mode);
2723 voe_.GetNsStatus(ns_enabled, ns_mode);
2724 EXPECT_TRUE(ec_enabled);
2725 EXPECT_TRUE(agc_enabled);
2726 EXPECT_FALSE(ns_enabled);
2727
2728 channel1->SetSend(cricket::SEND_NOTHING);
2729 voe_.GetEcStatus(ec_enabled, ec_mode);
2730 voe_.GetAgcStatus(agc_enabled, agc_mode);
2731 voe_.GetNsStatus(ns_enabled, ns_mode);
2732 EXPECT_TRUE(ec_enabled);
2733 EXPECT_TRUE(agc_enabled);
2734 EXPECT_TRUE(ns_enabled);
2735
2736 channel2->SetSend(cricket::SEND_MICROPHONE);
2737 voe_.GetEcStatus(ec_enabled, ec_mode);
2738 voe_.GetAgcStatus(agc_enabled, agc_mode);
2739 voe_.GetNsStatus(ns_enabled, ns_mode);
2740 EXPECT_TRUE(ec_enabled);
2741 EXPECT_FALSE(agc_enabled);
2742 EXPECT_TRUE(ns_enabled);
2743
2744 channel2->SetSend(cricket::SEND_NOTHING);
2745 voe_.GetEcStatus(ec_enabled, ec_mode);
2746 voe_.GetAgcStatus(agc_enabled, agc_mode);
2747 voe_.GetNsStatus(ns_enabled, ns_mode);
2748 EXPECT_TRUE(ec_enabled);
2749 EXPECT_TRUE(agc_enabled);
2750 EXPECT_TRUE(ns_enabled);
2751
2752 // Make sure settings take effect while we are sending.
mallinath@webrtc.orga27be8e2013-09-27 23:04:10 +00002753 ASSERT_TRUE(engine_.SetOptions(options_all));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002754 cricket::AudioOptions options_no_agc_nor_ns;
2755 options_no_agc_nor_ns.auto_gain_control.Set(false);
2756 options_no_agc_nor_ns.noise_suppression.Set(false);
2757 channel2->SetSend(cricket::SEND_MICROPHONE);
2758 channel2->SetOptions(options_no_agc_nor_ns);
2759
2760 expected_options.echo_cancellation.Set(true);
2761 expected_options.auto_gain_control.Set(false);
2762 expected_options.noise_suppression.Set(false);
2763 ASSERT_TRUE(channel2->GetOptions(&actual_options));
2764 EXPECT_EQ(expected_options, actual_options);
2765 voe_.GetEcStatus(ec_enabled, ec_mode);
2766 voe_.GetAgcStatus(agc_enabled, agc_mode);
2767 voe_.GetNsStatus(ns_enabled, ns_mode);
2768 EXPECT_TRUE(ec_enabled);
2769 EXPECT_FALSE(agc_enabled);
2770 EXPECT_FALSE(ns_enabled);
2771}
2772
wu@webrtc.orgde305012013-10-31 15:40:38 +00002773// This test verifies DSCP settings are properly applied on voice media channel.
2774TEST_F(WebRtcVoiceEngineTestFake, TestSetDscpOptions) {
2775 EXPECT_TRUE(SetupEngine());
2776 talk_base::scoped_ptr<cricket::VoiceMediaChannel> channel(
2777 engine_.CreateChannel());
2778 talk_base::scoped_ptr<cricket::FakeNetworkInterface> network_interface(
2779 new cricket::FakeNetworkInterface);
2780 channel->SetInterface(network_interface.get());
2781 cricket::AudioOptions options;
2782 options.dscp.Set(true);
2783 EXPECT_TRUE(channel->SetOptions(options));
2784 EXPECT_EQ(talk_base::DSCP_EF, network_interface->dscp());
henrika@webrtc.orgaebb1ad2014-01-14 10:00:58 +00002785 // Verify previous value is not modified if dscp option is not set.
2786 cricket::AudioOptions options1;
2787 EXPECT_TRUE(channel->SetOptions(options1));
2788 EXPECT_EQ(talk_base::DSCP_EF, network_interface->dscp());
wu@webrtc.orgde305012013-10-31 15:40:38 +00002789 options.dscp.Set(false);
2790 EXPECT_TRUE(channel->SetOptions(options));
2791 EXPECT_EQ(talk_base::DSCP_DEFAULT, network_interface->dscp());
2792}
2793
wu@webrtc.org1d1ffc92013-10-16 18:12:02 +00002794TEST(WebRtcVoiceEngineTest, TestDefaultOptionsBeforeInit) {
2795 cricket::WebRtcVoiceEngine engine;
2796 cricket::AudioOptions options = engine.GetOptions();
2797 // The default options should have at least a few things set. We purposefully
2798 // don't check the option values here, though.
2799 EXPECT_TRUE(options.echo_cancellation.IsSet());
2800 EXPECT_TRUE(options.auto_gain_control.IsSet());
2801 EXPECT_TRUE(options.noise_suppression.IsSet());
2802}
2803
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002804// Test that GetReceiveChannelNum returns the default channel for the first
2805// recv stream in 1-1 calls.
2806TEST_F(WebRtcVoiceEngineTestFake, TestGetReceiveChannelNumIn1To1Calls) {
2807 EXPECT_TRUE(SetupEngine());
2808 cricket::WebRtcVoiceMediaChannel* media_channel =
2809 static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_);
2810 // Test that GetChannelNum returns the default channel if the SSRC is unknown.
2811 EXPECT_EQ(media_channel->voe_channel(),
2812 media_channel->GetReceiveChannelNum(0));
2813 cricket::StreamParams stream;
2814 stream.ssrcs.push_back(kSsrc2);
2815 EXPECT_TRUE(channel_->AddRecvStream(stream));
2816 EXPECT_EQ(media_channel->voe_channel(),
2817 media_channel->GetReceiveChannelNum(kSsrc2));
2818}
2819
2820// Test that GetReceiveChannelNum doesn't return the default channel for the
2821// first recv stream in conference calls.
2822TEST_F(WebRtcVoiceEngineTestFake, TestGetChannelNumInConferenceCalls) {
2823 EXPECT_TRUE(SetupEngine());
2824 EXPECT_TRUE(channel_->SetOptions(options_conference_));
2825 cricket::StreamParams stream;
2826 stream.ssrcs.push_back(kSsrc2);
2827 EXPECT_TRUE(channel_->AddRecvStream(stream));
2828 cricket::WebRtcVoiceMediaChannel* media_channel =
2829 static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_);
2830 EXPECT_LT(media_channel->voe_channel(),
2831 media_channel->GetReceiveChannelNum(kSsrc2));
2832}
2833
2834TEST_F(WebRtcVoiceEngineTestFake, SetOutputScaling) {
2835 EXPECT_TRUE(SetupEngine());
2836 double left, right;
2837 EXPECT_TRUE(channel_->SetOutputScaling(0, 1, 2));
2838 EXPECT_TRUE(channel_->GetOutputScaling(0, &left, &right));
2839 EXPECT_DOUBLE_EQ(1, left);
2840 EXPECT_DOUBLE_EQ(2, right);
2841
2842 EXPECT_FALSE(channel_->SetOutputScaling(kSsrc2, 1, 2));
2843 cricket::StreamParams stream;
2844 stream.ssrcs.push_back(kSsrc2);
2845 EXPECT_TRUE(channel_->AddRecvStream(stream));
2846
2847 EXPECT_TRUE(channel_->SetOutputScaling(kSsrc2, 2, 1));
2848 EXPECT_TRUE(channel_->GetOutputScaling(kSsrc2, &left, &right));
2849 EXPECT_DOUBLE_EQ(2, left);
2850 EXPECT_DOUBLE_EQ(1, right);
2851}
2852
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002853// Tests for the actual WebRtc VoE library.
2854
2855// Tests that the library initializes and shuts down properly.
2856TEST(WebRtcVoiceEngineTest, StartupShutdown) {
2857 cricket::WebRtcVoiceEngine engine;
2858 EXPECT_TRUE(engine.Init(talk_base::Thread::Current()));
2859 cricket::VoiceMediaChannel* channel = engine.CreateChannel();
2860 EXPECT_TRUE(channel != NULL);
2861 delete channel;
2862 engine.Terminate();
2863
2864 // Reinit to catch regression where VoiceEngineObserver reference is lost
2865 EXPECT_TRUE(engine.Init(talk_base::Thread::Current()));
2866 engine.Terminate();
2867}
2868
2869// Tests that the logging from the library is cleartext.
2870TEST(WebRtcVoiceEngineTest, DISABLED_HasUnencryptedLogging) {
2871 cricket::WebRtcVoiceEngine engine;
2872 talk_base::scoped_ptr<talk_base::MemoryStream> stream(
2873 new talk_base::MemoryStream);
2874 size_t size = 0;
2875 bool cleartext = true;
2876 talk_base::LogMessage::AddLogToStream(stream.get(), talk_base::LS_VERBOSE);
2877 engine.SetLogging(talk_base::LS_VERBOSE, "");
2878 EXPECT_TRUE(engine.Init(talk_base::Thread::Current()));
2879 EXPECT_TRUE(stream->GetSize(&size));
2880 EXPECT_GT(size, 0U);
2881 engine.Terminate();
2882 talk_base::LogMessage::RemoveLogToStream(stream.get());
2883 const char* buf = stream->GetBuffer();
2884 for (size_t i = 0; i < size && cleartext; ++i) {
2885 int ch = static_cast<int>(buf[i]);
2886 ASSERT_GE(ch, 0) << "Out of bounds character in WebRtc VoE log: "
2887 << std::hex << ch;
2888 cleartext = (isprint(ch) || isspace(ch));
2889 }
2890 EXPECT_TRUE(cleartext);
2891}
2892
2893// Tests we do not see any references to a monitor thread being spun up
2894// when initiating the engine.
2895TEST(WebRtcVoiceEngineTest, HasNoMonitorThread) {
2896 cricket::WebRtcVoiceEngine engine;
2897 talk_base::scoped_ptr<talk_base::MemoryStream> stream(
2898 new talk_base::MemoryStream);
2899 talk_base::LogMessage::AddLogToStream(stream.get(), talk_base::LS_VERBOSE);
2900 engine.SetLogging(talk_base::LS_VERBOSE, "");
2901 EXPECT_TRUE(engine.Init(talk_base::Thread::Current()));
2902 engine.Terminate();
2903 talk_base::LogMessage::RemoveLogToStream(stream.get());
2904
2905 size_t size = 0;
2906 EXPECT_TRUE(stream->GetSize(&size));
2907 EXPECT_GT(size, 0U);
wu@webrtc.org9caf2762013-12-11 18:25:07 +00002908 const std::string logs(stream->GetBuffer(), size);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002909 EXPECT_NE(std::string::npos, logs.find("ProcessThread"));
2910}
2911
2912// Tests that the library is configured with the codecs we want.
2913TEST(WebRtcVoiceEngineTest, HasCorrectCodecs) {
2914 cricket::WebRtcVoiceEngine engine;
2915 // Check codecs by name.
2916 EXPECT_TRUE(engine.FindCodec(
2917 cricket::AudioCodec(96, "OPUS", 48000, 0, 2, 0)));
2918 EXPECT_TRUE(engine.FindCodec(
2919 cricket::AudioCodec(96, "ISAC", 16000, 0, 1, 0)));
2920 EXPECT_TRUE(engine.FindCodec(
2921 cricket::AudioCodec(96, "ISAC", 32000, 0, 1, 0)));
2922 // Check that name matching is case-insensitive.
2923 EXPECT_TRUE(engine.FindCodec(
2924 cricket::AudioCodec(96, "ILBC", 8000, 0, 1, 0)));
2925 EXPECT_TRUE(engine.FindCodec(
2926 cricket::AudioCodec(96, "iLBC", 8000, 0, 1, 0)));
2927 EXPECT_TRUE(engine.FindCodec(
2928 cricket::AudioCodec(96, "PCMU", 8000, 0, 1, 0)));
2929 EXPECT_TRUE(engine.FindCodec(
2930 cricket::AudioCodec(96, "PCMA", 8000, 0, 1, 0)));
2931 EXPECT_TRUE(engine.FindCodec(
2932 cricket::AudioCodec(96, "G722", 16000, 0, 1, 0)));
2933 EXPECT_TRUE(engine.FindCodec(
2934 cricket::AudioCodec(96, "red", 8000, 0, 1, 0)));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002935 EXPECT_TRUE(engine.FindCodec(
2936 cricket::AudioCodec(96, "CN", 32000, 0, 1, 0)));
2937 EXPECT_TRUE(engine.FindCodec(
2938 cricket::AudioCodec(96, "CN", 16000, 0, 1, 0)));
2939 EXPECT_TRUE(engine.FindCodec(
2940 cricket::AudioCodec(96, "CN", 8000, 0, 1, 0)));
2941 EXPECT_TRUE(engine.FindCodec(
2942 cricket::AudioCodec(96, "telephone-event", 8000, 0, 1, 0)));
2943 // Check codecs with an id by id.
2944 EXPECT_TRUE(engine.FindCodec(
2945 cricket::AudioCodec(0, "", 8000, 0, 1, 0))); // PCMU
2946 EXPECT_TRUE(engine.FindCodec(
2947 cricket::AudioCodec(8, "", 8000, 0, 1, 0))); // PCMA
2948 EXPECT_TRUE(engine.FindCodec(
2949 cricket::AudioCodec(9, "", 16000, 0, 1, 0))); // G722
2950 EXPECT_TRUE(engine.FindCodec(
2951 cricket::AudioCodec(13, "", 8000, 0, 1, 0))); // CN
2952 // Check sample/bitrate matching.
2953 EXPECT_TRUE(engine.FindCodec(
2954 cricket::AudioCodec(0, "PCMU", 8000, 64000, 1, 0)));
2955 // Check that bad codecs fail.
2956 EXPECT_FALSE(engine.FindCodec(cricket::AudioCodec(99, "ABCD", 0, 0, 1, 0)));
2957 EXPECT_FALSE(engine.FindCodec(cricket::AudioCodec(88, "", 0, 0, 1, 0)));
2958 EXPECT_FALSE(engine.FindCodec(cricket::AudioCodec(0, "", 0, 0, 2, 0)));
2959 EXPECT_FALSE(engine.FindCodec(cricket::AudioCodec(0, "", 5000, 0, 1, 0)));
2960 EXPECT_FALSE(engine.FindCodec(cricket::AudioCodec(0, "", 0, 5000, 1, 0)));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002961 // Verify the payload id of common audio codecs, including CN, ISAC, and G722.
2962 for (std::vector<cricket::AudioCodec>::const_iterator it =
2963 engine.codecs().begin(); it != engine.codecs().end(); ++it) {
2964 if (it->name == "CN" && it->clockrate == 16000) {
2965 EXPECT_EQ(105, it->id);
2966 } else if (it->name == "CN" && it->clockrate == 32000) {
2967 EXPECT_EQ(106, it->id);
2968 } else if (it->name == "ISAC" && it->clockrate == 16000) {
2969 EXPECT_EQ(103, it->id);
2970 } else if (it->name == "ISAC" && it->clockrate == 32000) {
2971 EXPECT_EQ(104, it->id);
2972 } else if (it->name == "G722" && it->clockrate == 16000) {
2973 EXPECT_EQ(9, it->id);
2974 } else if (it->name == "telephone-event") {
2975 EXPECT_EQ(126, it->id);
2976 } else if (it->name == "red") {
2977 EXPECT_EQ(127, it->id);
2978 } else if (it->name == "opus") {
2979 EXPECT_EQ(111, it->id);
wu@webrtc.org9caf2762013-12-11 18:25:07 +00002980 ASSERT_TRUE(it->params.find("minptime") != it->params.end());
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002981 EXPECT_EQ("10", it->params.find("minptime")->second);
wu@webrtc.org9caf2762013-12-11 18:25:07 +00002982 ASSERT_TRUE(it->params.find("maxptime") != it->params.end());
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002983 EXPECT_EQ("60", it->params.find("maxptime")->second);
2984 }
2985 }
2986
2987 engine.Terminate();
2988}
2989
2990// Tests that VoE supports at least 32 channels
2991TEST(WebRtcVoiceEngineTest, Has32Channels) {
2992 cricket::WebRtcVoiceEngine engine;
2993 EXPECT_TRUE(engine.Init(talk_base::Thread::Current()));
2994
2995 cricket::VoiceMediaChannel* channels[32];
2996 int num_channels = 0;
2997
2998 while (num_channels < ARRAY_SIZE(channels)) {
2999 cricket::VoiceMediaChannel* channel = engine.CreateChannel();
3000 if (!channel)
3001 break;
3002
3003 channels[num_channels++] = channel;
3004 }
3005
3006 int expected = ARRAY_SIZE(channels);
3007 EXPECT_EQ(expected, num_channels);
3008
3009 while (num_channels > 0) {
3010 delete channels[--num_channels];
3011 }
3012
3013 engine.Terminate();
3014}
3015
3016// Test that we set our preferred codecs properly.
3017TEST(WebRtcVoiceEngineTest, SetRecvCodecs) {
3018 cricket::WebRtcVoiceEngine engine;
3019 EXPECT_TRUE(engine.Init(talk_base::Thread::Current()));
3020 cricket::WebRtcVoiceMediaChannel channel(&engine);
3021 EXPECT_TRUE(channel.SetRecvCodecs(engine.codecs()));
3022}
3023
3024#ifdef WIN32
3025// Test our workarounds to WebRtc VoE' munging of the coinit count
3026TEST(WebRtcVoiceEngineTest, CoInitialize) {
3027 cricket::WebRtcVoiceEngine* engine = new cricket::WebRtcVoiceEngine();
3028
3029 // Initial refcount should be 0.
3030 EXPECT_EQ(S_OK, CoInitializeEx(NULL, COINIT_MULTITHREADED));
3031
3032 // Engine should start even with COM already inited.
3033 EXPECT_TRUE(engine->Init(talk_base::Thread::Current()));
3034 engine->Terminate();
3035 EXPECT_TRUE(engine->Init(talk_base::Thread::Current()));
3036 engine->Terminate();
3037
3038 // Refcount after terminate should be 1 (in reality 3); test if it is nonzero.
3039 EXPECT_EQ(S_FALSE, CoInitializeEx(NULL, COINIT_MULTITHREADED));
3040 // Decrement refcount to (hopefully) 0.
3041 CoUninitialize();
3042 CoUninitialize();
3043 delete engine;
3044
3045 // Ensure refcount is 0.
3046 EXPECT_EQ(S_OK, CoInitializeEx(NULL, COINIT_MULTITHREADED));
3047 CoUninitialize();
3048}
3049#endif
3050