dd31071e19
All audio in calls is now routed through AudioTransportProxy. The AudioTransport implemented by VoEBaseImpl is disconnected from AudioDevice and replaced by an empty proxy layer that forwards calls to the old Transport. This is a refactoring CL in preparation for landing https://codereview.webrtc.org/2436033002/, which will connect the new AudioMixer. In the planned configuration, the currently empty AudioTransportProxy will query the new mixer for audio instead of polling data from the old Transport. Mixed audio will be passed to an AudioProcessing interface. AudioTransportProxy is initialized with an AudioProcessing*, which is currently unused. No presubmit since we implement an interface with non-const references. NOPRESUBMIT=True BUG=webrtc:6346 Review-Url: https://codereview.webrtc.org/2454373002 Cr-Commit-Position: refs/heads/master@{#15133}
403 lines
17 KiB
C++
403 lines
17 KiB
C++
/*
|
|
* Copyright (c) 2015 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 <string>
|
|
#include <vector>
|
|
|
|
#include "webrtc/audio/audio_send_stream.h"
|
|
#include "webrtc/audio/audio_state.h"
|
|
#include "webrtc/audio/conversion.h"
|
|
#include "webrtc/base/task_queue.h"
|
|
#include "webrtc/logging/rtc_event_log/mock/mock_rtc_event_log.h"
|
|
#include "webrtc/modules/audio_processing/include/mock_audio_processing.h"
|
|
#include "webrtc/modules/congestion_controller/include/congestion_controller.h"
|
|
#include "webrtc/modules/congestion_controller/include/mock/mock_congestion_controller.h"
|
|
#include "webrtc/modules/pacing/paced_sender.h"
|
|
#include "webrtc/modules/remote_bitrate_estimator/include/mock/mock_remote_bitrate_estimator.h"
|
|
#include "webrtc/test/gtest.h"
|
|
#include "webrtc/test/mock_voe_channel_proxy.h"
|
|
#include "webrtc/test/mock_voice_engine.h"
|
|
|
|
namespace webrtc {
|
|
namespace test {
|
|
namespace {
|
|
|
|
using testing::_;
|
|
using testing::Return;
|
|
|
|
const int kChannelId = 1;
|
|
const uint32_t kSsrc = 1234;
|
|
const char* kCName = "foo_name";
|
|
const int kAudioLevelId = 2;
|
|
const int kTransportSequenceNumberId = 4;
|
|
const int kEchoDelayMedian = 254;
|
|
const int kEchoDelayStdDev = -3;
|
|
const int kEchoReturnLoss = -65;
|
|
const int kEchoReturnLossEnhancement = 101;
|
|
const float kResidualEchoLikelihood = -1.0f;
|
|
const unsigned int kSpeechInputLevel = 96;
|
|
const CallStatistics kCallStats = {
|
|
1345, 1678, 1901, 1234, 112, 13456, 17890, 1567, -1890, -1123};
|
|
const ReportBlock kReportBlock = {456, 780, 123, 567, 890, 132, 143, 13354};
|
|
const int kTelephoneEventPayloadType = 123;
|
|
const int kTelephoneEventPayloadFrequency = 65432;
|
|
const int kTelephoneEventCode = 45;
|
|
const int kTelephoneEventDuration = 6789;
|
|
const CodecInst kIsacCodec = {103, "isac", 16000, 320, 1, 32000};
|
|
|
|
class MockLimitObserver : public BitrateAllocator::LimitObserver {
|
|
public:
|
|
MOCK_METHOD2(OnAllocationLimitsChanged,
|
|
void(uint32_t min_send_bitrate_bps,
|
|
uint32_t max_padding_bitrate_bps));
|
|
};
|
|
|
|
struct ConfigHelper {
|
|
ConfigHelper()
|
|
: simulated_clock_(123456),
|
|
stream_config_(nullptr),
|
|
congestion_controller_(&simulated_clock_,
|
|
&bitrate_observer_,
|
|
&remote_bitrate_observer_,
|
|
&event_log_),
|
|
bitrate_allocator_(&limit_observer_),
|
|
worker_queue_("ConfigHelper_worker_queue") {
|
|
using testing::Invoke;
|
|
|
|
EXPECT_CALL(voice_engine_,
|
|
RegisterVoiceEngineObserver(_)).WillOnce(Return(0));
|
|
EXPECT_CALL(voice_engine_,
|
|
DeRegisterVoiceEngineObserver()).WillOnce(Return(0));
|
|
EXPECT_CALL(voice_engine_, audio_device_module());
|
|
EXPECT_CALL(voice_engine_, audio_processing());
|
|
EXPECT_CALL(voice_engine_, audio_transport());
|
|
|
|
AudioState::Config config;
|
|
config.voice_engine = &voice_engine_;
|
|
audio_state_ = AudioState::Create(config);
|
|
|
|
SetupDefaultChannelProxy();
|
|
|
|
EXPECT_CALL(voice_engine_, ChannelProxyFactory(kChannelId))
|
|
.WillOnce(Invoke([this](int channel_id) {
|
|
return channel_proxy_;
|
|
}));
|
|
|
|
SetupMockForSetupSendCodec();
|
|
|
|
stream_config_.voe_channel_id = kChannelId;
|
|
stream_config_.rtp.ssrc = kSsrc;
|
|
stream_config_.rtp.nack.rtp_history_ms = 200;
|
|
stream_config_.rtp.c_name = kCName;
|
|
stream_config_.rtp.extensions.push_back(
|
|
RtpExtension(RtpExtension::kAudioLevelUri, kAudioLevelId));
|
|
stream_config_.rtp.extensions.push_back(RtpExtension(
|
|
RtpExtension::kTransportSequenceNumberUri, kTransportSequenceNumberId));
|
|
// Use ISAC as default codec so as to prevent unnecessary |voice_engine_|
|
|
// calls from the default ctor behavior.
|
|
stream_config_.send_codec_spec.codec_inst = kIsacCodec;
|
|
}
|
|
|
|
AudioSendStream::Config& config() { return stream_config_; }
|
|
rtc::scoped_refptr<AudioState> audio_state() { return audio_state_; }
|
|
MockVoEChannelProxy* channel_proxy() { return channel_proxy_; }
|
|
CongestionController* congestion_controller() {
|
|
return &congestion_controller_;
|
|
}
|
|
BitrateAllocator* bitrate_allocator() { return &bitrate_allocator_; }
|
|
rtc::TaskQueue* worker_queue() { return &worker_queue_; }
|
|
RtcEventLog* event_log() { return &event_log_; }
|
|
MockVoiceEngine* voice_engine() { return &voice_engine_; }
|
|
|
|
void SetupDefaultChannelProxy() {
|
|
using testing::StrEq;
|
|
channel_proxy_ = new testing::StrictMock<MockVoEChannelProxy>();
|
|
EXPECT_CALL(*channel_proxy_, SetRTCPStatus(true)).Times(1);
|
|
EXPECT_CALL(*channel_proxy_, SetLocalSSRC(kSsrc)).Times(1);
|
|
EXPECT_CALL(*channel_proxy_, SetRTCP_CNAME(StrEq(kCName))).Times(1);
|
|
EXPECT_CALL(*channel_proxy_, SetNACKStatus(true, 10)).Times(1);
|
|
EXPECT_CALL(*channel_proxy_,
|
|
SetSendAudioLevelIndicationStatus(true, kAudioLevelId))
|
|
.Times(1);
|
|
EXPECT_CALL(*channel_proxy_,
|
|
EnableSendTransportSequenceNumber(kTransportSequenceNumberId))
|
|
.Times(1);
|
|
EXPECT_CALL(*channel_proxy_,
|
|
RegisterSenderCongestionControlObjects(
|
|
congestion_controller_.pacer(),
|
|
congestion_controller_.GetTransportFeedbackObserver(),
|
|
congestion_controller_.packet_router()))
|
|
.Times(1);
|
|
EXPECT_CALL(*channel_proxy_, ResetCongestionControlObjects()).Times(1);
|
|
EXPECT_CALL(*channel_proxy_, RegisterExternalTransport(nullptr)).Times(1);
|
|
EXPECT_CALL(*channel_proxy_, DeRegisterExternalTransport()).Times(1);
|
|
EXPECT_CALL(*channel_proxy_, SetRtcEventLog(testing::NotNull())).Times(1);
|
|
EXPECT_CALL(*channel_proxy_, SetRtcEventLog(testing::IsNull()))
|
|
.Times(1); // Destructor resets the event log
|
|
}
|
|
|
|
void SetupMockForSetupSendCodec() {
|
|
EXPECT_CALL(voice_engine_, SetVADStatus(kChannelId, false, _, _))
|
|
.WillOnce(Return(0));
|
|
EXPECT_CALL(voice_engine_, SetFECStatus(kChannelId, false))
|
|
.WillOnce(Return(0));
|
|
EXPECT_CALL(*channel_proxy_, DisableAudioNetworkAdaptor());
|
|
// Let |GetSendCodec| return -1 for the first time to indicate that no send
|
|
// codec has been set.
|
|
EXPECT_CALL(voice_engine_, GetSendCodec(kChannelId, _))
|
|
.WillOnce(Return(-1));
|
|
EXPECT_CALL(voice_engine_, SetSendCodec(kChannelId, _)).WillOnce(Return(0));
|
|
}
|
|
|
|
void SetupMockForSendTelephoneEvent() {
|
|
EXPECT_TRUE(channel_proxy_);
|
|
EXPECT_CALL(*channel_proxy_,
|
|
SetSendTelephoneEventPayloadType(kTelephoneEventPayloadType,
|
|
kTelephoneEventPayloadFrequency))
|
|
.WillOnce(Return(true));
|
|
EXPECT_CALL(*channel_proxy_,
|
|
SendTelephoneEventOutband(kTelephoneEventCode, kTelephoneEventDuration))
|
|
.WillOnce(Return(true));
|
|
}
|
|
|
|
void SetupMockForGetStats() {
|
|
using testing::DoAll;
|
|
using testing::SetArgReferee;
|
|
|
|
std::vector<ReportBlock> report_blocks;
|
|
webrtc::ReportBlock block = kReportBlock;
|
|
report_blocks.push_back(block); // Has wrong SSRC.
|
|
block.source_SSRC = kSsrc;
|
|
report_blocks.push_back(block); // Correct block.
|
|
block.fraction_lost = 0;
|
|
report_blocks.push_back(block); // Duplicate SSRC, bad fraction_lost.
|
|
|
|
EXPECT_TRUE(channel_proxy_);
|
|
EXPECT_CALL(*channel_proxy_, GetRTCPStatistics())
|
|
.WillRepeatedly(Return(kCallStats));
|
|
EXPECT_CALL(*channel_proxy_, GetRemoteRTCPReportBlocks())
|
|
.WillRepeatedly(Return(report_blocks));
|
|
|
|
EXPECT_CALL(voice_engine_, GetSendCodec(kChannelId, _))
|
|
.WillRepeatedly(DoAll(SetArgReferee<1>(kIsacCodec), Return(0)));
|
|
EXPECT_CALL(voice_engine_, GetSpeechInputLevelFullRange(_))
|
|
.WillRepeatedly(DoAll(SetArgReferee<0>(kSpeechInputLevel), Return(0)));
|
|
EXPECT_CALL(voice_engine_, audio_processing())
|
|
.WillRepeatedly(Return(&audio_processing_));
|
|
|
|
// We have to set the instantaneous value, the average, min and max. We only
|
|
// care about the instantaneous value, so we set all to the same value.
|
|
audio_processing_stats_.echo_return_loss.Set(
|
|
kEchoReturnLoss, kEchoReturnLoss, kEchoReturnLoss, kEchoReturnLoss);
|
|
audio_processing_stats_.echo_return_loss_enhancement.Set(
|
|
kEchoReturnLossEnhancement, kEchoReturnLossEnhancement,
|
|
kEchoReturnLossEnhancement, kEchoReturnLossEnhancement);
|
|
audio_processing_stats_.delay_median = kEchoDelayMedian;
|
|
audio_processing_stats_.delay_standard_deviation = kEchoDelayStdDev;
|
|
|
|
EXPECT_CALL(audio_processing_, GetStatistics())
|
|
.WillRepeatedly(Return(audio_processing_stats_));
|
|
}
|
|
|
|
private:
|
|
SimulatedClock simulated_clock_;
|
|
testing::StrictMock<MockVoiceEngine> voice_engine_;
|
|
rtc::scoped_refptr<AudioState> audio_state_;
|
|
AudioSendStream::Config stream_config_;
|
|
testing::StrictMock<MockVoEChannelProxy>* channel_proxy_ = nullptr;
|
|
testing::NiceMock<MockCongestionObserver> bitrate_observer_;
|
|
testing::NiceMock<MockRemoteBitrateObserver> remote_bitrate_observer_;
|
|
MockAudioProcessing audio_processing_;
|
|
AudioProcessing::AudioProcessingStatistics audio_processing_stats_;
|
|
CongestionController congestion_controller_;
|
|
MockRtcEventLog event_log_;
|
|
testing::NiceMock<MockLimitObserver> limit_observer_;
|
|
BitrateAllocator bitrate_allocator_;
|
|
// |worker_queue| is defined last to ensure all pending tasks are cancelled
|
|
// and deleted before any other members.
|
|
rtc::TaskQueue worker_queue_;
|
|
};
|
|
} // namespace
|
|
|
|
TEST(AudioSendStreamTest, ConfigToString) {
|
|
AudioSendStream::Config config(nullptr);
|
|
config.rtp.ssrc = kSsrc;
|
|
config.rtp.c_name = kCName;
|
|
config.voe_channel_id = kChannelId;
|
|
config.min_bitrate_bps = 12000;
|
|
config.max_bitrate_bps = 34000;
|
|
config.send_codec_spec.nack_enabled = true;
|
|
config.send_codec_spec.transport_cc_enabled = false;
|
|
config.send_codec_spec.enable_codec_fec = true;
|
|
config.send_codec_spec.enable_opus_dtx = false;
|
|
config.send_codec_spec.opus_max_playback_rate = 32000;
|
|
config.send_codec_spec.cng_payload_type = 42;
|
|
config.send_codec_spec.cng_plfreq = 56;
|
|
config.send_codec_spec.min_ptime_ms = 20;
|
|
config.send_codec_spec.max_ptime_ms = 60;
|
|
config.send_codec_spec.codec_inst = kIsacCodec;
|
|
config.rtp.extensions.push_back(
|
|
RtpExtension(RtpExtension::kAudioLevelUri, kAudioLevelId));
|
|
EXPECT_EQ(
|
|
"{rtp: {ssrc: 1234, extensions: [{uri: "
|
|
"urn:ietf:params:rtp-hdrext:ssrc-audio-level, id: 2}], nack: "
|
|
"{rtp_history_ms: 0}, c_name: foo_name}, send_transport: nullptr, "
|
|
"voe_channel_id: 1, min_bitrate_bps: 12000, max_bitrate_bps: 34000, "
|
|
"send_codec_spec: {nack_enabled: true, transport_cc_enabled: false, "
|
|
"enable_codec_fec: true, enable_opus_dtx: false, opus_max_playback_rate: "
|
|
"32000, cng_payload_type: 42, cng_plfreq: 56, min_ptime: 20, max_ptime: "
|
|
"60, codec_inst: {pltype: 103, plname: \"isac\", plfreq: 16000, pacsize: "
|
|
"320, channels: 1, rate: 32000}}}",
|
|
config.ToString());
|
|
}
|
|
|
|
TEST(AudioSendStreamTest, ConstructDestruct) {
|
|
ConfigHelper helper;
|
|
internal::AudioSendStream send_stream(
|
|
helper.config(), helper.audio_state(), helper.worker_queue(),
|
|
helper.congestion_controller(), helper.bitrate_allocator(),
|
|
helper.event_log());
|
|
}
|
|
|
|
TEST(AudioSendStreamTest, SendTelephoneEvent) {
|
|
ConfigHelper helper;
|
|
internal::AudioSendStream send_stream(
|
|
helper.config(), helper.audio_state(), helper.worker_queue(),
|
|
helper.congestion_controller(), helper.bitrate_allocator(),
|
|
helper.event_log());
|
|
helper.SetupMockForSendTelephoneEvent();
|
|
EXPECT_TRUE(send_stream.SendTelephoneEvent(kTelephoneEventPayloadType,
|
|
kTelephoneEventPayloadFrequency, kTelephoneEventCode,
|
|
kTelephoneEventDuration));
|
|
}
|
|
|
|
TEST(AudioSendStreamTest, SetMuted) {
|
|
ConfigHelper helper;
|
|
internal::AudioSendStream send_stream(
|
|
helper.config(), helper.audio_state(), helper.worker_queue(),
|
|
helper.congestion_controller(), helper.bitrate_allocator(),
|
|
helper.event_log());
|
|
EXPECT_CALL(*helper.channel_proxy(), SetInputMute(true));
|
|
send_stream.SetMuted(true);
|
|
}
|
|
|
|
TEST(AudioSendStreamTest, GetStats) {
|
|
ConfigHelper helper;
|
|
internal::AudioSendStream send_stream(
|
|
helper.config(), helper.audio_state(), helper.worker_queue(),
|
|
helper.congestion_controller(), helper.bitrate_allocator(),
|
|
helper.event_log());
|
|
helper.SetupMockForGetStats();
|
|
AudioSendStream::Stats stats = send_stream.GetStats();
|
|
EXPECT_EQ(kSsrc, stats.local_ssrc);
|
|
EXPECT_EQ(static_cast<int64_t>(kCallStats.bytesSent), stats.bytes_sent);
|
|
EXPECT_EQ(kCallStats.packetsSent, stats.packets_sent);
|
|
EXPECT_EQ(static_cast<int32_t>(kReportBlock.cumulative_num_packets_lost),
|
|
stats.packets_lost);
|
|
EXPECT_EQ(Q8ToFloat(kReportBlock.fraction_lost), stats.fraction_lost);
|
|
EXPECT_EQ(std::string(kIsacCodec.plname), stats.codec_name);
|
|
EXPECT_EQ(static_cast<int32_t>(kReportBlock.extended_highest_sequence_number),
|
|
stats.ext_seqnum);
|
|
EXPECT_EQ(static_cast<int32_t>(kReportBlock.interarrival_jitter /
|
|
(kIsacCodec.plfreq / 1000)),
|
|
stats.jitter_ms);
|
|
EXPECT_EQ(kCallStats.rttMs, stats.rtt_ms);
|
|
EXPECT_EQ(static_cast<int32_t>(kSpeechInputLevel), stats.audio_level);
|
|
EXPECT_EQ(-1, stats.aec_quality_min);
|
|
EXPECT_EQ(kEchoDelayMedian, stats.echo_delay_median_ms);
|
|
EXPECT_EQ(kEchoDelayStdDev, stats.echo_delay_std_ms);
|
|
EXPECT_EQ(kEchoReturnLoss, stats.echo_return_loss);
|
|
EXPECT_EQ(kEchoReturnLossEnhancement, stats.echo_return_loss_enhancement);
|
|
EXPECT_EQ(kResidualEchoLikelihood, stats.residual_echo_likelihood);
|
|
EXPECT_FALSE(stats.typing_noise_detected);
|
|
}
|
|
|
|
TEST(AudioSendStreamTest, GetStatsTypingNoiseDetected) {
|
|
ConfigHelper helper;
|
|
internal::AudioSendStream send_stream(
|
|
helper.config(), helper.audio_state(), helper.worker_queue(),
|
|
helper.congestion_controller(), helper.bitrate_allocator(),
|
|
helper.event_log());
|
|
helper.SetupMockForGetStats();
|
|
EXPECT_FALSE(send_stream.GetStats().typing_noise_detected);
|
|
|
|
internal::AudioState* internal_audio_state =
|
|
static_cast<internal::AudioState*>(helper.audio_state().get());
|
|
VoiceEngineObserver* voe_observer =
|
|
static_cast<VoiceEngineObserver*>(internal_audio_state);
|
|
voe_observer->CallbackOnError(-1, VE_TYPING_NOISE_WARNING);
|
|
EXPECT_TRUE(send_stream.GetStats().typing_noise_detected);
|
|
voe_observer->CallbackOnError(-1, VE_TYPING_NOISE_OFF_WARNING);
|
|
EXPECT_FALSE(send_stream.GetStats().typing_noise_detected);
|
|
}
|
|
|
|
TEST(AudioSendStreamTest, SendCodecAppliesConfigParams) {
|
|
ConfigHelper helper;
|
|
auto stream_config = helper.config();
|
|
const CodecInst kOpusCodec = {111, "opus", 48000, 960, 2, 64000};
|
|
stream_config.send_codec_spec.codec_inst = kOpusCodec;
|
|
stream_config.send_codec_spec.enable_codec_fec = true;
|
|
stream_config.send_codec_spec.enable_opus_dtx = true;
|
|
stream_config.send_codec_spec.opus_max_playback_rate = 12345;
|
|
stream_config.send_codec_spec.cng_plfreq = 16000;
|
|
stream_config.send_codec_spec.cng_payload_type = 105;
|
|
stream_config.send_codec_spec.min_ptime_ms = 10;
|
|
stream_config.send_codec_spec.max_ptime_ms = 60;
|
|
stream_config.audio_network_adaptor_config =
|
|
rtc::Optional<std::string>("abced");
|
|
EXPECT_CALL(*helper.voice_engine(), SetFECStatus(kChannelId, true))
|
|
.WillOnce(Return(0));
|
|
EXPECT_CALL(
|
|
*helper.voice_engine(),
|
|
SetOpusDtx(kChannelId, stream_config.send_codec_spec.enable_opus_dtx))
|
|
.WillOnce(Return(0));
|
|
EXPECT_CALL(
|
|
*helper.voice_engine(),
|
|
SetOpusMaxPlaybackRate(
|
|
kChannelId, stream_config.send_codec_spec.opus_max_playback_rate))
|
|
.WillOnce(Return(0));
|
|
EXPECT_CALL(*helper.voice_engine(),
|
|
SetSendCNPayloadType(
|
|
kChannelId, stream_config.send_codec_spec.cng_payload_type,
|
|
webrtc::kFreq16000Hz))
|
|
.WillOnce(Return(0));
|
|
EXPECT_CALL(
|
|
*helper.channel_proxy(),
|
|
SetReceiverFrameLengthRange(stream_config.send_codec_spec.min_ptime_ms,
|
|
stream_config.send_codec_spec.max_ptime_ms));
|
|
EXPECT_CALL(
|
|
*helper.channel_proxy(),
|
|
EnableAudioNetworkAdaptor(*stream_config.audio_network_adaptor_config));
|
|
internal::AudioSendStream send_stream(
|
|
stream_config, helper.audio_state(), helper.worker_queue(),
|
|
helper.congestion_controller(), helper.bitrate_allocator(),
|
|
helper.event_log());
|
|
}
|
|
|
|
// VAD is applied when codec is mono and the CNG frequency matches the codec
|
|
// sample rate.
|
|
TEST(AudioSendStreamTest, SendCodecCanApplyVad) {
|
|
ConfigHelper helper;
|
|
auto stream_config = helper.config();
|
|
const CodecInst kG722Codec = {9, "g722", 8000, 160, 1, 16000};
|
|
stream_config.send_codec_spec.codec_inst = kG722Codec;
|
|
stream_config.send_codec_spec.cng_plfreq = 8000;
|
|
stream_config.send_codec_spec.cng_payload_type = 105;
|
|
EXPECT_CALL(*helper.voice_engine(), SetVADStatus(kChannelId, true, _, _))
|
|
.WillOnce(Return(0));
|
|
internal::AudioSendStream send_stream(
|
|
stream_config, helper.audio_state(), helper.worker_queue(),
|
|
helper.congestion_controller(), helper.bitrate_allocator(),
|
|
helper.event_log());
|
|
}
|
|
|
|
} // namespace test
|
|
} // namespace webrtc
|