| Index: webrtc/media/webrtc/webrtcvoiceengine_unittest.cc
|
| diff --git a/webrtc/media/webrtc/webrtcvoiceengine_unittest.cc b/webrtc/media/webrtc/webrtcvoiceengine_unittest.cc
|
| deleted file mode 100644
|
| index a5acee8d936b8be756493defca369535a68b511d..0000000000000000000000000000000000000000
|
| --- a/webrtc/media/webrtc/webrtcvoiceengine_unittest.cc
|
| +++ /dev/null
|
| @@ -1,3285 +0,0 @@
|
| -/*
|
| - * Copyright (c) 2008 The WebRTC project authors. All Rights Reserved.
|
| - *
|
| - * Use of this source code is governed by a BSD-style license
|
| - * that can be found in the LICENSE file in the root of the source
|
| - * tree. An additional intellectual property rights grant can be found
|
| - * in the file PATENTS. All contributing project authors may
|
| - * be found in the AUTHORS file in the root of the source tree.
|
| - */
|
| -
|
| -#include "talk/session/media/channel.h"
|
| -#include "webrtc/base/arraysize.h"
|
| -#include "webrtc/base/byteorder.h"
|
| -#include "webrtc/base/gunit.h"
|
| -#include "webrtc/call.h"
|
| -#include "webrtc/p2p/base/faketransportcontroller.h"
|
| -#include "webrtc/test/field_trial.h"
|
| -#include "webrtc/media/base/constants.h"
|
| -#include "webrtc/media/base/fakemediaengine.h"
|
| -#include "webrtc/media/base/fakenetworkinterface.h"
|
| -#include "webrtc/media/base/fakertp.h"
|
| -#include "webrtc/media/webrtc/fakewebrtccall.h"
|
| -#include "webrtc/media/webrtc/fakewebrtcvoiceengine.h"
|
| -#include "webrtc/media/webrtc/webrtcvoiceengine.h"
|
| -
|
| -using cricket::kRtpAudioLevelHeaderExtension;
|
| -using cricket::kRtpAbsoluteSenderTimeHeaderExtension;
|
| -
|
| -namespace {
|
| -
|
| -const cricket::AudioCodec kPcmuCodec(0, "PCMU", 8000, 64000, 1, 0);
|
| -const cricket::AudioCodec kIsacCodec(103, "ISAC", 16000, 32000, 1, 0);
|
| -const cricket::AudioCodec kOpusCodec(111, "opus", 48000, 64000, 2, 0);
|
| -const cricket::AudioCodec kG722CodecVoE(9, "G722", 16000, 64000, 1, 0);
|
| -const cricket::AudioCodec kG722CodecSdp(9, "G722", 8000, 64000, 1, 0);
|
| -const cricket::AudioCodec kRedCodec(117, "red", 8000, 0, 1, 0);
|
| -const cricket::AudioCodec kCn8000Codec(13, "CN", 8000, 0, 1, 0);
|
| -const cricket::AudioCodec kCn16000Codec(105, "CN", 16000, 0, 1, 0);
|
| -const cricket::AudioCodec kTelephoneEventCodec(106, "telephone-event", 8000, 0,
|
| - 1, 0);
|
| -const uint32_t kSsrc1 = 0x99;
|
| -const uint32_t kSsrc2 = 0x98;
|
| -const uint32_t kSsrcs4[] = { 1, 2, 3, 4 };
|
| -
|
| -class FakeVoEWrapper : public cricket::VoEWrapper {
|
| - public:
|
| - explicit FakeVoEWrapper(cricket::FakeWebRtcVoiceEngine* engine)
|
| - : cricket::VoEWrapper(engine, // processing
|
| - engine, // base
|
| - engine, // codec
|
| - engine, // hw
|
| - engine, // network
|
| - engine, // rtp
|
| - engine) { // volume
|
| - }
|
| -};
|
| -} // namespace
|
| -
|
| -class FakeAudioSink : public webrtc::AudioSinkInterface {
|
| - public:
|
| - void OnData(const Data& audio) override {}
|
| -};
|
| -
|
| -class WebRtcVoiceEngineTestFake : public testing::Test {
|
| - public:
|
| - WebRtcVoiceEngineTestFake() : WebRtcVoiceEngineTestFake("") {}
|
| -
|
| - explicit WebRtcVoiceEngineTestFake(const char* field_trials)
|
| - : call_(webrtc::Call::Config()),
|
| - engine_(new FakeVoEWrapper(&voe_)),
|
| - channel_(nullptr),
|
| - override_field_trials_(field_trials) {
|
| - send_parameters_.codecs.push_back(kPcmuCodec);
|
| - recv_parameters_.codecs.push_back(kPcmuCodec);
|
| - }
|
| - bool SetupEngine() {
|
| - if (!engine_.Init(rtc::Thread::Current())) {
|
| - return false;
|
| - }
|
| - channel_ = engine_.CreateChannel(&call_, cricket::AudioOptions());
|
| - return (channel_ != nullptr);
|
| - }
|
| - bool SetupEngineWithRecvStream() {
|
| - if (!SetupEngine()) {
|
| - return false;
|
| - }
|
| - return channel_->AddRecvStream(
|
| - cricket::StreamParams::CreateLegacy(kSsrc1));
|
| - }
|
| - bool SetupEngineWithSendStream() {
|
| - if (!SetupEngine()) {
|
| - return false;
|
| - }
|
| - return channel_->AddSendStream(
|
| - cricket::StreamParams::CreateLegacy(kSsrc1));
|
| - }
|
| - void SetupForMultiSendStream() {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - // Remove stream added in Setup.
|
| - EXPECT_TRUE(call_.GetAudioSendStream(kSsrc1));
|
| - EXPECT_TRUE(channel_->RemoveSendStream(kSsrc1));
|
| - // Verify the channel does not exist.
|
| - EXPECT_FALSE(call_.GetAudioSendStream(kSsrc1));
|
| - }
|
| - void DeliverPacket(const void* data, int len) {
|
| - rtc::Buffer packet(reinterpret_cast<const uint8_t*>(data), len);
|
| - channel_->OnPacketReceived(&packet, rtc::PacketTime());
|
| - }
|
| - void TearDown() override {
|
| - delete channel_;
|
| - engine_.Terminate();
|
| - }
|
| -
|
| - const cricket::FakeAudioSendStream& GetSendStream(uint32_t ssrc) {
|
| - const auto* send_stream = call_.GetAudioSendStream(ssrc);
|
| - EXPECT_TRUE(send_stream);
|
| - return *send_stream;
|
| - }
|
| -
|
| - const cricket::FakeAudioReceiveStream& GetRecvStream(uint32_t ssrc) {
|
| - const auto* recv_stream = call_.GetAudioReceiveStream(ssrc);
|
| - EXPECT_TRUE(recv_stream);
|
| - return *recv_stream;
|
| - }
|
| -
|
| - const webrtc::AudioSendStream::Config& GetSendStreamConfig(uint32_t ssrc) {
|
| - const auto* send_stream = call_.GetAudioSendStream(ssrc);
|
| - EXPECT_TRUE(send_stream);
|
| - return send_stream->GetConfig();
|
| - }
|
| -
|
| - const webrtc::AudioReceiveStream::Config& GetRecvStreamConfig(uint32_t ssrc) {
|
| - const auto* recv_stream = call_.GetAudioReceiveStream(ssrc);
|
| - EXPECT_TRUE(recv_stream);
|
| - return recv_stream->GetConfig();
|
| - }
|
| -
|
| - void TestInsertDtmf(uint32_t ssrc, bool caller) {
|
| - EXPECT_TRUE(engine_.Init(rtc::Thread::Current()));
|
| - channel_ = engine_.CreateChannel(&call_, cricket::AudioOptions());
|
| - EXPECT_TRUE(channel_ != nullptr);
|
| - if (caller) {
|
| - // If this is a caller, local description will be applied and add the
|
| - // send stream.
|
| - EXPECT_TRUE(channel_->AddSendStream(
|
| - cricket::StreamParams::CreateLegacy(kSsrc1)));
|
| - }
|
| -
|
| - // Test we can only InsertDtmf when the other side supports telephone-event.
|
| - EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
|
| - EXPECT_TRUE(channel_->SetSend(cricket::SEND_MICROPHONE));
|
| - EXPECT_FALSE(channel_->CanInsertDtmf());
|
| - EXPECT_FALSE(channel_->InsertDtmf(ssrc, 1, 111));
|
| - send_parameters_.codecs.push_back(kTelephoneEventCodec);
|
| - EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
|
| - EXPECT_TRUE(channel_->CanInsertDtmf());
|
| -
|
| - if (!caller) {
|
| - // If this is callee, there's no active send channel yet.
|
| - EXPECT_FALSE(channel_->InsertDtmf(ssrc, 2, 123));
|
| - EXPECT_TRUE(channel_->AddSendStream(
|
| - cricket::StreamParams::CreateLegacy(kSsrc1)));
|
| - }
|
| -
|
| - // Check we fail if the ssrc is invalid.
|
| - EXPECT_FALSE(channel_->InsertDtmf(-1, 1, 111));
|
| -
|
| - // Test send.
|
| - cricket::FakeAudioSendStream::TelephoneEvent telephone_event =
|
| - GetSendStream(kSsrc1).GetLatestTelephoneEvent();
|
| - EXPECT_EQ(-1, telephone_event.payload_type);
|
| - EXPECT_TRUE(channel_->InsertDtmf(ssrc, 2, 123));
|
| - telephone_event = GetSendStream(kSsrc1).GetLatestTelephoneEvent();
|
| - EXPECT_EQ(kTelephoneEventCodec.id, telephone_event.payload_type);
|
| - EXPECT_EQ(2, telephone_event.event_code);
|
| - EXPECT_EQ(123, telephone_event.duration_ms);
|
| - }
|
| -
|
| - // Test that send bandwidth is set correctly.
|
| - // |codec| is the codec under test.
|
| - // |max_bitrate| is a parameter to set to SetMaxSendBandwidth().
|
| - // |expected_result| is the expected result from SetMaxSendBandwidth().
|
| - // |expected_bitrate| is the expected audio bitrate afterward.
|
| - void TestSendBandwidth(const cricket::AudioCodec& codec,
|
| - int max_bitrate,
|
| - bool expected_result,
|
| - int expected_bitrate) {
|
| - cricket::AudioSendParameters parameters;
|
| - parameters.codecs.push_back(codec);
|
| - parameters.max_bandwidth_bps = max_bitrate;
|
| - EXPECT_EQ(expected_result, channel_->SetSendParameters(parameters));
|
| -
|
| - int channel_num = voe_.GetLastChannel();
|
| - webrtc::CodecInst temp_codec;
|
| - EXPECT_FALSE(voe_.GetSendCodec(channel_num, temp_codec));
|
| - EXPECT_EQ(expected_bitrate, temp_codec.rate);
|
| - }
|
| -
|
| - void TestSetSendRtpHeaderExtensions(const std::string& ext) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| -
|
| - // Ensure extensions are off by default.
|
| - EXPECT_EQ(0u, GetSendStreamConfig(kSsrc1).rtp.extensions.size());
|
| -
|
| - // Ensure unknown extensions won't cause an error.
|
| - send_parameters_.extensions.push_back(cricket::RtpHeaderExtension(
|
| - "urn:ietf:params:unknownextention", 1));
|
| - EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
|
| - EXPECT_EQ(0u, GetSendStreamConfig(kSsrc1).rtp.extensions.size());
|
| -
|
| - // Ensure extensions stay off with an empty list of headers.
|
| - send_parameters_.extensions.clear();
|
| - EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
|
| - EXPECT_EQ(0u, GetSendStreamConfig(kSsrc1).rtp.extensions.size());
|
| -
|
| - // Ensure extension is set properly.
|
| - const int id = 1;
|
| - send_parameters_.extensions.push_back(cricket::RtpHeaderExtension(ext, id));
|
| - EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
|
| - EXPECT_EQ(1u, GetSendStreamConfig(kSsrc1).rtp.extensions.size());
|
| - EXPECT_EQ(ext, GetSendStreamConfig(kSsrc1).rtp.extensions[0].name);
|
| - EXPECT_EQ(id, GetSendStreamConfig(kSsrc1).rtp.extensions[0].id);
|
| -
|
| - // Ensure extension is set properly on new stream.
|
| - EXPECT_TRUE(channel_->AddSendStream(
|
| - cricket::StreamParams::CreateLegacy(kSsrc2)));
|
| - EXPECT_NE(call_.GetAudioSendStream(kSsrc1),
|
| - call_.GetAudioSendStream(kSsrc2));
|
| - EXPECT_EQ(1u, GetSendStreamConfig(kSsrc2).rtp.extensions.size());
|
| - EXPECT_EQ(ext, GetSendStreamConfig(kSsrc2).rtp.extensions[0].name);
|
| - EXPECT_EQ(id, GetSendStreamConfig(kSsrc2).rtp.extensions[0].id);
|
| -
|
| - // Ensure all extensions go back off with an empty list.
|
| - send_parameters_.codecs.push_back(kPcmuCodec);
|
| - send_parameters_.extensions.clear();
|
| - EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
|
| - EXPECT_EQ(0u, GetSendStreamConfig(kSsrc1).rtp.extensions.size());
|
| - EXPECT_EQ(0u, GetSendStreamConfig(kSsrc2).rtp.extensions.size());
|
| - }
|
| -
|
| - void TestSetRecvRtpHeaderExtensions(const std::string& ext) {
|
| - EXPECT_TRUE(SetupEngineWithRecvStream());
|
| -
|
| - // Ensure extensions are off by default.
|
| - EXPECT_EQ(0u, GetRecvStreamConfig(kSsrc1).rtp.extensions.size());
|
| -
|
| - // Ensure unknown extensions won't cause an error.
|
| - recv_parameters_.extensions.push_back(cricket::RtpHeaderExtension(
|
| - "urn:ietf:params:unknownextention", 1));
|
| - EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
|
| - EXPECT_EQ(0u, GetRecvStreamConfig(kSsrc1).rtp.extensions.size());
|
| -
|
| - // Ensure extensions stay off with an empty list of headers.
|
| - recv_parameters_.extensions.clear();
|
| - EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
|
| - EXPECT_EQ(0u, GetRecvStreamConfig(kSsrc1).rtp.extensions.size());
|
| -
|
| - // Ensure extension is set properly.
|
| - const int id = 2;
|
| - recv_parameters_.extensions.push_back(cricket::RtpHeaderExtension(ext, id));
|
| - EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
|
| - EXPECT_EQ(1u, GetRecvStreamConfig(kSsrc1).rtp.extensions.size());
|
| - EXPECT_EQ(ext, GetRecvStreamConfig(kSsrc1).rtp.extensions[0].name);
|
| - EXPECT_EQ(id, GetRecvStreamConfig(kSsrc1).rtp.extensions[0].id);
|
| -
|
| - // Ensure extension is set properly on new stream.
|
| - EXPECT_TRUE(channel_->AddRecvStream(
|
| - cricket::StreamParams::CreateLegacy(kSsrc2)));
|
| - EXPECT_NE(call_.GetAudioReceiveStream(kSsrc1),
|
| - call_.GetAudioReceiveStream(kSsrc2));
|
| - EXPECT_EQ(1u, GetRecvStreamConfig(kSsrc2).rtp.extensions.size());
|
| - EXPECT_EQ(ext, GetRecvStreamConfig(kSsrc2).rtp.extensions[0].name);
|
| - EXPECT_EQ(id, GetRecvStreamConfig(kSsrc2).rtp.extensions[0].id);
|
| -
|
| - // Ensure all extensions go back off with an empty list.
|
| - recv_parameters_.extensions.clear();
|
| - EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
|
| - EXPECT_EQ(0u, GetRecvStreamConfig(kSsrc1).rtp.extensions.size());
|
| - EXPECT_EQ(0u, GetRecvStreamConfig(kSsrc2).rtp.extensions.size());
|
| - }
|
| -
|
| - webrtc::AudioSendStream::Stats GetAudioSendStreamStats() const {
|
| - webrtc::AudioSendStream::Stats stats;
|
| - stats.local_ssrc = 12;
|
| - stats.bytes_sent = 345;
|
| - stats.packets_sent = 678;
|
| - stats.packets_lost = 9012;
|
| - stats.fraction_lost = 34.56f;
|
| - stats.codec_name = "codec_name_send";
|
| - stats.ext_seqnum = 789;
|
| - stats.jitter_ms = 12;
|
| - stats.rtt_ms = 345;
|
| - stats.audio_level = 678;
|
| - stats.aec_quality_min = 9.01f;
|
| - stats.echo_delay_median_ms = 234;
|
| - stats.echo_delay_std_ms = 567;
|
| - stats.echo_return_loss = 890;
|
| - stats.echo_return_loss_enhancement = 1234;
|
| - stats.typing_noise_detected = true;
|
| - return stats;
|
| - }
|
| - void SetAudioSendStreamStats() {
|
| - for (auto* s : call_.GetAudioSendStreams()) {
|
| - s->SetStats(GetAudioSendStreamStats());
|
| - }
|
| - }
|
| - void VerifyVoiceSenderInfo(const cricket::VoiceSenderInfo& info,
|
| - bool is_sending) {
|
| - const auto stats = GetAudioSendStreamStats();
|
| - EXPECT_EQ(info.ssrc(), stats.local_ssrc);
|
| - EXPECT_EQ(info.bytes_sent, stats.bytes_sent);
|
| - EXPECT_EQ(info.packets_sent, stats.packets_sent);
|
| - EXPECT_EQ(info.packets_lost, stats.packets_lost);
|
| - EXPECT_EQ(info.fraction_lost, stats.fraction_lost);
|
| - EXPECT_EQ(info.codec_name, stats.codec_name);
|
| - EXPECT_EQ(info.ext_seqnum, stats.ext_seqnum);
|
| - EXPECT_EQ(info.jitter_ms, stats.jitter_ms);
|
| - EXPECT_EQ(info.rtt_ms, stats.rtt_ms);
|
| - EXPECT_EQ(info.audio_level, stats.audio_level);
|
| - EXPECT_EQ(info.aec_quality_min, stats.aec_quality_min);
|
| - EXPECT_EQ(info.echo_delay_median_ms, stats.echo_delay_median_ms);
|
| - EXPECT_EQ(info.echo_delay_std_ms, stats.echo_delay_std_ms);
|
| - EXPECT_EQ(info.echo_return_loss, stats.echo_return_loss);
|
| - EXPECT_EQ(info.echo_return_loss_enhancement,
|
| - stats.echo_return_loss_enhancement);
|
| - EXPECT_EQ(info.typing_noise_detected,
|
| - stats.typing_noise_detected && is_sending);
|
| - }
|
| -
|
| - webrtc::AudioReceiveStream::Stats GetAudioReceiveStreamStats() const {
|
| - webrtc::AudioReceiveStream::Stats stats;
|
| - stats.remote_ssrc = 123;
|
| - stats.bytes_rcvd = 456;
|
| - stats.packets_rcvd = 768;
|
| - stats.packets_lost = 101;
|
| - stats.fraction_lost = 23.45f;
|
| - stats.codec_name = "codec_name_recv";
|
| - stats.ext_seqnum = 678;
|
| - stats.jitter_ms = 901;
|
| - stats.jitter_buffer_ms = 234;
|
| - stats.jitter_buffer_preferred_ms = 567;
|
| - stats.delay_estimate_ms = 890;
|
| - stats.audio_level = 1234;
|
| - stats.expand_rate = 5.67f;
|
| - stats.speech_expand_rate = 8.90f;
|
| - stats.secondary_decoded_rate = 1.23f;
|
| - stats.accelerate_rate = 4.56f;
|
| - stats.preemptive_expand_rate = 7.89f;
|
| - stats.decoding_calls_to_silence_generator = 12;
|
| - stats.decoding_calls_to_neteq = 345;
|
| - stats.decoding_normal = 67890;
|
| - stats.decoding_plc = 1234;
|
| - stats.decoding_cng = 5678;
|
| - stats.decoding_plc_cng = 9012;
|
| - stats.capture_start_ntp_time_ms = 3456;
|
| - return stats;
|
| - }
|
| - void SetAudioReceiveStreamStats() {
|
| - for (auto* s : call_.GetAudioReceiveStreams()) {
|
| - s->SetStats(GetAudioReceiveStreamStats());
|
| - }
|
| - }
|
| - void VerifyVoiceReceiverInfo(const cricket::VoiceReceiverInfo& info) {
|
| - const auto stats = GetAudioReceiveStreamStats();
|
| - EXPECT_EQ(info.ssrc(), stats.remote_ssrc);
|
| - EXPECT_EQ(info.bytes_rcvd, stats.bytes_rcvd);
|
| - EXPECT_EQ(info.packets_rcvd, stats.packets_rcvd);
|
| - EXPECT_EQ(info.packets_lost, stats.packets_lost);
|
| - EXPECT_EQ(info.fraction_lost, stats.fraction_lost);
|
| - EXPECT_EQ(info.codec_name, stats.codec_name);
|
| - EXPECT_EQ(info.ext_seqnum, stats.ext_seqnum);
|
| - EXPECT_EQ(info.jitter_ms, stats.jitter_ms);
|
| - EXPECT_EQ(info.jitter_buffer_ms, stats.jitter_buffer_ms);
|
| - EXPECT_EQ(info.jitter_buffer_preferred_ms,
|
| - stats.jitter_buffer_preferred_ms);
|
| - EXPECT_EQ(info.delay_estimate_ms, stats.delay_estimate_ms);
|
| - EXPECT_EQ(info.audio_level, stats.audio_level);
|
| - EXPECT_EQ(info.expand_rate, stats.expand_rate);
|
| - EXPECT_EQ(info.speech_expand_rate, stats.speech_expand_rate);
|
| - EXPECT_EQ(info.secondary_decoded_rate, stats.secondary_decoded_rate);
|
| - EXPECT_EQ(info.accelerate_rate, stats.accelerate_rate);
|
| - EXPECT_EQ(info.preemptive_expand_rate, stats.preemptive_expand_rate);
|
| - EXPECT_EQ(info.decoding_calls_to_silence_generator,
|
| - stats.decoding_calls_to_silence_generator);
|
| - EXPECT_EQ(info.decoding_calls_to_neteq, stats.decoding_calls_to_neteq);
|
| - EXPECT_EQ(info.decoding_normal, stats.decoding_normal);
|
| - EXPECT_EQ(info.decoding_plc, stats.decoding_plc);
|
| - EXPECT_EQ(info.decoding_cng, stats.decoding_cng);
|
| - EXPECT_EQ(info.decoding_plc_cng, stats.decoding_plc_cng);
|
| - EXPECT_EQ(info.capture_start_ntp_time_ms, stats.capture_start_ntp_time_ms);
|
| - }
|
| -
|
| - protected:
|
| - cricket::FakeCall call_;
|
| - cricket::FakeWebRtcVoiceEngine voe_;
|
| - cricket::WebRtcVoiceEngine engine_;
|
| - cricket::VoiceMediaChannel* channel_;
|
| - cricket::AudioSendParameters send_parameters_;
|
| - cricket::AudioRecvParameters recv_parameters_;
|
| -
|
| - private:
|
| - webrtc::test::ScopedFieldTrials override_field_trials_;
|
| -};
|
| -
|
| -// Tests that our stub library "works".
|
| -TEST_F(WebRtcVoiceEngineTestFake, StartupShutdown) {
|
| - EXPECT_FALSE(voe_.IsInited());
|
| - EXPECT_TRUE(engine_.Init(rtc::Thread::Current()));
|
| - EXPECT_TRUE(voe_.IsInited());
|
| - engine_.Terminate();
|
| - EXPECT_FALSE(voe_.IsInited());
|
| -}
|
| -
|
| -// Tests that we can create and destroy a channel.
|
| -TEST_F(WebRtcVoiceEngineTestFake, CreateChannel) {
|
| - EXPECT_TRUE(engine_.Init(rtc::Thread::Current()));
|
| - channel_ = engine_.CreateChannel(&call_, cricket::AudioOptions());
|
| - EXPECT_TRUE(channel_ != nullptr);
|
| -}
|
| -
|
| -// Tests that the list of supported codecs is created properly and ordered
|
| -// correctly
|
| -TEST_F(WebRtcVoiceEngineTestFake, CodecPreference) {
|
| - const std::vector<cricket::AudioCodec>& codecs = engine_.codecs();
|
| - ASSERT_FALSE(codecs.empty());
|
| - EXPECT_STRCASEEQ("opus", codecs[0].name.c_str());
|
| - EXPECT_EQ(48000, codecs[0].clockrate);
|
| - EXPECT_EQ(2, codecs[0].channels);
|
| - EXPECT_EQ(64000, codecs[0].bitrate);
|
| - int pref = codecs[0].preference;
|
| - for (size_t i = 1; i < codecs.size(); ++i) {
|
| - EXPECT_GT(pref, codecs[i].preference);
|
| - pref = codecs[i].preference;
|
| - }
|
| -}
|
| -
|
| -TEST_F(WebRtcVoiceEngineTestFake, OpusSupportsTransportCc) {
|
| - const std::vector<cricket::AudioCodec>& codecs = engine_.codecs();
|
| - bool opus_found = false;
|
| - for (cricket::AudioCodec codec : codecs) {
|
| - if (codec.name == "opus") {
|
| - EXPECT_TRUE(HasTransportCc(codec));
|
| - opus_found = true;
|
| - }
|
| - }
|
| - EXPECT_TRUE(opus_found);
|
| -}
|
| -
|
| -// Tests that we can find codecs by name or id, and that we interpret the
|
| -// clockrate and bitrate fields properly.
|
| -TEST_F(WebRtcVoiceEngineTestFake, FindCodec) {
|
| - cricket::AudioCodec codec;
|
| - webrtc::CodecInst codec_inst;
|
| - // Find PCMU with explicit clockrate and bitrate.
|
| - EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(kPcmuCodec, &codec_inst));
|
| - // Find ISAC with explicit clockrate and 0 bitrate.
|
| - EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(kIsacCodec, &codec_inst));
|
| - // Find telephone-event with explicit clockrate and 0 bitrate.
|
| - EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(kTelephoneEventCodec,
|
| - &codec_inst));
|
| - // Find ISAC with a different payload id.
|
| - codec = kIsacCodec;
|
| - codec.id = 127;
|
| - EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(codec, &codec_inst));
|
| - EXPECT_EQ(codec.id, codec_inst.pltype);
|
| - // Find PCMU with a 0 clockrate.
|
| - codec = kPcmuCodec;
|
| - codec.clockrate = 0;
|
| - EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(codec, &codec_inst));
|
| - EXPECT_EQ(codec.id, codec_inst.pltype);
|
| - EXPECT_EQ(8000, codec_inst.plfreq);
|
| - // Find PCMU with a 0 bitrate.
|
| - codec = kPcmuCodec;
|
| - codec.bitrate = 0;
|
| - EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(codec, &codec_inst));
|
| - EXPECT_EQ(codec.id, codec_inst.pltype);
|
| - EXPECT_EQ(64000, codec_inst.rate);
|
| - // Find ISAC with an explicit bitrate.
|
| - codec = kIsacCodec;
|
| - codec.bitrate = 32000;
|
| - EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(codec, &codec_inst));
|
| - EXPECT_EQ(codec.id, codec_inst.pltype);
|
| - EXPECT_EQ(32000, codec_inst.rate);
|
| -}
|
| -
|
| -// Test that we set our inbound codecs properly, including changing PT.
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecs) {
|
| - EXPECT_TRUE(SetupEngine());
|
| - cricket::AudioRecvParameters parameters;
|
| - parameters.codecs.push_back(kIsacCodec);
|
| - parameters.codecs.push_back(kPcmuCodec);
|
| - parameters.codecs.push_back(kTelephoneEventCodec);
|
| - parameters.codecs[0].id = 106; // collide with existing telephone-event
|
| - parameters.codecs[2].id = 126;
|
| - EXPECT_TRUE(channel_->SetRecvParameters(parameters));
|
| - EXPECT_TRUE(channel_->AddRecvStream(
|
| - cricket::StreamParams::CreateLegacy(kSsrc1)));
|
| - int channel_num = voe_.GetLastChannel();
|
| - webrtc::CodecInst gcodec;
|
| - rtc::strcpyn(gcodec.plname, arraysize(gcodec.plname), "ISAC");
|
| - gcodec.plfreq = 16000;
|
| - gcodec.channels = 1;
|
| - EXPECT_EQ(0, voe_.GetRecPayloadType(channel_num, gcodec));
|
| - EXPECT_EQ(106, gcodec.pltype);
|
| - EXPECT_STREQ("ISAC", gcodec.plname);
|
| - rtc::strcpyn(gcodec.plname, arraysize(gcodec.plname), "telephone-event");
|
| - gcodec.plfreq = 8000;
|
| - EXPECT_EQ(0, voe_.GetRecPayloadType(channel_num, gcodec));
|
| - EXPECT_EQ(126, gcodec.pltype);
|
| - EXPECT_STREQ("telephone-event", gcodec.plname);
|
| -}
|
| -
|
| -// Test that we fail to set an unknown inbound codec.
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecsUnsupportedCodec) {
|
| - EXPECT_TRUE(SetupEngine());
|
| - cricket::AudioRecvParameters parameters;
|
| - parameters.codecs.push_back(kIsacCodec);
|
| - parameters.codecs.push_back(cricket::AudioCodec(127, "XYZ", 32000, 0, 1, 0));
|
| - EXPECT_FALSE(channel_->SetRecvParameters(parameters));
|
| -}
|
| -
|
| -// Test that we fail if we have duplicate types in the inbound list.
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecsDuplicatePayloadType) {
|
| - EXPECT_TRUE(SetupEngine());
|
| - cricket::AudioRecvParameters parameters;
|
| - parameters.codecs.push_back(kIsacCodec);
|
| - parameters.codecs.push_back(kCn16000Codec);
|
| - parameters.codecs[1].id = kIsacCodec.id;
|
| - EXPECT_FALSE(channel_->SetRecvParameters(parameters));
|
| -}
|
| -
|
| -// Test that we can decode OPUS without stereo parameters.
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecsWithOpusNoStereo) {
|
| - EXPECT_TRUE(SetupEngine());
|
| - cricket::AudioRecvParameters parameters;
|
| - parameters.codecs.push_back(kIsacCodec);
|
| - parameters.codecs.push_back(kPcmuCodec);
|
| - parameters.codecs.push_back(kOpusCodec);
|
| - EXPECT_TRUE(channel_->SetRecvParameters(parameters));
|
| - EXPECT_TRUE(channel_->AddRecvStream(
|
| - cricket::StreamParams::CreateLegacy(kSsrc1)));
|
| - int channel_num = voe_.GetLastChannel();
|
| - webrtc::CodecInst opus;
|
| - cricket::WebRtcVoiceEngine::ToCodecInst(kOpusCodec, &opus);
|
| - // Even without stereo parameters, recv codecs still specify channels = 2.
|
| - EXPECT_EQ(2, opus.channels);
|
| - EXPECT_EQ(111, opus.pltype);
|
| - EXPECT_STREQ("opus", opus.plname);
|
| - opus.pltype = 0;
|
| - EXPECT_EQ(0, voe_.GetRecPayloadType(channel_num, opus));
|
| - EXPECT_EQ(111, opus.pltype);
|
| -}
|
| -
|
| -// Test that we can decode OPUS with stereo = 0.
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecsWithOpus0Stereo) {
|
| - EXPECT_TRUE(SetupEngine());
|
| - cricket::AudioRecvParameters parameters;
|
| - parameters.codecs.push_back(kIsacCodec);
|
| - parameters.codecs.push_back(kPcmuCodec);
|
| - parameters.codecs.push_back(kOpusCodec);
|
| - parameters.codecs[2].params["stereo"] = "0";
|
| - EXPECT_TRUE(channel_->SetRecvParameters(parameters));
|
| - EXPECT_TRUE(channel_->AddRecvStream(
|
| - cricket::StreamParams::CreateLegacy(kSsrc1)));
|
| - int channel_num2 = voe_.GetLastChannel();
|
| - webrtc::CodecInst opus;
|
| - cricket::WebRtcVoiceEngine::ToCodecInst(kOpusCodec, &opus);
|
| - // Even when stereo is off, recv codecs still specify channels = 2.
|
| - EXPECT_EQ(2, opus.channels);
|
| - EXPECT_EQ(111, opus.pltype);
|
| - EXPECT_STREQ("opus", opus.plname);
|
| - opus.pltype = 0;
|
| - EXPECT_EQ(0, voe_.GetRecPayloadType(channel_num2, opus));
|
| - EXPECT_EQ(111, opus.pltype);
|
| -}
|
| -
|
| -// Test that we can decode OPUS with stereo = 1.
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecsWithOpus1Stereo) {
|
| - EXPECT_TRUE(SetupEngine());
|
| - cricket::AudioRecvParameters parameters;
|
| - parameters.codecs.push_back(kIsacCodec);
|
| - parameters.codecs.push_back(kPcmuCodec);
|
| - parameters.codecs.push_back(kOpusCodec);
|
| - parameters.codecs[2].params["stereo"] = "1";
|
| - EXPECT_TRUE(channel_->SetRecvParameters(parameters));
|
| - EXPECT_TRUE(channel_->AddRecvStream(
|
| - cricket::StreamParams::CreateLegacy(kSsrc1)));
|
| - int channel_num2 = voe_.GetLastChannel();
|
| - webrtc::CodecInst opus;
|
| - cricket::WebRtcVoiceEngine::ToCodecInst(kOpusCodec, &opus);
|
| - EXPECT_EQ(2, opus.channels);
|
| - EXPECT_EQ(111, opus.pltype);
|
| - EXPECT_STREQ("opus", opus.plname);
|
| - opus.pltype = 0;
|
| - EXPECT_EQ(0, voe_.GetRecPayloadType(channel_num2, opus));
|
| - EXPECT_EQ(111, opus.pltype);
|
| -}
|
| -
|
| -// Test that changes to recv codecs are applied to all streams.
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecsWithMultipleStreams) {
|
| - EXPECT_TRUE(SetupEngine());
|
| - cricket::AudioRecvParameters parameters;
|
| - parameters.codecs.push_back(kIsacCodec);
|
| - parameters.codecs.push_back(kPcmuCodec);
|
| - parameters.codecs.push_back(kTelephoneEventCodec);
|
| - parameters.codecs[0].id = 106; // collide with existing telephone-event
|
| - parameters.codecs[2].id = 126;
|
| - EXPECT_TRUE(channel_->SetRecvParameters(parameters));
|
| - EXPECT_TRUE(channel_->AddRecvStream(
|
| - cricket::StreamParams::CreateLegacy(kSsrc1)));
|
| - int channel_num2 = voe_.GetLastChannel();
|
| - webrtc::CodecInst gcodec;
|
| - rtc::strcpyn(gcodec.plname, arraysize(gcodec.plname), "ISAC");
|
| - gcodec.plfreq = 16000;
|
| - gcodec.channels = 1;
|
| - EXPECT_EQ(0, voe_.GetRecPayloadType(channel_num2, gcodec));
|
| - EXPECT_EQ(106, gcodec.pltype);
|
| - EXPECT_STREQ("ISAC", gcodec.plname);
|
| - rtc::strcpyn(gcodec.plname, arraysize(gcodec.plname), "telephone-event");
|
| - gcodec.plfreq = 8000;
|
| - gcodec.channels = 1;
|
| - EXPECT_EQ(0, voe_.GetRecPayloadType(channel_num2, gcodec));
|
| - EXPECT_EQ(126, gcodec.pltype);
|
| - EXPECT_STREQ("telephone-event", gcodec.plname);
|
| -}
|
| -
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecsAfterAddingStreams) {
|
| - EXPECT_TRUE(SetupEngineWithRecvStream());
|
| - cricket::AudioRecvParameters parameters;
|
| - parameters.codecs.push_back(kIsacCodec);
|
| - parameters.codecs[0].id = 106; // collide with existing telephone-event
|
| - EXPECT_TRUE(channel_->SetRecvParameters(parameters));
|
| -
|
| - int channel_num2 = voe_.GetLastChannel();
|
| - webrtc::CodecInst gcodec;
|
| - rtc::strcpyn(gcodec.plname, arraysize(gcodec.plname), "ISAC");
|
| - gcodec.plfreq = 16000;
|
| - gcodec.channels = 1;
|
| - EXPECT_EQ(0, voe_.GetRecPayloadType(channel_num2, gcodec));
|
| - EXPECT_EQ(106, gcodec.pltype);
|
| - EXPECT_STREQ("ISAC", gcodec.plname);
|
| -}
|
| -
|
| -// Test that we can apply the same set of codecs again while playing.
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecsWhilePlaying) {
|
| - EXPECT_TRUE(SetupEngineWithRecvStream());
|
| - cricket::AudioRecvParameters parameters;
|
| - parameters.codecs.push_back(kIsacCodec);
|
| - parameters.codecs.push_back(kCn16000Codec);
|
| - EXPECT_TRUE(channel_->SetRecvParameters(parameters));
|
| - EXPECT_TRUE(channel_->SetPlayout(true));
|
| - EXPECT_TRUE(channel_->SetRecvParameters(parameters));
|
| -
|
| - // Changing the payload type of a codec should fail.
|
| - parameters.codecs[0].id = 127;
|
| - EXPECT_FALSE(channel_->SetRecvParameters(parameters));
|
| - int channel_num = voe_.GetLastChannel();
|
| - EXPECT_TRUE(voe_.GetPlayout(channel_num));
|
| -}
|
| -
|
| -// Test that we can add a codec while playing.
|
| -TEST_F(WebRtcVoiceEngineTestFake, AddRecvCodecsWhilePlaying) {
|
| - EXPECT_TRUE(SetupEngineWithRecvStream());
|
| - cricket::AudioRecvParameters parameters;
|
| - parameters.codecs.push_back(kIsacCodec);
|
| - parameters.codecs.push_back(kCn16000Codec);
|
| - EXPECT_TRUE(channel_->SetRecvParameters(parameters));
|
| - EXPECT_TRUE(channel_->SetPlayout(true));
|
| -
|
| - parameters.codecs.push_back(kOpusCodec);
|
| - EXPECT_TRUE(channel_->SetRecvParameters(parameters));
|
| - int channel_num = voe_.GetLastChannel();
|
| - EXPECT_TRUE(voe_.GetPlayout(channel_num));
|
| - webrtc::CodecInst gcodec;
|
| - EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(kOpusCodec, &gcodec));
|
| - EXPECT_EQ(kOpusCodec.id, gcodec.pltype);
|
| -}
|
| -
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetSendBandwidthAuto) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| -
|
| - // Test that when autobw is enabled, bitrate is kept as the default
|
| - // value. autobw is enabled for the following tests because the target
|
| - // bitrate is <= 0.
|
| -
|
| - // ISAC, default bitrate == 32000.
|
| - TestSendBandwidth(kIsacCodec, 0, true, 32000);
|
| -
|
| - // PCMU, default bitrate == 64000.
|
| - TestSendBandwidth(kPcmuCodec, -1, true, 64000);
|
| -
|
| - // opus, default bitrate == 64000.
|
| - TestSendBandwidth(kOpusCodec, -1, true, 64000);
|
| -}
|
| -
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthMultiRateAsCaller) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| -
|
| - // Test that the bitrate of a multi-rate codec is always the maximum.
|
| -
|
| - // ISAC, default bitrate == 32000.
|
| - TestSendBandwidth(kIsacCodec, 128000, true, 128000);
|
| - TestSendBandwidth(kIsacCodec, 16000, true, 16000);
|
| -
|
| - // opus, default bitrate == 64000.
|
| - TestSendBandwidth(kOpusCodec, 96000, true, 96000);
|
| - TestSendBandwidth(kOpusCodec, 48000, true, 48000);
|
| -}
|
| -
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthFixedRateAsCaller) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| -
|
| - // Test that we can only set a maximum bitrate for a fixed-rate codec
|
| - // if it's bigger than the fixed rate.
|
| -
|
| - // PCMU, fixed bitrate == 64000.
|
| - TestSendBandwidth(kPcmuCodec, 0, true, 64000);
|
| - TestSendBandwidth(kPcmuCodec, 1, false, 64000);
|
| - TestSendBandwidth(kPcmuCodec, 128000, true, 64000);
|
| - TestSendBandwidth(kPcmuCodec, 32000, false, 64000);
|
| - TestSendBandwidth(kPcmuCodec, 64000, true, 64000);
|
| - TestSendBandwidth(kPcmuCodec, 63999, false, 64000);
|
| - TestSendBandwidth(kPcmuCodec, 64001, true, 64000);
|
| -}
|
| -
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthMultiRateAsCallee) {
|
| - EXPECT_TRUE(SetupEngine());
|
| - const int kDesiredBitrate = 128000;
|
| - cricket::AudioSendParameters parameters;
|
| - parameters.codecs = engine_.codecs();
|
| - parameters.max_bandwidth_bps = kDesiredBitrate;
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| -
|
| - EXPECT_TRUE(channel_->AddSendStream(
|
| - cricket::StreamParams::CreateLegacy(kSsrc1)));
|
| -
|
| - int channel_num = voe_.GetLastChannel();
|
| - webrtc::CodecInst codec;
|
| - EXPECT_EQ(0, voe_.GetSendCodec(channel_num, codec));
|
| - EXPECT_EQ(kDesiredBitrate, codec.rate);
|
| -}
|
| -
|
| -// Test that bitrate cannot be set for CBR codecs.
|
| -// Bitrate is ignored if it is higher than the fixed bitrate.
|
| -// Bitrate less then the fixed bitrate is an error.
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthCbr) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| -
|
| - // PCMU, default bitrate == 64000.
|
| - EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
|
| - int channel_num = voe_.GetLastChannel();
|
| - webrtc::CodecInst codec;
|
| - EXPECT_EQ(0, voe_.GetSendCodec(channel_num, codec));
|
| - EXPECT_EQ(64000, codec.rate);
|
| -
|
| - send_parameters_.max_bandwidth_bps = 128000;
|
| - EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
|
| - EXPECT_EQ(0, voe_.GetSendCodec(channel_num, codec));
|
| - EXPECT_EQ(64000, codec.rate);
|
| -
|
| - send_parameters_.max_bandwidth_bps = 128;
|
| - EXPECT_FALSE(channel_->SetSendParameters(send_parameters_));
|
| - EXPECT_EQ(0, voe_.GetSendCodec(channel_num, codec));
|
| - EXPECT_EQ(64000, codec.rate);
|
| -}
|
| -
|
| -// Test that we apply codecs properly.
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecs) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - cricket::AudioSendParameters parameters;
|
| - parameters.codecs.push_back(kIsacCodec);
|
| - parameters.codecs.push_back(kPcmuCodec);
|
| - parameters.codecs.push_back(kRedCodec);
|
| - parameters.codecs[0].id = 96;
|
| - parameters.codecs[0].bitrate = 48000;
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - EXPECT_EQ(1, voe_.GetNumSetSendCodecs());
|
| - int channel_num = voe_.GetLastChannel();
|
| - webrtc::CodecInst gcodec;
|
| - EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
|
| - EXPECT_EQ(96, gcodec.pltype);
|
| - EXPECT_EQ(48000, gcodec.rate);
|
| - EXPECT_STREQ("ISAC", gcodec.plname);
|
| - EXPECT_FALSE(voe_.GetVAD(channel_num));
|
| - EXPECT_FALSE(voe_.GetRED(channel_num));
|
| - EXPECT_EQ(13, voe_.GetSendCNPayloadType(channel_num, false));
|
| - EXPECT_EQ(105, voe_.GetSendCNPayloadType(channel_num, true));
|
| - EXPECT_FALSE(channel_->CanInsertDtmf());
|
| -}
|
| -
|
| -// Test that VoE Channel doesn't call SetSendCodec again if same codec is tried
|
| -// to apply.
|
| -TEST_F(WebRtcVoiceEngineTestFake, DontResetSetSendCodec) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - cricket::AudioSendParameters parameters;
|
| - parameters.codecs.push_back(kIsacCodec);
|
| - parameters.codecs.push_back(kPcmuCodec);
|
| - parameters.codecs.push_back(kRedCodec);
|
| - parameters.codecs[0].id = 96;
|
| - parameters.codecs[0].bitrate = 48000;
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - EXPECT_EQ(1, voe_.GetNumSetSendCodecs());
|
| - // Calling SetSendCodec again with same codec which is already set.
|
| - // In this case media channel shouldn't send codec to VoE.
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - EXPECT_EQ(1, voe_.GetNumSetSendCodecs());
|
| -}
|
| -
|
| -// Verify that G722 is set with 16000 samples per second to WebRTC.
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecG722) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - int channel_num = voe_.GetLastChannel();
|
| - cricket::AudioSendParameters parameters;
|
| - parameters.codecs.push_back(kG722CodecSdp);
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - webrtc::CodecInst gcodec;
|
| - EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
|
| - EXPECT_STREQ("G722", gcodec.plname);
|
| - EXPECT_EQ(1, gcodec.channels);
|
| - EXPECT_EQ(16000, gcodec.plfreq);
|
| -}
|
| -
|
| -// Test that if clockrate is not 48000 for opus, we fail.
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusBadClockrate) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - cricket::AudioSendParameters parameters;
|
| - parameters.codecs.push_back(kOpusCodec);
|
| - parameters.codecs[0].bitrate = 0;
|
| - parameters.codecs[0].clockrate = 50000;
|
| - EXPECT_FALSE(channel_->SetSendParameters(parameters));
|
| -}
|
| -
|
| -// Test that if channels=0 for opus, we fail.
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusBad0ChannelsNoStereo) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - cricket::AudioSendParameters parameters;
|
| - parameters.codecs.push_back(kOpusCodec);
|
| - parameters.codecs[0].bitrate = 0;
|
| - parameters.codecs[0].channels = 0;
|
| - EXPECT_FALSE(channel_->SetSendParameters(parameters));
|
| -}
|
| -
|
| -// Test that if channels=0 for opus, we fail.
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusBad0Channels1Stereo) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - cricket::AudioSendParameters parameters;
|
| - parameters.codecs.push_back(kOpusCodec);
|
| - parameters.codecs[0].bitrate = 0;
|
| - parameters.codecs[0].channels = 0;
|
| - parameters.codecs[0].params["stereo"] = "1";
|
| - EXPECT_FALSE(channel_->SetSendParameters(parameters));
|
| -}
|
| -
|
| -// Test that if channel is 1 for opus and there's no stereo, we fail.
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpus1ChannelNoStereo) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - cricket::AudioSendParameters parameters;
|
| - parameters.codecs.push_back(kOpusCodec);
|
| - parameters.codecs[0].bitrate = 0;
|
| - parameters.codecs[0].channels = 1;
|
| - EXPECT_FALSE(channel_->SetSendParameters(parameters));
|
| -}
|
| -
|
| -// Test that if channel is 1 for opus and stereo=0, we fail.
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusBad1Channel0Stereo) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - cricket::AudioSendParameters parameters;
|
| - parameters.codecs.push_back(kOpusCodec);
|
| - parameters.codecs[0].bitrate = 0;
|
| - parameters.codecs[0].channels = 1;
|
| - parameters.codecs[0].params["stereo"] = "0";
|
| - EXPECT_FALSE(channel_->SetSendParameters(parameters));
|
| -}
|
| -
|
| -// Test that if channel is 1 for opus and stereo=1, we fail.
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusBad1Channel1Stereo) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - cricket::AudioSendParameters parameters;
|
| - parameters.codecs.push_back(kOpusCodec);
|
| - parameters.codecs[0].bitrate = 0;
|
| - parameters.codecs[0].channels = 1;
|
| - parameters.codecs[0].params["stereo"] = "1";
|
| - EXPECT_FALSE(channel_->SetSendParameters(parameters));
|
| -}
|
| -
|
| -// Test that with bitrate=0 and no stereo,
|
| -// channels and bitrate are 1 and 32000.
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGood0BitrateNoStereo) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - int channel_num = voe_.GetLastChannel();
|
| - cricket::AudioSendParameters parameters;
|
| - parameters.codecs.push_back(kOpusCodec);
|
| - parameters.codecs[0].bitrate = 0;
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - webrtc::CodecInst gcodec;
|
| - EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
|
| - EXPECT_STREQ("opus", gcodec.plname);
|
| - EXPECT_EQ(1, gcodec.channels);
|
| - EXPECT_EQ(32000, gcodec.rate);
|
| -}
|
| -
|
| -// Test that with bitrate=0 and stereo=0,
|
| -// channels and bitrate are 1 and 32000.
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGood0Bitrate0Stereo) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - int channel_num = voe_.GetLastChannel();
|
| - cricket::AudioSendParameters parameters;
|
| - parameters.codecs.push_back(kOpusCodec);
|
| - parameters.codecs[0].bitrate = 0;
|
| - parameters.codecs[0].params["stereo"] = "0";
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - webrtc::CodecInst gcodec;
|
| - EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
|
| - EXPECT_STREQ("opus", gcodec.plname);
|
| - EXPECT_EQ(1, gcodec.channels);
|
| - EXPECT_EQ(32000, gcodec.rate);
|
| -}
|
| -
|
| -// Test that with bitrate=invalid and stereo=0,
|
| -// channels and bitrate are 1 and 32000.
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodXBitrate0Stereo) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - int channel_num = voe_.GetLastChannel();
|
| - cricket::AudioSendParameters parameters;
|
| - parameters.codecs.push_back(kOpusCodec);
|
| - parameters.codecs[0].params["stereo"] = "0";
|
| - webrtc::CodecInst gcodec;
|
| -
|
| - // bitrate that's out of the range between 6000 and 510000 will be clamped.
|
| - parameters.codecs[0].bitrate = 5999;
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
|
| - EXPECT_STREQ("opus", gcodec.plname);
|
| - EXPECT_EQ(1, gcodec.channels);
|
| - EXPECT_EQ(6000, gcodec.rate);
|
| -
|
| - parameters.codecs[0].bitrate = 510001;
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
|
| - EXPECT_STREQ("opus", gcodec.plname);
|
| - EXPECT_EQ(1, gcodec.channels);
|
| - EXPECT_EQ(510000, gcodec.rate);
|
| -}
|
| -
|
| -// Test that with bitrate=0 and stereo=1,
|
| -// channels and bitrate are 2 and 64000.
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGood0Bitrate1Stereo) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - int channel_num = voe_.GetLastChannel();
|
| - cricket::AudioSendParameters parameters;
|
| - parameters.codecs.push_back(kOpusCodec);
|
| - parameters.codecs[0].bitrate = 0;
|
| - parameters.codecs[0].params["stereo"] = "1";
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - webrtc::CodecInst gcodec;
|
| - EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
|
| - EXPECT_STREQ("opus", gcodec.plname);
|
| - EXPECT_EQ(2, gcodec.channels);
|
| - EXPECT_EQ(64000, gcodec.rate);
|
| -}
|
| -
|
| -// Test that with bitrate=invalid and stereo=1,
|
| -// channels and bitrate are 2 and 64000.
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodXBitrate1Stereo) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - int channel_num = voe_.GetLastChannel();
|
| - cricket::AudioSendParameters parameters;
|
| - parameters.codecs.push_back(kOpusCodec);
|
| - parameters.codecs[0].params["stereo"] = "1";
|
| - webrtc::CodecInst gcodec;
|
| -
|
| - // bitrate that's out of the range between 6000 and 510000 will be clamped.
|
| - parameters.codecs[0].bitrate = 5999;
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
|
| - EXPECT_STREQ("opus", gcodec.plname);
|
| - EXPECT_EQ(2, gcodec.channels);
|
| - EXPECT_EQ(6000, gcodec.rate);
|
| -
|
| - parameters.codecs[0].bitrate = 510001;
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
|
| - EXPECT_STREQ("opus", gcodec.plname);
|
| - EXPECT_EQ(2, gcodec.channels);
|
| - EXPECT_EQ(510000, gcodec.rate);
|
| -}
|
| -
|
| -// Test that with bitrate=N and stereo unset,
|
| -// channels and bitrate are 1 and N.
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrateNoStereo) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - int channel_num = voe_.GetLastChannel();
|
| - cricket::AudioSendParameters parameters;
|
| - parameters.codecs.push_back(kOpusCodec);
|
| - parameters.codecs[0].bitrate = 96000;
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - webrtc::CodecInst gcodec;
|
| - EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
|
| - EXPECT_EQ(111, gcodec.pltype);
|
| - EXPECT_EQ(96000, gcodec.rate);
|
| - EXPECT_STREQ("opus", gcodec.plname);
|
| - EXPECT_EQ(1, gcodec.channels);
|
| - EXPECT_EQ(48000, gcodec.plfreq);
|
| -}
|
| -
|
| -// Test that with bitrate=N and stereo=0,
|
| -// channels and bitrate are 1 and N.
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrate0Stereo) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - int channel_num = voe_.GetLastChannel();
|
| - cricket::AudioSendParameters parameters;
|
| - parameters.codecs.push_back(kOpusCodec);
|
| - parameters.codecs[0].bitrate = 30000;
|
| - parameters.codecs[0].params["stereo"] = "0";
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - webrtc::CodecInst gcodec;
|
| - EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
|
| - EXPECT_EQ(1, gcodec.channels);
|
| - EXPECT_EQ(30000, gcodec.rate);
|
| - EXPECT_STREQ("opus", gcodec.plname);
|
| -}
|
| -
|
| -// Test that with bitrate=N and without any parameters,
|
| -// channels and bitrate are 1 and N.
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrateNoParameters) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - int channel_num = voe_.GetLastChannel();
|
| - cricket::AudioSendParameters parameters;
|
| - parameters.codecs.push_back(kOpusCodec);
|
| - parameters.codecs[0].bitrate = 30000;
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - webrtc::CodecInst gcodec;
|
| - EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
|
| - EXPECT_EQ(1, gcodec.channels);
|
| - EXPECT_EQ(30000, gcodec.rate);
|
| - EXPECT_STREQ("opus", gcodec.plname);
|
| -}
|
| -
|
| -// Test that with bitrate=N and stereo=1,
|
| -// channels and bitrate are 2 and N.
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrate1Stereo) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - int channel_num = voe_.GetLastChannel();
|
| - cricket::AudioSendParameters parameters;
|
| - parameters.codecs.push_back(kOpusCodec);
|
| - parameters.codecs[0].bitrate = 30000;
|
| - parameters.codecs[0].params["stereo"] = "1";
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - webrtc::CodecInst gcodec;
|
| - EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
|
| - EXPECT_EQ(2, gcodec.channels);
|
| - EXPECT_EQ(30000, gcodec.rate);
|
| - EXPECT_STREQ("opus", gcodec.plname);
|
| -}
|
| -
|
| -// Test that bitrate will be overridden by the "maxaveragebitrate" parameter.
|
| -// Also test that the "maxaveragebitrate" can't be set to values outside the
|
| -// range of 6000 and 510000
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusMaxAverageBitrate) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - int channel_num = voe_.GetLastChannel();
|
| - cricket::AudioSendParameters parameters;
|
| - parameters.codecs.push_back(kOpusCodec);
|
| - parameters.codecs[0].bitrate = 30000;
|
| - webrtc::CodecInst gcodec;
|
| -
|
| - // Ignore if less than 6000.
|
| - parameters.codecs[0].params["maxaveragebitrate"] = "5999";
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
|
| - EXPECT_EQ(6000, gcodec.rate);
|
| -
|
| - // Ignore if larger than 510000.
|
| - parameters.codecs[0].params["maxaveragebitrate"] = "510001";
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
|
| - EXPECT_EQ(510000, gcodec.rate);
|
| -
|
| - parameters.codecs[0].params["maxaveragebitrate"] = "200000";
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
|
| - EXPECT_EQ(200000, gcodec.rate);
|
| -}
|
| -
|
| -// Test that we can enable NACK with opus as caller.
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecEnableNackAsCaller) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - int channel_num = voe_.GetLastChannel();
|
| - cricket::AudioSendParameters parameters;
|
| - parameters.codecs.push_back(kOpusCodec);
|
| - parameters.codecs[0].AddFeedbackParam(
|
| - cricket::FeedbackParam(cricket::kRtcpFbParamNack,
|
| - cricket::kParamValueEmpty));
|
| - EXPECT_FALSE(voe_.GetNACK(channel_num));
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - EXPECT_TRUE(voe_.GetNACK(channel_num));
|
| -}
|
| -
|
| -// Test that we can enable NACK with opus as callee.
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecEnableNackAsCallee) {
|
| - EXPECT_TRUE(SetupEngineWithRecvStream());
|
| - int channel_num = voe_.GetLastChannel();
|
| - cricket::AudioSendParameters parameters;
|
| - parameters.codecs.push_back(kOpusCodec);
|
| - parameters.codecs[0].AddFeedbackParam(
|
| - cricket::FeedbackParam(cricket::kRtcpFbParamNack,
|
| - cricket::kParamValueEmpty));
|
| - EXPECT_FALSE(voe_.GetNACK(channel_num));
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - EXPECT_FALSE(voe_.GetNACK(channel_num));
|
| -
|
| - EXPECT_TRUE(channel_->AddSendStream(
|
| - cricket::StreamParams::CreateLegacy(kSsrc1)));
|
| - EXPECT_TRUE(voe_.GetNACK(voe_.GetLastChannel()));
|
| -}
|
| -
|
| -// Test that we can enable NACK on receive streams.
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecEnableNackRecvStreams) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - int channel_num1 = voe_.GetLastChannel();
|
| - EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(2)));
|
| - int channel_num2 = voe_.GetLastChannel();
|
| - cricket::AudioSendParameters parameters;
|
| - parameters.codecs.push_back(kOpusCodec);
|
| - parameters.codecs[0].AddFeedbackParam(
|
| - cricket::FeedbackParam(cricket::kRtcpFbParamNack,
|
| - cricket::kParamValueEmpty));
|
| - EXPECT_FALSE(voe_.GetNACK(channel_num1));
|
| - EXPECT_FALSE(voe_.GetNACK(channel_num2));
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - EXPECT_TRUE(voe_.GetNACK(channel_num1));
|
| - EXPECT_TRUE(voe_.GetNACK(channel_num2));
|
| -}
|
| -
|
| -// Test that we can disable NACK.
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecDisableNack) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - int channel_num = voe_.GetLastChannel();
|
| - cricket::AudioSendParameters parameters;
|
| - parameters.codecs.push_back(kOpusCodec);
|
| - parameters.codecs[0].AddFeedbackParam(
|
| - cricket::FeedbackParam(cricket::kRtcpFbParamNack,
|
| - cricket::kParamValueEmpty));
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - EXPECT_TRUE(voe_.GetNACK(channel_num));
|
| -
|
| - parameters.codecs.clear();
|
| - parameters.codecs.push_back(kOpusCodec);
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - EXPECT_FALSE(voe_.GetNACK(channel_num));
|
| -}
|
| -
|
| -// Test that we can disable NACK on receive streams.
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecDisableNackRecvStreams) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - int channel_num1 = voe_.GetLastChannel();
|
| - EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(2)));
|
| - int channel_num2 = voe_.GetLastChannel();
|
| - cricket::AudioSendParameters parameters;
|
| - parameters.codecs.push_back(kOpusCodec);
|
| - parameters.codecs[0].AddFeedbackParam(
|
| - cricket::FeedbackParam(cricket::kRtcpFbParamNack,
|
| - cricket::kParamValueEmpty));
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - EXPECT_TRUE(voe_.GetNACK(channel_num1));
|
| - EXPECT_TRUE(voe_.GetNACK(channel_num2));
|
| -
|
| - parameters.codecs.clear();
|
| - parameters.codecs.push_back(kOpusCodec);
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - EXPECT_FALSE(voe_.GetNACK(channel_num1));
|
| - EXPECT_FALSE(voe_.GetNACK(channel_num2));
|
| -}
|
| -
|
| -// Test that NACK is enabled on a new receive stream.
|
| -TEST_F(WebRtcVoiceEngineTestFake, AddRecvStreamEnableNack) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - int channel_num = voe_.GetLastChannel();
|
| - cricket::AudioSendParameters parameters;
|
| - parameters.codecs.push_back(kIsacCodec);
|
| - parameters.codecs.push_back(kCn16000Codec);
|
| - parameters.codecs[0].AddFeedbackParam(
|
| - cricket::FeedbackParam(cricket::kRtcpFbParamNack,
|
| - cricket::kParamValueEmpty));
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - EXPECT_TRUE(voe_.GetNACK(channel_num));
|
| -
|
| - EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(2)));
|
| - channel_num = voe_.GetLastChannel();
|
| - EXPECT_TRUE(voe_.GetNACK(channel_num));
|
| - EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(3)));
|
| - channel_num = voe_.GetLastChannel();
|
| - EXPECT_TRUE(voe_.GetNACK(channel_num));
|
| -}
|
| -
|
| -// Test that without useinbandfec, Opus FEC is off.
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecNoOpusFec) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - int channel_num = voe_.GetLastChannel();
|
| - cricket::AudioSendParameters parameters;
|
| - parameters.codecs.push_back(kOpusCodec);
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - EXPECT_FALSE(voe_.GetCodecFEC(channel_num));
|
| -}
|
| -
|
| -// Test that with useinbandfec=0, Opus FEC is off.
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusDisableFec) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - int channel_num = voe_.GetLastChannel();
|
| - cricket::AudioSendParameters parameters;
|
| - parameters.codecs.push_back(kOpusCodec);
|
| - parameters.codecs[0].bitrate = 0;
|
| - parameters.codecs[0].params["useinbandfec"] = "0";
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - EXPECT_FALSE(voe_.GetCodecFEC(channel_num));
|
| - webrtc::CodecInst gcodec;
|
| - EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
|
| - EXPECT_STREQ("opus", gcodec.plname);
|
| - EXPECT_EQ(1, gcodec.channels);
|
| - EXPECT_EQ(32000, gcodec.rate);
|
| -}
|
| -
|
| -// Test that with useinbandfec=1, Opus FEC is on.
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusEnableFec) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - int channel_num = voe_.GetLastChannel();
|
| - cricket::AudioSendParameters parameters;
|
| - parameters.codecs.push_back(kOpusCodec);
|
| - parameters.codecs[0].bitrate = 0;
|
| - parameters.codecs[0].params["useinbandfec"] = "1";
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - EXPECT_TRUE(voe_.GetCodecFEC(channel_num));
|
| - webrtc::CodecInst gcodec;
|
| - EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
|
| - EXPECT_STREQ("opus", gcodec.plname);
|
| - EXPECT_EQ(1, gcodec.channels);
|
| - EXPECT_EQ(32000, gcodec.rate);
|
| -}
|
| -
|
| -// Test that with useinbandfec=1, stereo=1, Opus FEC is on.
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusEnableFecStereo) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - int channel_num = voe_.GetLastChannel();
|
| - cricket::AudioSendParameters parameters;
|
| - parameters.codecs.push_back(kOpusCodec);
|
| - parameters.codecs[0].bitrate = 0;
|
| - parameters.codecs[0].params["stereo"] = "1";
|
| - parameters.codecs[0].params["useinbandfec"] = "1";
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - EXPECT_TRUE(voe_.GetCodecFEC(channel_num));
|
| - webrtc::CodecInst gcodec;
|
| - EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
|
| - EXPECT_STREQ("opus", gcodec.plname);
|
| - EXPECT_EQ(2, gcodec.channels);
|
| - EXPECT_EQ(64000, gcodec.rate);
|
| -}
|
| -
|
| -// Test that with non-Opus, codec FEC is off.
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecIsacNoFec) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - int channel_num = voe_.GetLastChannel();
|
| - cricket::AudioSendParameters parameters;
|
| - parameters.codecs.push_back(kIsacCodec);
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - EXPECT_FALSE(voe_.GetCodecFEC(channel_num));
|
| -}
|
| -
|
| -// Test the with non-Opus, even if useinbandfec=1, FEC is off.
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecIsacWithParamNoFec) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - int channel_num = voe_.GetLastChannel();
|
| - cricket::AudioSendParameters parameters;
|
| - parameters.codecs.push_back(kIsacCodec);
|
| - parameters.codecs[0].params["useinbandfec"] = "1";
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - EXPECT_FALSE(voe_.GetCodecFEC(channel_num));
|
| -}
|
| -
|
| -// Test that Opus FEC status can be changed.
|
| -TEST_F(WebRtcVoiceEngineTestFake, ChangeOpusFecStatus) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - int channel_num = voe_.GetLastChannel();
|
| - cricket::AudioSendParameters parameters;
|
| - parameters.codecs.push_back(kOpusCodec);
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - EXPECT_FALSE(voe_.GetCodecFEC(channel_num));
|
| - parameters.codecs[0].params["useinbandfec"] = "1";
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - EXPECT_TRUE(voe_.GetCodecFEC(channel_num));
|
| -}
|
| -
|
| -TEST_F(WebRtcVoiceEngineTestFake, TransportCcCanBeEnabledAndDisabled) {
|
| - EXPECT_TRUE(SetupEngine());
|
| - cricket::AudioSendParameters send_parameters;
|
| - send_parameters.codecs.push_back(kOpusCodec);
|
| - EXPECT_TRUE(send_parameters.codecs[0].feedback_params.params().empty());
|
| - EXPECT_TRUE(channel_->SetSendParameters(send_parameters));
|
| -
|
| - cricket::AudioRecvParameters recv_parameters;
|
| - recv_parameters.codecs.push_back(kIsacCodec);
|
| - EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters));
|
| - EXPECT_TRUE(
|
| - channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrc1)));
|
| - ASSERT_TRUE(call_.GetAudioReceiveStream(kSsrc1) != nullptr);
|
| - EXPECT_FALSE(
|
| - call_.GetAudioReceiveStream(kSsrc1)->GetConfig().rtp.transport_cc);
|
| -
|
| - send_parameters.codecs = engine_.codecs();
|
| - EXPECT_TRUE(channel_->SetSendParameters(send_parameters));
|
| - ASSERT_TRUE(call_.GetAudioReceiveStream(kSsrc1) != nullptr);
|
| - EXPECT_TRUE(
|
| - call_.GetAudioReceiveStream(kSsrc1)->GetConfig().rtp.transport_cc);
|
| -}
|
| -
|
| -// Test maxplaybackrate <= 8000 triggers Opus narrow band mode.
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateNb) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - int channel_num = voe_.GetLastChannel();
|
| - cricket::AudioSendParameters parameters;
|
| - parameters.codecs.push_back(kOpusCodec);
|
| - parameters.codecs[0].bitrate = 0;
|
| - parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 8000);
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - EXPECT_EQ(cricket::kOpusBandwidthNb,
|
| - voe_.GetMaxEncodingBandwidth(channel_num));
|
| - webrtc::CodecInst gcodec;
|
| - EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
|
| - EXPECT_STREQ("opus", gcodec.plname);
|
| -
|
| - EXPECT_EQ(12000, gcodec.rate);
|
| - parameters.codecs[0].SetParam(cricket::kCodecParamStereo, "1");
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
|
| - EXPECT_EQ(24000, gcodec.rate);
|
| -}
|
| -
|
| -// Test 8000 < maxplaybackrate <= 12000 triggers Opus medium band mode.
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateMb) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - int channel_num = voe_.GetLastChannel();
|
| - cricket::AudioSendParameters parameters;
|
| - parameters.codecs.push_back(kOpusCodec);
|
| - parameters.codecs[0].bitrate = 0;
|
| - parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 8001);
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - EXPECT_EQ(cricket::kOpusBandwidthMb,
|
| - voe_.GetMaxEncodingBandwidth(channel_num));
|
| - webrtc::CodecInst gcodec;
|
| - EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
|
| - EXPECT_STREQ("opus", gcodec.plname);
|
| -
|
| - EXPECT_EQ(20000, gcodec.rate);
|
| - parameters.codecs[0].SetParam(cricket::kCodecParamStereo, "1");
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
|
| - EXPECT_EQ(40000, gcodec.rate);
|
| -}
|
| -
|
| -// Test 12000 < maxplaybackrate <= 16000 triggers Opus wide band mode.
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateWb) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - int channel_num = voe_.GetLastChannel();
|
| - cricket::AudioSendParameters parameters;
|
| - parameters.codecs.push_back(kOpusCodec);
|
| - parameters.codecs[0].bitrate = 0;
|
| - parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 12001);
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - EXPECT_EQ(cricket::kOpusBandwidthWb,
|
| - voe_.GetMaxEncodingBandwidth(channel_num));
|
| - webrtc::CodecInst gcodec;
|
| - EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
|
| - EXPECT_STREQ("opus", gcodec.plname);
|
| -
|
| - EXPECT_EQ(20000, gcodec.rate);
|
| - parameters.codecs[0].SetParam(cricket::kCodecParamStereo, "1");
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
|
| - EXPECT_EQ(40000, gcodec.rate);
|
| -}
|
| -
|
| -// Test 16000 < maxplaybackrate <= 24000 triggers Opus super wide band mode.
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateSwb) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - int channel_num = voe_.GetLastChannel();
|
| - cricket::AudioSendParameters parameters;
|
| - parameters.codecs.push_back(kOpusCodec);
|
| - parameters.codecs[0].bitrate = 0;
|
| - parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 16001);
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - EXPECT_EQ(cricket::kOpusBandwidthSwb,
|
| - voe_.GetMaxEncodingBandwidth(channel_num));
|
| - webrtc::CodecInst gcodec;
|
| - EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
|
| - EXPECT_STREQ("opus", gcodec.plname);
|
| -
|
| - EXPECT_EQ(32000, gcodec.rate);
|
| - parameters.codecs[0].SetParam(cricket::kCodecParamStereo, "1");
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
|
| - EXPECT_EQ(64000, gcodec.rate);
|
| -}
|
| -
|
| -// Test 24000 < maxplaybackrate triggers Opus full band mode.
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateFb) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - int channel_num = voe_.GetLastChannel();
|
| - cricket::AudioSendParameters parameters;
|
| - parameters.codecs.push_back(kOpusCodec);
|
| - parameters.codecs[0].bitrate = 0;
|
| - parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 24001);
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - EXPECT_EQ(cricket::kOpusBandwidthFb,
|
| - voe_.GetMaxEncodingBandwidth(channel_num));
|
| - webrtc::CodecInst gcodec;
|
| - EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
|
| - EXPECT_STREQ("opus", gcodec.plname);
|
| -
|
| - EXPECT_EQ(32000, gcodec.rate);
|
| - parameters.codecs[0].SetParam(cricket::kCodecParamStereo, "1");
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
|
| - EXPECT_EQ(64000, gcodec.rate);
|
| -}
|
| -
|
| -// Test Opus that without maxplaybackrate, default playback rate is used.
|
| -TEST_F(WebRtcVoiceEngineTestFake, DefaultOpusMaxPlaybackRate) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - int channel_num = voe_.GetLastChannel();
|
| - cricket::AudioSendParameters parameters;
|
| - parameters.codecs.push_back(kOpusCodec);
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - EXPECT_EQ(cricket::kOpusBandwidthFb,
|
| - voe_.GetMaxEncodingBandwidth(channel_num));
|
| -}
|
| -
|
| -// Test the with non-Opus, maxplaybackrate has no effect.
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetNonOpusMaxPlaybackRate) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - int channel_num = voe_.GetLastChannel();
|
| - cricket::AudioSendParameters parameters;
|
| - parameters.codecs.push_back(kIsacCodec);
|
| - parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 32000);
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - EXPECT_EQ(0, voe_.GetMaxEncodingBandwidth(channel_num));
|
| -}
|
| -
|
| -// Test maxplaybackrate can be set on two streams.
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateOnTwoStreams) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - int channel_num = voe_.GetLastChannel();
|
| - cricket::AudioSendParameters parameters;
|
| - parameters.codecs.push_back(kOpusCodec);
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - // Default bandwidth is 24000.
|
| - EXPECT_EQ(cricket::kOpusBandwidthFb,
|
| - voe_.GetMaxEncodingBandwidth(channel_num));
|
| -
|
| - parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 8000);
|
| -
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - EXPECT_EQ(cricket::kOpusBandwidthNb,
|
| - voe_.GetMaxEncodingBandwidth(channel_num));
|
| -
|
| - channel_->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc2));
|
| - channel_num = voe_.GetLastChannel();
|
| - EXPECT_EQ(cricket::kOpusBandwidthNb,
|
| - voe_.GetMaxEncodingBandwidth(channel_num));
|
| -}
|
| -
|
| -// Test that with usedtx=0, Opus DTX is off.
|
| -TEST_F(WebRtcVoiceEngineTestFake, DisableOpusDtxOnOpus) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - int channel_num = voe_.GetLastChannel();
|
| - cricket::AudioSendParameters parameters;
|
| - parameters.codecs.push_back(kOpusCodec);
|
| - parameters.codecs[0].params["usedtx"] = "0";
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - EXPECT_FALSE(voe_.GetOpusDtx(channel_num));
|
| -}
|
| -
|
| -// Test that with usedtx=1, Opus DTX is on.
|
| -TEST_F(WebRtcVoiceEngineTestFake, EnableOpusDtxOnOpus) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - int channel_num = voe_.GetLastChannel();
|
| - cricket::AudioSendParameters parameters;
|
| - parameters.codecs.push_back(kOpusCodec);
|
| - parameters.codecs[0].params["usedtx"] = "1";
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - EXPECT_TRUE(voe_.GetOpusDtx(channel_num));
|
| - EXPECT_FALSE(voe_.GetVAD(channel_num)); // Opus DTX should not affect VAD.
|
| -}
|
| -
|
| -// Test that usedtx=1 works with stereo Opus.
|
| -TEST_F(WebRtcVoiceEngineTestFake, EnableOpusDtxOnOpusStereo) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - int channel_num = voe_.GetLastChannel();
|
| - cricket::AudioSendParameters parameters;
|
| - parameters.codecs.push_back(kOpusCodec);
|
| - parameters.codecs[0].params["usedtx"] = "1";
|
| - parameters.codecs[0].params["stereo"] = "1";
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - EXPECT_TRUE(voe_.GetOpusDtx(channel_num));
|
| - EXPECT_FALSE(voe_.GetVAD(channel_num)); // Opus DTX should not affect VAD.
|
| -}
|
| -
|
| -// Test that usedtx=1 does not work with non Opus.
|
| -TEST_F(WebRtcVoiceEngineTestFake, CannotEnableOpusDtxOnNonOpus) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - int channel_num = voe_.GetLastChannel();
|
| - cricket::AudioSendParameters parameters;
|
| - parameters.codecs.push_back(kIsacCodec);
|
| - parameters.codecs[0].params["usedtx"] = "1";
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - EXPECT_FALSE(voe_.GetOpusDtx(channel_num));
|
| -}
|
| -
|
| -// Test that we can switch back and forth between Opus and ISAC with CN.
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsIsacOpusSwitching) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - int channel_num = voe_.GetLastChannel();
|
| - cricket::AudioSendParameters opus_parameters;
|
| - opus_parameters.codecs.push_back(kOpusCodec);
|
| - EXPECT_TRUE(channel_->SetSendParameters(opus_parameters));
|
| - webrtc::CodecInst gcodec;
|
| - EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
|
| - EXPECT_EQ(111, gcodec.pltype);
|
| - EXPECT_STREQ("opus", gcodec.plname);
|
| -
|
| - cricket::AudioSendParameters isac_parameters;
|
| - isac_parameters.codecs.push_back(kIsacCodec);
|
| - isac_parameters.codecs.push_back(kCn16000Codec);
|
| - isac_parameters.codecs.push_back(kOpusCodec);
|
| - EXPECT_TRUE(channel_->SetSendParameters(isac_parameters));
|
| - EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
|
| - EXPECT_EQ(103, gcodec.pltype);
|
| - EXPECT_STREQ("ISAC", gcodec.plname);
|
| -
|
| - EXPECT_TRUE(channel_->SetSendParameters(opus_parameters));
|
| - EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
|
| - EXPECT_EQ(111, gcodec.pltype);
|
| - EXPECT_STREQ("opus", gcodec.plname);
|
| -}
|
| -
|
| -// Test that we handle various ways of specifying bitrate.
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsBitrate) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - int channel_num = voe_.GetLastChannel();
|
| - cricket::AudioSendParameters parameters;
|
| - parameters.codecs.push_back(kIsacCodec); // bitrate == 32000
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - webrtc::CodecInst gcodec;
|
| - EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
|
| - EXPECT_EQ(103, gcodec.pltype);
|
| - EXPECT_STREQ("ISAC", gcodec.plname);
|
| - EXPECT_EQ(32000, gcodec.rate);
|
| -
|
| - parameters.codecs[0].bitrate = 0; // bitrate == default
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
|
| - EXPECT_EQ(103, gcodec.pltype);
|
| - EXPECT_STREQ("ISAC", gcodec.plname);
|
| - EXPECT_EQ(-1, gcodec.rate);
|
| -
|
| - parameters.codecs[0].bitrate = 28000; // bitrate == 28000
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
|
| - EXPECT_EQ(103, gcodec.pltype);
|
| - EXPECT_STREQ("ISAC", gcodec.plname);
|
| - EXPECT_EQ(28000, gcodec.rate);
|
| -
|
| - parameters.codecs[0] = kPcmuCodec; // bitrate == 64000
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
|
| - EXPECT_EQ(0, gcodec.pltype);
|
| - EXPECT_STREQ("PCMU", gcodec.plname);
|
| - EXPECT_EQ(64000, gcodec.rate);
|
| -
|
| - parameters.codecs[0].bitrate = 0; // bitrate == default
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
|
| - EXPECT_EQ(0, gcodec.pltype);
|
| - EXPECT_STREQ("PCMU", gcodec.plname);
|
| - EXPECT_EQ(64000, gcodec.rate);
|
| -
|
| - parameters.codecs[0] = kOpusCodec;
|
| - parameters.codecs[0].bitrate = 0; // bitrate == default
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
|
| - EXPECT_EQ(111, gcodec.pltype);
|
| - EXPECT_STREQ("opus", gcodec.plname);
|
| - EXPECT_EQ(32000, gcodec.rate);
|
| -}
|
| -
|
| -// Test that we could set packet size specified in kCodecParamPTime.
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsPTimeAsPacketSize) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - int channel_num = voe_.GetLastChannel();
|
| - cricket::AudioSendParameters parameters;
|
| - parameters.codecs.push_back(kOpusCodec);
|
| - parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 40); // Within range.
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - webrtc::CodecInst gcodec;
|
| - EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
|
| - EXPECT_EQ(1920, gcodec.pacsize); // Opus gets 40ms.
|
| -
|
| - parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 5); // Below range.
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
|
| - EXPECT_EQ(480, gcodec.pacsize); // Opus gets 10ms.
|
| -
|
| - parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 80); // Beyond range.
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
|
| - EXPECT_EQ(2880, gcodec.pacsize); // Opus gets 60ms.
|
| -
|
| - parameters.codecs[0] = kIsacCodec; // Also try Isac, with unsupported size.
|
| - parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 40); // Within range.
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
|
| - EXPECT_EQ(480, gcodec.pacsize); // Isac gets 30ms as the next smallest value.
|
| -
|
| - parameters.codecs[0] = kG722CodecSdp; // Try G722 @8kHz as negotiated in SDP.
|
| - parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 40);
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
|
| - EXPECT_EQ(640, gcodec.pacsize); // G722 gets 40ms @16kHz as defined in VoE.
|
| -}
|
| -
|
| -// Test that we fail if no codecs are specified.
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsNoCodecs) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - cricket::AudioSendParameters parameters;
|
| - EXPECT_FALSE(channel_->SetSendParameters(parameters));
|
| -}
|
| -
|
| -// Test that we can set send codecs even with telephone-event codec as the first
|
| -// one on the list.
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsDTMFOnTop) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - int channel_num = voe_.GetLastChannel();
|
| - cricket::AudioSendParameters parameters;
|
| - parameters.codecs.push_back(kTelephoneEventCodec);
|
| - parameters.codecs.push_back(kIsacCodec);
|
| - parameters.codecs.push_back(kPcmuCodec);
|
| - parameters.codecs[0].id = 98; // DTMF
|
| - parameters.codecs[1].id = 96;
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - webrtc::CodecInst gcodec;
|
| - EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
|
| - EXPECT_EQ(96, gcodec.pltype);
|
| - EXPECT_STREQ("ISAC", gcodec.plname);
|
| - EXPECT_TRUE(channel_->CanInsertDtmf());
|
| -}
|
| -
|
| -// Test that we can set send codecs even with CN codec as the first
|
| -// one on the list.
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNOnTop) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - int channel_num = voe_.GetLastChannel();
|
| - cricket::AudioSendParameters parameters;
|
| - parameters.codecs.push_back(kCn16000Codec);
|
| - parameters.codecs.push_back(kIsacCodec);
|
| - parameters.codecs.push_back(kPcmuCodec);
|
| - parameters.codecs[0].id = 98; // wideband CN
|
| - parameters.codecs[1].id = 96;
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - webrtc::CodecInst gcodec;
|
| - EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
|
| - EXPECT_EQ(96, gcodec.pltype);
|
| - EXPECT_STREQ("ISAC", gcodec.plname);
|
| - EXPECT_EQ(98, voe_.GetSendCNPayloadType(channel_num, true));
|
| -}
|
| -
|
| -// Test that we set VAD and DTMF types correctly as caller.
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNandDTMFAsCaller) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - int channel_num = voe_.GetLastChannel();
|
| - cricket::AudioSendParameters parameters;
|
| - parameters.codecs.push_back(kIsacCodec);
|
| - parameters.codecs.push_back(kPcmuCodec);
|
| - // TODO(juberti): cn 32000
|
| - parameters.codecs.push_back(kCn16000Codec);
|
| - parameters.codecs.push_back(kCn8000Codec);
|
| - parameters.codecs.push_back(kTelephoneEventCodec);
|
| - parameters.codecs.push_back(kRedCodec);
|
| - parameters.codecs[0].id = 96;
|
| - parameters.codecs[2].id = 97; // wideband CN
|
| - parameters.codecs[4].id = 98; // DTMF
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - webrtc::CodecInst gcodec;
|
| - EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
|
| - EXPECT_EQ(96, gcodec.pltype);
|
| - EXPECT_STREQ("ISAC", gcodec.plname);
|
| - EXPECT_TRUE(voe_.GetVAD(channel_num));
|
| - EXPECT_FALSE(voe_.GetRED(channel_num));
|
| - EXPECT_EQ(13, voe_.GetSendCNPayloadType(channel_num, false));
|
| - EXPECT_EQ(97, voe_.GetSendCNPayloadType(channel_num, true));
|
| - EXPECT_TRUE(channel_->CanInsertDtmf());
|
| -}
|
| -
|
| -// Test that we set VAD and DTMF types correctly as callee.
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNandDTMFAsCallee) {
|
| - EXPECT_TRUE(engine_.Init(rtc::Thread::Current()));
|
| - channel_ = engine_.CreateChannel(&call_, cricket::AudioOptions());
|
| - EXPECT_TRUE(channel_ != nullptr);
|
| -
|
| - cricket::AudioSendParameters parameters;
|
| - parameters.codecs.push_back(kIsacCodec);
|
| - parameters.codecs.push_back(kPcmuCodec);
|
| - // TODO(juberti): cn 32000
|
| - parameters.codecs.push_back(kCn16000Codec);
|
| - parameters.codecs.push_back(kCn8000Codec);
|
| - parameters.codecs.push_back(kTelephoneEventCodec);
|
| - parameters.codecs.push_back(kRedCodec);
|
| - parameters.codecs[0].id = 96;
|
| - parameters.codecs[2].id = 97; // wideband CN
|
| - parameters.codecs[4].id = 98; // DTMF
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - EXPECT_TRUE(channel_->AddSendStream(
|
| - cricket::StreamParams::CreateLegacy(kSsrc1)));
|
| - int channel_num = voe_.GetLastChannel();
|
| -
|
| - webrtc::CodecInst gcodec;
|
| - EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
|
| - EXPECT_EQ(96, gcodec.pltype);
|
| - EXPECT_STREQ("ISAC", gcodec.plname);
|
| - EXPECT_TRUE(voe_.GetVAD(channel_num));
|
| - EXPECT_FALSE(voe_.GetRED(channel_num));
|
| - EXPECT_EQ(13, voe_.GetSendCNPayloadType(channel_num, false));
|
| - EXPECT_EQ(97, voe_.GetSendCNPayloadType(channel_num, true));
|
| - EXPECT_TRUE(channel_->CanInsertDtmf());
|
| -}
|
| -
|
| -// Test that we only apply VAD if we have a CN codec that matches the
|
| -// send codec clockrate.
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNNoMatch) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - int channel_num = voe_.GetLastChannel();
|
| - cricket::AudioSendParameters parameters;
|
| - // Set ISAC(16K) and CN(16K). VAD should be activated.
|
| - parameters.codecs.push_back(kIsacCodec);
|
| - parameters.codecs.push_back(kCn16000Codec);
|
| - parameters.codecs[1].id = 97;
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - webrtc::CodecInst gcodec;
|
| - EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
|
| - EXPECT_STREQ("ISAC", gcodec.plname);
|
| - EXPECT_TRUE(voe_.GetVAD(channel_num));
|
| - EXPECT_EQ(97, voe_.GetSendCNPayloadType(channel_num, true));
|
| - // Set PCMU(8K) and CN(16K). VAD should not be activated.
|
| - parameters.codecs[0] = kPcmuCodec;
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
|
| - EXPECT_STREQ("PCMU", gcodec.plname);
|
| - EXPECT_FALSE(voe_.GetVAD(channel_num));
|
| - // Set PCMU(8K) and CN(8K). VAD should be activated.
|
| - parameters.codecs[1] = kCn8000Codec;
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
|
| - EXPECT_STREQ("PCMU", gcodec.plname);
|
| - EXPECT_TRUE(voe_.GetVAD(channel_num));
|
| - EXPECT_EQ(13, voe_.GetSendCNPayloadType(channel_num, false));
|
| - // Set ISAC(16K) and CN(8K). VAD should not be activated.
|
| - parameters.codecs[0] = kIsacCodec;
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
|
| - EXPECT_STREQ("ISAC", gcodec.plname);
|
| - EXPECT_FALSE(voe_.GetVAD(channel_num));
|
| -}
|
| -
|
| -// Test that we perform case-insensitive matching of codec names.
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCaseInsensitive) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - int channel_num = voe_.GetLastChannel();
|
| - cricket::AudioSendParameters parameters;
|
| - parameters.codecs.push_back(kIsacCodec);
|
| - parameters.codecs.push_back(kPcmuCodec);
|
| - parameters.codecs.push_back(kCn16000Codec);
|
| - parameters.codecs.push_back(kCn8000Codec);
|
| - parameters.codecs.push_back(kTelephoneEventCodec);
|
| - parameters.codecs.push_back(kRedCodec);
|
| - parameters.codecs[0].name = "iSaC";
|
| - parameters.codecs[0].id = 96;
|
| - parameters.codecs[2].id = 97; // wideband CN
|
| - parameters.codecs[4].id = 98; // DTMF
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - webrtc::CodecInst gcodec;
|
| - EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
|
| - EXPECT_EQ(96, gcodec.pltype);
|
| - EXPECT_STREQ("ISAC", gcodec.plname);
|
| - EXPECT_TRUE(voe_.GetVAD(channel_num));
|
| - EXPECT_FALSE(voe_.GetRED(channel_num));
|
| - EXPECT_EQ(13, voe_.GetSendCNPayloadType(channel_num, false));
|
| - EXPECT_EQ(97, voe_.GetSendCNPayloadType(channel_num, true));
|
| - EXPECT_TRUE(channel_->CanInsertDtmf());
|
| -}
|
| -
|
| -// Test that we set up RED correctly as caller.
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsREDAsCaller) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - int channel_num = voe_.GetLastChannel();
|
| - cricket::AudioSendParameters parameters;
|
| - parameters.codecs.push_back(kRedCodec);
|
| - parameters.codecs.push_back(kIsacCodec);
|
| - parameters.codecs.push_back(kPcmuCodec);
|
| - parameters.codecs[0].id = 127;
|
| - parameters.codecs[0].params[""] = "96/96";
|
| - parameters.codecs[1].id = 96;
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - webrtc::CodecInst gcodec;
|
| - EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
|
| - EXPECT_EQ(96, gcodec.pltype);
|
| - EXPECT_STREQ("ISAC", gcodec.plname);
|
| - EXPECT_TRUE(voe_.GetRED(channel_num));
|
| - EXPECT_EQ(127, voe_.GetSendREDPayloadType(channel_num));
|
| -}
|
| -
|
| -// Test that we set up RED correctly as callee.
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsREDAsCallee) {
|
| - EXPECT_TRUE(engine_.Init(rtc::Thread::Current()));
|
| - channel_ = engine_.CreateChannel(&call_, cricket::AudioOptions());
|
| - EXPECT_TRUE(channel_ != nullptr);
|
| -
|
| - cricket::AudioSendParameters parameters;
|
| - parameters.codecs.push_back(kRedCodec);
|
| - parameters.codecs.push_back(kIsacCodec);
|
| - parameters.codecs.push_back(kPcmuCodec);
|
| - parameters.codecs[0].id = 127;
|
| - parameters.codecs[0].params[""] = "96/96";
|
| - parameters.codecs[1].id = 96;
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - EXPECT_TRUE(channel_->AddSendStream(
|
| - cricket::StreamParams::CreateLegacy(kSsrc1)));
|
| - int channel_num = voe_.GetLastChannel();
|
| - webrtc::CodecInst gcodec;
|
| - EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
|
| - EXPECT_EQ(96, gcodec.pltype);
|
| - EXPECT_STREQ("ISAC", gcodec.plname);
|
| - EXPECT_TRUE(voe_.GetRED(channel_num));
|
| - EXPECT_EQ(127, voe_.GetSendREDPayloadType(channel_num));
|
| -}
|
| -
|
| -// Test that we set up RED correctly if params are omitted.
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsREDNoParams) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - int channel_num = voe_.GetLastChannel();
|
| - cricket::AudioSendParameters parameters;
|
| - parameters.codecs.push_back(kRedCodec);
|
| - parameters.codecs.push_back(kIsacCodec);
|
| - parameters.codecs.push_back(kPcmuCodec);
|
| - parameters.codecs[0].id = 127;
|
| - parameters.codecs[1].id = 96;
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - webrtc::CodecInst gcodec;
|
| - EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
|
| - EXPECT_EQ(96, gcodec.pltype);
|
| - EXPECT_STREQ("ISAC", gcodec.plname);
|
| - EXPECT_TRUE(voe_.GetRED(channel_num));
|
| - EXPECT_EQ(127, voe_.GetSendREDPayloadType(channel_num));
|
| -}
|
| -
|
| -// Test that we ignore RED if the parameters aren't named the way we expect.
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsBadRED1) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - int channel_num = voe_.GetLastChannel();
|
| - cricket::AudioSendParameters parameters;
|
| - parameters.codecs.push_back(kRedCodec);
|
| - parameters.codecs.push_back(kIsacCodec);
|
| - parameters.codecs.push_back(kPcmuCodec);
|
| - parameters.codecs[0].id = 127;
|
| - parameters.codecs[0].params["ABC"] = "96/96";
|
| - parameters.codecs[1].id = 96;
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - webrtc::CodecInst gcodec;
|
| - EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
|
| - EXPECT_EQ(96, gcodec.pltype);
|
| - EXPECT_STREQ("ISAC", gcodec.plname);
|
| - EXPECT_FALSE(voe_.GetRED(channel_num));
|
| -}
|
| -
|
| -// Test that we ignore RED if it uses different primary/secondary encoding.
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsBadRED2) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - int channel_num = voe_.GetLastChannel();
|
| - cricket::AudioSendParameters parameters;
|
| - parameters.codecs.push_back(kRedCodec);
|
| - parameters.codecs.push_back(kIsacCodec);
|
| - parameters.codecs.push_back(kPcmuCodec);
|
| - parameters.codecs[0].id = 127;
|
| - parameters.codecs[0].params[""] = "96/0";
|
| - parameters.codecs[1].id = 96;
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - webrtc::CodecInst gcodec;
|
| - EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
|
| - EXPECT_EQ(96, gcodec.pltype);
|
| - EXPECT_STREQ("ISAC", gcodec.plname);
|
| - EXPECT_FALSE(voe_.GetRED(channel_num));
|
| -}
|
| -
|
| -// Test that we ignore RED if it uses more than 2 encodings.
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsBadRED3) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - int channel_num = voe_.GetLastChannel();
|
| - cricket::AudioSendParameters parameters;
|
| - parameters.codecs.push_back(kRedCodec);
|
| - parameters.codecs.push_back(kIsacCodec);
|
| - parameters.codecs.push_back(kPcmuCodec);
|
| - parameters.codecs[0].id = 127;
|
| - parameters.codecs[0].params[""] = "96/96/96";
|
| - parameters.codecs[1].id = 96;
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - webrtc::CodecInst gcodec;
|
| - EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
|
| - EXPECT_EQ(96, gcodec.pltype);
|
| - EXPECT_STREQ("ISAC", gcodec.plname);
|
| - EXPECT_FALSE(voe_.GetRED(channel_num));
|
| -}
|
| -
|
| -// Test that we ignore RED if it has bogus codec ids.
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsBadRED4) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - int channel_num = voe_.GetLastChannel();
|
| - cricket::AudioSendParameters parameters;
|
| - parameters.codecs.push_back(kRedCodec);
|
| - parameters.codecs.push_back(kIsacCodec);
|
| - parameters.codecs.push_back(kPcmuCodec);
|
| - parameters.codecs[0].id = 127;
|
| - parameters.codecs[0].params[""] = "ABC/ABC";
|
| - parameters.codecs[1].id = 96;
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - webrtc::CodecInst gcodec;
|
| - EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
|
| - EXPECT_EQ(96, gcodec.pltype);
|
| - EXPECT_STREQ("ISAC", gcodec.plname);
|
| - EXPECT_FALSE(voe_.GetRED(channel_num));
|
| -}
|
| -
|
| -// Test that we ignore RED if it refers to a codec that is not present.
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsBadRED5) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - int channel_num = voe_.GetLastChannel();
|
| - cricket::AudioSendParameters parameters;
|
| - parameters.codecs.push_back(kRedCodec);
|
| - parameters.codecs.push_back(kIsacCodec);
|
| - parameters.codecs.push_back(kPcmuCodec);
|
| - parameters.codecs[0].id = 127;
|
| - parameters.codecs[0].params[""] = "97/97";
|
| - parameters.codecs[1].id = 96;
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - webrtc::CodecInst gcodec;
|
| - EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
|
| - EXPECT_EQ(96, gcodec.pltype);
|
| - EXPECT_STREQ("ISAC", gcodec.plname);
|
| - EXPECT_FALSE(voe_.GetRED(channel_num));
|
| -}
|
| -
|
| -class WebRtcVoiceEngineWithSendSideBweTest : public WebRtcVoiceEngineTestFake {
|
| - public:
|
| - WebRtcVoiceEngineWithSendSideBweTest()
|
| - : WebRtcVoiceEngineTestFake("WebRTC-Audio-SendSideBwe/Enabled/") {}
|
| -};
|
| -
|
| -TEST_F(WebRtcVoiceEngineWithSendSideBweTest,
|
| - SupportsTransportSequenceNumberHeaderExtension) {
|
| - cricket::RtpCapabilities capabilities = engine_.GetCapabilities();
|
| - ASSERT_FALSE(capabilities.header_extensions.empty());
|
| - for (const cricket::RtpHeaderExtension& extension :
|
| - capabilities.header_extensions) {
|
| - if (extension.uri == cricket::kRtpTransportSequenceNumberHeaderExtension) {
|
| - EXPECT_EQ(cricket::kRtpTransportSequenceNumberHeaderExtensionDefaultId,
|
| - extension.id);
|
| - return;
|
| - }
|
| - }
|
| - FAIL() << "Transport sequence number extension not in header-extension list.";
|
| -}
|
| -
|
| -// Test support for audio level header extension.
|
| -TEST_F(WebRtcVoiceEngineTestFake, SendAudioLevelHeaderExtensions) {
|
| - TestSetSendRtpHeaderExtensions(kRtpAudioLevelHeaderExtension);
|
| -}
|
| -TEST_F(WebRtcVoiceEngineTestFake, RecvAudioLevelHeaderExtensions) {
|
| - TestSetRecvRtpHeaderExtensions(kRtpAudioLevelHeaderExtension);
|
| -}
|
| -
|
| -// Test support for absolute send time header extension.
|
| -TEST_F(WebRtcVoiceEngineTestFake, SendAbsoluteSendTimeHeaderExtensions) {
|
| - TestSetSendRtpHeaderExtensions(kRtpAbsoluteSenderTimeHeaderExtension);
|
| -}
|
| -TEST_F(WebRtcVoiceEngineTestFake, RecvAbsoluteSendTimeHeaderExtensions) {
|
| - TestSetRecvRtpHeaderExtensions(kRtpAbsoluteSenderTimeHeaderExtension);
|
| -}
|
| -
|
| -// Test that we can create a channel and start sending on it.
|
| -TEST_F(WebRtcVoiceEngineTestFake, Send) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - int channel_num = voe_.GetLastChannel();
|
| - EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
|
| - EXPECT_TRUE(channel_->SetSend(cricket::SEND_MICROPHONE));
|
| - EXPECT_TRUE(voe_.GetSend(channel_num));
|
| - EXPECT_TRUE(channel_->SetSend(cricket::SEND_NOTHING));
|
| - EXPECT_FALSE(voe_.GetSend(channel_num));
|
| -}
|
| -
|
| -// Test that we can create a channel and start playing out on it.
|
| -TEST_F(WebRtcVoiceEngineTestFake, Playout) {
|
| - EXPECT_TRUE(SetupEngineWithRecvStream());
|
| - int channel_num = voe_.GetLastChannel();
|
| - EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
|
| - EXPECT_TRUE(channel_->SetPlayout(true));
|
| - EXPECT_TRUE(voe_.GetPlayout(channel_num));
|
| - EXPECT_TRUE(channel_->SetPlayout(false));
|
| - EXPECT_FALSE(voe_.GetPlayout(channel_num));
|
| -}
|
| -
|
| -// Test that we can add and remove send streams.
|
| -TEST_F(WebRtcVoiceEngineTestFake, CreateAndDeleteMultipleSendStreams) {
|
| - SetupForMultiSendStream();
|
| -
|
| - // Set the global state for sending.
|
| - EXPECT_TRUE(channel_->SetSend(cricket::SEND_MICROPHONE));
|
| -
|
| - for (uint32_t ssrc : kSsrcs4) {
|
| - EXPECT_TRUE(channel_->AddSendStream(
|
| - cricket::StreamParams::CreateLegacy(ssrc)));
|
| - // Verify that we are in a sending state for all the created streams.
|
| - EXPECT_TRUE(voe_.GetSend(GetSendStreamConfig(ssrc).voe_channel_id));
|
| - }
|
| - EXPECT_EQ(arraysize(kSsrcs4), call_.GetAudioSendStreams().size());
|
| -
|
| - // Delete the send streams.
|
| - for (uint32_t ssrc : kSsrcs4) {
|
| - EXPECT_TRUE(channel_->RemoveSendStream(ssrc));
|
| - EXPECT_FALSE(call_.GetAudioSendStream(ssrc));
|
| - EXPECT_FALSE(channel_->RemoveSendStream(ssrc));
|
| - }
|
| - EXPECT_EQ(0u, call_.GetAudioSendStreams().size());
|
| -}
|
| -
|
| -// Test SetSendCodecs correctly configure the codecs in all send streams.
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsWithMultipleSendStreams) {
|
| - SetupForMultiSendStream();
|
| -
|
| - // Create send streams.
|
| - for (uint32_t ssrc : kSsrcs4) {
|
| - EXPECT_TRUE(channel_->AddSendStream(
|
| - cricket::StreamParams::CreateLegacy(ssrc)));
|
| - }
|
| -
|
| - cricket::AudioSendParameters parameters;
|
| - // Set ISAC(16K) and CN(16K). VAD should be activated.
|
| - parameters.codecs.push_back(kIsacCodec);
|
| - parameters.codecs.push_back(kCn16000Codec);
|
| - parameters.codecs[1].id = 97;
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| -
|
| - // Verify ISAC and VAD are corrected configured on all send channels.
|
| - webrtc::CodecInst gcodec;
|
| - for (uint32_t ssrc : kSsrcs4) {
|
| - int channel_num = GetSendStreamConfig(ssrc).voe_channel_id;
|
| - EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
|
| - EXPECT_STREQ("ISAC", gcodec.plname);
|
| - EXPECT_TRUE(voe_.GetVAD(channel_num));
|
| - EXPECT_EQ(97, voe_.GetSendCNPayloadType(channel_num, true));
|
| - }
|
| -
|
| - // Change to PCMU(8K) and CN(16K). VAD should not be activated.
|
| - parameters.codecs[0] = kPcmuCodec;
|
| - EXPECT_TRUE(channel_->SetSendParameters(parameters));
|
| - for (uint32_t ssrc : kSsrcs4) {
|
| - int channel_num = GetSendStreamConfig(ssrc).voe_channel_id;
|
| - EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
|
| - EXPECT_STREQ("PCMU", gcodec.plname);
|
| - EXPECT_FALSE(voe_.GetVAD(channel_num));
|
| - }
|
| -}
|
| -
|
| -// Test we can SetSend on all send streams correctly.
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetSendWithMultipleSendStreams) {
|
| - SetupForMultiSendStream();
|
| -
|
| - // Create the send channels and they should be a SEND_NOTHING date.
|
| - for (uint32_t ssrc : kSsrcs4) {
|
| - EXPECT_TRUE(channel_->AddSendStream(
|
| - cricket::StreamParams::CreateLegacy(ssrc)));
|
| - int channel_num = voe_.GetLastChannel();
|
| - EXPECT_FALSE(voe_.GetSend(channel_num));
|
| - }
|
| -
|
| - // Set the global state for starting sending.
|
| - EXPECT_TRUE(channel_->SetSend(cricket::SEND_MICROPHONE));
|
| - for (uint32_t ssrc : kSsrcs4) {
|
| - // Verify that we are in a sending state for all the send streams.
|
| - int channel_num = GetSendStreamConfig(ssrc).voe_channel_id;
|
| - EXPECT_TRUE(voe_.GetSend(channel_num));
|
| - }
|
| -
|
| - // Set the global state for stopping sending.
|
| - EXPECT_TRUE(channel_->SetSend(cricket::SEND_NOTHING));
|
| - for (uint32_t ssrc : kSsrcs4) {
|
| - // Verify that we are in a stop state for all the send streams.
|
| - int channel_num = GetSendStreamConfig(ssrc).voe_channel_id;
|
| - EXPECT_FALSE(voe_.GetSend(channel_num));
|
| - }
|
| -}
|
| -
|
| -// Test we can set the correct statistics on all send streams.
|
| -TEST_F(WebRtcVoiceEngineTestFake, GetStatsWithMultipleSendStreams) {
|
| - SetupForMultiSendStream();
|
| -
|
| - // Create send streams.
|
| - for (uint32_t ssrc : kSsrcs4) {
|
| - EXPECT_TRUE(channel_->AddSendStream(
|
| - cricket::StreamParams::CreateLegacy(ssrc)));
|
| - }
|
| - SetAudioSendStreamStats();
|
| -
|
| - // Create a receive stream to check that none of the send streams end up in
|
| - // the receive stream stats.
|
| - EXPECT_TRUE(channel_->AddRecvStream(
|
| - cricket::StreamParams::CreateLegacy(kSsrc2)));
|
| - // We need send codec to be set to get all stats.
|
| - EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
|
| - EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
|
| -
|
| - // Check stats for the added streams.
|
| - {
|
| - cricket::VoiceMediaInfo info;
|
| - EXPECT_EQ(true, channel_->GetStats(&info));
|
| -
|
| - // We have added 4 send streams. We should see empty stats for all.
|
| - EXPECT_EQ(static_cast<size_t>(arraysize(kSsrcs4)), info.senders.size());
|
| - for (const auto& sender : info.senders) {
|
| - VerifyVoiceSenderInfo(sender, false);
|
| - }
|
| -
|
| - // We have added one receive stream. We should see empty stats.
|
| - EXPECT_EQ(info.receivers.size(), 1u);
|
| - EXPECT_EQ(info.receivers[0].ssrc(), 0);
|
| - }
|
| -
|
| - // Remove the kSsrc2 stream. No receiver stats.
|
| - {
|
| - cricket::VoiceMediaInfo info;
|
| - EXPECT_TRUE(channel_->RemoveRecvStream(kSsrc2));
|
| - EXPECT_EQ(true, channel_->GetStats(&info));
|
| - EXPECT_EQ(static_cast<size_t>(arraysize(kSsrcs4)), info.senders.size());
|
| - EXPECT_EQ(0u, info.receivers.size());
|
| - }
|
| -
|
| - // Deliver a new packet - a default receive stream should be created and we
|
| - // should see stats again.
|
| - {
|
| - cricket::VoiceMediaInfo info;
|
| - DeliverPacket(kPcmuFrame, sizeof(kPcmuFrame));
|
| - SetAudioReceiveStreamStats();
|
| - EXPECT_EQ(true, channel_->GetStats(&info));
|
| - EXPECT_EQ(static_cast<size_t>(arraysize(kSsrcs4)), info.senders.size());
|
| - EXPECT_EQ(1u, info.receivers.size());
|
| - VerifyVoiceReceiverInfo(info.receivers[0]);
|
| - }
|
| -}
|
| -
|
| -// Test that we can add and remove receive streams, and do proper send/playout.
|
| -// We can receive on multiple streams while sending one stream.
|
| -TEST_F(WebRtcVoiceEngineTestFake, PlayoutWithMultipleStreams) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - int channel_num1 = voe_.GetLastChannel();
|
| -
|
| - // Start playout without a receive stream.
|
| - EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
|
| - EXPECT_TRUE(channel_->SetPlayout(true));
|
| - EXPECT_FALSE(voe_.GetPlayout(channel_num1));
|
| -
|
| - // Adding another stream should enable playout on the new stream only.
|
| - EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(2)));
|
| - int channel_num2 = voe_.GetLastChannel();
|
| - EXPECT_TRUE(channel_->SetSend(cricket::SEND_MICROPHONE));
|
| - EXPECT_TRUE(voe_.GetSend(channel_num1));
|
| - EXPECT_FALSE(voe_.GetSend(channel_num2));
|
| -
|
| - // Make sure only the new stream is played out.
|
| - EXPECT_FALSE(voe_.GetPlayout(channel_num1));
|
| - EXPECT_TRUE(voe_.GetPlayout(channel_num2));
|
| -
|
| - // Adding yet another stream should have stream 2 and 3 enabled for playout.
|
| - EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(3)));
|
| - int channel_num3 = voe_.GetLastChannel();
|
| - EXPECT_FALSE(voe_.GetPlayout(channel_num1));
|
| - EXPECT_TRUE(voe_.GetPlayout(channel_num2));
|
| - EXPECT_TRUE(voe_.GetPlayout(channel_num3));
|
| - EXPECT_FALSE(voe_.GetSend(channel_num3));
|
| -
|
| - // Stop sending.
|
| - EXPECT_TRUE(channel_->SetSend(cricket::SEND_NOTHING));
|
| - EXPECT_FALSE(voe_.GetSend(channel_num1));
|
| - EXPECT_FALSE(voe_.GetSend(channel_num2));
|
| - EXPECT_FALSE(voe_.GetSend(channel_num3));
|
| -
|
| - // Stop playout.
|
| - EXPECT_TRUE(channel_->SetPlayout(false));
|
| - EXPECT_FALSE(voe_.GetPlayout(channel_num1));
|
| - EXPECT_FALSE(voe_.GetPlayout(channel_num2));
|
| - EXPECT_FALSE(voe_.GetPlayout(channel_num3));
|
| -
|
| - // Restart playout and make sure only recv streams are played out.
|
| - EXPECT_TRUE(channel_->SetPlayout(true));
|
| - EXPECT_FALSE(voe_.GetPlayout(channel_num1));
|
| - EXPECT_TRUE(voe_.GetPlayout(channel_num2));
|
| - EXPECT_TRUE(voe_.GetPlayout(channel_num3));
|
| -
|
| - // Now remove the recv streams and verify that the send stream doesn't play.
|
| - EXPECT_TRUE(channel_->RemoveRecvStream(3));
|
| - EXPECT_TRUE(channel_->RemoveRecvStream(2));
|
| - EXPECT_FALSE(voe_.GetPlayout(channel_num1));
|
| -}
|
| -
|
| -// Test that we can create a channel configured for Codian bridges,
|
| -// and start sending on it.
|
| -TEST_F(WebRtcVoiceEngineTestFake, CodianSend) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - cricket::AudioOptions options_adjust_agc;
|
| - options_adjust_agc.adjust_agc_delta = rtc::Optional<int>(-10);
|
| - int channel_num = voe_.GetLastChannel();
|
| - webrtc::AgcConfig agc_config;
|
| - EXPECT_EQ(0, voe_.GetAgcConfig(agc_config));
|
| - EXPECT_EQ(0, agc_config.targetLeveldBOv);
|
| - send_parameters_.options = options_adjust_agc;
|
| - EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
|
| - EXPECT_TRUE(channel_->SetSend(cricket::SEND_MICROPHONE));
|
| - EXPECT_TRUE(voe_.GetSend(channel_num));
|
| - EXPECT_EQ(0, voe_.GetAgcConfig(agc_config));
|
| - EXPECT_EQ(agc_config.targetLeveldBOv, 10); // level was attenuated
|
| - EXPECT_TRUE(channel_->SetSend(cricket::SEND_NOTHING));
|
| - EXPECT_FALSE(voe_.GetSend(channel_num));
|
| - EXPECT_EQ(0, voe_.GetAgcConfig(agc_config));
|
| -}
|
| -
|
| -TEST_F(WebRtcVoiceEngineTestFake, TxAgcConfigViaOptions) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - webrtc::AgcConfig agc_config;
|
| - EXPECT_EQ(0, voe_.GetAgcConfig(agc_config));
|
| - EXPECT_EQ(0, agc_config.targetLeveldBOv);
|
| - send_parameters_.options.tx_agc_target_dbov = rtc::Optional<uint16_t>(3);
|
| - send_parameters_.options.tx_agc_digital_compression_gain =
|
| - rtc::Optional<uint16_t>(9);
|
| - send_parameters_.options.tx_agc_limiter = rtc::Optional<bool>(true);
|
| - send_parameters_.options.auto_gain_control = rtc::Optional<bool>(true);
|
| - EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
|
| - EXPECT_EQ(0, voe_.GetAgcConfig(agc_config));
|
| - EXPECT_EQ(3, agc_config.targetLeveldBOv);
|
| - EXPECT_EQ(9, agc_config.digitalCompressionGaindB);
|
| - EXPECT_TRUE(agc_config.limiterEnable);
|
| -
|
| - // Check interaction with adjust_agc_delta. Both should be respected, for
|
| - // backwards compatibility.
|
| - send_parameters_.options.adjust_agc_delta = rtc::Optional<int>(-10);
|
| - EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
|
| - EXPECT_EQ(0, voe_.GetAgcConfig(agc_config));
|
| - EXPECT_EQ(13, agc_config.targetLeveldBOv);
|
| -}
|
| -
|
| -TEST_F(WebRtcVoiceEngineTestFake, SampleRatesViaOptions) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - send_parameters_.options.recording_sample_rate =
|
| - rtc::Optional<uint32_t>(48000);
|
| - send_parameters_.options.playout_sample_rate = rtc::Optional<uint32_t>(44100);
|
| - EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
|
| -
|
| - unsigned int recording_sample_rate, playout_sample_rate;
|
| - EXPECT_EQ(0, voe_.RecordingSampleRate(&recording_sample_rate));
|
| - EXPECT_EQ(0, voe_.PlayoutSampleRate(&playout_sample_rate));
|
| - EXPECT_EQ(48000u, recording_sample_rate);
|
| - EXPECT_EQ(44100u, playout_sample_rate);
|
| -}
|
| -
|
| -// Test that we can set the outgoing SSRC properly.
|
| -// SSRC is set in SetupEngine by calling AddSendStream.
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetSendSsrc) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - EXPECT_TRUE(call_.GetAudioSendStream(kSsrc1));
|
| -}
|
| -
|
| -TEST_F(WebRtcVoiceEngineTestFake, GetStats) {
|
| - // Setup. We need send codec to be set to get all stats.
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - SetAudioSendStreamStats();
|
| - // SetupEngineWithSendStream adds a send stream with kSsrc1, so the receive
|
| - // stream has to use a different SSRC.
|
| - EXPECT_TRUE(channel_->AddRecvStream(
|
| - cricket::StreamParams::CreateLegacy(kSsrc2)));
|
| - EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
|
| - EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
|
| -
|
| - // Check stats for the added streams.
|
| - {
|
| - cricket::VoiceMediaInfo info;
|
| - EXPECT_EQ(true, channel_->GetStats(&info));
|
| -
|
| - // We have added one send stream. We should see the stats we've set.
|
| - EXPECT_EQ(1u, info.senders.size());
|
| - VerifyVoiceSenderInfo(info.senders[0], false);
|
| - // We have added one receive stream. We should see empty stats.
|
| - EXPECT_EQ(info.receivers.size(), 1u);
|
| - EXPECT_EQ(info.receivers[0].ssrc(), 0);
|
| - }
|
| -
|
| - // Start sending - this affects some reported stats.
|
| - {
|
| - cricket::VoiceMediaInfo info;
|
| - EXPECT_TRUE(channel_->SetSend(cricket::SEND_MICROPHONE));
|
| - EXPECT_EQ(true, channel_->GetStats(&info));
|
| - VerifyVoiceSenderInfo(info.senders[0], true);
|
| - }
|
| -
|
| - // Remove the kSsrc2 stream. No receiver stats.
|
| - {
|
| - cricket::VoiceMediaInfo info;
|
| - EXPECT_TRUE(channel_->RemoveRecvStream(kSsrc2));
|
| - EXPECT_EQ(true, channel_->GetStats(&info));
|
| - EXPECT_EQ(1u, info.senders.size());
|
| - EXPECT_EQ(0u, info.receivers.size());
|
| - }
|
| -
|
| - // Deliver a new packet - a default receive stream should be created and we
|
| - // should see stats again.
|
| - {
|
| - cricket::VoiceMediaInfo info;
|
| - DeliverPacket(kPcmuFrame, sizeof(kPcmuFrame));
|
| - SetAudioReceiveStreamStats();
|
| - EXPECT_EQ(true, channel_->GetStats(&info));
|
| - EXPECT_EQ(1u, info.senders.size());
|
| - EXPECT_EQ(1u, info.receivers.size());
|
| - VerifyVoiceReceiverInfo(info.receivers[0]);
|
| - }
|
| -}
|
| -
|
| -// Test that we can set the outgoing SSRC properly with multiple streams.
|
| -// SSRC is set in SetupEngine by calling AddSendStream.
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetSendSsrcWithMultipleStreams) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - EXPECT_TRUE(call_.GetAudioSendStream(kSsrc1));
|
| - EXPECT_TRUE(channel_->AddRecvStream(
|
| - cricket::StreamParams::CreateLegacy(kSsrc2)));
|
| - EXPECT_EQ(kSsrc1, GetRecvStreamConfig(kSsrc2).rtp.local_ssrc);
|
| -}
|
| -
|
| -// Test that the local SSRC is the same on sending and receiving channels if the
|
| -// receive channel is created before the send channel.
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetSendSsrcAfterCreatingReceiveChannel) {
|
| - EXPECT_TRUE(engine_.Init(rtc::Thread::Current()));
|
| - channel_ = engine_.CreateChannel(&call_, cricket::AudioOptions());
|
| -
|
| - EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1)));
|
| - int receive_channel_num = voe_.GetLastChannel();
|
| - EXPECT_TRUE(channel_->AddSendStream(
|
| - cricket::StreamParams::CreateLegacy(1234)));
|
| -
|
| - EXPECT_TRUE(call_.GetAudioSendStream(1234));
|
| - EXPECT_EQ(1234U, voe_.GetLocalSSRC(receive_channel_num));
|
| -}
|
| -
|
| -// Test that we can properly receive packets.
|
| -TEST_F(WebRtcVoiceEngineTestFake, Recv) {
|
| - EXPECT_TRUE(SetupEngine());
|
| - EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1)));
|
| - DeliverPacket(kPcmuFrame, sizeof(kPcmuFrame));
|
| - int channel_num = voe_.GetLastChannel();
|
| - EXPECT_TRUE(voe_.CheckPacket(channel_num, kPcmuFrame, sizeof(kPcmuFrame)));
|
| -}
|
| -
|
| -// Test that we can properly receive packets on multiple streams.
|
| -TEST_F(WebRtcVoiceEngineTestFake, RecvWithMultipleStreams) {
|
| - EXPECT_TRUE(SetupEngine());
|
| - EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1)));
|
| - int channel_num1 = voe_.GetLastChannel();
|
| - EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(2)));
|
| - int channel_num2 = voe_.GetLastChannel();
|
| - EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(3)));
|
| - int channel_num3 = voe_.GetLastChannel();
|
| - // Create packets with the right SSRCs.
|
| - char packets[4][sizeof(kPcmuFrame)];
|
| - for (size_t i = 0; i < arraysize(packets); ++i) {
|
| - memcpy(packets[i], kPcmuFrame, sizeof(kPcmuFrame));
|
| - rtc::SetBE32(packets[i] + 8, static_cast<uint32_t>(i));
|
| - }
|
| - EXPECT_TRUE(voe_.CheckNoPacket(channel_num1));
|
| - EXPECT_TRUE(voe_.CheckNoPacket(channel_num2));
|
| - EXPECT_TRUE(voe_.CheckNoPacket(channel_num3));
|
| -
|
| - DeliverPacket(packets[0], sizeof(packets[0]));
|
| - EXPECT_TRUE(voe_.CheckNoPacket(channel_num1));
|
| - EXPECT_TRUE(voe_.CheckNoPacket(channel_num2));
|
| - EXPECT_TRUE(voe_.CheckNoPacket(channel_num3));
|
| -
|
| - DeliverPacket(packets[1], sizeof(packets[1]));
|
| - EXPECT_TRUE(voe_.CheckPacket(channel_num1, packets[1], sizeof(packets[1])));
|
| - EXPECT_TRUE(voe_.CheckNoPacket(channel_num2));
|
| - EXPECT_TRUE(voe_.CheckNoPacket(channel_num3));
|
| -
|
| - DeliverPacket(packets[2], sizeof(packets[2]));
|
| - EXPECT_TRUE(voe_.CheckNoPacket(channel_num1));
|
| - EXPECT_TRUE(voe_.CheckPacket(channel_num2, packets[2], sizeof(packets[2])));
|
| - EXPECT_TRUE(voe_.CheckNoPacket(channel_num3));
|
| -
|
| - DeliverPacket(packets[3], sizeof(packets[3]));
|
| - EXPECT_TRUE(voe_.CheckNoPacket(channel_num1));
|
| - EXPECT_TRUE(voe_.CheckNoPacket(channel_num2));
|
| - EXPECT_TRUE(voe_.CheckPacket(channel_num3, packets[3], sizeof(packets[3])));
|
| -
|
| - EXPECT_TRUE(channel_->RemoveRecvStream(3));
|
| - EXPECT_TRUE(channel_->RemoveRecvStream(2));
|
| - EXPECT_TRUE(channel_->RemoveRecvStream(1));
|
| -}
|
| -
|
| -// Test that receiving on an unsignalled stream works (default channel will be
|
| -// created).
|
| -TEST_F(WebRtcVoiceEngineTestFake, RecvUnsignalled) {
|
| - EXPECT_TRUE(SetupEngine());
|
| - DeliverPacket(kPcmuFrame, sizeof(kPcmuFrame));
|
| - int channel_num = voe_.GetLastChannel();
|
| - EXPECT_TRUE(voe_.CheckPacket(channel_num, kPcmuFrame, sizeof(kPcmuFrame)));
|
| -}
|
| -
|
| -// Test that receiving on an unsignalled stream works (default channel will be
|
| -// created), and that packets will be forwarded to the default channel
|
| -// regardless of their SSRCs.
|
| -TEST_F(WebRtcVoiceEngineTestFake, RecvUnsignalledWithSsrcSwitch) {
|
| - EXPECT_TRUE(SetupEngine());
|
| - char packet[sizeof(kPcmuFrame)];
|
| - memcpy(packet, kPcmuFrame, sizeof(kPcmuFrame));
|
| -
|
| - // Note that the first unknown SSRC cannot be 0, because we only support
|
| - // creating receive streams for SSRC!=0.
|
| - DeliverPacket(packet, sizeof(packet));
|
| - int channel_num = voe_.GetLastChannel();
|
| - EXPECT_TRUE(voe_.CheckPacket(channel_num, packet, sizeof(packet)));
|
| - // Once we have the default channel, SSRC==0 will be ok.
|
| - for (uint32_t ssrc = 0; ssrc < 10; ++ssrc) {
|
| - rtc::SetBE32(&packet[8], ssrc);
|
| - DeliverPacket(packet, sizeof(packet));
|
| - EXPECT_TRUE(voe_.CheckPacket(channel_num, packet, sizeof(packet)));
|
| - }
|
| -}
|
| -
|
| -// Test that a default channel is created even after a signalled stream has been
|
| -// added, and that this stream will get any packets for unknown SSRCs.
|
| -TEST_F(WebRtcVoiceEngineTestFake, RecvUnsignalledAfterSignalled) {
|
| - EXPECT_TRUE(SetupEngine());
|
| - char packet[sizeof(kPcmuFrame)];
|
| - memcpy(packet, kPcmuFrame, sizeof(kPcmuFrame));
|
| -
|
| - // Add a known stream, send packet and verify we got it.
|
| - EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1)));
|
| - int signalled_channel_num = voe_.GetLastChannel();
|
| - DeliverPacket(packet, sizeof(packet));
|
| - EXPECT_TRUE(voe_.CheckPacket(signalled_channel_num, packet, sizeof(packet)));
|
| -
|
| - // Note that the first unknown SSRC cannot be 0, because we only support
|
| - // creating receive streams for SSRC!=0.
|
| - rtc::SetBE32(&packet[8], 7011);
|
| - DeliverPacket(packet, sizeof(packet));
|
| - int channel_num = voe_.GetLastChannel();
|
| - EXPECT_NE(channel_num, signalled_channel_num);
|
| - EXPECT_TRUE(voe_.CheckPacket(channel_num, packet, sizeof(packet)));
|
| - // Once we have the default channel, SSRC==0 will be ok.
|
| - for (uint32_t ssrc = 0; ssrc < 20; ssrc += 2) {
|
| - rtc::SetBE32(&packet[8], ssrc);
|
| - DeliverPacket(packet, sizeof(packet));
|
| - EXPECT_TRUE(voe_.CheckPacket(channel_num, packet, sizeof(packet)));
|
| - }
|
| -}
|
| -
|
| -// Test that we properly handle failures to add a receive stream.
|
| -TEST_F(WebRtcVoiceEngineTestFake, AddRecvStreamFail) {
|
| - EXPECT_TRUE(SetupEngine());
|
| - voe_.set_fail_create_channel(true);
|
| - EXPECT_FALSE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(2)));
|
| -}
|
| -
|
| -// Test that we properly handle failures to add a send stream.
|
| -TEST_F(WebRtcVoiceEngineTestFake, AddSendStreamFail) {
|
| - EXPECT_TRUE(SetupEngine());
|
| - voe_.set_fail_create_channel(true);
|
| - EXPECT_FALSE(channel_->AddSendStream(cricket::StreamParams::CreateLegacy(2)));
|
| -}
|
| -
|
| -// Test that AddRecvStream creates new stream.
|
| -TEST_F(WebRtcVoiceEngineTestFake, AddRecvStream) {
|
| - EXPECT_TRUE(SetupEngineWithRecvStream());
|
| - int channel_num = voe_.GetLastChannel();
|
| - EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1)));
|
| - EXPECT_NE(channel_num, voe_.GetLastChannel());
|
| -}
|
| -
|
| -// Test that after adding a recv stream, we do not decode more codecs than
|
| -// those previously passed into SetRecvCodecs.
|
| -TEST_F(WebRtcVoiceEngineTestFake, AddRecvStreamUnsupportedCodec) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - cricket::AudioRecvParameters parameters;
|
| - parameters.codecs.push_back(kIsacCodec);
|
| - parameters.codecs.push_back(kPcmuCodec);
|
| - EXPECT_TRUE(channel_->SetRecvParameters(parameters));
|
| - EXPECT_TRUE(channel_->AddRecvStream(
|
| - cricket::StreamParams::CreateLegacy(kSsrc1)));
|
| - int channel_num2 = voe_.GetLastChannel();
|
| - webrtc::CodecInst gcodec;
|
| - rtc::strcpyn(gcodec.plname, arraysize(gcodec.plname), "opus");
|
| - gcodec.plfreq = 48000;
|
| - gcodec.channels = 2;
|
| - EXPECT_EQ(-1, voe_.GetRecPayloadType(channel_num2, gcodec));
|
| -}
|
| -
|
| -// Test that we properly clean up any streams that were added, even if
|
| -// not explicitly removed.
|
| -TEST_F(WebRtcVoiceEngineTestFake, StreamCleanup) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
|
| - EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1)));
|
| - EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(2)));
|
| - EXPECT_EQ(3, voe_.GetNumChannels()); // default channel + 2 added
|
| - delete channel_;
|
| - channel_ = NULL;
|
| - EXPECT_EQ(0, voe_.GetNumChannels());
|
| -}
|
| -
|
| -TEST_F(WebRtcVoiceEngineTestFake, TestAddRecvStreamFailWithZeroSsrc) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - EXPECT_FALSE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(0)));
|
| -}
|
| -
|
| -TEST_F(WebRtcVoiceEngineTestFake, TestNoLeakingWhenAddRecvStreamFail) {
|
| - EXPECT_TRUE(SetupEngine());
|
| - EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1)));
|
| - // Manually delete channel to simulate a failure.
|
| - int channel = voe_.GetLastChannel();
|
| - EXPECT_EQ(0, voe_.DeleteChannel(channel));
|
| - // Add recv stream 2 should work.
|
| - EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(2)));
|
| - int new_channel = voe_.GetLastChannel();
|
| - EXPECT_NE(channel, new_channel);
|
| - // The last created channel is deleted too.
|
| - EXPECT_EQ(0, voe_.DeleteChannel(new_channel));
|
| -}
|
| -
|
| -// Test the InsertDtmf on default send stream as caller.
|
| -TEST_F(WebRtcVoiceEngineTestFake, InsertDtmfOnDefaultSendStreamAsCaller) {
|
| - TestInsertDtmf(0, true);
|
| -}
|
| -
|
| -// Test the InsertDtmf on default send stream as callee
|
| -TEST_F(WebRtcVoiceEngineTestFake, InsertDtmfOnDefaultSendStreamAsCallee) {
|
| - TestInsertDtmf(0, false);
|
| -}
|
| -
|
| -// Test the InsertDtmf on specified send stream as caller.
|
| -TEST_F(WebRtcVoiceEngineTestFake, InsertDtmfOnSendStreamAsCaller) {
|
| - TestInsertDtmf(kSsrc1, true);
|
| -}
|
| -
|
| -// Test the InsertDtmf on specified send stream as callee.
|
| -TEST_F(WebRtcVoiceEngineTestFake, InsertDtmfOnSendStreamAsCallee) {
|
| - TestInsertDtmf(kSsrc1, false);
|
| -}
|
| -
|
| -TEST_F(WebRtcVoiceEngineTestFake, TestSetPlayoutError) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
|
| - EXPECT_TRUE(channel_->SetSend(cricket::SEND_MICROPHONE));
|
| - EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(2)));
|
| - EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(3)));
|
| - EXPECT_TRUE(channel_->SetPlayout(true));
|
| - voe_.set_playout_fail_channel(voe_.GetLastChannel() - 1);
|
| - EXPECT_TRUE(channel_->SetPlayout(false));
|
| - EXPECT_FALSE(channel_->SetPlayout(true));
|
| -}
|
| -
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetAudioOptions) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| -
|
| - bool ec_enabled;
|
| - webrtc::EcModes ec_mode;
|
| - webrtc::AecmModes aecm_mode;
|
| - bool cng_enabled;
|
| - bool agc_enabled;
|
| - webrtc::AgcModes agc_mode;
|
| - webrtc::AgcConfig agc_config;
|
| - bool ns_enabled;
|
| - webrtc::NsModes ns_mode;
|
| - bool highpass_filter_enabled;
|
| - bool stereo_swapping_enabled;
|
| - bool typing_detection_enabled;
|
| - voe_.GetEcStatus(ec_enabled, ec_mode);
|
| - voe_.GetAecmMode(aecm_mode, cng_enabled);
|
| - voe_.GetAgcStatus(agc_enabled, agc_mode);
|
| - voe_.GetAgcConfig(agc_config);
|
| - voe_.GetNsStatus(ns_enabled, ns_mode);
|
| - highpass_filter_enabled = voe_.IsHighPassFilterEnabled();
|
| - stereo_swapping_enabled = voe_.IsStereoChannelSwappingEnabled();
|
| - voe_.GetTypingDetectionStatus(typing_detection_enabled);
|
| - EXPECT_TRUE(ec_enabled);
|
| - EXPECT_TRUE(voe_.ec_metrics_enabled());
|
| - EXPECT_FALSE(cng_enabled);
|
| - EXPECT_TRUE(agc_enabled);
|
| - EXPECT_EQ(0, agc_config.targetLeveldBOv);
|
| - EXPECT_TRUE(ns_enabled);
|
| - EXPECT_TRUE(highpass_filter_enabled);
|
| - EXPECT_FALSE(stereo_swapping_enabled);
|
| - EXPECT_TRUE(typing_detection_enabled);
|
| - EXPECT_EQ(ec_mode, webrtc::kEcConference);
|
| - EXPECT_EQ(ns_mode, webrtc::kNsHighSuppression);
|
| - EXPECT_EQ(50, voe_.GetNetEqCapacity());
|
| - EXPECT_FALSE(voe_.GetNetEqFastAccelerate());
|
| -
|
| - // Nothing set in AudioOptions, so everything should be as default.
|
| - send_parameters_.options = cricket::AudioOptions();
|
| - EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
|
| - voe_.GetEcStatus(ec_enabled, ec_mode);
|
| - voe_.GetAecmMode(aecm_mode, cng_enabled);
|
| - voe_.GetAgcStatus(agc_enabled, agc_mode);
|
| - voe_.GetAgcConfig(agc_config);
|
| - voe_.GetNsStatus(ns_enabled, ns_mode);
|
| - highpass_filter_enabled = voe_.IsHighPassFilterEnabled();
|
| - stereo_swapping_enabled = voe_.IsStereoChannelSwappingEnabled();
|
| - voe_.GetTypingDetectionStatus(typing_detection_enabled);
|
| - EXPECT_TRUE(ec_enabled);
|
| - EXPECT_TRUE(voe_.ec_metrics_enabled());
|
| - EXPECT_FALSE(cng_enabled);
|
| - EXPECT_TRUE(agc_enabled);
|
| - EXPECT_EQ(0, agc_config.targetLeveldBOv);
|
| - EXPECT_TRUE(ns_enabled);
|
| - EXPECT_TRUE(highpass_filter_enabled);
|
| - EXPECT_FALSE(stereo_swapping_enabled);
|
| - EXPECT_TRUE(typing_detection_enabled);
|
| - EXPECT_EQ(ec_mode, webrtc::kEcConference);
|
| - EXPECT_EQ(ns_mode, webrtc::kNsHighSuppression);
|
| - EXPECT_EQ(50, voe_.GetNetEqCapacity());
|
| - EXPECT_FALSE(voe_.GetNetEqFastAccelerate());
|
| -
|
| - // Turn echo cancellation off
|
| - send_parameters_.options.echo_cancellation = rtc::Optional<bool>(false);
|
| - EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
|
| - voe_.GetEcStatus(ec_enabled, ec_mode);
|
| - EXPECT_FALSE(ec_enabled);
|
| -
|
| - // Turn echo cancellation back on, with settings, and make sure
|
| - // nothing else changed.
|
| - send_parameters_.options.echo_cancellation = rtc::Optional<bool>(true);
|
| - EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
|
| - voe_.GetEcStatus(ec_enabled, ec_mode);
|
| - voe_.GetAecmMode(aecm_mode, cng_enabled);
|
| - voe_.GetAgcStatus(agc_enabled, agc_mode);
|
| - voe_.GetAgcConfig(agc_config);
|
| - voe_.GetNsStatus(ns_enabled, ns_mode);
|
| - highpass_filter_enabled = voe_.IsHighPassFilterEnabled();
|
| - stereo_swapping_enabled = voe_.IsStereoChannelSwappingEnabled();
|
| - voe_.GetTypingDetectionStatus(typing_detection_enabled);
|
| - EXPECT_TRUE(ec_enabled);
|
| - EXPECT_TRUE(voe_.ec_metrics_enabled());
|
| - EXPECT_TRUE(agc_enabled);
|
| - EXPECT_EQ(0, agc_config.targetLeveldBOv);
|
| - EXPECT_TRUE(ns_enabled);
|
| - EXPECT_TRUE(highpass_filter_enabled);
|
| - EXPECT_FALSE(stereo_swapping_enabled);
|
| - EXPECT_TRUE(typing_detection_enabled);
|
| - EXPECT_EQ(ec_mode, webrtc::kEcConference);
|
| - EXPECT_EQ(ns_mode, webrtc::kNsHighSuppression);
|
| -
|
| - // Turn on delay agnostic aec and make sure nothing change w.r.t. echo
|
| - // control.
|
| - send_parameters_.options.delay_agnostic_aec = rtc::Optional<bool>(true);
|
| - EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
|
| - voe_.GetEcStatus(ec_enabled, ec_mode);
|
| - voe_.GetAecmMode(aecm_mode, cng_enabled);
|
| - EXPECT_TRUE(ec_enabled);
|
| - EXPECT_TRUE(voe_.ec_metrics_enabled());
|
| - EXPECT_EQ(ec_mode, webrtc::kEcConference);
|
| -
|
| - // Turn off echo cancellation and delay agnostic aec.
|
| - send_parameters_.options.delay_agnostic_aec = rtc::Optional<bool>(false);
|
| - send_parameters_.options.extended_filter_aec = rtc::Optional<bool>(false);
|
| - send_parameters_.options.echo_cancellation = rtc::Optional<bool>(false);
|
| - EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
|
| - voe_.GetEcStatus(ec_enabled, ec_mode);
|
| - EXPECT_FALSE(ec_enabled);
|
| - // Turning delay agnostic aec back on should also turn on echo cancellation.
|
| - send_parameters_.options.delay_agnostic_aec = rtc::Optional<bool>(true);
|
| - EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
|
| - voe_.GetEcStatus(ec_enabled, ec_mode);
|
| - EXPECT_TRUE(ec_enabled);
|
| - EXPECT_TRUE(voe_.ec_metrics_enabled());
|
| - EXPECT_EQ(ec_mode, webrtc::kEcConference);
|
| -
|
| - // Turn off AGC
|
| - send_parameters_.options.auto_gain_control = rtc::Optional<bool>(false);
|
| - EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
|
| - voe_.GetAgcStatus(agc_enabled, agc_mode);
|
| - EXPECT_FALSE(agc_enabled);
|
| -
|
| - // Turn AGC back on
|
| - send_parameters_.options.auto_gain_control = rtc::Optional<bool>(true);
|
| - send_parameters_.options.adjust_agc_delta = rtc::Optional<int>();
|
| - EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
|
| - voe_.GetAgcStatus(agc_enabled, agc_mode);
|
| - EXPECT_TRUE(agc_enabled);
|
| - voe_.GetAgcConfig(agc_config);
|
| - EXPECT_EQ(0, agc_config.targetLeveldBOv);
|
| -
|
| - // Turn off other options (and stereo swapping on).
|
| - send_parameters_.options.noise_suppression = rtc::Optional<bool>(false);
|
| - send_parameters_.options.highpass_filter = rtc::Optional<bool>(false);
|
| - send_parameters_.options.typing_detection = rtc::Optional<bool>(false);
|
| - send_parameters_.options.stereo_swapping = rtc::Optional<bool>(true);
|
| - EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
|
| - voe_.GetNsStatus(ns_enabled, ns_mode);
|
| - highpass_filter_enabled = voe_.IsHighPassFilterEnabled();
|
| - stereo_swapping_enabled = voe_.IsStereoChannelSwappingEnabled();
|
| - voe_.GetTypingDetectionStatus(typing_detection_enabled);
|
| - EXPECT_FALSE(ns_enabled);
|
| - EXPECT_FALSE(highpass_filter_enabled);
|
| - EXPECT_FALSE(typing_detection_enabled);
|
| - EXPECT_TRUE(stereo_swapping_enabled);
|
| -
|
| - // Set options again to ensure it has no impact.
|
| - EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
|
| - voe_.GetEcStatus(ec_enabled, ec_mode);
|
| - voe_.GetNsStatus(ns_enabled, ns_mode);
|
| - EXPECT_TRUE(ec_enabled);
|
| - EXPECT_EQ(webrtc::kEcConference, ec_mode);
|
| - EXPECT_FALSE(ns_enabled);
|
| - EXPECT_EQ(webrtc::kNsHighSuppression, ns_mode);
|
| -}
|
| -
|
| -TEST_F(WebRtcVoiceEngineTestFake, DefaultOptions) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| -
|
| - bool ec_enabled;
|
| - webrtc::EcModes ec_mode;
|
| - bool agc_enabled;
|
| - webrtc::AgcModes agc_mode;
|
| - bool ns_enabled;
|
| - webrtc::NsModes ns_mode;
|
| - bool highpass_filter_enabled;
|
| - bool stereo_swapping_enabled;
|
| - bool typing_detection_enabled;
|
| -
|
| - voe_.GetEcStatus(ec_enabled, ec_mode);
|
| - voe_.GetAgcStatus(agc_enabled, agc_mode);
|
| - voe_.GetNsStatus(ns_enabled, ns_mode);
|
| - highpass_filter_enabled = voe_.IsHighPassFilterEnabled();
|
| - stereo_swapping_enabled = voe_.IsStereoChannelSwappingEnabled();
|
| - voe_.GetTypingDetectionStatus(typing_detection_enabled);
|
| - EXPECT_TRUE(ec_enabled);
|
| - EXPECT_TRUE(agc_enabled);
|
| - EXPECT_TRUE(ns_enabled);
|
| - EXPECT_TRUE(highpass_filter_enabled);
|
| - EXPECT_TRUE(typing_detection_enabled);
|
| - EXPECT_FALSE(stereo_swapping_enabled);
|
| -}
|
| -
|
| -TEST_F(WebRtcVoiceEngineTestFake, InitDoesNotOverwriteDefaultAgcConfig) {
|
| - webrtc::AgcConfig set_config = {0};
|
| - set_config.targetLeveldBOv = 3;
|
| - set_config.digitalCompressionGaindB = 9;
|
| - set_config.limiterEnable = true;
|
| - EXPECT_EQ(0, voe_.SetAgcConfig(set_config));
|
| - EXPECT_TRUE(engine_.Init(rtc::Thread::Current()));
|
| -
|
| - webrtc::AgcConfig config = {0};
|
| - EXPECT_EQ(0, voe_.GetAgcConfig(config));
|
| - EXPECT_EQ(set_config.targetLeveldBOv, config.targetLeveldBOv);
|
| - EXPECT_EQ(set_config.digitalCompressionGaindB,
|
| - config.digitalCompressionGaindB);
|
| - EXPECT_EQ(set_config.limiterEnable, config.limiterEnable);
|
| -}
|
| -
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetOptionOverridesViaChannels) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - rtc::scoped_ptr<cricket::WebRtcVoiceMediaChannel> channel1(
|
| - static_cast<cricket::WebRtcVoiceMediaChannel*>(
|
| - engine_.CreateChannel(&call_, cricket::AudioOptions())));
|
| - rtc::scoped_ptr<cricket::WebRtcVoiceMediaChannel> channel2(
|
| - static_cast<cricket::WebRtcVoiceMediaChannel*>(
|
| - engine_.CreateChannel(&call_, cricket::AudioOptions())));
|
| -
|
| - // Have to add a stream to make SetSend work.
|
| - cricket::StreamParams stream1;
|
| - stream1.ssrcs.push_back(1);
|
| - channel1->AddSendStream(stream1);
|
| - cricket::StreamParams stream2;
|
| - stream2.ssrcs.push_back(2);
|
| - channel2->AddSendStream(stream2);
|
| -
|
| - // AEC and AGC and NS
|
| - cricket::AudioSendParameters parameters_options_all = send_parameters_;
|
| - parameters_options_all.options.echo_cancellation = rtc::Optional<bool>(true);
|
| - parameters_options_all.options.auto_gain_control = rtc::Optional<bool>(true);
|
| - parameters_options_all.options.noise_suppression = rtc::Optional<bool>(true);
|
| - ASSERT_TRUE(channel1->SetSendParameters(parameters_options_all));
|
| - EXPECT_EQ(parameters_options_all.options, channel1->options());
|
| - ASSERT_TRUE(channel2->SetSendParameters(parameters_options_all));
|
| - EXPECT_EQ(parameters_options_all.options, channel2->options());
|
| -
|
| - // unset NS
|
| - cricket::AudioSendParameters parameters_options_no_ns = send_parameters_;
|
| - parameters_options_no_ns.options.noise_suppression =
|
| - rtc::Optional<bool>(false);
|
| - ASSERT_TRUE(channel1->SetSendParameters(parameters_options_no_ns));
|
| - cricket::AudioOptions expected_options = parameters_options_all.options;
|
| - expected_options.echo_cancellation = rtc::Optional<bool>(true);
|
| - expected_options.auto_gain_control = rtc::Optional<bool>(true);
|
| - expected_options.noise_suppression = rtc::Optional<bool>(false);
|
| - EXPECT_EQ(expected_options, channel1->options());
|
| -
|
| - // unset AGC
|
| - cricket::AudioSendParameters parameters_options_no_agc = send_parameters_;
|
| - parameters_options_no_agc.options.auto_gain_control =
|
| - rtc::Optional<bool>(false);
|
| - ASSERT_TRUE(channel2->SetSendParameters(parameters_options_no_agc));
|
| - expected_options.echo_cancellation = rtc::Optional<bool>(true);
|
| - expected_options.auto_gain_control = rtc::Optional<bool>(false);
|
| - expected_options.noise_suppression = rtc::Optional<bool>(true);
|
| - EXPECT_EQ(expected_options, channel2->options());
|
| -
|
| - ASSERT_TRUE(channel_->SetSendParameters(parameters_options_all));
|
| - bool ec_enabled;
|
| - webrtc::EcModes ec_mode;
|
| - bool agc_enabled;
|
| - webrtc::AgcModes agc_mode;
|
| - bool ns_enabled;
|
| - webrtc::NsModes ns_mode;
|
| - voe_.GetEcStatus(ec_enabled, ec_mode);
|
| - voe_.GetAgcStatus(agc_enabled, agc_mode);
|
| - voe_.GetNsStatus(ns_enabled, ns_mode);
|
| - EXPECT_TRUE(ec_enabled);
|
| - EXPECT_TRUE(agc_enabled);
|
| - EXPECT_TRUE(ns_enabled);
|
| -
|
| - channel1->SetSend(cricket::SEND_MICROPHONE);
|
| - voe_.GetEcStatus(ec_enabled, ec_mode);
|
| - voe_.GetAgcStatus(agc_enabled, agc_mode);
|
| - voe_.GetNsStatus(ns_enabled, ns_mode);
|
| - EXPECT_TRUE(ec_enabled);
|
| - EXPECT_TRUE(agc_enabled);
|
| - EXPECT_FALSE(ns_enabled);
|
| -
|
| - channel2->SetSend(cricket::SEND_MICROPHONE);
|
| - voe_.GetEcStatus(ec_enabled, ec_mode);
|
| - voe_.GetAgcStatus(agc_enabled, agc_mode);
|
| - voe_.GetNsStatus(ns_enabled, ns_mode);
|
| - EXPECT_TRUE(ec_enabled);
|
| - EXPECT_FALSE(agc_enabled);
|
| - EXPECT_TRUE(ns_enabled);
|
| -
|
| - // Make sure settings take effect while we are sending.
|
| - ASSERT_TRUE(channel_->SetSendParameters(parameters_options_all));
|
| - cricket::AudioSendParameters parameters_options_no_agc_nor_ns =
|
| - send_parameters_;
|
| - parameters_options_no_agc_nor_ns.options.auto_gain_control =
|
| - rtc::Optional<bool>(false);
|
| - parameters_options_no_agc_nor_ns.options.noise_suppression =
|
| - rtc::Optional<bool>(false);
|
| - channel2->SetSend(cricket::SEND_MICROPHONE);
|
| - channel2->SetSendParameters(parameters_options_no_agc_nor_ns);
|
| - expected_options.echo_cancellation = rtc::Optional<bool>(true);
|
| - expected_options.auto_gain_control = rtc::Optional<bool>(false);
|
| - expected_options.noise_suppression = rtc::Optional<bool>(false);
|
| - EXPECT_EQ(expected_options, channel2->options());
|
| - voe_.GetEcStatus(ec_enabled, ec_mode);
|
| - voe_.GetAgcStatus(agc_enabled, agc_mode);
|
| - voe_.GetNsStatus(ns_enabled, ns_mode);
|
| - EXPECT_TRUE(ec_enabled);
|
| - EXPECT_FALSE(agc_enabled);
|
| - EXPECT_FALSE(ns_enabled);
|
| -}
|
| -
|
| -// This test verifies DSCP settings are properly applied on voice media channel.
|
| -TEST_F(WebRtcVoiceEngineTestFake, TestSetDscpOptions) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - rtc::scoped_ptr<cricket::VoiceMediaChannel> channel(
|
| - engine_.CreateChannel(&call_, cricket::AudioOptions()));
|
| - rtc::scoped_ptr<cricket::FakeNetworkInterface> network_interface(
|
| - new cricket::FakeNetworkInterface);
|
| - channel->SetInterface(network_interface.get());
|
| - cricket::AudioSendParameters parameters = send_parameters_;
|
| - parameters.options.dscp = rtc::Optional<bool>(true);
|
| - EXPECT_TRUE(channel->SetSendParameters(parameters));
|
| - EXPECT_EQ(rtc::DSCP_EF, network_interface->dscp());
|
| - // Verify previous value is not modified if dscp option is not set.
|
| - EXPECT_TRUE(channel->SetSendParameters(send_parameters_));
|
| - EXPECT_EQ(rtc::DSCP_EF, network_interface->dscp());
|
| - parameters.options.dscp = rtc::Optional<bool>(false);
|
| - EXPECT_TRUE(channel->SetSendParameters(parameters));
|
| - EXPECT_EQ(rtc::DSCP_DEFAULT, network_interface->dscp());
|
| -}
|
| -
|
| -TEST_F(WebRtcVoiceEngineTestFake, TestGetReceiveChannelId) {
|
| - EXPECT_TRUE(SetupEngine());
|
| - cricket::WebRtcVoiceMediaChannel* media_channel =
|
| - static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_);
|
| - EXPECT_EQ(-1, media_channel->GetReceiveChannelId(0));
|
| - EXPECT_TRUE(channel_->AddRecvStream(
|
| - cricket::StreamParams::CreateLegacy(kSsrc1)));
|
| - int channel_id = voe_.GetLastChannel();
|
| - EXPECT_EQ(channel_id, media_channel->GetReceiveChannelId(kSsrc1));
|
| - EXPECT_EQ(-1, media_channel->GetReceiveChannelId(kSsrc2));
|
| - EXPECT_TRUE(channel_->AddRecvStream(
|
| - cricket::StreamParams::CreateLegacy(kSsrc2)));
|
| - int channel_id2 = voe_.GetLastChannel();
|
| - EXPECT_EQ(channel_id2, media_channel->GetReceiveChannelId(kSsrc2));
|
| -}
|
| -
|
| -TEST_F(WebRtcVoiceEngineTestFake, TestGetSendChannelId) {
|
| - EXPECT_TRUE(SetupEngine());
|
| - cricket::WebRtcVoiceMediaChannel* media_channel =
|
| - static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_);
|
| - EXPECT_EQ(-1, media_channel->GetSendChannelId(0));
|
| - EXPECT_TRUE(channel_->AddSendStream(
|
| - cricket::StreamParams::CreateLegacy(kSsrc1)));
|
| - int channel_id = voe_.GetLastChannel();
|
| - EXPECT_EQ(channel_id, media_channel->GetSendChannelId(kSsrc1));
|
| - EXPECT_EQ(-1, media_channel->GetSendChannelId(kSsrc2));
|
| - EXPECT_TRUE(channel_->AddSendStream(
|
| - cricket::StreamParams::CreateLegacy(kSsrc2)));
|
| - int channel_id2 = voe_.GetLastChannel();
|
| - EXPECT_EQ(channel_id2, media_channel->GetSendChannelId(kSsrc2));
|
| -}
|
| -
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetOutputVolume) {
|
| - EXPECT_TRUE(SetupEngine());
|
| - EXPECT_FALSE(channel_->SetOutputVolume(kSsrc2, 0.5));
|
| - cricket::StreamParams stream;
|
| - stream.ssrcs.push_back(kSsrc2);
|
| - EXPECT_TRUE(channel_->AddRecvStream(stream));
|
| - int channel_id = voe_.GetLastChannel();
|
| - EXPECT_TRUE(channel_->SetOutputVolume(kSsrc2, 3));
|
| - float scale = 0;
|
| - EXPECT_EQ(0, voe_.GetChannelOutputVolumeScaling(channel_id, scale));
|
| - EXPECT_DOUBLE_EQ(3, scale);
|
| -}
|
| -
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetOutputVolumeDefaultRecvStream) {
|
| - EXPECT_TRUE(SetupEngine());
|
| - EXPECT_TRUE(channel_->SetOutputVolume(0, 2));
|
| - DeliverPacket(kPcmuFrame, sizeof(kPcmuFrame));
|
| - int channel_id = voe_.GetLastChannel();
|
| - float scale = 0;
|
| - EXPECT_EQ(0, voe_.GetChannelOutputVolumeScaling(channel_id, scale));
|
| - EXPECT_DOUBLE_EQ(2, scale);
|
| - EXPECT_TRUE(channel_->SetOutputVolume(0, 3));
|
| - EXPECT_EQ(0, voe_.GetChannelOutputVolumeScaling(channel_id, scale));
|
| - EXPECT_DOUBLE_EQ(3, scale);
|
| -}
|
| -
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetsSyncGroupFromSyncLabel) {
|
| - const uint32_t kAudioSsrc = 123;
|
| - const std::string kSyncLabel = "AvSyncLabel";
|
| -
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - cricket::StreamParams sp = cricket::StreamParams::CreateLegacy(kAudioSsrc);
|
| - sp.sync_label = kSyncLabel;
|
| - // Creating two channels to make sure that sync label is set properly for both
|
| - // the default voice channel and following ones.
|
| - EXPECT_TRUE(channel_->AddRecvStream(sp));
|
| - sp.ssrcs[0] += 1;
|
| - EXPECT_TRUE(channel_->AddRecvStream(sp));
|
| -
|
| - ASSERT_EQ(2, call_.GetAudioReceiveStreams().size());
|
| - EXPECT_EQ(kSyncLabel,
|
| - call_.GetAudioReceiveStream(kAudioSsrc)->GetConfig().sync_group)
|
| - << "SyncGroup should be set based on sync_label";
|
| - EXPECT_EQ(kSyncLabel,
|
| - call_.GetAudioReceiveStream(kAudioSsrc + 1)->GetConfig().sync_group)
|
| - << "SyncGroup should be set based on sync_label";
|
| -}
|
| -
|
| -// TODO(solenberg): Remove, once recv streams are configured through Call.
|
| -// (This is then covered by TestSetRecvRtpHeaderExtensions.)
|
| -TEST_F(WebRtcVoiceEngineTestFake, ConfiguresAudioReceiveStreamRtpExtensions) {
|
| - // Test that setting the header extensions results in the expected state
|
| - // changes on an associated Call.
|
| - std::vector<uint32_t> ssrcs;
|
| - ssrcs.push_back(223);
|
| - ssrcs.push_back(224);
|
| -
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - cricket::WebRtcVoiceMediaChannel* media_channel =
|
| - static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_);
|
| - EXPECT_TRUE(media_channel->SetSendParameters(send_parameters_));
|
| - for (uint32_t ssrc : ssrcs) {
|
| - EXPECT_TRUE(media_channel->AddRecvStream(
|
| - cricket::StreamParams::CreateLegacy(ssrc)));
|
| - }
|
| -
|
| - EXPECT_EQ(2, call_.GetAudioReceiveStreams().size());
|
| - for (uint32_t ssrc : ssrcs) {
|
| - const auto* s = call_.GetAudioReceiveStream(ssrc);
|
| - EXPECT_NE(nullptr, s);
|
| - EXPECT_EQ(0, s->GetConfig().rtp.extensions.size());
|
| - }
|
| -
|
| - // Set up receive extensions.
|
| - cricket::RtpCapabilities capabilities = engine_.GetCapabilities();
|
| - cricket::AudioRecvParameters recv_parameters;
|
| - recv_parameters.extensions = capabilities.header_extensions;
|
| - channel_->SetRecvParameters(recv_parameters);
|
| - EXPECT_EQ(2, call_.GetAudioReceiveStreams().size());
|
| - for (uint32_t ssrc : ssrcs) {
|
| - const auto* s = call_.GetAudioReceiveStream(ssrc);
|
| - EXPECT_NE(nullptr, s);
|
| - const auto& s_exts = s->GetConfig().rtp.extensions;
|
| - EXPECT_EQ(capabilities.header_extensions.size(), s_exts.size());
|
| - for (const auto& e_ext : capabilities.header_extensions) {
|
| - for (const auto& s_ext : s_exts) {
|
| - if (e_ext.id == s_ext.id) {
|
| - EXPECT_EQ(e_ext.uri, s_ext.name);
|
| - }
|
| - }
|
| - }
|
| - }
|
| -
|
| - // Disable receive extensions.
|
| - channel_->SetRecvParameters(cricket::AudioRecvParameters());
|
| - for (uint32_t ssrc : ssrcs) {
|
| - const auto* s = call_.GetAudioReceiveStream(ssrc);
|
| - EXPECT_NE(nullptr, s);
|
| - EXPECT_EQ(0, s->GetConfig().rtp.extensions.size());
|
| - }
|
| -}
|
| -
|
| -TEST_F(WebRtcVoiceEngineTestFake, DeliverAudioPacket_Call) {
|
| - // Test that packets are forwarded to the Call when configured accordingly.
|
| - const uint32_t kAudioSsrc = 1;
|
| - rtc::Buffer kPcmuPacket(kPcmuFrame, sizeof(kPcmuFrame));
|
| - static const unsigned char kRtcp[] = {
|
| - 0x80, 0xc9, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
|
| - 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
|
| - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
| - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
|
| - };
|
| - rtc::Buffer kRtcpPacket(kRtcp, sizeof(kRtcp));
|
| -
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - cricket::WebRtcVoiceMediaChannel* media_channel =
|
| - static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_);
|
| - EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
|
| - EXPECT_TRUE(media_channel->AddRecvStream(
|
| - cricket::StreamParams::CreateLegacy(kAudioSsrc)));
|
| -
|
| - EXPECT_EQ(1, call_.GetAudioReceiveStreams().size());
|
| - const cricket::FakeAudioReceiveStream* s =
|
| - call_.GetAudioReceiveStream(kAudioSsrc);
|
| - EXPECT_EQ(0, s->received_packets());
|
| - channel_->OnPacketReceived(&kPcmuPacket, rtc::PacketTime());
|
| - EXPECT_EQ(1, s->received_packets());
|
| - channel_->OnRtcpReceived(&kRtcpPacket, rtc::PacketTime());
|
| - EXPECT_EQ(2, s->received_packets());
|
| -}
|
| -
|
| -// All receive channels should be associated with the first send channel,
|
| -// since they do not send RTCP SR.
|
| -TEST_F(WebRtcVoiceEngineTestFake, AssociateFirstSendChannel) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
|
| - int default_channel = voe_.GetLastChannel();
|
| - EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1)));
|
| - int recv_ch = voe_.GetLastChannel();
|
| - EXPECT_NE(recv_ch, default_channel);
|
| - EXPECT_EQ(voe_.GetAssociateSendChannel(recv_ch), default_channel);
|
| - EXPECT_TRUE(channel_->AddSendStream(cricket::StreamParams::CreateLegacy(2)));
|
| - EXPECT_EQ(voe_.GetAssociateSendChannel(recv_ch), default_channel);
|
| - EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(3)));
|
| - recv_ch = voe_.GetLastChannel();
|
| - EXPECT_NE(recv_ch, default_channel);
|
| - EXPECT_EQ(voe_.GetAssociateSendChannel(recv_ch), default_channel);
|
| -}
|
| -
|
| -TEST_F(WebRtcVoiceEngineTestFake, AssociateChannelResetUponDeleteChannnel) {
|
| - EXPECT_TRUE(SetupEngineWithSendStream());
|
| - EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
|
| -
|
| - EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1)));
|
| - int recv_ch = voe_.GetLastChannel();
|
| -
|
| - EXPECT_TRUE(channel_->AddSendStream(cricket::StreamParams::CreateLegacy(2)));
|
| - int send_ch = voe_.GetLastChannel();
|
| -
|
| - // Manually associate |recv_ch| to |send_ch|. This test is to verify a
|
| - // deleting logic, i.e., deleting |send_ch| will reset the associate send
|
| - // channel of |recv_ch|.This is not a common case, sinceļ¼ normally, only the
|
| - // default channel can be associated. However, the default is not deletable.
|
| - // So we force the |recv_ch| to associate with a non-default channel.
|
| - EXPECT_EQ(0, voe_.AssociateSendChannel(recv_ch, send_ch));
|
| - EXPECT_EQ(voe_.GetAssociateSendChannel(recv_ch), send_ch);
|
| -
|
| - EXPECT_TRUE(channel_->RemoveSendStream(2));
|
| - EXPECT_EQ(voe_.GetAssociateSendChannel(recv_ch), -1);
|
| -}
|
| -
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetRawAudioSink) {
|
| - EXPECT_TRUE(SetupEngine());
|
| - rtc::scoped_ptr<FakeAudioSink> fake_sink_1(new FakeAudioSink());
|
| - rtc::scoped_ptr<FakeAudioSink> fake_sink_2(new FakeAudioSink());
|
| -
|
| - // Setting the sink before a recv stream exists should do nothing.
|
| - channel_->SetRawAudioSink(kSsrc1, std::move(fake_sink_1));
|
| - EXPECT_TRUE(
|
| - channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrc1)));
|
| - EXPECT_EQ(nullptr, GetRecvStream(kSsrc1).sink());
|
| -
|
| - // Now try actually setting the sink.
|
| - channel_->SetRawAudioSink(kSsrc1, std::move(fake_sink_2));
|
| - EXPECT_NE(nullptr, GetRecvStream(kSsrc1).sink());
|
| -
|
| - // Now try resetting it.
|
| - channel_->SetRawAudioSink(kSsrc1, nullptr);
|
| - EXPECT_EQ(nullptr, GetRecvStream(kSsrc1).sink());
|
| -}
|
| -
|
| -TEST_F(WebRtcVoiceEngineTestFake, SetRawAudioSinkDefaultRecvStream) {
|
| - EXPECT_TRUE(SetupEngine());
|
| - rtc::scoped_ptr<FakeAudioSink> fake_sink_1(new FakeAudioSink());
|
| - rtc::scoped_ptr<FakeAudioSink> fake_sink_2(new FakeAudioSink());
|
| -
|
| - // Should be able to set a default sink even when no stream exists.
|
| - channel_->SetRawAudioSink(0, std::move(fake_sink_1));
|
| -
|
| - // Create default channel and ensure it's assigned the default sink.
|
| - DeliverPacket(kPcmuFrame, sizeof(kPcmuFrame));
|
| - EXPECT_NE(nullptr, GetRecvStream(0x01).sink());
|
| -
|
| - // Try resetting the default sink.
|
| - channel_->SetRawAudioSink(0, nullptr);
|
| - EXPECT_EQ(nullptr, GetRecvStream(0x01).sink());
|
| -
|
| - // Try setting the default sink while the default stream exists.
|
| - channel_->SetRawAudioSink(0, std::move(fake_sink_2));
|
| - EXPECT_NE(nullptr, GetRecvStream(0x01).sink());
|
| -
|
| - // If we remove and add a default stream, it should get the same sink.
|
| - EXPECT_TRUE(channel_->RemoveRecvStream(0x01));
|
| - DeliverPacket(kPcmuFrame, sizeof(kPcmuFrame));
|
| - EXPECT_NE(nullptr, GetRecvStream(0x01).sink());
|
| -}
|
| -
|
| -// Tests that the library initializes and shuts down properly.
|
| -TEST(WebRtcVoiceEngineTest, StartupShutdown) {
|
| - cricket::WebRtcVoiceEngine engine;
|
| - EXPECT_TRUE(engine.Init(rtc::Thread::Current()));
|
| - rtc::scoped_ptr<webrtc::Call> call(
|
| - webrtc::Call::Create(webrtc::Call::Config()));
|
| - cricket::VoiceMediaChannel* channel =
|
| - engine.CreateChannel(call.get(), cricket::AudioOptions());
|
| - EXPECT_TRUE(channel != nullptr);
|
| - delete channel;
|
| - engine.Terminate();
|
| -
|
| - // Reinit to catch regression where VoiceEngineObserver reference is lost
|
| - EXPECT_TRUE(engine.Init(rtc::Thread::Current()));
|
| - engine.Terminate();
|
| -}
|
| -
|
| -// Tests that the library is configured with the codecs we want.
|
| -TEST(WebRtcVoiceEngineTest, HasCorrectCodecs) {
|
| - // Check codecs by name.
|
| - EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(
|
| - cricket::AudioCodec(96, "OPUS", 48000, 0, 2, 0), nullptr));
|
| - EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(
|
| - cricket::AudioCodec(96, "ISAC", 16000, 0, 1, 0), nullptr));
|
| - EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(
|
| - cricket::AudioCodec(96, "ISAC", 32000, 0, 1, 0), nullptr));
|
| - // Check that name matching is case-insensitive.
|
| - EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(
|
| - cricket::AudioCodec(96, "ILBC", 8000, 0, 1, 0), nullptr));
|
| - EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(
|
| - cricket::AudioCodec(96, "iLBC", 8000, 0, 1, 0), nullptr));
|
| - EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(
|
| - cricket::AudioCodec(96, "PCMU", 8000, 0, 1, 0), nullptr));
|
| - EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(
|
| - cricket::AudioCodec(96, "PCMA", 8000, 0, 1, 0), nullptr));
|
| - EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(
|
| - cricket::AudioCodec(96, "G722", 8000, 0, 1, 0), nullptr));
|
| - EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(
|
| - cricket::AudioCodec(96, "red", 8000, 0, 1, 0), nullptr));
|
| - EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(
|
| - cricket::AudioCodec(96, "CN", 32000, 0, 1, 0), nullptr));
|
| - EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(
|
| - cricket::AudioCodec(96, "CN", 16000, 0, 1, 0), nullptr));
|
| - EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(
|
| - cricket::AudioCodec(96, "CN", 8000, 0, 1, 0), nullptr));
|
| - EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(
|
| - cricket::AudioCodec(96, "telephone-event", 8000, 0, 1, 0), nullptr));
|
| - // Check codecs with an id by id.
|
| - EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(
|
| - cricket::AudioCodec(0, "", 8000, 0, 1, 0), nullptr)); // PCMU
|
| - EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(
|
| - cricket::AudioCodec(8, "", 8000, 0, 1, 0), nullptr)); // PCMA
|
| - EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(
|
| - cricket::AudioCodec(9, "", 8000, 0, 1, 0), nullptr)); // G722
|
| - EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(
|
| - cricket::AudioCodec(13, "", 8000, 0, 1, 0), nullptr)); // CN
|
| - // Check sample/bitrate matching.
|
| - EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(
|
| - cricket::AudioCodec(0, "PCMU", 8000, 64000, 1, 0), nullptr));
|
| - // Check that bad codecs fail.
|
| - EXPECT_FALSE(cricket::WebRtcVoiceEngine::ToCodecInst(
|
| - cricket::AudioCodec(99, "ABCD", 0, 0, 1, 0), nullptr));
|
| - EXPECT_FALSE(cricket::WebRtcVoiceEngine::ToCodecInst(
|
| - cricket::AudioCodec(88, "", 0, 0, 1, 0), nullptr));
|
| - EXPECT_FALSE(cricket::WebRtcVoiceEngine::ToCodecInst(
|
| - cricket::AudioCodec(0, "", 0, 0, 2, 0), nullptr));
|
| - EXPECT_FALSE(cricket::WebRtcVoiceEngine::ToCodecInst(
|
| - cricket::AudioCodec(0, "", 5000, 0, 1, 0), nullptr));
|
| - EXPECT_FALSE(cricket::WebRtcVoiceEngine::ToCodecInst(
|
| - cricket::AudioCodec(0, "", 0, 5000, 1, 0), nullptr));
|
| -
|
| - // Verify the payload id of common audio codecs, including CN, ISAC, and G722.
|
| - cricket::WebRtcVoiceEngine engine;
|
| - for (std::vector<cricket::AudioCodec>::const_iterator it =
|
| - engine.codecs().begin(); it != engine.codecs().end(); ++it) {
|
| - if (it->name == "CN" && it->clockrate == 16000) {
|
| - EXPECT_EQ(105, it->id);
|
| - } else if (it->name == "CN" && it->clockrate == 32000) {
|
| - EXPECT_EQ(106, it->id);
|
| - } else if (it->name == "ISAC" && it->clockrate == 16000) {
|
| - EXPECT_EQ(103, it->id);
|
| - } else if (it->name == "ISAC" && it->clockrate == 32000) {
|
| - EXPECT_EQ(104, it->id);
|
| - } else if (it->name == "G722" && it->clockrate == 8000) {
|
| - EXPECT_EQ(9, it->id);
|
| - } else if (it->name == "telephone-event") {
|
| - EXPECT_EQ(126, it->id);
|
| - } else if (it->name == "red") {
|
| - EXPECT_EQ(127, it->id);
|
| - } else if (it->name == "opus") {
|
| - EXPECT_EQ(111, it->id);
|
| - ASSERT_TRUE(it->params.find("minptime") != it->params.end());
|
| - EXPECT_EQ("10", it->params.find("minptime")->second);
|
| - ASSERT_TRUE(it->params.find("maxptime") != it->params.end());
|
| - EXPECT_EQ("60", it->params.find("maxptime")->second);
|
| - ASSERT_TRUE(it->params.find("useinbandfec") != it->params.end());
|
| - EXPECT_EQ("1", it->params.find("useinbandfec")->second);
|
| - }
|
| - }
|
| - engine.Terminate();
|
| -}
|
| -
|
| -// Tests that VoE supports at least 32 channels
|
| -TEST(WebRtcVoiceEngineTest, Has32Channels) {
|
| - cricket::WebRtcVoiceEngine engine;
|
| - EXPECT_TRUE(engine.Init(rtc::Thread::Current()));
|
| - rtc::scoped_ptr<webrtc::Call> call(
|
| - webrtc::Call::Create(webrtc::Call::Config()));
|
| -
|
| - cricket::VoiceMediaChannel* channels[32];
|
| - int num_channels = 0;
|
| - while (num_channels < arraysize(channels)) {
|
| - cricket::VoiceMediaChannel* channel =
|
| - engine.CreateChannel(call.get(), cricket::AudioOptions());
|
| - if (!channel)
|
| - break;
|
| - channels[num_channels++] = channel;
|
| - }
|
| -
|
| - int expected = arraysize(channels);
|
| - EXPECT_EQ(expected, num_channels);
|
| -
|
| - while (num_channels > 0) {
|
| - delete channels[--num_channels];
|
| - }
|
| - engine.Terminate();
|
| -}
|
| -
|
| -// Test that we set our preferred codecs properly.
|
| -TEST(WebRtcVoiceEngineTest, SetRecvCodecs) {
|
| - cricket::WebRtcVoiceEngine engine;
|
| - EXPECT_TRUE(engine.Init(rtc::Thread::Current()));
|
| - rtc::scoped_ptr<webrtc::Call> call(
|
| - webrtc::Call::Create(webrtc::Call::Config()));
|
| - cricket::WebRtcVoiceMediaChannel channel(&engine, cricket::AudioOptions(),
|
| - call.get());
|
| - cricket::AudioRecvParameters parameters;
|
| - parameters.codecs = engine.codecs();
|
| - EXPECT_TRUE(channel.SetRecvParameters(parameters));
|
| -}
|
|
|
Chromium Code Reviews
Issue 1684163002:
Rename webrtc/media/webrtc -> webrtc/media/engine (Closed)
Base URL: https://chromium.googlesource.com/external/webrtc.git@master