blob: 4d6580631d7aa02134e562511aeb0d5f71a559e9 [file] [log] [blame]
/*
* 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 "media/engine/webrtc_voice_engine.h"
#include <memory>
#include <utility>
#include "absl/memory/memory.h"
#include "absl/strings/match.h"
#include "absl/types/optional.h"
#include "api/audio_codecs/builtin_audio_decoder_factory.h"
#include "api/audio_codecs/builtin_audio_encoder_factory.h"
#include "api/environment/environment.h"
#include "api/environment/environment_factory.h"
#include "api/media_types.h"
#include "api/rtp_parameters.h"
#include "api/scoped_refptr.h"
#include "api/task_queue/default_task_queue_factory.h"
#include "api/transport/field_trial_based_config.h"
#include "call/call.h"
#include "media/base/codec.h"
#include "media/base/fake_media_engine.h"
#include "media/base/fake_network_interface.h"
#include "media/base/fake_rtp.h"
#include "media/base/media_channel.h"
#include "media/base/media_constants.h"
#include "media/engine/fake_webrtc_call.h"
#include "modules/audio_device/include/mock_audio_device.h"
#include "modules/audio_mixer/audio_mixer_impl.h"
#include "modules/audio_processing/include/mock_audio_processing.h"
#include "modules/rtp_rtcp/source/rtp_header_extensions.h"
#include "modules/rtp_rtcp/source/rtp_packet_received.h"
#include "rtc_base/arraysize.h"
#include "rtc_base/byte_order.h"
#include "rtc_base/numerics/safe_conversions.h"
#include "test/gtest.h"
#include "test/mock_audio_decoder_factory.h"
#include "test/mock_audio_encoder_factory.h"
#include "test/scoped_key_value_config.h"
namespace {
using ::testing::_;
using ::testing::ContainerEq;
using ::testing::Contains;
using ::testing::Field;
using ::testing::IsEmpty;
using ::testing::Return;
using ::testing::ReturnPointee;
using ::testing::SaveArg;
using ::testing::StrictMock;
using ::testing::UnorderedElementsAreArray;
using ::webrtc::BitrateConstraints;
using ::webrtc::Call;
using ::webrtc::CallConfig;
using ::webrtc::CreateEnvironment;
using ::webrtc::Environment;
constexpr uint32_t kMaxUnsignaledRecvStreams = 4;
const cricket::AudioCodec kPcmuCodec =
cricket::CreateAudioCodec(0, "PCMU", 8000, 1);
const cricket::AudioCodec kOpusCodec =
cricket::CreateAudioCodec(111, "opus", 48000, 2);
const cricket::AudioCodec kG722CodecVoE =
cricket::CreateAudioCodec(9, "G722", 16000, 1);
const cricket::AudioCodec kG722CodecSdp =
cricket::CreateAudioCodec(9, "G722", 8000, 1);
const cricket::AudioCodec kCn8000Codec =
cricket::CreateAudioCodec(13, "CN", 8000, 1);
const cricket::AudioCodec kCn16000Codec =
cricket::CreateAudioCodec(105, "CN", 16000, 1);
const cricket::AudioCodec kRed48000Codec =
cricket::CreateAudioCodec(112, "RED", 48000, 2);
const cricket::AudioCodec kTelephoneEventCodec1 =
cricket::CreateAudioCodec(106, "telephone-event", 8000, 1);
const cricket::AudioCodec kTelephoneEventCodec2 =
cricket::CreateAudioCodec(107, "telephone-event", 32000, 1);
const uint32_t kSsrc0 = 0;
const uint32_t kSsrc1 = 1;
const uint32_t kSsrcX = 0x99;
const uint32_t kSsrcY = 0x17;
const uint32_t kSsrcZ = 0x42;
const uint32_t kSsrcW = 0x02;
const uint32_t kSsrcs4[] = {11, 200, 30, 44};
constexpr int kRtpHistoryMs = 5000;
constexpr webrtc::AudioProcessing::Config::GainController1::Mode
kDefaultAgcMode =
#if defined(WEBRTC_IOS) || defined(WEBRTC_ANDROID)
webrtc::AudioProcessing::Config::GainController1::kFixedDigital;
#else
webrtc::AudioProcessing::Config::GainController1::kAdaptiveAnalog;
#endif
constexpr webrtc::AudioProcessing::Config::NoiseSuppression::Level
kDefaultNsLevel =
webrtc::AudioProcessing::Config::NoiseSuppression::Level::kHigh;
void AdmSetupExpectations(webrtc::test::MockAudioDeviceModule* adm) {
RTC_DCHECK(adm);
// Setup.
EXPECT_CALL(*adm, Init()).WillOnce(Return(0));
EXPECT_CALL(*adm, RegisterAudioCallback(_)).WillOnce(Return(0));
#if defined(WEBRTC_WIN)
EXPECT_CALL(
*adm,
SetPlayoutDevice(
::testing::Matcher<webrtc::AudioDeviceModule::WindowsDeviceType>(
webrtc::AudioDeviceModule::kDefaultCommunicationDevice)))
.WillOnce(Return(0));
#else
EXPECT_CALL(*adm, SetPlayoutDevice(0)).WillOnce(Return(0));
#endif // #if defined(WEBRTC_WIN)
EXPECT_CALL(*adm, InitSpeaker()).WillOnce(Return(0));
EXPECT_CALL(*adm, StereoPlayoutIsAvailable(::testing::_)).WillOnce(Return(0));
EXPECT_CALL(*adm, SetStereoPlayout(false)).WillOnce(Return(0));
#if defined(WEBRTC_WIN)
EXPECT_CALL(
*adm,
SetRecordingDevice(
::testing::Matcher<webrtc::AudioDeviceModule::WindowsDeviceType>(
webrtc::AudioDeviceModule::kDefaultCommunicationDevice)))
.WillOnce(Return(0));
#else
EXPECT_CALL(*adm, SetRecordingDevice(0)).WillOnce(Return(0));
#endif // #if defined(WEBRTC_WIN)
EXPECT_CALL(*adm, InitMicrophone()).WillOnce(Return(0));
EXPECT_CALL(*adm, StereoRecordingIsAvailable(::testing::_))
.WillOnce(Return(0));
EXPECT_CALL(*adm, SetStereoRecording(false)).WillOnce(Return(0));
EXPECT_CALL(*adm, BuiltInAECIsAvailable()).WillOnce(Return(false));
EXPECT_CALL(*adm, BuiltInAGCIsAvailable()).WillOnce(Return(false));
EXPECT_CALL(*adm, BuiltInNSIsAvailable()).WillOnce(Return(false));
// Teardown.
EXPECT_CALL(*adm, StopPlayout()).WillOnce(Return(0));
EXPECT_CALL(*adm, StopRecording()).WillOnce(Return(0));
EXPECT_CALL(*adm, RegisterAudioCallback(nullptr)).WillOnce(Return(0));
EXPECT_CALL(*adm, Terminate()).WillOnce(Return(0));
}
} // namespace
// Tests that our stub library "works".
TEST(WebRtcVoiceEngineTestStubLibrary, StartupShutdown) {
for (bool use_null_apm : {false, true}) {
std::unique_ptr<webrtc::TaskQueueFactory> task_queue_factory =
webrtc::CreateDefaultTaskQueueFactory();
rtc::scoped_refptr<webrtc::test::MockAudioDeviceModule> adm =
webrtc::test::MockAudioDeviceModule::CreateStrict();
AdmSetupExpectations(adm.get());
rtc::scoped_refptr<StrictMock<webrtc::test::MockAudioProcessing>> apm =
use_null_apm ? nullptr
: rtc::make_ref_counted<
StrictMock<webrtc::test::MockAudioProcessing>>();
webrtc::AudioProcessing::Config apm_config;
if (!use_null_apm) {
EXPECT_CALL(*apm, GetConfig()).WillRepeatedly(ReturnPointee(&apm_config));
EXPECT_CALL(*apm, ApplyConfig(_)).WillRepeatedly(SaveArg<0>(&apm_config));
EXPECT_CALL(*apm, DetachAecDump());
}
{
webrtc::FieldTrialBasedConfig trials;
cricket::WebRtcVoiceEngine engine(
task_queue_factory.get(), adm.get(),
webrtc::MockAudioEncoderFactory::CreateUnusedFactory(),
webrtc::MockAudioDecoderFactory::CreateUnusedFactory(), nullptr, apm,
nullptr, trials);
engine.Init();
}
}
}
class FakeAudioSink : public webrtc::AudioSinkInterface {
public:
void OnData(const Data& audio) override {}
};
class FakeAudioSource : public cricket::AudioSource {
void SetSink(Sink* sink) override {}
};
class WebRtcVoiceEngineTestFake : public ::testing::TestWithParam<bool> {
public:
WebRtcVoiceEngineTestFake()
: use_null_apm_(GetParam()),
task_queue_factory_(webrtc::CreateDefaultTaskQueueFactory()),
adm_(webrtc::test::MockAudioDeviceModule::CreateStrict()),
apm_(use_null_apm_
? nullptr
: rtc::make_ref_counted<
StrictMock<webrtc::test::MockAudioProcessing>>()),
call_(&field_trials_) {
// AudioDeviceModule.
AdmSetupExpectations(adm_.get());
if (!use_null_apm_) {
// AudioProcessing.
EXPECT_CALL(*apm_, GetConfig())
.WillRepeatedly(ReturnPointee(&apm_config_));
EXPECT_CALL(*apm_, ApplyConfig(_))
.WillRepeatedly(SaveArg<0>(&apm_config_));
EXPECT_CALL(*apm_, DetachAecDump());
}
// Default Options.
// TODO(kwiberg): We should use mock factories here, but a bunch of
// the tests here probe the specific set of codecs provided by the builtin
// factories. Those tests should probably be moved elsewhere.
auto encoder_factory = webrtc::CreateBuiltinAudioEncoderFactory();
auto decoder_factory = webrtc::CreateBuiltinAudioDecoderFactory();
engine_.reset(new cricket::WebRtcVoiceEngine(
task_queue_factory_.get(), adm_.get(), encoder_factory, decoder_factory,
nullptr, apm_, nullptr, field_trials_));
engine_->Init();
send_parameters_.codecs.push_back(kPcmuCodec);
recv_parameters_.codecs.push_back(kPcmuCodec);
if (!use_null_apm_) {
// Default Options.
VerifyEchoCancellationSettings(/*enabled=*/true);
EXPECT_TRUE(IsHighPassFilterEnabled());
EXPECT_TRUE(apm_config_.noise_suppression.enabled);
EXPECT_EQ(apm_config_.noise_suppression.level, kDefaultNsLevel);
VerifyGainControlEnabledCorrectly();
VerifyGainControlDefaultSettings();
}
}
bool SetupChannel() {
send_channel_ = engine_->CreateSendChannel(
&call_, cricket::MediaConfig(), cricket::AudioOptions(),
webrtc::CryptoOptions(), webrtc::AudioCodecPairId::Create());
receive_channel_ = engine_->CreateReceiveChannel(
&call_, cricket::MediaConfig(), cricket::AudioOptions(),
webrtc::CryptoOptions(), webrtc::AudioCodecPairId::Create());
send_channel_->SetSsrcListChangedCallback(
[receive_channel =
receive_channel_.get()](const std::set<uint32_t>& choices) {
receive_channel->ChooseReceiverReportSsrc(choices);
});
send_channel_->SetSendCodecChangedCallback(
[receive_channel = receive_channel_.get(),
send_channel = send_channel_.get()]() {
receive_channel->SetReceiveNackEnabled(
send_channel->SendCodecHasNack());
receive_channel->SetReceiveNonSenderRttEnabled(
send_channel->SenderNonSenderRttEnabled());
});
return true;
}
bool SetupRecvStream() {
if (!SetupChannel()) {
return false;
}
return AddRecvStream(kSsrcX);
}
bool SetupSendStream() {
return SetupSendStream(cricket::StreamParams::CreateLegacy(kSsrcX));
}
bool SetupSendStream(const cricket::StreamParams& sp) {
if (!SetupChannel()) {
return false;
}
if (!send_channel_->AddSendStream(sp)) {
return false;
}
if (!use_null_apm_) {
EXPECT_CALL(*apm_, set_output_will_be_muted(false));
}
return send_channel_->SetAudioSend(kSsrcX, true, nullptr, &fake_source_);
}
bool AddRecvStream(uint32_t ssrc) {
EXPECT_TRUE(receive_channel_);
return receive_channel_->AddRecvStream(
cricket::StreamParams::CreateLegacy(ssrc));
}
void SetupForMultiSendStream() {
EXPECT_TRUE(SetupSendStream());
// Remove stream added in Setup.
EXPECT_TRUE(call_.GetAudioSendStream(kSsrcX));
EXPECT_TRUE(send_channel_->RemoveSendStream(kSsrcX));
// Verify the channel does not exist.
EXPECT_FALSE(call_.GetAudioSendStream(kSsrcX));
}
void DeliverPacket(const void* data, int len) {
webrtc::RtpPacketReceived packet;
packet.Parse(reinterpret_cast<const uint8_t*>(data), len);
receive_channel_->OnPacketReceived(packet);
rtc::Thread::Current()->ProcessMessages(0);
}
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) {
return GetSendStream(ssrc).GetConfig();
}
const webrtc::AudioReceiveStreamInterface::Config& GetRecvStreamConfig(
uint32_t ssrc) {
return GetRecvStream(ssrc).GetConfig();
}
void SetSend(bool enable) {
ASSERT_TRUE(send_channel_);
if (enable) {
EXPECT_CALL(*adm_, RecordingIsInitialized())
.Times(::testing::AtMost(1))
.WillOnce(Return(false));
EXPECT_CALL(*adm_, Recording())
.Times(::testing::AtMost(1))
.WillOnce(Return(false));
EXPECT_CALL(*adm_, InitRecording())
.Times(::testing::AtMost(1))
.WillOnce(Return(0));
}
send_channel_->SetSend(enable);
}
void SetSenderParameters(const cricket::AudioSenderParameter& params) {
ASSERT_TRUE(send_channel_);
EXPECT_TRUE(send_channel_->SetSenderParameters(params));
}
void SetAudioSend(uint32_t ssrc,
bool enable,
cricket::AudioSource* source,
const cricket::AudioOptions* options = nullptr) {
ASSERT_TRUE(send_channel_);
if (!use_null_apm_) {
EXPECT_CALL(*apm_, set_output_will_be_muted(!enable));
}
EXPECT_TRUE(send_channel_->SetAudioSend(ssrc, enable, options, source));
}
void TestInsertDtmf(uint32_t ssrc,
bool caller,
const cricket::AudioCodec& codec) {
EXPECT_TRUE(SetupChannel());
if (caller) {
// If this is a caller, local description will be applied and add the
// send stream.
EXPECT_TRUE(send_channel_->AddSendStream(
cricket::StreamParams::CreateLegacy(kSsrcX)));
}
// Test we can only InsertDtmf when the other side supports telephone-event.
SetSenderParameters(send_parameters_);
SetSend(true);
EXPECT_FALSE(send_channel_->CanInsertDtmf());
EXPECT_FALSE(send_channel_->InsertDtmf(ssrc, 1, 111));
send_parameters_.codecs.push_back(codec);
SetSenderParameters(send_parameters_);
EXPECT_TRUE(send_channel_->CanInsertDtmf());
if (!caller) {
// If this is callee, there's no active send channel yet.
EXPECT_FALSE(send_channel_->InsertDtmf(ssrc, 2, 123));
EXPECT_TRUE(send_channel_->AddSendStream(
cricket::StreamParams::CreateLegacy(kSsrcX)));
}
// Check we fail if the ssrc is invalid.
EXPECT_FALSE(send_channel_->InsertDtmf(-1, 1, 111));
// Test send.
cricket::FakeAudioSendStream::TelephoneEvent telephone_event =
GetSendStream(kSsrcX).GetLatestTelephoneEvent();
EXPECT_EQ(-1, telephone_event.payload_type);
EXPECT_TRUE(send_channel_->InsertDtmf(ssrc, 2, 123));
telephone_event = GetSendStream(kSsrcX).GetLatestTelephoneEvent();
EXPECT_EQ(codec.id, telephone_event.payload_type);
EXPECT_EQ(codec.clockrate, telephone_event.payload_frequency);
EXPECT_EQ(2, telephone_event.event_code);
EXPECT_EQ(123, telephone_event.duration_ms);
}
void TestExtmapAllowMixedCaller(bool extmap_allow_mixed) {
// For a caller, the answer will be applied in set remote description
// where SetSenderParameters() is called.
EXPECT_TRUE(SetupChannel());
EXPECT_TRUE(send_channel_->AddSendStream(
cricket::StreamParams::CreateLegacy(kSsrcX)));
send_parameters_.extmap_allow_mixed = extmap_allow_mixed;
SetSenderParameters(send_parameters_);
const webrtc::AudioSendStream::Config& config = GetSendStreamConfig(kSsrcX);
EXPECT_EQ(extmap_allow_mixed, config.rtp.extmap_allow_mixed);
}
void TestExtmapAllowMixedCallee(bool extmap_allow_mixed) {
// For a callee, the answer will be applied in set local description
// where SetExtmapAllowMixed() and AddSendStream() are called.
EXPECT_TRUE(SetupChannel());
send_channel_->SetExtmapAllowMixed(extmap_allow_mixed);
EXPECT_TRUE(send_channel_->AddSendStream(
cricket::StreamParams::CreateLegacy(kSsrcX)));
const webrtc::AudioSendStream::Config& config = GetSendStreamConfig(kSsrcX);
EXPECT_EQ(extmap_allow_mixed, config.rtp.extmap_allow_mixed);
}
// 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 TestMaxSendBandwidth(const cricket::AudioCodec& codec,
int max_bitrate,
bool expected_result,
int expected_bitrate) {
cricket::AudioSenderParameter parameters;
parameters.codecs.push_back(codec);
parameters.max_bandwidth_bps = max_bitrate;
if (expected_result) {
SetSenderParameters(parameters);
} else {
EXPECT_FALSE(send_channel_->SetSenderParameters(parameters));
}
EXPECT_EQ(expected_bitrate, GetCodecBitrate(kSsrcX));
}
// Sets the per-stream maximum bitrate limit for the specified SSRC.
bool SetMaxBitrateForStream(int32_t ssrc, int bitrate) {
webrtc::RtpParameters parameters =
send_channel_->GetRtpSendParameters(ssrc);
EXPECT_EQ(1UL, parameters.encodings.size());
parameters.encodings[0].max_bitrate_bps = bitrate;
return send_channel_->SetRtpSendParameters(ssrc, parameters).ok();
}
void SetGlobalMaxBitrate(const cricket::AudioCodec& codec, int bitrate) {
cricket::AudioSenderParameter send_parameters;
send_parameters.codecs.push_back(codec);
send_parameters.max_bandwidth_bps = bitrate;
SetSenderParameters(send_parameters);
}
void CheckSendCodecBitrate(int32_t ssrc,
const char expected_name[],
int expected_bitrate) {
const auto& spec = GetSendStreamConfig(ssrc).send_codec_spec;
EXPECT_EQ(expected_name, spec->format.name);
EXPECT_EQ(expected_bitrate, spec->target_bitrate_bps);
}
absl::optional<int> GetCodecBitrate(int32_t ssrc) {
return GetSendStreamConfig(ssrc).send_codec_spec->target_bitrate_bps;
}
int GetMaxBitrate(int32_t ssrc) {
return GetSendStreamConfig(ssrc).max_bitrate_bps;
}
const absl::optional<std::string>& GetAudioNetworkAdaptorConfig(
int32_t ssrc) {
return GetSendStreamConfig(ssrc).audio_network_adaptor_config;
}
void SetAndExpectMaxBitrate(const cricket::AudioCodec& codec,
int global_max,
int stream_max,
bool expected_result,
int expected_codec_bitrate) {
// Clear the bitrate limit from the previous test case.
EXPECT_TRUE(SetMaxBitrateForStream(kSsrcX, -1));
// Attempt to set the requested bitrate limits.
SetGlobalMaxBitrate(codec, global_max);
EXPECT_EQ(expected_result, SetMaxBitrateForStream(kSsrcX, stream_max));
// Verify that reading back the parameters gives results
// consistent with the Set() result.
webrtc::RtpParameters resulting_parameters =
send_channel_->GetRtpSendParameters(kSsrcX);
EXPECT_EQ(1UL, resulting_parameters.encodings.size());
EXPECT_EQ(expected_result ? stream_max : -1,
resulting_parameters.encodings[0].max_bitrate_bps);
// Verify that the codec settings have the expected bitrate.
EXPECT_EQ(expected_codec_bitrate, GetCodecBitrate(kSsrcX));
EXPECT_EQ(expected_codec_bitrate, GetMaxBitrate(kSsrcX));
}
void SetSendCodecsShouldWorkForBitrates(const char* min_bitrate_kbps,
int expected_min_bitrate_bps,
const char* start_bitrate_kbps,
int expected_start_bitrate_bps,
const char* max_bitrate_kbps,
int expected_max_bitrate_bps) {
EXPECT_TRUE(SetupSendStream());
auto& codecs = send_parameters_.codecs;
codecs.clear();
codecs.push_back(kOpusCodec);
codecs[0].params[cricket::kCodecParamMinBitrate] = min_bitrate_kbps;
codecs[0].params[cricket::kCodecParamStartBitrate] = start_bitrate_kbps;
codecs[0].params[cricket::kCodecParamMaxBitrate] = max_bitrate_kbps;
EXPECT_CALL(*call_.GetMockTransportControllerSend(),
SetSdpBitrateParameters(
AllOf(Field(&BitrateConstraints::min_bitrate_bps,
expected_min_bitrate_bps),
Field(&BitrateConstraints::start_bitrate_bps,
expected_start_bitrate_bps),
Field(&BitrateConstraints::max_bitrate_bps,
expected_max_bitrate_bps))));
SetSenderParameters(send_parameters_);
}
void TestSetSendRtpHeaderExtensions(const std::string& ext) {
EXPECT_TRUE(SetupSendStream());
// Ensure extensions are off by default.
EXPECT_EQ(0u, GetSendStreamConfig(kSsrcX).rtp.extensions.size());
// Ensure unknown extensions won't cause an error.
send_parameters_.extensions.push_back(
webrtc::RtpExtension("urn:ietf:params:unknownextention", 1));
SetSenderParameters(send_parameters_);
EXPECT_EQ(0u, GetSendStreamConfig(kSsrcX).rtp.extensions.size());
// Ensure extensions stay off with an empty list of headers.
send_parameters_.extensions.clear();
SetSenderParameters(send_parameters_);
EXPECT_EQ(0u, GetSendStreamConfig(kSsrcX).rtp.extensions.size());
// Ensure extension is set properly.
const int id = 1;
send_parameters_.extensions.push_back(webrtc::RtpExtension(ext, id));
SetSenderParameters(send_parameters_);
EXPECT_EQ(1u, GetSendStreamConfig(kSsrcX).rtp.extensions.size());
EXPECT_EQ(ext, GetSendStreamConfig(kSsrcX).rtp.extensions[0].uri);
EXPECT_EQ(id, GetSendStreamConfig(kSsrcX).rtp.extensions[0].id);
// Ensure extension is set properly on new stream.
EXPECT_TRUE(send_channel_->AddSendStream(
cricket::StreamParams::CreateLegacy(kSsrcY)));
EXPECT_NE(call_.GetAudioSendStream(kSsrcX),
call_.GetAudioSendStream(kSsrcY));
EXPECT_EQ(1u, GetSendStreamConfig(kSsrcY).rtp.extensions.size());
EXPECT_EQ(ext, GetSendStreamConfig(kSsrcY).rtp.extensions[0].uri);
EXPECT_EQ(id, GetSendStreamConfig(kSsrcY).rtp.extensions[0].id);
// Ensure all extensions go back off with an empty list.
send_parameters_.codecs.push_back(kPcmuCodec);
send_parameters_.extensions.clear();
SetSenderParameters(send_parameters_);
EXPECT_EQ(0u, GetSendStreamConfig(kSsrcX).rtp.extensions.size());
EXPECT_EQ(0u, GetSendStreamConfig(kSsrcY).rtp.extensions.size());
}
void TestSetRecvRtpHeaderExtensions(const std::string& ext) {
EXPECT_TRUE(SetupRecvStream());
// Ensure extensions are off by default.
EXPECT_THAT(
receive_channel_->GetRtpReceiverParameters(kSsrcX).header_extensions,
IsEmpty());
// Ensure unknown extensions won't cause an error.
recv_parameters_.extensions.push_back(
webrtc::RtpExtension("urn:ietf:params:unknownextention", 1));
EXPECT_TRUE(receive_channel_->SetReceiverParameters(recv_parameters_));
EXPECT_THAT(
receive_channel_->GetRtpReceiverParameters(kSsrcX).header_extensions,
IsEmpty());
// Ensure extensions stay off with an empty list of headers.
recv_parameters_.extensions.clear();
EXPECT_TRUE(receive_channel_->SetReceiverParameters(recv_parameters_));
EXPECT_THAT(
receive_channel_->GetRtpReceiverParameters(kSsrcX).header_extensions,
IsEmpty());
// Ensure extension is set properly.
const int id = 2;
recv_parameters_.extensions.push_back(webrtc::RtpExtension(ext, id));
EXPECT_TRUE(receive_channel_->SetReceiverParameters(recv_parameters_));
EXPECT_EQ(
receive_channel_->GetRtpReceiverParameters(kSsrcX).header_extensions,
recv_parameters_.extensions);
// Ensure extension is set properly on new stream.
EXPECT_TRUE(AddRecvStream(kSsrcY));
EXPECT_EQ(
receive_channel_->GetRtpReceiverParameters(kSsrcY).header_extensions,
recv_parameters_.extensions);
// Ensure all extensions go back off with an empty list.
recv_parameters_.extensions.clear();
EXPECT_TRUE(receive_channel_->SetReceiverParameters(recv_parameters_));
EXPECT_THAT(
receive_channel_->GetRtpReceiverParameters(kSsrcX).header_extensions,
IsEmpty());
EXPECT_THAT(
receive_channel_->GetRtpReceiverParameters(kSsrcY).header_extensions,
IsEmpty());
}
webrtc::AudioSendStream::Stats GetAudioSendStreamStats() const {
webrtc::AudioSendStream::Stats stats;
stats.local_ssrc = 12;
stats.payload_bytes_sent = 345;
stats.header_and_padding_bytes_sent = 56;
stats.packets_sent = 678;
stats.packets_lost = 9012;
stats.fraction_lost = 34.56f;
stats.codec_name = "codec_name_send";
stats.codec_payload_type = 0;
stats.jitter_ms = 12;
stats.rtt_ms = 345;
stats.audio_level = 678;
stats.apm_statistics.delay_median_ms = 234;
stats.apm_statistics.delay_standard_deviation_ms = 567;
stats.apm_statistics.echo_return_loss = 890;
stats.apm_statistics.echo_return_loss_enhancement = 1234;
stats.apm_statistics.residual_echo_likelihood = 0.432f;
stats.apm_statistics.residual_echo_likelihood_recent_max = 0.6f;
stats.ana_statistics.bitrate_action_counter = 321;
stats.ana_statistics.channel_action_counter = 432;
stats.ana_statistics.dtx_action_counter = 543;
stats.ana_statistics.fec_action_counter = 654;
stats.ana_statistics.frame_length_increase_counter = 765;
stats.ana_statistics.frame_length_decrease_counter = 876;
stats.ana_statistics.uplink_packet_loss_fraction = 987.0;
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.payload_bytes_sent, stats.payload_bytes_sent);
EXPECT_EQ(info.header_and_padding_bytes_sent,
stats.header_and_padding_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.codec_payload_type, stats.codec_payload_type);
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.apm_statistics.delay_median_ms,
stats.apm_statistics.delay_median_ms);
EXPECT_EQ(info.apm_statistics.delay_standard_deviation_ms,
stats.apm_statistics.delay_standard_deviation_ms);
EXPECT_EQ(info.apm_statistics.echo_return_loss,
stats.apm_statistics.echo_return_loss);
EXPECT_EQ(info.apm_statistics.echo_return_loss_enhancement,
stats.apm_statistics.echo_return_loss_enhancement);
EXPECT_EQ(info.apm_statistics.residual_echo_likelihood,
stats.apm_statistics.residual_echo_likelihood);
EXPECT_EQ(info.apm_statistics.residual_echo_likelihood_recent_max,
stats.apm_statistics.residual_echo_likelihood_recent_max);
EXPECT_EQ(info.ana_statistics.bitrate_action_counter,
stats.ana_statistics.bitrate_action_counter);
EXPECT_EQ(info.ana_statistics.channel_action_counter,
stats.ana_statistics.channel_action_counter);
EXPECT_EQ(info.ana_statistics.dtx_action_counter,
stats.ana_statistics.dtx_action_counter);
EXPECT_EQ(info.ana_statistics.fec_action_counter,
stats.ana_statistics.fec_action_counter);
EXPECT_EQ(info.ana_statistics.frame_length_increase_counter,
stats.ana_statistics.frame_length_increase_counter);
EXPECT_EQ(info.ana_statistics.frame_length_decrease_counter,
stats.ana_statistics.frame_length_decrease_counter);
EXPECT_EQ(info.ana_statistics.uplink_packet_loss_fraction,
stats.ana_statistics.uplink_packet_loss_fraction);
}
webrtc::AudioReceiveStreamInterface::Stats GetAudioReceiveStreamStats()
const {
webrtc::AudioReceiveStreamInterface::Stats stats;
stats.remote_ssrc = 123;
stats.payload_bytes_received = 456;
stats.header_and_padding_bytes_received = 67;
stats.packets_received = 768;
stats.packets_lost = 101;
stats.codec_name = "codec_name_recv";
stats.codec_payload_type = 0;
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.total_samples_received = 5678901;
stats.concealed_samples = 234;
stats.concealment_events = 12;
stats.jitter_buffer_delay_seconds = 34;
stats.jitter_buffer_emitted_count = 77;
stats.expand_rate = 5.67f;
stats.speech_expand_rate = 8.90f;
stats.secondary_decoded_rate = 1.23f;
stats.secondary_discarded_rate = 0.12f;
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_codec_plc = 1236;
stats.decoding_cng = 5678;
stats.decoding_plc_cng = 9012;
stats.decoding_muted_output = 3456;
stats.capture_start_ntp_time_ms = 7890;
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.payload_bytes_received, stats.payload_bytes_received);
EXPECT_EQ(info.header_and_padding_bytes_received,
stats.header_and_padding_bytes_received);
EXPECT_EQ(rtc::checked_cast<unsigned int>(info.packets_received),
stats.packets_received);
EXPECT_EQ(info.packets_lost, stats.packets_lost);
EXPECT_EQ(info.codec_name, stats.codec_name);
EXPECT_EQ(info.codec_payload_type, stats.codec_payload_type);
EXPECT_EQ(rtc::checked_cast<unsigned int>(info.jitter_ms), stats.jitter_ms);
EXPECT_EQ(rtc::checked_cast<unsigned int>(info.jitter_buffer_ms),
stats.jitter_buffer_ms);
EXPECT_EQ(rtc::checked_cast<unsigned int>(info.jitter_buffer_preferred_ms),
stats.jitter_buffer_preferred_ms);
EXPECT_EQ(rtc::checked_cast<unsigned int>(info.delay_estimate_ms),
stats.delay_estimate_ms);
EXPECT_EQ(info.audio_level, stats.audio_level);
EXPECT_EQ(info.total_samples_received, stats.total_samples_received);
EXPECT_EQ(info.concealed_samples, stats.concealed_samples);
EXPECT_EQ(info.concealment_events, stats.concealment_events);
EXPECT_EQ(info.jitter_buffer_delay_seconds,
stats.jitter_buffer_delay_seconds);
EXPECT_EQ(info.jitter_buffer_emitted_count,
stats.jitter_buffer_emitted_count);
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.secondary_discarded_rate, stats.secondary_discarded_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_codec_plc, stats.decoding_codec_plc);
EXPECT_EQ(info.decoding_cng, stats.decoding_cng);
EXPECT_EQ(info.decoding_plc_cng, stats.decoding_plc_cng);
EXPECT_EQ(info.decoding_muted_output, stats.decoding_muted_output);
EXPECT_EQ(info.capture_start_ntp_time_ms, stats.capture_start_ntp_time_ms);
}
void VerifyVoiceSendRecvCodecs(
const cricket::VoiceMediaSendInfo& send_info,
const cricket::VoiceMediaReceiveInfo& receive_info) const {
EXPECT_EQ(send_parameters_.codecs.size(), send_info.send_codecs.size());
for (const cricket::AudioCodec& codec : send_parameters_.codecs) {
ASSERT_EQ(send_info.send_codecs.count(codec.id), 1U);
EXPECT_EQ(send_info.send_codecs.find(codec.id)->second,
codec.ToCodecParameters());
}
EXPECT_EQ(recv_parameters_.codecs.size(),
receive_info.receive_codecs.size());
for (const cricket::AudioCodec& codec : recv_parameters_.codecs) {
ASSERT_EQ(receive_info.receive_codecs.count(codec.id), 1U);
EXPECT_EQ(receive_info.receive_codecs.find(codec.id)->second,
codec.ToCodecParameters());
}
}
void VerifyGainControlEnabledCorrectly() {
EXPECT_TRUE(apm_config_.gain_controller1.enabled);
EXPECT_EQ(kDefaultAgcMode, apm_config_.gain_controller1.mode);
}
void VerifyGainControlDefaultSettings() {
EXPECT_EQ(3, apm_config_.gain_controller1.target_level_dbfs);
EXPECT_EQ(9, apm_config_.gain_controller1.compression_gain_db);
EXPECT_TRUE(apm_config_.gain_controller1.enable_limiter);
}
void VerifyEchoCancellationSettings(bool enabled) {
constexpr bool kDefaultUseAecm =
#if defined(WEBRTC_ANDROID)
true;
#else
false;
#endif
EXPECT_EQ(apm_config_.echo_canceller.enabled, enabled);
EXPECT_EQ(apm_config_.echo_canceller.mobile_mode, kDefaultUseAecm);
}
bool IsHighPassFilterEnabled() {
return apm_config_.high_pass_filter.enabled;
}
cricket::WebRtcVoiceSendChannel* SendImplFromPointer(
cricket::VoiceMediaSendChannelInterface* channel) {
return static_cast<cricket::WebRtcVoiceSendChannel*>(channel);
}
cricket::WebRtcVoiceSendChannel* SendImpl() {
return SendImplFromPointer(send_channel_.get());
}
cricket::WebRtcVoiceReceiveChannel* ReceiveImpl() {
return static_cast<cricket::WebRtcVoiceReceiveChannel*>(
receive_channel_.get());
}
protected:
rtc::AutoThread main_thread_;
const bool use_null_apm_;
webrtc::test::ScopedKeyValueConfig field_trials_;
std::unique_ptr<webrtc::TaskQueueFactory> task_queue_factory_;
rtc::scoped_refptr<webrtc::test::MockAudioDeviceModule> adm_;
rtc::scoped_refptr<StrictMock<webrtc::test::MockAudioProcessing>> apm_;
cricket::FakeCall call_;
std::unique_ptr<cricket::WebRtcVoiceEngine> engine_;
std::unique_ptr<cricket::VoiceMediaSendChannelInterface> send_channel_;
std::unique_ptr<cricket::VoiceMediaReceiveChannelInterface> receive_channel_;
cricket::AudioSenderParameter send_parameters_;
cricket::AudioReceiverParameters recv_parameters_;
FakeAudioSource fake_source_;
webrtc::AudioProcessing::Config apm_config_;
};
INSTANTIATE_TEST_SUITE_P(TestBothWithAndWithoutNullApm,
WebRtcVoiceEngineTestFake,
::testing::Values(false, true));
// Tests that we can create and destroy a channel.
TEST_P(WebRtcVoiceEngineTestFake, CreateMediaChannel) {
EXPECT_TRUE(SetupChannel());
}
// Test that we can add a send stream and that it has the correct defaults.
TEST_P(WebRtcVoiceEngineTestFake, CreateSendStream) {
EXPECT_TRUE(SetupChannel());
EXPECT_TRUE(send_channel_->AddSendStream(
cricket::StreamParams::CreateLegacy(kSsrcX)));
const webrtc::AudioSendStream::Config& config = GetSendStreamConfig(kSsrcX);
EXPECT_EQ(kSsrcX, config.rtp.ssrc);
EXPECT_EQ("", config.rtp.c_name);
EXPECT_EQ(0u, config.rtp.extensions.size());
EXPECT_EQ(SendImpl()->transport(), config.send_transport);
}
// Test that we can add a receive stream and that it has the correct defaults.
TEST_P(WebRtcVoiceEngineTestFake, CreateRecvStream) {
EXPECT_TRUE(SetupChannel());
EXPECT_TRUE(AddRecvStream(kSsrcX));
const webrtc::AudioReceiveStreamInterface::Config& config =
GetRecvStreamConfig(kSsrcX);
EXPECT_EQ(kSsrcX, config.rtp.remote_ssrc);
EXPECT_EQ(0xFA17FA17, config.rtp.local_ssrc);
EXPECT_EQ(ReceiveImpl()->transport(), config.rtcp_send_transport);
EXPECT_EQ("", config.sync_group);
}
TEST_P(WebRtcVoiceEngineTestFake, OpusSupportsTransportCc) {
const std::vector<cricket::AudioCodec>& codecs = engine_->send_codecs();
bool opus_found = false;
for (const cricket::AudioCodec& codec : codecs) {
if (codec.name == "opus") {
EXPECT_TRUE(HasTransportCc(codec));
opus_found = true;
}
}
EXPECT_TRUE(opus_found);
}
// Test that we set our inbound codecs properly, including changing PT.
TEST_P(WebRtcVoiceEngineTestFake, SetRecvCodecs) {
EXPECT_TRUE(SetupChannel());
cricket::AudioReceiverParameters parameters;
parameters.codecs.push_back(kOpusCodec);
parameters.codecs.push_back(kPcmuCodec);
parameters.codecs.push_back(kTelephoneEventCodec1);
parameters.codecs.push_back(kTelephoneEventCodec2);
parameters.codecs[0].id = 106; // collide with existing CN 32k
parameters.codecs[2].id = 126;
EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters));
EXPECT_TRUE(AddRecvStream(kSsrcX));
EXPECT_THAT(GetRecvStreamConfig(kSsrcX).decoder_map,
(ContainerEq<std::map<int, webrtc::SdpAudioFormat>>(
{{0, {"PCMU", 8000, 1}},
{106, {"OPUS", 48000, 2}},
{126, {"telephone-event", 8000, 1}},
{107, {"telephone-event", 32000, 1}}})));
}
// Test that we fail to set an unknown inbound codec.
TEST_P(WebRtcVoiceEngineTestFake, SetRecvCodecsUnsupportedCodec) {
EXPECT_TRUE(SetupChannel());
cricket::AudioReceiverParameters parameters;
parameters.codecs.push_back(kOpusCodec);
parameters.codecs.push_back(cricket::CreateAudioCodec(127, "XYZ", 32000, 1));
EXPECT_FALSE(receive_channel_->SetReceiverParameters(parameters));
}
// Test that we fail if we have duplicate types in the inbound list.
TEST_P(WebRtcVoiceEngineTestFake, SetRecvCodecsDuplicatePayloadType) {
EXPECT_TRUE(SetupChannel());
cricket::AudioReceiverParameters parameters;
parameters.codecs.push_back(kOpusCodec);
parameters.codecs.push_back(kCn16000Codec);
parameters.codecs[1].id = kOpusCodec.id;
EXPECT_FALSE(receive_channel_->SetReceiverParameters(parameters));
}
// Test that we can decode OPUS without stereo parameters.
TEST_P(WebRtcVoiceEngineTestFake, SetRecvCodecsWithOpusNoStereo) {
EXPECT_TRUE(SetupChannel());
cricket::AudioReceiverParameters parameters;
parameters.codecs.push_back(kPcmuCodec);
parameters.codecs.push_back(kOpusCodec);
EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters));
EXPECT_TRUE(AddRecvStream(kSsrcX));
EXPECT_THAT(GetRecvStreamConfig(kSsrcX).decoder_map,
(ContainerEq<std::map<int, webrtc::SdpAudioFormat>>(
{{0, {"PCMU", 8000, 1}}, {111, {"opus", 48000, 2}}})));
}
// Test that we can decode OPUS with stereo = 0.
TEST_P(WebRtcVoiceEngineTestFake, SetRecvCodecsWithOpus0Stereo) {
EXPECT_TRUE(SetupChannel());
cricket::AudioReceiverParameters parameters;
parameters.codecs.push_back(kPcmuCodec);
parameters.codecs.push_back(kOpusCodec);
parameters.codecs[1].params["stereo"] = "0";
EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters));
EXPECT_TRUE(AddRecvStream(kSsrcX));
EXPECT_THAT(GetRecvStreamConfig(kSsrcX).decoder_map,
(ContainerEq<std::map<int, webrtc::SdpAudioFormat>>(
{{0, {"PCMU", 8000, 1}},
{111, {"opus", 48000, 2, {{"stereo", "0"}}}}})));
}
// Test that we can decode OPUS with stereo = 1.
TEST_P(WebRtcVoiceEngineTestFake, SetRecvCodecsWithOpus1Stereo) {
EXPECT_TRUE(SetupChannel());
cricket::AudioReceiverParameters parameters;
parameters.codecs.push_back(kPcmuCodec);
parameters.codecs.push_back(kOpusCodec);
parameters.codecs[1].params["stereo"] = "1";
EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters));
EXPECT_TRUE(AddRecvStream(kSsrcX));
EXPECT_THAT(GetRecvStreamConfig(kSsrcX).decoder_map,
(ContainerEq<std::map<int, webrtc::SdpAudioFormat>>(
{{0, {"PCMU", 8000, 1}},
{111, {"opus", 48000, 2, {{"stereo", "1"}}}}})));
}
// Test that changes to recv codecs are applied to all streams.
TEST_P(WebRtcVoiceEngineTestFake, SetRecvCodecsWithMultipleStreams) {
EXPECT_TRUE(SetupChannel());
cricket::AudioReceiverParameters parameters;
parameters.codecs.push_back(kOpusCodec);
parameters.codecs.push_back(kPcmuCodec);
parameters.codecs.push_back(kTelephoneEventCodec1);
parameters.codecs.push_back(kTelephoneEventCodec2);
parameters.codecs[0].id = 106; // collide with existing CN 32k
parameters.codecs[2].id = 126;
EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters));
for (const auto& ssrc : {kSsrcX, kSsrcY}) {
EXPECT_TRUE(AddRecvStream(ssrc));
EXPECT_THAT(GetRecvStreamConfig(ssrc).decoder_map,
(ContainerEq<std::map<int, webrtc::SdpAudioFormat>>(
{{0, {"PCMU", 8000, 1}},
{106, {"OPUS", 48000, 2}},
{126, {"telephone-event", 8000, 1}},
{107, {"telephone-event", 32000, 1}}})));
}
}
TEST_P(WebRtcVoiceEngineTestFake, SetRecvCodecsAfterAddingStreams) {
EXPECT_TRUE(SetupRecvStream());
cricket::AudioReceiverParameters parameters;
parameters.codecs.push_back(kOpusCodec);
parameters.codecs[0].id = 106; // collide with existing CN 32k
EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters));
const auto& dm = GetRecvStreamConfig(kSsrcX).decoder_map;
ASSERT_EQ(1u, dm.count(106));
EXPECT_EQ(webrtc::SdpAudioFormat("opus", 48000, 2), dm.at(106));
}
// Test that we can apply the same set of codecs again while playing.
TEST_P(WebRtcVoiceEngineTestFake, SetRecvCodecsWhilePlaying) {
EXPECT_TRUE(SetupRecvStream());
cricket::AudioReceiverParameters parameters;
parameters.codecs.push_back(kPcmuCodec);
parameters.codecs.push_back(kCn16000Codec);
EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters));
receive_channel_->SetPlayout(true);
EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters));
// Remapping a payload type to a different codec should fail.
parameters.codecs[0] = kOpusCodec;
parameters.codecs[0].id = kPcmuCodec.id;
EXPECT_FALSE(receive_channel_->SetReceiverParameters(parameters));
EXPECT_TRUE(GetRecvStream(kSsrcX).started());
}
// Test that we can add a codec while playing.
TEST_P(WebRtcVoiceEngineTestFake, AddRecvCodecsWhilePlaying) {
EXPECT_TRUE(SetupRecvStream());
cricket::AudioReceiverParameters parameters;
parameters.codecs.push_back(kPcmuCodec);
parameters.codecs.push_back(kCn16000Codec);
EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters));
receive_channel_->SetPlayout(true);
parameters.codecs.push_back(kOpusCodec);
EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters));
EXPECT_TRUE(GetRecvStream(kSsrcX).started());
}
// Test that we accept adding the same codec with a different payload type.
// See: https://bugs.chromium.org/p/webrtc/issues/detail?id=5847
TEST_P(WebRtcVoiceEngineTestFake, ChangeRecvCodecPayloadType) {
EXPECT_TRUE(SetupRecvStream());
cricket::AudioReceiverParameters parameters;
parameters.codecs.push_back(kOpusCodec);
EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters));
++parameters.codecs[0].id;
EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters));
}
// Test that we do allow setting Opus/Red by default.
TEST_P(WebRtcVoiceEngineTestFake, RecvRedDefault) {
EXPECT_TRUE(SetupRecvStream());
cricket::AudioReceiverParameters parameters;
parameters.codecs.push_back(kOpusCodec);
parameters.codecs.push_back(kRed48000Codec);
parameters.codecs[1].params[""] = "111/111";
EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters));
EXPECT_THAT(GetRecvStreamConfig(kSsrcX).decoder_map,
(ContainerEq<std::map<int, webrtc::SdpAudioFormat>>(
{{111, {"opus", 48000, 2}},
{112, {"red", 48000, 2, {{"", "111/111"}}}}})));
}
TEST_P(WebRtcVoiceEngineTestFake, SetSendBandwidthAuto) {
EXPECT_TRUE(SetupSendStream());
// 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.
// PCMU, default bitrate == 64000.
TestMaxSendBandwidth(kPcmuCodec, -1, true, 64000);
// opus, default bitrate == 32000 in mono.
TestMaxSendBandwidth(kOpusCodec, -1, true, 32000);
}
TEST_P(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthMultiRateAsCaller) {
EXPECT_TRUE(SetupSendStream());
// opus, default bitrate == 64000.
TestMaxSendBandwidth(kOpusCodec, 96000, true, 96000);
TestMaxSendBandwidth(kOpusCodec, 48000, true, 48000);
// Rates above the max (510000) should be capped.
TestMaxSendBandwidth(kOpusCodec, 600000, true, 510000);
}
TEST_P(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthFixedRateAsCaller) {
EXPECT_TRUE(SetupSendStream());
// 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.
TestMaxSendBandwidth(kPcmuCodec, 0, true, 64000);
TestMaxSendBandwidth(kPcmuCodec, 1, false, 64000);
TestMaxSendBandwidth(kPcmuCodec, 128000, true, 64000);
TestMaxSendBandwidth(kPcmuCodec, 32000, false, 64000);
TestMaxSendBandwidth(kPcmuCodec, 64000, true, 64000);
TestMaxSendBandwidth(kPcmuCodec, 63999, false, 64000);
TestMaxSendBandwidth(kPcmuCodec, 64001, true, 64000);
}
TEST_P(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthMultiRateAsCallee) {
EXPECT_TRUE(SetupChannel());
const int kDesiredBitrate = 128000;
cricket::AudioSenderParameter parameters;
parameters.codecs = engine_->send_codecs();
parameters.max_bandwidth_bps = kDesiredBitrate;
SetSenderParameters(parameters);
EXPECT_TRUE(send_channel_->AddSendStream(
cricket::StreamParams::CreateLegacy(kSsrcX)));
EXPECT_EQ(kDesiredBitrate, GetCodecBitrate(kSsrcX));
}
// 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_P(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthCbr) {
EXPECT_TRUE(SetupSendStream());
// PCMU, default bitrate == 64000.
SetSenderParameters(send_parameters_);
EXPECT_EQ(64000, GetCodecBitrate(kSsrcX));
send_parameters_.max_bandwidth_bps = 128000;
SetSenderParameters(send_parameters_);
EXPECT_EQ(64000, GetCodecBitrate(kSsrcX));
send_parameters_.max_bandwidth_bps = 128;
EXPECT_FALSE(send_channel_->SetSenderParameters(send_parameters_));
EXPECT_EQ(64000, GetCodecBitrate(kSsrcX));
}
// Test that the per-stream bitrate limit and the global
// bitrate limit both apply.
TEST_P(WebRtcVoiceEngineTestFake, SetMaxBitratePerStream) {
EXPECT_TRUE(SetupSendStream());
// opus, default bitrate == 32000.
SetAndExpectMaxBitrate(kOpusCodec, 0, 0, true, 32000);
SetAndExpectMaxBitrate(kOpusCodec, 48000, 0, true, 48000);
SetAndExpectMaxBitrate(kOpusCodec, 48000, 64000, true, 48000);
SetAndExpectMaxBitrate(kOpusCodec, 64000, 48000, true, 48000);
// CBR codecs allow both maximums to exceed the bitrate.
SetAndExpectMaxBitrate(kPcmuCodec, 0, 0, true, 64000);
SetAndExpectMaxBitrate(kPcmuCodec, 64001, 0, true, 64000);
SetAndExpectMaxBitrate(kPcmuCodec, 0, 64001, true, 64000);
SetAndExpectMaxBitrate(kPcmuCodec, 64001, 64001, true, 64000);
// CBR codecs don't allow per stream maximums to be too low.
SetAndExpectMaxBitrate(kPcmuCodec, 0, 63999, false, 64000);
SetAndExpectMaxBitrate(kPcmuCodec, 64001, 63999, false, 64000);
}
// Test that an attempt to set RtpParameters for a stream that does not exist
// fails.
TEST_P(WebRtcVoiceEngineTestFake, CannotSetMaxBitrateForNonexistentStream) {
EXPECT_TRUE(SetupChannel());
webrtc::RtpParameters nonexistent_parameters =
send_channel_->GetRtpSendParameters(kSsrcX);
EXPECT_EQ(0u, nonexistent_parameters.encodings.size());
nonexistent_parameters.encodings.push_back(webrtc::RtpEncodingParameters());
EXPECT_FALSE(
send_channel_->SetRtpSendParameters(kSsrcX, nonexistent_parameters).ok());
}
TEST_P(WebRtcVoiceEngineTestFake,
CannotSetRtpSendParametersWithIncorrectNumberOfEncodings) {
// This test verifies that setting RtpParameters succeeds only if
// the structure contains exactly one encoding.
// TODO(skvlad): Update this test when we start supporting setting parameters
// for each encoding individually.
EXPECT_TRUE(SetupSendStream());
webrtc::RtpParameters parameters =
send_channel_->GetRtpSendParameters(kSsrcX);
// Two or more encodings should result in failure.
parameters.encodings.push_back(webrtc::RtpEncodingParameters());
EXPECT_FALSE(send_channel_->SetRtpSendParameters(kSsrcX, parameters).ok());
// Zero encodings should also fail.
parameters.encodings.clear();
EXPECT_FALSE(send_channel_->SetRtpSendParameters(kSsrcX, parameters).ok());
}
// Changing the SSRC through RtpParameters is not allowed.
TEST_P(WebRtcVoiceEngineTestFake, CannotSetSsrcInRtpSendParameters) {
EXPECT_TRUE(SetupSendStream());
webrtc::RtpParameters parameters =
send_channel_->GetRtpSendParameters(kSsrcX);
parameters.encodings[0].ssrc = 0xdeadbeef;
EXPECT_FALSE(send_channel_->SetRtpSendParameters(kSsrcX, parameters).ok());
}
// Test that a stream will not be sending if its encoding is made
// inactive through SetRtpSendParameters.
TEST_P(WebRtcVoiceEngineTestFake, SetRtpParametersEncodingsActive) {
EXPECT_TRUE(SetupSendStream());
SetSend(true);
EXPECT_TRUE(GetSendStream(kSsrcX).IsSending());
// Get current parameters and change "active" to false.
webrtc::RtpParameters parameters =
send_channel_->GetRtpSendParameters(kSsrcX);
ASSERT_EQ(1u, parameters.encodings.size());
ASSERT_TRUE(parameters.encodings[0].active);
parameters.encodings[0].active = false;
EXPECT_TRUE(send_channel_->SetRtpSendParameters(kSsrcX, parameters).ok());
EXPECT_FALSE(GetSendStream(kSsrcX).IsSending());
// Now change it back to active and verify we resume sending.
// This should occur even when other parameters are updated.
parameters.encodings[0].active = true;
parameters.encodings[0].max_bitrate_bps = absl::optional<int>(6000);
EXPECT_TRUE(send_channel_->SetRtpSendParameters(kSsrcX, parameters).ok());
EXPECT_TRUE(GetSendStream(kSsrcX).IsSending());
}
TEST_P(WebRtcVoiceEngineTestFake, SetRtpParametersAdaptivePtime) {
EXPECT_TRUE(SetupSendStream());
// Get current parameters and change "adaptive_ptime" to true.
webrtc::RtpParameters parameters =
send_channel_->GetRtpSendParameters(kSsrcX);
ASSERT_EQ(1u, parameters.encodings.size());
ASSERT_FALSE(parameters.encodings[0].adaptive_ptime);
parameters.encodings[0].adaptive_ptime = true;
EXPECT_TRUE(send_channel_->SetRtpSendParameters(kSsrcX, parameters).ok());
EXPECT_TRUE(GetAudioNetworkAdaptorConfig(kSsrcX));
EXPECT_EQ(16000, GetSendStreamConfig(kSsrcX).min_bitrate_bps);
parameters.encodings[0].adaptive_ptime = false;
EXPECT_TRUE(send_channel_->SetRtpSendParameters(kSsrcX, parameters).ok());
EXPECT_FALSE(GetAudioNetworkAdaptorConfig(kSsrcX));
EXPECT_EQ(32000, GetSendStreamConfig(kSsrcX).min_bitrate_bps);
}
TEST_P(WebRtcVoiceEngineTestFake,
DisablingAdaptivePtimeDoesNotRemoveAudioNetworkAdaptorFromOptions) {
EXPECT_TRUE(SetupSendStream());
send_parameters_.options.audio_network_adaptor = true;
send_parameters_.options.audio_network_adaptor_config = {"1234"};
SetSenderParameters(send_parameters_);
EXPECT_EQ(send_parameters_.options.audio_network_adaptor_config,
GetAudioNetworkAdaptorConfig(kSsrcX));
webrtc::RtpParameters parameters =
send_channel_->GetRtpSendParameters(kSsrcX);
parameters.encodings[0].adaptive_ptime = false;
EXPECT_TRUE(send_channel_->SetRtpSendParameters(kSsrcX, parameters).ok());
EXPECT_EQ(send_parameters_.options.audio_network_adaptor_config,
GetAudioNetworkAdaptorConfig(kSsrcX));
}
TEST_P(WebRtcVoiceEngineTestFake, AdaptivePtimeFieldTrial) {
webrtc::test::ScopedKeyValueConfig override_field_trials(
field_trials_, "WebRTC-Audio-AdaptivePtime/enabled:true/");
EXPECT_TRUE(SetupSendStream());
EXPECT_TRUE(GetAudioNetworkAdaptorConfig(kSsrcX));
}
// Test that SetRtpSendParameters configures the correct encoding channel for
// each SSRC.
TEST_P(WebRtcVoiceEngineTestFake, RtpParametersArePerStream) {
SetupForMultiSendStream();
// Create send streams.
for (uint32_t ssrc : kSsrcs4) {
EXPECT_TRUE(send_channel_->AddSendStream(
cricket::StreamParams::CreateLegacy(ssrc)));
}
// Configure one stream to be limited by the stream config, another to be
// limited by the global max, and the third one with no per-stream limit
// (still subject to the global limit).
SetGlobalMaxBitrate(kOpusCodec, 32000);
EXPECT_TRUE(SetMaxBitrateForStream(kSsrcs4[0], 24000));
EXPECT_TRUE(SetMaxBitrateForStream(kSsrcs4[1], 48000));
EXPECT_TRUE(SetMaxBitrateForStream(kSsrcs4[2], -1));
EXPECT_EQ(24000, GetCodecBitrate(kSsrcs4[0]));
EXPECT_EQ(32000, GetCodecBitrate(kSsrcs4[1]));
EXPECT_EQ(32000, GetCodecBitrate(kSsrcs4[2]));
// Remove the global cap; the streams should switch to their respective
// maximums (or remain unchanged if there was no other limit on them.)
SetGlobalMaxBitrate(kOpusCodec, -1);
EXPECT_EQ(24000, GetCodecBitrate(kSsrcs4[0]));
EXPECT_EQ(48000, GetCodecBitrate(kSsrcs4[1]));
EXPECT_EQ(32000, GetCodecBitrate(kSsrcs4[2]));
}
// Test that GetRtpSendParameters returns the currently configured codecs.
TEST_P(WebRtcVoiceEngineTestFake, GetRtpSendParametersCodecs) {
EXPECT_TRUE(SetupSendStream());
cricket::AudioSenderParameter parameters;
parameters.codecs.push_back(kOpusCodec);
parameters.codecs.push_back(kPcmuCodec);
SetSenderParameters(parameters);
webrtc::RtpParameters rtp_parameters =
send_channel_->GetRtpSendParameters(kSsrcX);
ASSERT_EQ(2u, rtp_parameters.codecs.size());
EXPECT_EQ(kOpusCodec.ToCodecParameters(), rtp_parameters.codecs[0]);
EXPECT_EQ(kPcmuCodec.ToCodecParameters(), rtp_parameters.codecs[1]);
}
// Test that GetRtpSendParameters returns the currently configured RTCP CNAME.
TEST_P(WebRtcVoiceEngineTestFake, GetRtpSendParametersRtcpCname) {
cricket::StreamParams params = cricket::StreamParams::CreateLegacy(kSsrcX);
params.cname = "rtcpcname";
EXPECT_TRUE(SetupSendStream(params));
webrtc::RtpParameters rtp_parameters =
send_channel_->GetRtpSendParameters(kSsrcX);
EXPECT_STREQ("rtcpcname", rtp_parameters.rtcp.cname.c_str());
}
TEST_P(WebRtcVoiceEngineTestFake,
DetectRtpSendParameterHeaderExtensionsChange) {
EXPECT_TRUE(SetupSendStream());
webrtc::RtpParameters rtp_parameters =
send_channel_->GetRtpSendParameters(kSsrcX);
rtp_parameters.header_extensions.emplace_back();
EXPECT_NE(0u, rtp_parameters.header_extensions.size());
webrtc::RTCError result =
send_channel_->SetRtpSendParameters(kSsrcX, rtp_parameters);
EXPECT_EQ(webrtc::RTCErrorType::INVALID_MODIFICATION, result.type());
}
// Test that GetRtpSendParameters returns an SSRC.
TEST_P(WebRtcVoiceEngineTestFake, GetRtpSendParametersSsrc) {
EXPECT_TRUE(SetupSendStream());
webrtc::RtpParameters rtp_parameters =
send_channel_->GetRtpSendParameters(kSsrcX);
ASSERT_EQ(1u, rtp_parameters.encodings.size());
EXPECT_EQ(kSsrcX, rtp_parameters.encodings[0].ssrc);
}
// Test that if we set/get parameters multiple times, we get the same results.
TEST_P(WebRtcVoiceEngineTestFake, SetAndGetRtpSendParameters) {
EXPECT_TRUE(SetupSendStream());
cricket::AudioSenderParameter parameters;
parameters.codecs.push_back(kOpusCodec);
parameters.codecs.push_back(kPcmuCodec);
SetSenderParameters(parameters);
webrtc::RtpParameters initial_params =
send_channel_->GetRtpSendParameters(kSsrcX);
// We should be able to set the params we just got.
EXPECT_TRUE(send_channel_->SetRtpSendParameters(kSsrcX, initial_params).ok());
// ... And this shouldn't change the params returned by GetRtpSendParameters.
webrtc::RtpParameters new_params =
send_channel_->GetRtpSendParameters(kSsrcX);
EXPECT_EQ(initial_params, send_channel_->GetRtpSendParameters(kSsrcX));
}
// Test that we remove the codec from RTP parameters if it's not negotiated
// anymore.
TEST_P(WebRtcVoiceEngineTestFake,
SetSendParametersRemovesSelectedCodecFromRtpParameters) {
EXPECT_TRUE(SetupSendStream());
cricket::AudioSenderParameter parameters;
parameters.codecs.push_back(kOpusCodec);
parameters.codecs.push_back(kPcmuCodec);
SetSenderParameters(parameters);
webrtc::RtpParameters initial_params =
send_channel_->GetRtpSendParameters(kSsrcX);
webrtc::RtpCodec opus_rtp_codec;
opus_rtp_codec.name = "opus";
opus_rtp_codec.kind = cricket::MEDIA_TYPE_AUDIO;
opus_rtp_codec.num_channels = 2;
opus_rtp_codec.clock_rate = 48000;
initial_params.encodings[0].codec = opus_rtp_codec;
// We should be able to set the params with the opus codec that has been
// negotiated.
EXPECT_TRUE(send_channel_->SetRtpSendParameters(kSsrcX, initial_params).ok());
parameters.codecs.clear();
parameters.codecs.push_back(kPcmuCodec);
SetSenderParameters(parameters);
// Since Opus is no longer negotiated, the RTP parameters should not have a
// forced codec anymore.
webrtc::RtpParameters new_params =
send_channel_->GetRtpSendParameters(kSsrcX);
EXPECT_EQ(new_params.encodings[0].codec, absl::nullopt);
}
// Test that max_bitrate_bps in send stream config gets updated correctly when
// SetRtpSendParameters is called.
TEST_P(WebRtcVoiceEngineTestFake, SetRtpSendParameterUpdatesMaxBitrate) {
EXPECT_TRUE(SetupSendStream());
cricket::AudioSenderParameter send_parameters;
send_parameters.codecs.push_back(kOpusCodec);
SetSenderParameters(send_parameters);
webrtc::RtpParameters rtp_parameters =
send_channel_->GetRtpSendParameters(kSsrcX);
// Expect empty on parameters.encodings[0].max_bitrate_bps;
EXPECT_FALSE(rtp_parameters.encodings[0].max_bitrate_bps);
constexpr int kMaxBitrateBps = 6000;
rtp_parameters.encodings[0].max_bitrate_bps = kMaxBitrateBps;
EXPECT_TRUE(send_channel_->SetRtpSendParameters(kSsrcX, rtp_parameters).ok());
const int max_bitrate = GetSendStreamConfig(kSsrcX).max_bitrate_bps;
EXPECT_EQ(max_bitrate, kMaxBitrateBps);
}
// Tests that when RTCRtpEncodingParameters.bitrate_priority gets set to
// a value <= 0, setting the parameters returns false.
TEST_P(WebRtcVoiceEngineTestFake, SetRtpSendParameterInvalidBitratePriority) {
EXPECT_TRUE(SetupSendStream());
webrtc::RtpParameters rtp_parameters =
send_channel_->GetRtpSendParameters(kSsrcX);
EXPECT_EQ(1UL, rtp_parameters.encodings.size());
EXPECT_EQ(webrtc::kDefaultBitratePriority,
rtp_parameters.encodings[0].bitrate_priority);
rtp_parameters.encodings[0].bitrate_priority = 0;
EXPECT_FALSE(
send_channel_->SetRtpSendParameters(kSsrcX, rtp_parameters).ok());
rtp_parameters.encodings[0].bitrate_priority = -1.0;
EXPECT_FALSE(
send_channel_->SetRtpSendParameters(kSsrcX, rtp_parameters).ok());
}
// Test that the bitrate_priority in the send stream config gets updated when
// SetRtpSendParameters is set for the VoiceMediaChannel.
TEST_P(WebRtcVoiceEngineTestFake, SetRtpSendParameterUpdatesBitratePriority) {
EXPECT_TRUE(SetupSendStream());
webrtc::RtpParameters rtp_parameters =
send_channel_->GetRtpSendParameters(kSsrcX);
EXPECT_EQ(1UL, rtp_parameters.encodings.size());
EXPECT_EQ(webrtc::kDefaultBitratePriority,
rtp_parameters.encodings[0].bitrate_priority);
double new_bitrate_priority = 2.0;
rtp_parameters.encodings[0].bitrate_priority = new_bitrate_priority;
EXPECT_TRUE(send_channel_->SetRtpSendParameters(kSsrcX, rtp_parameters).ok());
// The priority should get set for both the audio channel's rtp parameters
// and the audio send stream's audio config.
EXPECT_EQ(new_bitrate_priority, send_channel_->GetRtpSendParameters(kSsrcX)
.encodings[0]
.bitrate_priority);
EXPECT_EQ(new_bitrate_priority, GetSendStreamConfig(kSsrcX).bitrate_priority);
}
// Test that GetRtpReceiverParameters returns the currently configured codecs.
TEST_P(WebRtcVoiceEngineTestFake, GetRtpReceiveParametersCodecs) {
EXPECT_TRUE(SetupRecvStream());
cricket::AudioReceiverParameters parameters;
parameters.codecs.push_back(kOpusCodec);
parameters.codecs.push_back(kPcmuCodec);
EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters));
webrtc::RtpParameters rtp_parameters =
receive_channel_->GetRtpReceiverParameters(kSsrcX);
ASSERT_EQ(2u, rtp_parameters.codecs.size());
EXPECT_EQ(kOpusCodec.ToCodecParameters(), rtp_parameters.codecs[0]);
EXPECT_EQ(kPcmuCodec.ToCodecParameters(), rtp_parameters.codecs[1]);
}
// Test that GetRtpReceiverParameters returns an SSRC.
TEST_P(WebRtcVoiceEngineTestFake, GetRtpReceiveParametersSsrc) {
EXPECT_TRUE(SetupRecvStream());
webrtc::RtpParameters rtp_parameters =
receive_channel_->GetRtpReceiverParameters(kSsrcX);
ASSERT_EQ(1u, rtp_parameters.encodings.size());
EXPECT_EQ(kSsrcX, rtp_parameters.encodings[0].ssrc);
}
// Test that if we set/get parameters multiple times, we get the same results.
TEST_P(WebRtcVoiceEngineTestFake, SetAndGetRtpReceiveParameters) {
EXPECT_TRUE(SetupRecvStream());
cricket::AudioReceiverParameters parameters;
parameters.codecs.push_back(kOpusCodec);
parameters.codecs.push_back(kPcmuCodec);
EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters));
webrtc::RtpParameters initial_params =
receive_channel_->GetRtpReceiverParameters(kSsrcX);
// ... And this shouldn't change the params returned by
// GetRtpReceiverParameters.
webrtc::RtpParameters new_params =
receive_channel_->GetRtpReceiverParameters(kSsrcX);
EXPECT_EQ(initial_params, receive_channel_->GetRtpReceiverParameters(kSsrcX));
}
// Test that GetRtpReceiverParameters returns parameters correctly when SSRCs
// aren't signaled. It should return an empty "RtpEncodingParameters" when
// configured to receive an unsignaled stream and no packets have been received
// yet, and start returning the SSRC once a packet has been received.
TEST_P(WebRtcVoiceEngineTestFake, GetRtpReceiveParametersWithUnsignaledSsrc) {
ASSERT_TRUE(SetupChannel());
// Call necessary methods to configure receiving a default stream as
// soon as it arrives.
cricket::AudioReceiverParameters parameters;
parameters.codecs.push_back(kOpusCodec);
parameters.codecs.push_back(kPcmuCodec);
EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters));
// Call GetDefaultRtpReceiveParameters before configured to receive an
// unsignaled stream. Should return nothing.
EXPECT_EQ(webrtc::RtpParameters(),
receive_channel_->GetDefaultRtpReceiveParameters());
// Set a sink for an unsignaled stream.
std::unique_ptr<FakeAudioSink> fake_sink(new FakeAudioSink());
receive_channel_->SetDefaultRawAudioSink(std::move(fake_sink));
// Call GetDefaultRtpReceiveParameters before the SSRC is known.
webrtc::RtpParameters rtp_parameters =
receive_channel_->GetDefaultRtpReceiveParameters();
ASSERT_EQ(1u, rtp_parameters.encodings.size());
EXPECT_FALSE(rtp_parameters.encodings[0].ssrc);
// Receive PCMU packet (SSRC=1).
DeliverPacket(kPcmuFrame, sizeof(kPcmuFrame));
// The `ssrc` member should still be unset.
rtp_parameters = receive_channel_->GetDefaultRtpReceiveParameters();
ASSERT_EQ(1u, rtp_parameters.encodings.size());
EXPECT_FALSE(rtp_parameters.encodings[0].ssrc);
}
TEST_P(WebRtcVoiceEngineTestFake, OnPacketReceivedIdentifiesExtensions) {
ASSERT_TRUE(SetupChannel());
cricket::AudioReceiverParameters parameters = recv_parameters_;
parameters.extensions.push_back(
RtpExtension(RtpExtension::kAudioLevelUri, /*id=*/1));
ASSERT_TRUE(receive_channel_->SetReceiverParameters(parameters));
webrtc::RtpHeaderExtensionMap extension_map(parameters.extensions);
webrtc::RtpPacketReceived reference_packet(&extension_map);
constexpr uint8_t kAudioLevel = 123;
reference_packet.SetExtension<webrtc::AudioLevel>(/*voice_activity=*/true,
kAudioLevel);
// Create a packet without the extension map but with the same content.
webrtc::RtpPacketReceived received_packet;
ASSERT_TRUE(received_packet.Parse(reference_packet.Buffer()));
receive_channel_->OnPacketReceived(received_packet);
rtc::Thread::Current()->ProcessMessages(0);
bool voice_activity;
uint8_t audio_level;
EXPECT_TRUE(call_.last_received_rtp_packet().GetExtension<webrtc::AudioLevel>(
&voice_activity, &audio_level));
EXPECT_EQ(audio_level, kAudioLevel);
}
// Test that we apply codecs properly.
TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecs) {
EXPECT_TRUE(SetupSendStream());
cricket::AudioSenderParameter parameters;
parameters.codecs.push_back(kOpusCodec);
parameters.codecs.push_back(kPcmuCodec);
parameters.codecs.push_back(kCn8000Codec);
parameters.codecs[0].id = 96;
parameters.codecs[0].bitrate = 22000;
SetSenderParameters(parameters);
const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec;
EXPECT_EQ(96, send_codec_spec.payload_type);
EXPECT_EQ(22000, send_codec_spec.target_bitrate_bps);
EXPECT_STRCASEEQ("OPUS", send_codec_spec.format.name.c_str());
EXPECT_NE(send_codec_spec.format.clockrate_hz, 8000);
EXPECT_EQ(absl::nullopt, send_codec_spec.cng_payload_type);
EXPECT_FALSE(send_channel_->CanInsertDtmf());
}
// Test that we use Opus/Red by default when it is
// listed as the first codec and there is an fmtp line.
TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsRed) {
EXPECT_TRUE(SetupSendStream());
cricket::AudioSenderParameter parameters;
parameters.codecs.push_back(kRed48000Codec);
parameters.codecs[0].params[""] = "111/111";
parameters.codecs.push_back(kOpusCodec);
SetSenderParameters(parameters);
const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec;
EXPECT_EQ(111, send_codec_spec.payload_type);
EXPECT_STRCASEEQ("opus", send_codec_spec.format.name.c_str());
EXPECT_EQ(112, send_codec_spec.red_payload_type);
}
// Test that we do not use Opus/Red by default when it is
// listed as the first codec but there is no fmtp line.
TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsRedNoFmtp) {
EXPECT_TRUE(SetupSendStream());
cricket::AudioSenderParameter parameters;
parameters.codecs.push_back(kRed48000Codec);
parameters.codecs.push_back(kOpusCodec);
SetSenderParameters(parameters);
const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec;
EXPECT_EQ(111, send_codec_spec.payload_type);
EXPECT_STRCASEEQ("opus", send_codec_spec.format.name.c_str());
EXPECT_EQ(absl::nullopt, send_codec_spec.red_payload_type);
}
// Test that we do not use Opus/Red by default.
TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsRedDefault) {
EXPECT_TRUE(SetupSendStream());
cricket::AudioSenderParameter parameters;
parameters.codecs.push_back(kOpusCodec);
parameters.codecs.push_back(kRed48000Codec);
parameters.codecs[1].params[""] = "111/111";
SetSenderParameters(parameters);
const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec;
EXPECT_EQ(111, send_codec_spec.payload_type);
EXPECT_STRCASEEQ("opus", send_codec_spec.format.name.c_str());
EXPECT_EQ(absl::nullopt, send_codec_spec.red_payload_type);
}
// Test that the RED fmtp line must match the payload type.
TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsRedFmtpMismatch) {
EXPECT_TRUE(SetupSendStream());
cricket::AudioSenderParameter parameters;
parameters.codecs.push_back(kRed48000Codec);
parameters.codecs[0].params[""] = "8/8";
parameters.codecs.push_back(kOpusCodec);
SetSenderParameters(parameters);
const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec;
EXPECT_EQ(111, send_codec_spec.payload_type);
EXPECT_STRCASEEQ("opus", send_codec_spec.format.name.c_str());
EXPECT_EQ(absl::nullopt, send_codec_spec.red_payload_type);
}
// Test that the RED fmtp line must show 2..32 payloads.
TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsRedFmtpAmountOfRedundancy) {
EXPECT_TRUE(SetupSendStream());
cricket::AudioSenderParameter parameters;
parameters.codecs.push_back(kRed48000Codec);
parameters.codecs[0].params[""] = "111";
parameters.codecs.push_back(kOpusCodec);
SetSenderParameters(parameters);
const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec;
EXPECT_EQ(111, send_codec_spec.payload_type);
EXPECT_STRCASEEQ("opus", send_codec_spec.format.name.c_str());
EXPECT_EQ(absl::nullopt, send_codec_spec.red_payload_type);
for (int i = 1; i < 32; i++) {
parameters.codecs[0].params[""] += "/111";
SetSenderParameters(parameters);
const auto& send_codec_spec2 = *GetSendStreamConfig(kSsrcX).send_codec_spec;
EXPECT_EQ(111, send_codec_spec2.payload_type);
EXPECT_STRCASEEQ("opus", send_codec_spec2.format.name.c_str());
EXPECT_EQ(112, send_codec_spec2.red_payload_type);
}
parameters.codecs[0].params[""] += "/111";
SetSenderParameters(parameters);
const auto& send_codec_spec3 = *GetSendStreamConfig(kSsrcX).send_codec_spec;
EXPECT_EQ(111, send_codec_spec3.payload_type);
EXPECT_STRCASEEQ("opus", send_codec_spec3.format.name.c_str());
EXPECT_EQ(absl::nullopt, send_codec_spec3.red_payload_type);
}
// Test that WebRtcVoiceEngine reconfigures, rather than recreates its
// AudioSendStream.
TEST_P(WebRtcVoiceEngineTestFake, DontRecreateSendStream) {
EXPECT_TRUE(SetupSendStream());
cricket::AudioSenderParameter parameters;
parameters.codecs.push_back(kOpusCodec);
parameters.codecs.push_back(kPcmuCodec);
parameters.codecs.push_back(kCn8000Codec);
parameters.codecs[0].id = 96;
parameters.codecs[0].bitrate = 48000;
const int initial_num = call_.GetNumCreatedSendStreams();
SetSenderParameters(parameters);
EXPECT_EQ(initial_num, call_.GetNumCreatedSendStreams());
// Calling SetSendCodec again with same codec which is already set.
// In this case media channel shouldn't send codec to VoE.
SetSenderParameters(parameters);
EXPECT_EQ(initial_num, call_.GetNumCreatedSendStreams());
}
// TODO(ossu): Revisit if these tests need to be here, now that these kinds of
// tests should be available in AudioEncoderOpusTest.
// Test that if clockrate is not 48000 for opus, we fail.
TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpusBadClockrate) {
EXPECT_TRUE(SetupSendStream());
cricket::AudioSenderParameter parameters;
parameters.codecs.push_back(kOpusCodec);
parameters.codecs[0].bitrate = 0;
parameters.codecs[0].clockrate = 50000;
EXPECT_FALSE(send_channel_->SetSenderParameters(parameters));
}
// Test that if channels=0 for opus, we fail.
TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpusBad0ChannelsNoStereo) {
EXPECT_TRUE(SetupSendStream());
cricket::AudioSenderParameter parameters;
parameters.codecs.push_back(kOpusCodec);
parameters.codecs[0].bitrate = 0;
parameters.codecs[0].channels = 0;
EXPECT_FALSE(send_channel_->SetSenderParameters(parameters));
}
// Test that if channels=0 for opus, we fail.
TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpusBad0Channels1Stereo) {
EXPECT_TRUE(SetupSendStream());
cricket::AudioSenderParameter parameters;
parameters.codecs.push_back(kOpusCodec);
parameters.codecs[0].bitrate = 0;
parameters.codecs[0].channels = 0;
parameters.codecs[0].params["stereo"] = "1";
EXPECT_FALSE(send_channel_->SetSenderParameters(parameters));
}
// Test that if channel is 1 for opus and there's no stereo, we fail.
TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpus1ChannelNoStereo) {
EXPECT_TRUE(SetupSendStream());
cricket::AudioSenderParameter parameters;
parameters.codecs.push_back(kOpusCodec);
parameters.codecs[0].bitrate = 0;
parameters.codecs[0].channels = 1;
EXPECT_FALSE(send_channel_->SetSenderParameters(parameters));
}
// Test that if channel is 1 for opus and stereo=0, we fail.
TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpusBad1Channel0Stereo) {
EXPECT_TRUE(SetupSendStream());
cricket::AudioSenderParameter parameters;
parameters.codecs.push_back(kOpusCodec);
parameters.codecs[0].bitrate = 0;
parameters.codecs[0].channels = 1;
parameters.codecs[0].params["stereo"] = "0";
EXPECT_FALSE(send_channel_->SetSenderParameters(parameters));
}
// Test that if channel is 1 for opus and stereo=1, we fail.
TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpusBad1Channel1Stereo) {
EXPECT_TRUE(SetupSendStream());
cricket::AudioSenderParameter parameters;
parameters.codecs.push_back(kOpusCodec);
parameters.codecs[0].bitrate = 0;
parameters.codecs[0].channels = 1;
parameters.codecs[0].params["stereo"] = "1";
EXPECT_FALSE(send_channel_->SetSenderParameters(parameters));
}
// Test that with bitrate=0 and no stereo, bitrate is 32000.
TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpusGood0BitrateNoStereo) {
EXPECT_TRUE(SetupSendStream());
cricket::AudioSenderParameter parameters;
parameters.codecs.push_back(kOpusCodec);
parameters.codecs[0].bitrate = 0;
SetSenderParameters(parameters);
CheckSendCodecBitrate(kSsrcX, "opus", 32000);
}
// Test that with bitrate=0 and stereo=0, bitrate is 32000.
TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpusGood0Bitrate0Stereo) {
EXPECT_TRUE(SetupSendStream());
cricket::AudioSenderParameter parameters;
parameters.codecs.push_back(kOpusCodec);
parameters.codecs[0].bitrate = 0;
parameters.codecs[0].params["stereo"] = "0";
SetSenderParameters(parameters);
CheckSendCodecBitrate(kSsrcX, "opus", 32000);
}
// Test that with bitrate=invalid and stereo=0, bitrate is 32000.
TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodXBitrate0Stereo) {
EXPECT_TRUE(SetupSendStream());
cricket::AudioSenderParameter parameters;
parameters.codecs.push_back(kOpusCodec);
parameters.codecs[0].params["stereo"] = "0";
// bitrate that's out of the range between 6000 and 510000 will be clamped.
parameters.codecs[0].bitrate = 5999;
SetSenderParameters(parameters);
CheckSendCodecBitrate(kSsrcX, "opus", 6000);
parameters.codecs[0].bitrate = 510001;
SetSenderParameters(parameters);
CheckSendCodecBitrate(kSsrcX, "opus", 510000);
}
// Test that with bitrate=0 and stereo=1, bitrate is 64000.
TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpusGood0Bitrate1Stereo) {
EXPECT_TRUE(SetupSendStream());
cricket::AudioSenderParameter parameters;
parameters.codecs.push_back(kOpusCodec);
parameters.codecs[0].bitrate = 0;
parameters.codecs[0].params["stereo"] = "1";
SetSenderParameters(parameters);
CheckSendCodecBitrate(kSsrcX, "opus", 64000);
}
// Test that with bitrate=invalid and stereo=1, bitrate is 64000.
TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodXBitrate1Stereo) {
EXPECT_TRUE(SetupSendStream());
cricket::AudioSenderParameter parameters;
parameters.codecs.push_back(kOpusCodec);
parameters.codecs[0].params["stereo"] = "1";
// bitrate that's out of the range between 6000 and 510000 will be clamped.
parameters.codecs[0].bitrate = 5999;
SetSenderParameters(parameters);
CheckSendCodecBitrate(kSsrcX, "opus", 6000);
parameters.codecs[0].bitrate = 510001;
SetSenderParameters(parameters);
CheckSendCodecBitrate(kSsrcX, "opus", 510000);
}
// Test that with bitrate=N and stereo unset, bitrate is N.
TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrateNoStereo) {
EXPECT_TRUE(SetupSendStream());
cricket::AudioSenderParameter parameters;
parameters.codecs.push_back(kOpusCodec);
parameters.codecs[0].bitrate = 96000;
SetSenderParameters(parameters);
const auto& spec = *GetSendStreamConfig(kSsrcX).send_codec_spec;
EXPECT_EQ(111, spec.payload_type);
EXPECT_EQ(96000, spec.target_bitrate_bps);
EXPECT_EQ("opus", spec.format.name);
EXPECT_EQ(2u, spec.format.num_channels);
EXPECT_EQ(48000, spec.format.clockrate_hz);
}
// Test that with bitrate=N and stereo=0, bitrate is N.
TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrate0Stereo) {
EXPECT_TRUE(SetupSendStream());
cricket::AudioSenderParameter parameters;
parameters.codecs.push_back(kOpusCodec);
parameters.codecs[0].bitrate = 30000;
parameters.codecs[0].params["stereo"] = "0";
SetSenderParameters(parameters);
CheckSendCodecBitrate(kSsrcX, "opus", 30000);
}
// Test that with bitrate=N and without any parameters, bitrate is N.
TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrateNoParameters) {
EXPECT_TRUE(SetupSendStream());
cricket::AudioSenderParameter parameters;
parameters.codecs.push_back(kOpusCodec);
parameters.codecs[0].bitrate = 30000;
SetSenderParameters(parameters);
CheckSendCodecBitrate(kSsrcX, "opus", 30000);
}
// Test that with bitrate=N and stereo=1, bitrate is N.
TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrate1Stereo) {
EXPECT_TRUE(SetupSendStream());
cricket::AudioSenderParameter parameters;
parameters.codecs.push_back(kOpusCodec);
parameters.codecs[0].bitrate = 30000;
parameters.codecs[0].params["stereo"] = "1";
SetSenderParameters(parameters);
CheckSendCodecBitrate(kSsrcX, "opus", 30000);
}
TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsWithBitrates) {
SetSendCodecsShouldWorkForBitrates("100", 100000, "150", 150000, "200",
200000);
}
TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsWithHighMaxBitrate) {
SetSendCodecsShouldWorkForBitrates("", 0, "", -1, "10000", 10000000);
}
TEST_P(WebRtcVoiceEngineTestFake,
SetSendCodecsWithoutBitratesUsesCorrectDefaults) {
SetSendCodecsShouldWorkForBitrates("", 0, "", -1, "", -1);
}
TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsCapsMinAndStartBitrate) {
SetSendCodecsShouldWorkForBitrates("-1", 0, "-100", -1, "", -1);
}
TEST_P(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthForAudioDoesntAffectBwe) {
SetSendCodecsShouldWorkForBitrates("100", 100000, "150", 150000, "200",
200000);
send_parameters_.max_bandwidth_bps = 100000;
// Setting max bitrate should keep previous min bitrate
// Setting max bitrate should not reset start bitrate.
EXPECT_CALL(*call_.GetMockTransportControllerSend(),
SetSdpBitrateParameters(
AllOf(Field(&BitrateConstraints::min_bitrate_bps, 100000),
Field(&BitrateConstraints::start_bitrate_bps, -1),
Field(&BitrateConstraints::max_bitrate_bps, 200000))));
SetSenderParameters(send_parameters_);
}
// Test that we can enable NACK with opus as callee.
TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecEnableNackAsCallee) {
EXPECT_TRUE(SetupRecvStream());
cricket::AudioSenderParameter parameters;
parameters.codecs.push_back(kOpusCodec);
parameters.codecs[0].AddFeedbackParam(cricket::FeedbackParam(
cricket::kRtcpFbParamNack, cricket::kParamValueEmpty));
EXPECT_EQ(0, GetRecvStreamConfig(kSsrcX).rtp.nack.rtp_history_ms);
SetSenderParameters(parameters);
// NACK should be enabled even with no send stream.
EXPECT_EQ(kRtpHistoryMs, GetRecvStreamConfig(kSsrcX).rtp.nack.rtp_history_ms);
EXPECT_TRUE(send_channel_->AddSendStream(
cricket::StreamParams::CreateLegacy(kSsrcX)));
}
// Test that we can enable NACK on receive streams.
TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecEnableNackRecvStreams) {
EXPECT_TRUE(SetupSendStream());
EXPECT_TRUE(AddRecvStream(kSsrcY));
cricket::AudioSenderParameter parameters;
parameters.codecs.push_back(kOpusCodec);
parameters.codecs[0].AddFeedbackParam(cricket::FeedbackParam(
cricket::kRtcpFbParamNack, cricket::kParamValueEmpty));
EXPECT_EQ(0, GetRecvStreamConfig(kSsrcY).rtp.nack.rtp_history_ms);
SetSenderParameters(parameters);
EXPECT_EQ(kRtpHistoryMs, GetRecvStreamConfig(kSsrcY).rtp.nack.rtp_history_ms);
}
// Test that we can disable NACK on receive streams.
TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecDisableNackRecvStreams) {
EXPECT_TRUE(SetupSendStream());
EXPECT_TRUE(AddRecvStream(kSsrcY));
cricket::AudioSenderParameter parameters;
parameters.codecs.push_back(kOpusCodec);
parameters.codecs[0].AddFeedbackParam(cricket::FeedbackParam(
cricket::kRtcpFbParamNack, cricket::kParamValueEmpty));
SetSenderParameters(parameters);
EXPECT_EQ(kRtpHistoryMs, GetRecvStreamConfig(kSsrcY).rtp.nack.rtp_history_ms);
parameters.codecs.clear();
parameters.codecs.push_back(kOpusCodec);
SetSenderParameters(parameters);
EXPECT_EQ(0, GetRecvStreamConfig(kSsrcY).rtp.nack.rtp_history_ms);
}
// Test that NACK is enabled on a new receive stream.
TEST_P(WebRtcVoiceEngineTestFake, AddRecvStreamEnableNack) {
EXPECT_TRUE(SetupSendStream());
cricket::AudioSenderParameter parameters;
parameters.codecs.push_back(kOpusCodec);
parameters.codecs.push_back(kCn16000Codec);
parameters.codecs[0].AddFeedbackParam(cricket::FeedbackParam(
cricket::kRtcpFbParamNack, cricket::kParamValueEmpty));
SetSenderParameters(parameters);
EXPECT_TRUE(AddRecvStream(kSsrcY));
EXPECT_EQ(kRtpHistoryMs, GetRecvStreamConfig(kSsrcY).rtp.nack.rtp_history_ms);
EXPECT_TRUE(AddRecvStream(kSsrcZ));
EXPECT_EQ(kRtpHistoryMs, GetRecvStreamConfig(kSsrcZ).rtp.nack.rtp_history_ms);
}
// Test that we can switch back and forth between Opus and PCMU with CN.
TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsOpusPcmuSwitching) {
EXPECT_TRUE(SetupSendStream());
cricket::AudioSenderParameter opus_parameters;
opus_parameters.codecs.push_back(kOpusCodec);
SetSenderParameters(opus_parameters);
{
const auto& spec = *GetSendStreamConfig(kSsrcX).send_codec_spec;
EXPECT_EQ(111, spec.payload_type);
EXPECT_STRCASEEQ("opus", spec.format.name.c_str());
}
cricket::AudioSenderParameter pcmu_parameters;
pcmu_parameters.codecs.push_back(kPcmuCodec);
pcmu_parameters.codecs.push_back(kCn16000Codec);
pcmu_parameters.codecs.push_back(kOpusCodec);
SetSenderParameters(pcmu_parameters);
{
const auto& spec = *GetSendStreamConfig(kSsrcX).send_codec_spec;
EXPECT_EQ(0, spec.payload_type);
EXPECT_STRCASEEQ("PCMU", spec.format.name.c_str());
}
SetSenderParameters(opus_parameters);
{
const auto& spec = *GetSendStreamConfig(kSsrcX).send_codec_spec;
EXPECT_EQ(111, spec.payload_type);
EXPECT_STRCASEEQ("opus", spec.format.name.c_str());
}
}
// Test that we handle various ways of specifying bitrate.
TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsBitrate) {
EXPECT_TRUE(SetupSendStream());
cricket::AudioSenderParameter parameters;
parameters.codecs.push_back(kPcmuCodec);
SetSenderParameters(parameters);
{
const auto& spec = *GetSendStreamConfig(kSsrcX).send_codec_spec;
EXPECT_EQ(0, spec.payload_type);
EXPECT_STRCASEEQ("PCMU", spec.format.name.c_str());
EXPECT_EQ(64000, spec.target_bitrate_bps);
}
parameters.codecs[0].bitrate = 0; // bitrate == default
SetSenderParameters(parameters);
{
const auto& spec = *GetSendStreamConfig(kSsrcX).send_codec_spec;
EXPECT_EQ(0, spec.payload_type);
EXPECT_STREQ("PCMU", spec.format.name.c_str());
EXPECT_EQ(64000, spec.target_bitrate_bps);
}
parameters.codecs[0] = kOpusCodec;
parameters.codecs[0].bitrate = 0; // bitrate == default
SetSenderParameters(parameters);
{
const auto& spec = *GetSendStreamConfig(kSsrcX).send_codec_spec;
EXPECT_EQ(111, spec.payload_type);
EXPECT_STREQ("opus", spec.format.name.c_str());
EXPECT_EQ(32000, spec.target_bitrate_bps);
}
}
// Test that we fail if no codecs are specified.
TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsNoCodecs) {
EXPECT_TRUE(SetupSendStream());
cricket::AudioSenderParameter parameters;
EXPECT_FALSE(send_channel_->SetSenderParameters(parameters));
}
// Test that we can set send codecs even with telephone-event codec as the first
// one on the list.
TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsDTMFOnTop) {
EXPECT_TRUE(SetupSendStream());
cricket::AudioSenderParameter parameters;
parameters.codecs.push_back(kTelephoneEventCodec1);
parameters.codecs.push_back(kOpusCodec);
parameters.codecs.push_back(kPcmuCodec);
parameters.codecs[0].id = 98; // DTMF
parameters.codecs[1].id = 96;
SetSenderParameters(parameters);
const auto& spec = *GetSendStreamConfig(kSsrcX).send_codec_spec;
EXPECT_EQ(96, spec.payload_type);
EXPECT_STRCASEEQ("OPUS", spec.format.name.c_str());
SetSend(true);
EXPECT_TRUE(send_channel_->CanInsertDtmf());
}
// Test that CanInsertDtmf() is governed by the send flag
TEST_P(WebRtcVoiceEngineTestFake, DTMFControlledBySendFlag) {
EXPECT_TRUE(SetupSendStream());
cricket::AudioSenderParameter parameters;
parameters.codecs.push_back(kTelephoneEventCodec1);
parameters.codecs.push_back(kPcmuCodec);
parameters.codecs[0].id = 98; // DTMF
parameters.codecs[1].id = 96;
SetSenderParameters(parameters);
EXPECT_FALSE(send_channel_->CanInsertDtmf());
SetSend(true);
EXPECT_TRUE(send_channel_->CanInsertDtmf());
SetSend(false);
EXPECT_FALSE(send_channel_->CanInsertDtmf());
}
// Test that payload type range is limited for telephone-event codec.
TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsDTMFPayloadTypeOutOfRange) {
EXPECT_TRUE(SetupSendStream());
cricket::AudioSenderParameter parameters;
parameters.codecs.push_back(kTelephoneEventCodec2);
parameters.codecs.push_back(kOpusCodec);
parameters.codecs[0].id = 0; // DTMF
parameters.codecs[1].id = 96;
SetSenderParameters(parameters);
SetSend(true);
EXPECT_TRUE(send_channel_->CanInsertDtmf());
parameters.codecs[0].id = 128; // DTMF
EXPECT_FALSE(send_channel_->SetSenderParameters(parameters));
EXPECT_FALSE(send_channel_->CanInsertDtmf());
parameters.codecs[0].id = 127;
SetSenderParameters(parameters);
EXPECT_TRUE(send_channel_->CanInsertDtmf());
parameters.codecs[0].id = -1; // DTMF
EXPECT_FALSE(send_channel_->SetSenderParameters(parameters));
EXPECT_FALSE(send_channel_->CanInsertDtmf());
}
// Test that we can set send codecs even with CN codec as the first
// one on the list.
TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsCNOnTop) {
EXPECT_TRUE(SetupSendStream());
cricket::AudioSenderParameter parameters;
parameters.codecs.push_back(kCn8000Codec);
parameters.codecs.push_back(kPcmuCodec);
parameters.codecs[0].id = 98; // narrowband CN
SetSenderParameters(parameters);
const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec;
EXPECT_EQ(0, send_codec_spec.payload_type);
EXPECT_STRCASEEQ("PCMU", send_codec_spec.format.name.c_str());
EXPECT_EQ(98, send_codec_spec.cng_payload_type);
}
// Test that we set VAD and DTMF types correctly as caller.
TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsCNandDTMFAsCaller) {
EXPECT_TRUE(SetupSendStream());
cricket::AudioSenderParameter parameters;
parameters.codecs.push_back(kPcmuCodec);
parameters.codecs.push_back(kCn16000Codec);
parameters.codecs.push_back(kCn8000Codec);
parameters.codecs.push_back(kTelephoneEventCodec1);
parameters.codecs[0].id = 96;
parameters.codecs[2].id = 97; // narrowband CN
parameters.codecs[3].id = 98; // DTMF
SetSenderParameters(parameters);
const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec;
EXPECT_EQ(96, send_codec_spec.payload_type);
EXPECT_STRCASEEQ("PCMU", send_codec_spec.format.name.c_str());
EXPECT_EQ(1u, send_codec_spec.format.num_channels);
EXPECT_EQ(97, send_codec_spec.cng_payload_type);
SetSend(true);
EXPECT_TRUE(send_channel_->CanInsertDtmf());
}
// Test that we set VAD and DTMF types correctly as callee.
TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsCNandDTMFAsCallee) {
EXPECT_TRUE(SetupChannel());
cricket::AudioSenderParameter parameters;
parameters.codecs.push_back(kPcmuCodec);
parameters.codecs.push_back(kCn16000Codec);
parameters.codecs.push_back(kCn8000Codec);
parameters.codecs.push_back(kTelephoneEventCodec2);
parameters.codecs[0].id = 96;
parameters.codecs[2].id = 97; // narrowband CN
parameters.codecs[3].id = 98; // DTMF
SetSenderParameters(parameters);
EXPECT_TRUE(send_channel_->AddSendStream(
cricket::StreamParams::CreateLegacy(kSsrcX)));
const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec;
EXPECT_EQ(96, send_codec_spec.payload_type);
EXPECT_STRCASEEQ("PCMU", send_codec_spec.format.name.c_str());
EXPECT_EQ(1u, send_codec_spec.format.num_channels);
EXPECT_EQ(97, send_codec_spec.cng_payload_type);
SetSend(true);
EXPECT_TRUE(send_channel_->CanInsertDtmf());
}
// Test that we only apply VAD if we have a CN codec that matches the
// send codec clockrate.
TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsCNNoMatch) {
EXPECT_TRUE(SetupSendStream());
cricket::AudioSenderParameter parameters;
// Set PCMU(8K) and CN(16K). VAD should not be activated.
parameters.codecs.push_back(kPcmuCodec);
parameters.codecs.push_back(kCn16000Codec);
parameters.codecs[1].id = 97;
SetSenderParameters(parameters);
{
const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec;
EXPECT_STRCASEEQ("PCMU", send_codec_spec.format.name.c_str());
EXPECT_EQ(absl::nullopt, send_codec_spec.cng_payload_type);
}
// Set PCMU(8K) and CN(8K). VAD should be activated.
parameters.codecs[1] = kCn8000Codec;
SetSenderParameters(parameters);
{
const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec;
EXPECT_STRCASEEQ("PCMU", send_codec_spec.format.name.c_str());
EXPECT_EQ(1u, send_codec_spec.format.num_channels);
EXPECT_EQ(13, send_codec_spec.cng_payload_type);
}
// Set OPUS(48K) and CN(8K). VAD should not be activated.
parameters.codecs[0] = kOpusCodec;
SetSenderParameters(parameters);
{
const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec;
EXPECT_STRCASEEQ("OPUS", send_codec_spec.format.name.c_str());
EXPECT_EQ(absl::nullopt, send_codec_spec.cng_payload_type);
}
}
// Test that we perform case-insensitive matching of codec names.
TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsCaseInsensitive) {
EXPECT_TRUE(SetupSendStream());
cricket::AudioSenderParameter parameters;
parameters.codecs.push_back(kPcmuCodec);
parameters.codecs.push_back(kCn16000Codec);
parameters.codecs.push_back(kCn8000Codec);
parameters.codecs.push_back(kTelephoneEventCodec1);
parameters.codecs[0].name = "PcMu";
parameters.codecs[0].id = 96;
parameters.codecs[2].id = 97; // narrowband CN
parameters.codecs[3].id = 98; // DTMF
SetSenderParameters(parameters);
const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec;
EXPECT_EQ(96, send_codec_spec.payload_type);
EXPECT_STRCASEEQ("PCMU", send_codec_spec.format.name.c_str());
EXPECT_EQ(1u, send_codec_spec.format.num_channels);
EXPECT_EQ(97, send_codec_spec.cng_payload_type);
SetSend(true);
EXPECT_TRUE(send_channel_->CanInsertDtmf());
}
TEST_P(WebRtcVoiceEngineTestFake,
SupportsTransportSequenceNumberHeaderExtension) {
const std::vector<webrtc::RtpExtension> header_extensions =
GetDefaultEnabledRtpHeaderExtensions(*engine_);
EXPECT_THAT(header_extensions,
Contains(::testing::Field(
"uri", &RtpExtension::uri,
webrtc::RtpExtension::kTransportSequenceNumberUri)));
}
// Test support for audio level header extension.
TEST_P(WebRtcVoiceEngineTestFake, SendAudioLevelHeaderExtensions) {
TestSetSendRtpHeaderExtensions(webrtc::RtpExtension::kAudioLevelUri);
}
TEST_P(WebRtcVoiceEngineTestFake, RecvAudioLevelHeaderExtensions) {
TestSetRecvRtpHeaderExtensions(webrtc::RtpExtension::kAudioLevelUri);
}
// Test support for transport sequence number header extension.
TEST_P(WebRtcVoiceEngineTestFake, SendTransportSequenceNumberHeaderExtensions) {
TestSetSendRtpHeaderExtensions(
webrtc::RtpExtension::kTransportSequenceNumberUri);
}
TEST_P(WebRtcVoiceEngineTestFake, RecvTransportSequenceNumberHeaderExtensions) {
TestSetRecvRtpHeaderExtensions(
webrtc::RtpExtension::kTransportSequenceNumberUri);
}
// Test that we can create a channel and start sending on it.
TEST_P(WebRtcVoiceEngineTestFake, Send) {
EXPECT_TRUE(SetupSendStream());
SetSenderParameters(send_parameters_);
SetSend(true);
EXPECT_TRUE(GetSendStream(kSsrcX).IsSending());
SetSend(false);
EXPECT_FALSE(GetSendStream(kSsrcX).IsSending());
}
// Test that a channel is muted/unmuted.
TEST_P(WebRtcVoiceEngineTestFake, SendStateMuteUnmute) {
EXPECT_TRUE(SetupSendStream());
SetSenderParameters(send_parameters_);
EXPECT_FALSE(GetSendStream(kSsrcX).muted());
SetAudioSend(kSsrcX, true, nullptr);
EXPECT_FALSE(GetSendStream(kSsrcX).muted());
SetAudioSend(kSsrcX, false, nullptr);
EXPECT_TRUE(GetSendStream(kSsrcX).muted());
}
// Test that SetSenderParameters() does not alter a stream's send state.
TEST_P(WebRtcVoiceEngineTestFake, SendStateWhenStreamsAreRecreated) {
EXPECT_TRUE(SetupSendStream());
EXPECT_FALSE(GetSendStream(kSsrcX).IsSending());
// Turn on sending.
SetSend(true);
EXPECT_TRUE(GetSendStream(kSsrcX).IsSending());
// Changing RTP header extensions will recreate the AudioSendStream.
send_parameters_.extensions.push_back(
webrtc::RtpExtension(webrtc::RtpExtension::kAudioLevelUri, 12));
SetSenderParameters(send_parameters_);
EXPECT_TRUE(GetSendStream(kSsrcX).IsSending());
// Turn off sending.
SetSend(false);
EXPECT_FALSE(GetSendStream(kSsrcX).IsSending());
// Changing RTP header extensions will recreate the AudioSendStream.
send_parameters_.extensions.clear();
SetSenderParameters(send_parameters_);
EXPECT_FALSE(GetSendStream(kSsrcX).IsSending());
}
// Test that we can create a channel and start playing out on it.
TEST_P(WebRtcVoiceEngineTestFake, Playout) {
EXPECT_TRUE(SetupRecvStream());
EXPECT_TRUE(receive_channel_->SetReceiverParameters(recv_parameters_));
receive_channel_->SetPlayout(true);
EXPECT_TRUE(GetRecvStream(kSsrcX).started());
receive_channel_->SetPlayout(false);
EXPECT_FALSE(GetRecvStream(kSsrcX).started());
}
// Test that we can add and remove send streams.
TEST_P(WebRtcVoiceEngineTestFake, CreateAndDeleteMultipleSendStreams) {
SetupForMultiSendStream();
// Set the global state for sending.
SetSend(true);
for (uint32_t ssrc : kSsrcs4) {
EXPECT_TRUE(send_channel_->AddSendStream(
cricket::StreamParams::CreateLegacy(ssrc)));
SetAudioSend(ssrc, true, &fake_source_);
// Verify that we are in a sending state for all the created streams.
EXPECT_TRUE(GetSendStream(ssrc).IsSending());
}
EXPECT_EQ(arraysize(kSsrcs4), call_.GetAudioSendStreams().size());
// Delete the send streams.
for (uint32_t ssrc : kSsrcs4) {
EXPECT_TRUE(send_channel_->RemoveSendStream(ssrc));
EXPECT_FALSE(call_.GetAudioSendStream(ssrc));
EXPECT_FALSE(send_channel_->RemoveSendStream(ssrc));
}
EXPECT_EQ(0u, call_.GetAudioSendStreams().size());
}
// Test SetSendCodecs correctly configure the codecs in all send streams.
TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsWithMultipleSendStreams) {
SetupForMultiSendStream();
// Create send streams.
for (uint32_t ssrc : kSsrcs4) {
EXPECT_TRUE(send_channel_->AddSendStream(
cricket::StreamParams::CreateLegacy(ssrc)));
}
cricket::AudioSenderParameter parameters;
// Set PCMU and CN(8K). VAD should be activated.
parameters.codecs.push_back(kPcmuCodec);
parameters.codecs.push_back(kCn8000Codec);
parameters.codecs[1].id = 97;
SetSenderParameters(parameters);
// Verify PCMU and VAD are corrected configured on all send channels.
for (uint32_t ssrc : kSsrcs4) {
ASSERT_TRUE(call_.GetAudioSendStream(ssrc) != nullptr);
const auto& send_codec_spec =
*call_.GetAudioSendStream(ssrc)->GetConfig().send_codec_spec;
EXPECT_STRCASEEQ("PCMU", send_codec_spec.format.name.c_str());
EXPECT_EQ(1u, send_codec_spec.format.num_channels);
EXPECT_EQ(97, send_codec_spec.cng_payload_type);
}
// Change to PCMU(8K) and CN(16K).
parameters.codecs[0] = kPcmuCodec;
parameters.codecs[1] = kCn16000Codec;
SetSenderParameters(parameters);
for (uint32_t ssrc : kSsrcs4) {
ASSERT_TRUE(call_.GetAudioSendStream(ssrc) != nullptr);
const auto& send_codec_spec =
*call_.GetAudioSendStream(ssrc)->GetConfig().send_codec_spec;
EXPECT_STRCASEEQ("PCMU", send_codec_spec.format.name.c_str());
EXPECT_EQ(absl::nullopt, send_codec_spec.cng_payload_type);
}
}
// Test we can SetSend on all send streams correctly.
TEST_P(WebRtcVoiceEngineTestFake, SetSendWithMultipleSendStreams) {
SetupForMultiSendStream();
// Create the send channels and they should be a "not sending" date.
for (uint32_t ssrc : kSsrcs4) {
EXPECT_TRUE(send_channel_->AddSendStream(
cricket::StreamParams::CreateLegacy(ssrc)));
SetAudioSend(ssrc, true, &fake_source_);
EXPECT_FALSE(GetSendStream(ssrc).IsSending());
}
// Set the global state for starting sending.
SetSend(true);
for (uint32_t ssrc : kSsrcs4) {
// Verify that we are in a sending state for all the send streams.
EXPECT_TRUE(GetSendStream(ssrc).IsSending());
}
// Set the global state for stopping sending.
SetSend(false);
for (uint32_t ssrc : kSsrcs4) {
// Verify that we are in a stop state for all the send streams.
EXPECT_FALSE(GetSendStream(ssrc).IsSending());
}
}
// Test we can set the correct statistics on all send streams.
TEST_P(WebRtcVoiceEngineTestFake, GetStatsWithMultipleSendStreams) {
SetupForMultiSendStream();
// Create send streams.
for (uint32_t ssrc : kSsrcs4) {
EXPECT_TRUE(send_channel_->AddSendStream(
cricket::StreamParams::CreateLegacy(ssrc)));
}
// Create a receive stream to check that none of the send streams end up in
// the receive stream stats.
EXPECT_TRUE(AddRecvStream(kSsrcY));
// We need send codec to be set to get all stats.
SetSenderParameters(send_parameters_);
EXPECT_TRUE(receive_channel_->SetReceiverParameters(recv_parameters_));
SetAudioSendStreamStats();
SetAudioReceiveStreamStats();
// Check stats for the added streams.
{
EXPECT_CALL(*adm_, GetPlayoutUnderrunCount()).WillOnce(Return(0));
cricket::VoiceMediaSendInfo send_info;
cricket::VoiceMediaReceiveInfo receive_info;
EXPECT_EQ(true, send_channel_->GetStats(&send_info));
EXPECT_EQ(true, receive_channel_->GetStats(
&receive_info, /*get_and_clear_legacy_stats=*/true));
// We have added 4 send streams. We should see empty stats for all.
EXPECT_EQ(static_cast<size_t>(arraysize(kSsrcs4)),
send_info.senders.size());
for (const auto& sender : send_info.senders) {
VerifyVoiceSenderInfo(sender, false);
}
VerifyVoiceSendRecvCodecs(send_info, receive_info);
// We have added one receive stream. We should see empty stats.
EXPECT_EQ(receive_info.receivers.size(), 1u);
EXPECT_EQ(receive_info.receivers[0].ssrc(), 123u);
}
// Remove the kSsrcY stream. No receiver stats.
{
cricket::VoiceMediaReceiveInfo receive_info;
cricket::VoiceMediaSendInfo send_info;
EXPECT_TRUE(receive_channel_->RemoveRecvStream(kSsrcY));
EXPECT_CALL(*adm_, GetPlayoutUnderrunCount()).WillOnce(Return(0));
EXPECT_EQ(true, send_channel_->GetStats(&send_info));
EXPECT_EQ(true, receive_channel_->GetStats(
&receive_info, /*get_and_clear_legacy_stats=*/true));
EXPECT_EQ(static_cast<size_t>(arraysize(kSsrcs4)),
send_info.senders.size());
EXPECT_EQ(0u, receive_info.receivers.size());
}
// Deliver a new packet - a default receive stream should be created and we
// should see stats again.
{
cricket::VoiceMediaSendInfo send_info;
cricket::VoiceMediaReceiveInfo receive_info;
DeliverPacket(kPcmuFrame, sizeof(kPcmuFrame));
SetAudioReceiveStreamStats();
EXPECT_CALL(*adm_, GetPlayoutUnderrunCount()).WillOnce(Return(0));
EXPECT_EQ(true, send_channel_->GetStats(&send_info));
EXPECT_EQ(true, receive_channel_->GetStats(
&receive_info, /*get_and_clear_legacy_stats=*/true));
EXPECT_EQ(static_cast<size_t>(arraysize(kSsrcs4)),
send_info.senders.size());
EXPECT_EQ(1u, receive_info.receivers.size());
VerifyVoiceReceiverInfo(receive_info.receivers[0]);
VerifyVoiceSendRecvCodecs(send_info, receive_info);
}
}
// 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_P(WebRtcVoiceEngineTestFake, PlayoutWithMultipleStreams) {
EXPECT_TRUE(SetupSendStream());
// Start playout without a receive stream.
SetSenderParameters(send_parameters_);
receive_channel_->SetPlayout(true);
// Adding another stream should enable playout on the new stream only.
EXPECT_TRUE(AddRecvStream(kSsrcY));
SetSend(true);
EXPECT_TRUE(GetSendStream(kSsrcX).IsSending());
// Make sure only the new stream is played out.
EXPECT_TRUE(GetRecvStream(kSsrcY).started());
// Adding yet another stream should have stream 2 and 3 enabled for playout.
EXPECT_TRUE(AddRecvStream(kSsrcZ));
EXPECT_TRUE(GetRecvStream(kSsrcY).started());
EXPECT_TRUE(GetRecvStream(kSsrcZ).started());
// Stop sending.
SetSend(false);
EXPECT_FALSE(GetSendStream(kSsrcX).IsSending());
// Stop playout.
receive_channel_->SetPlayout(false);
EXPECT_FALSE(GetRecvStream(kSsrcY).started());
EXPECT_FALSE(GetRecvStream(kSsrcZ).started());
// Restart playout and make sure recv streams are played out.
receive_channel_->SetPlayout(true);
EXPECT_TRUE(GetRecvStream(kSsrcY).started());
EXPECT_TRUE(GetRecvStream(kSsrcZ).started());
// Now remove the recv streams.
EXPECT_TRUE(receive_channel_->RemoveRecvStream(kSsrcZ));
EXPECT_TRUE(receive_channel_->RemoveRecvStream(kSsrcY));
}
TEST_P(WebRtcVoiceEngineTestFake, SetAudioNetworkAdaptorViaOptions) {
EXPECT_TRUE(SetupSendStream());
send_parameters_.options.audio_network_adaptor = true;
send_parameters_.options.audio_network_adaptor_config = {"1234"};
SetSenderParameters(send_parameters_);
EXPECT_EQ(send_parameters_.options.audio_network_adaptor_config,
GetAudioNetworkAdaptorConfig(kSsrcX));
}
TEST_P(WebRtcVoiceEngineTestFake, AudioSendResetAudioNetworkAdaptor) {
EXPECT_TRUE(SetupSendStream());
send_parameters_.options.audio_network_adaptor = true;
send_parameters_.options.audio_network_adaptor_config = {"1234"};
SetSenderParameters(send_parameters_);
EXPECT_EQ(send_parameters_.options.audio_network_adaptor_config,
GetAudioNetworkAdaptorConfig(kSsrcX));
cricket::AudioOptions options;
options.audio_network_adaptor = false;
SetAudioSend(kSsrcX, true, nullptr, &options);
EXPECT_EQ(absl::nullopt, GetAudioNetworkAdaptorConfig(kSsrcX));
}
TEST_P(WebRtcVoiceEngineTestFake, AudioNetworkAdaptorNotGetOverridden) {
EXPECT_TRUE(SetupSendStream());
send_parameters_.options.audio_network_adaptor = true;
send_parameters_.options.audio_network_adaptor_config = {"1234"};
SetSenderParameters(send_parameters_);
EXPECT_EQ(send_parameters_.options.audio_network_adaptor_config,
GetAudioNetworkAdaptorConfig(kSsrcX));
const int initial_num = call_.GetNumCreatedSendStreams();
cricket::AudioOptions options;
options.audio_network_adaptor = absl::nullopt;
// Unvalued `options.audio_network_adaptor` should not reset audio network
// adaptor.
SetAudioSend(kSsrcX, true, nullptr, &options);
// AudioSendStream not expected to be recreated.
EXPECT_EQ(initial_num, call_.GetNumCreatedSendStreams());
EXPECT_EQ(send_parameters_.options.audio_network_adaptor_config,
GetAudioNetworkAdaptorConfig(kSsrcX));
}
// Test that we can set the outgoing SSRC properly.
// SSRC is set in SetupSendStream() by calling AddSendStream.
TEST_P(WebRtcVoiceEngineTestFake, SetSendSsrc) {
EXPECT_TRUE(SetupSendStream());
EXPECT_TRUE(call_.GetAudioSendStream(kSsrcX));
}
TEST_P(WebRtcVoiceEngineTestFake, GetStats) {
// Setup. We need send codec to be set to get all stats.
EXPECT_TRUE(SetupSendStream());
// SetupSendStream adds a send stream with kSsrcX, so the receive
// stream has to use a different SSRC.
EXPECT_TRUE(AddRecvStream(kSsrcY));
SetSenderParameters(send_parameters_);
EXPECT_TRUE(receive_channel_->SetReceiverParameters(recv_parameters_));
SetAudioSendStreamStats();
// Check stats for the added streams.
{
EXPECT_CALL(*adm_, GetPlayoutUnderrunCount()).WillOnce(Return(0));
cricket::VoiceMediaSendInfo send_info;
cricket::VoiceMediaReceiveInfo receive_info;
EXPECT_EQ(true, send_channel_->GetStats(&send_info));
EXPECT_EQ(true, receive_channel_->GetStats(
&receive_info, /*get_and_clear_legacy_stats=*/true));
// We have added one send stream. We should see the stats we've set.
EXPECT_EQ(1u, send_info.senders.size());
VerifyVoiceSenderInfo(send_info.senders[0], false);
// We have added one receive stream. We should see empty stats.
EXPECT_EQ(receive_info.receivers.size(), 1u);
EXPECT_EQ(receive_info.receivers[0].ssrc(), 0u);
}
// Start sending - this affects some reported stats.
{
SetSend(true);
EXPECT_CALL(*adm_, GetPlayoutUnderrunCount()).WillOnce(Return(0));
cricket::VoiceMediaSendInfo send_info;
cricket::VoiceMediaReceiveInfo receive_info;
SetAudioReceiveStreamStats();
EXPECT_EQ(true, send_channel_->GetStats(&send_info));
EXPECT_EQ(true, receive_channel_->GetStats(
&receive_info, /*get_and_clear_legacy_stats=*/true));
VerifyVoiceSenderInfo(send_info.senders[0], true);
VerifyVoiceSendRecvCodecs(send_info, receive_info);
}
// Remove the kSsrcY stream. No receiver stats.
{
EXPECT_TRUE(receive_channel_->RemoveRecvStream(kSsrcY));
EXPECT_CALL(*adm_, GetPlayoutUnderrunCount()).WillOnce(Return(0));
cricket::VoiceMediaSendInfo send_info;
cricket::VoiceMediaReceiveInfo receive_info;
EXPECT_EQ(true, send_channel_->GetStats(&send_info));
EXPECT_EQ(true, receive_channel_->GetStats(
&receive_info, /*get_and_clear_legacy_stats=*/true));
EXPECT_EQ(1u, send_info.senders.size());
EXPECT_EQ(0u, receive_info.receivers.size());
}
// Deliver a new packet - a default receive stream should be created and we
// should see stats again.
{
DeliverPacket(kPcmuFrame, sizeof(kPcmuFrame));
SetAudioReceiveStreamStats();
EXPECT_CALL(*adm_, GetPlayoutUnderrunCount()).WillOnce(Return(0));
cricket::VoiceMediaSendInfo send_info;
cricket::VoiceMediaReceiveInfo receive_info;
EXPECT_EQ(true, send_channel_->GetStats(&send_info));
EXPECT_EQ(true, receive_channel_->GetStats(
&receive_info, /*get_and_clear_legacy_stats=*/true));
EXPECT_EQ(1u, send_info.senders.size());
EXPECT_EQ(1u, receive_info.receivers.size());
VerifyVoiceReceiverInfo(receive_info.receivers[0]);
VerifyVoiceSendRecvCodecs(send_info, receive_info);
}
}
// Test that we can set the outgoing SSRC properly with multiple streams.
// SSRC is set in SetupSendStream() by calling AddSendStream.
TEST_P(WebRtcVoiceEngineTestFake, SetSendSsrcWithMultipleStreams) {
EXPECT_TRUE(SetupSendStream());
EXPECT_TRUE(call_.GetAudioSendStream(kSsrcX));
EXPECT_TRUE(AddRecvStream(kSsrcY));
EXPECT_EQ(kSsrcX, GetRecvStreamConfig(kSsrcY).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_P(WebRtcVoiceEngineTestFake, SetSendSsrcAfterCreatingReceiveChannel) {
EXPECT_TRUE(SetupChannel());
EXPECT_TRUE(AddRecvStream(kSsrcY));
EXPECT_TRUE(send_channel_->AddSendStream(
cricket::StreamParams::CreateLegacy(kSsrcX)));
EXPECT_TRUE(call_.GetAudioSendStream(kSsrcX));
EXPECT_EQ(kSsrcX, GetRecvStreamConfig(kSsrcY).rtp.local_ssrc);
}
// Test that we can properly receive packets.
TEST_P(WebRtcVoiceEngineTestFake, Recv) {
EXPECT_TRUE(SetupChannel());
EXPECT_TRUE(AddRecvStream(1));
DeliverPacket(kPcmuFrame, sizeof(kPcmuFrame));
EXPECT_TRUE(
GetRecvStream(1).VerifyLastPacket(kPcmuFrame, sizeof(kPcmuFrame)));
}
// Test that we can properly receive packets on multiple streams.
TEST_P(WebRtcVoiceEngineTestFake, RecvWithMultipleStreams) {
EXPECT_TRUE(SetupChannel());
const uint32_t ssrc1 = 1;
const uint32_t ssrc2 = 2;
const uint32_t ssrc3 = 3;
EXPECT_TRUE(AddRecvStream(ssrc1));
EXPECT_TRUE(AddRecvStream(ssrc2));
EXPECT_TRUE(AddRecvStream(ssrc3));
// Create packets with the right SSRCs.
unsigned 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));
}
const cricket::FakeAudioReceiveStream& s1 = GetRecvStream(ssrc1);
const cricket::FakeAudioReceiveStream& s2 = GetRecvStream(ssrc2);
const cricket::FakeAudioReceiveStream& s3 = GetRecvStream(ssrc3);
EXPECT_EQ(s1.received_packets(), 0);
EXPECT_EQ(s2.received_packets(), 0);
EXPECT_EQ(s3.received_packets(), 0);
DeliverPacket(packets[0], sizeof(packets[0]));
EXPECT_EQ(s1.received_packets(), 0);
EXPECT_EQ(s2.received_packets(), 0);
EXPECT_EQ(s3.received_packets(), 0);
DeliverPacket(packets[1], sizeof(packets[1]));
EXPECT_EQ(s1.received_packets(), 1);
EXPECT_TRUE(s1.VerifyLastPacket(packets[1], sizeof(packets[1])));
EXPECT_EQ(s2.received_packets(), 0);
EXPECT_EQ(s3.received_packets(), 0);
DeliverPacket(packets[2], sizeof(packets[2]));
EXPECT_EQ(s1.received_packets(), 1);
EXPECT_EQ(s2.received_packets(), 1);
EXPECT_TRUE(s2.VerifyLastPacket(packets[2], sizeof(packets[2])));
EXPECT_EQ(s3.received_packets(), 0);
DeliverPacket(packets[3], sizeof(packets[3]));
EXPECT_EQ(s1.received_packets(), 1);
EXPECT_EQ(s2.received_packets(), 1);
EXPECT_EQ(s3.received_packets(), 1);
EXPECT_TRUE(s3.VerifyLastPacket(packets[3], sizeof(packets[3])));
EXPECT_TRUE(receive_channel_->RemoveRecvStream(ssrc3));
EXPECT_TRUE(receive_channel_->RemoveRecvStream(ssrc2));
EXPECT_TRUE(receive_channel_->RemoveRecvStream(ssrc1));
}
// Test that receiving on an unsignaled stream works (a stream is created).
TEST_P(WebRtcVoiceEngineTestFake, RecvUnsignaled) {
EXPECT_TRUE(SetupChannel());
EXPECT_EQ(0u, call_.GetAudioReceiveStreams().size());
DeliverPacket(kPcmuFrame, sizeof(kPcmuFrame));
EXPECT_EQ(1u, call_.GetAudioReceiveStreams().size());
EXPECT_TRUE(
GetRecvStream(kSsrc1).VerifyLastPacket(kPcmuFrame, sizeof(kPcmuFrame)));
}
// Tests that when we add a stream without SSRCs, but contains a stream_id
// that it is stored and its stream id is later used when the first packet
// arrives to properly create a receive stream with a sync label.
TEST_P(WebRtcVoiceEngineTestFake, RecvUnsignaledSsrcWithSignaledStreamId) {
const char kSyncLabel[] = "sync_label";
EXPECT_TRUE(SetupChannel());
cricket::StreamParams unsignaled_stream;
unsignaled_stream.set_stream_ids({kSyncLabel});
ASSERT_TRUE(receive_channel_->AddRecvStream(unsignaled_stream));
// The stream shouldn't have been created at this point because it doesn't
// have any SSRCs.
EXPECT_EQ(0u, call_.GetAudioReceiveStreams().size());
DeliverPacket(kPcmuFrame, sizeof(kPcmuFrame));
EXPECT_EQ(1u, call_.GetAudioReceiveStreams().size());
EXPECT_TRUE(
GetRecvStream(kSsrc1).VerifyLastPacket(kPcmuFrame, sizeof(kPcmuFrame)));
EXPECT_EQ(kSyncLabel, GetRecvStream(kSsrc1).GetConfig().sync_group);