blob: ea70d304d79acb3e7526b3caf01dcd4f5d8d1a90 [file] [log] [blame]
solenbergc7a8b082015-10-16 14:35:07 -07001/*
2 * Copyright (c) 2015 The WebRTC project authors. All Rights Reserved.
3 *
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
10
Fredrik Solenbergea073732015-12-01 11:26:34 +010011#include <string>
12#include <vector>
13
solenbergc7a8b082015-10-16 14:35:07 -070014#include "testing/gtest/include/gtest/gtest.h"
15
16#include "webrtc/audio/audio_send_stream.h"
solenberg566ef242015-11-06 15:34:49 -080017#include "webrtc/audio/audio_state.h"
solenberg85a04962015-10-27 03:35:21 -070018#include "webrtc/audio/conversion.h"
perkjec81bcd2016-05-11 06:01:13 -070019#include "webrtc/modules/congestion_controller/include/mock/mock_congestion_controller.h"
ivoc14d5dbe2016-07-04 07:06:55 -070020#include "webrtc/call/mock/mock_rtc_event_log.h"
Stefan Holmer80e12072016-02-23 13:30:42 +010021#include "webrtc/modules/congestion_controller/include/congestion_controller.h"
Stefan Holmerb86d4e42015-12-07 10:26:18 +010022#include "webrtc/modules/pacing/paced_sender.h"
Stefan Holmer58c664c2016-02-08 14:31:30 +010023#include "webrtc/modules/remote_bitrate_estimator/include/mock/mock_remote_bitrate_estimator.h"
solenberg13725082015-11-25 08:16:52 -080024#include "webrtc/test/mock_voe_channel_proxy.h"
Fredrik Solenberg0ccae132015-11-03 10:15:49 +010025#include "webrtc/test/mock_voice_engine.h"
solenbergc7a8b082015-10-16 14:35:07 -070026
27namespace webrtc {
solenberg85a04962015-10-27 03:35:21 -070028namespace test {
Fredrik Solenberg0ccae132015-11-03 10:15:49 +010029namespace {
30
solenberg3a941542015-11-16 07:34:50 -080031using testing::_;
32using testing::Return;
33
Fredrik Solenberg0ccae132015-11-03 10:15:49 +010034const int kChannelId = 1;
35const uint32_t kSsrc = 1234;
solenberg3a941542015-11-16 07:34:50 -080036const char* kCName = "foo_name";
37const int kAudioLevelId = 2;
38const int kAbsSendTimeId = 3;
Stefan Holmerb86d4e42015-12-07 10:26:18 +010039const int kTransportSequenceNumberId = 4;
solenberg566ef242015-11-06 15:34:49 -080040const int kEchoDelayMedian = 254;
41const int kEchoDelayStdDev = -3;
42const int kEchoReturnLoss = -65;
43const int kEchoReturnLossEnhancement = 101;
44const unsigned int kSpeechInputLevel = 96;
45const CallStatistics kCallStats = {
46 1345, 1678, 1901, 1234, 112, 13456, 17890, 1567, -1890, -1123};
pkasting25702cb2016-01-08 13:50:27 -080047const CodecInst kCodecInst = {-121, "codec_name_send", 48000, -231, 0, -671};
solenberg566ef242015-11-06 15:34:49 -080048const ReportBlock kReportBlock = {456, 780, 123, 567, 890, 132, 143, 13354};
Fredrik Solenbergb5727682015-12-04 15:22:19 +010049const int kTelephoneEventPayloadType = 123;
solenberg8842c3e2016-03-11 03:06:41 -080050const int kTelephoneEventCode = 45;
51const int kTelephoneEventDuration = 6789;
solenberg566ef242015-11-06 15:34:49 -080052
53struct ConfigHelper {
Stefan Holmerb86d4e42015-12-07 10:26:18 +010054 ConfigHelper()
Stefan Holmer58c664c2016-02-08 14:31:30 +010055 : simulated_clock_(123456),
56 stream_config_(nullptr),
Stefan Holmer58c664c2016-02-08 14:31:30 +010057 congestion_controller_(&simulated_clock_,
Stefan Holmer58c664c2016-02-08 14:31:30 +010058 &bitrate_observer_,
ivoc14d5dbe2016-07-04 07:06:55 -070059 &remote_bitrate_observer_,
60 &event_log_) {
solenberg13725082015-11-25 08:16:52 -080061 using testing::Invoke;
solenberg3a941542015-11-16 07:34:50 -080062 using testing::StrEq;
63
solenberg566ef242015-11-06 15:34:49 -080064 EXPECT_CALL(voice_engine_,
solenberg3a941542015-11-16 07:34:50 -080065 RegisterVoiceEngineObserver(_)).WillOnce(Return(0));
solenberg566ef242015-11-06 15:34:49 -080066 EXPECT_CALL(voice_engine_,
solenberg3a941542015-11-16 07:34:50 -080067 DeRegisterVoiceEngineObserver()).WillOnce(Return(0));
solenberg566ef242015-11-06 15:34:49 -080068 AudioState::Config config;
69 config.voice_engine = &voice_engine_;
70 audio_state_ = AudioState::Create(config);
solenberg3a941542015-11-16 07:34:50 -080071
solenberg13725082015-11-25 08:16:52 -080072 EXPECT_CALL(voice_engine_, ChannelProxyFactory(kChannelId))
73 .WillOnce(Invoke([this](int channel_id) {
74 EXPECT_FALSE(channel_proxy_);
75 channel_proxy_ = new testing::StrictMock<MockVoEChannelProxy>();
76 EXPECT_CALL(*channel_proxy_, SetRTCPStatus(true)).Times(1);
77 EXPECT_CALL(*channel_proxy_, SetLocalSSRC(kSsrc)).Times(1);
78 EXPECT_CALL(*channel_proxy_, SetRTCP_CNAME(StrEq(kCName))).Times(1);
solenberg971cab02016-06-14 10:02:41 -070079 EXPECT_CALL(*channel_proxy_, SetNACKStatus(true, 10)).Times(1);
solenberg358057b2015-11-27 10:46:42 -080080 EXPECT_CALL(*channel_proxy_,
81 SetSendAbsoluteSenderTimeStatus(true, kAbsSendTimeId)).Times(1);
82 EXPECT_CALL(*channel_proxy_,
83 SetSendAudioLevelIndicationStatus(true, kAudioLevelId)).Times(1);
Stefan Holmerb86d4e42015-12-07 10:26:18 +010084 EXPECT_CALL(*channel_proxy_, EnableSendTransportSequenceNumber(
85 kTransportSequenceNumberId))
86 .Times(1);
87 EXPECT_CALL(*channel_proxy_,
stefanbba9dec2016-02-01 04:39:55 -080088 RegisterSenderCongestionControlObjects(
Stefan Holmerb86d4e42015-12-07 10:26:18 +010089 congestion_controller_.pacer(),
90 congestion_controller_.GetTransportFeedbackObserver(),
91 congestion_controller_.packet_router()))
92 .Times(1);
stefanbba9dec2016-02-01 04:39:55 -080093 EXPECT_CALL(*channel_proxy_, ResetCongestionControlObjects())
Stefan Holmerb86d4e42015-12-07 10:26:18 +010094 .Times(1);
mflodman3d7db262016-04-29 00:57:13 -070095 EXPECT_CALL(*channel_proxy_, RegisterExternalTransport(nullptr))
96 .Times(1);
97 EXPECT_CALL(*channel_proxy_, DeRegisterExternalTransport())
98 .Times(1);
solenberg13725082015-11-25 08:16:52 -080099 return channel_proxy_;
100 }));
solenberg566ef242015-11-06 15:34:49 -0800101 stream_config_.voe_channel_id = kChannelId;
102 stream_config_.rtp.ssrc = kSsrc;
solenberg971cab02016-06-14 10:02:41 -0700103 stream_config_.rtp.nack.rtp_history_ms = 200;
solenberg3a941542015-11-16 07:34:50 -0800104 stream_config_.rtp.c_name = kCName;
105 stream_config_.rtp.extensions.push_back(
isheriff6f8d6862016-05-26 11:24:55 -0700106 RtpExtension(RtpExtension::kAudioLevelUri, kAudioLevelId));
solenberg3a941542015-11-16 07:34:50 -0800107 stream_config_.rtp.extensions.push_back(
isheriff6f8d6862016-05-26 11:24:55 -0700108 RtpExtension(RtpExtension::kAbsSendTimeUri, kAbsSendTimeId));
Stefan Holmerb86d4e42015-12-07 10:26:18 +0100109 stream_config_.rtp.extensions.push_back(RtpExtension(
isheriff6f8d6862016-05-26 11:24:55 -0700110 RtpExtension::kTransportSequenceNumberUri, kTransportSequenceNumberId));
solenberg566ef242015-11-06 15:34:49 -0800111 }
112
113 AudioSendStream::Config& config() { return stream_config_; }
114 rtc::scoped_refptr<AudioState> audio_state() { return audio_state_; }
solenberg94218532016-06-16 10:53:22 -0700115 MockVoEChannelProxy* channel_proxy() { return channel_proxy_; }
Stefan Holmerb86d4e42015-12-07 10:26:18 +0100116 CongestionController* congestion_controller() {
117 return &congestion_controller_;
118 }
solenberg566ef242015-11-06 15:34:49 -0800119
Fredrik Solenbergb5727682015-12-04 15:22:19 +0100120 void SetupMockForSendTelephoneEvent() {
121 EXPECT_TRUE(channel_proxy_);
122 EXPECT_CALL(*channel_proxy_,
123 SetSendTelephoneEventPayloadType(kTelephoneEventPayloadType))
124 .WillOnce(Return(true));
125 EXPECT_CALL(*channel_proxy_,
126 SendTelephoneEventOutband(kTelephoneEventCode, kTelephoneEventDuration))
127 .WillOnce(Return(true));
128 }
129
solenberg566ef242015-11-06 15:34:49 -0800130 void SetupMockForGetStats() {
solenberg3a941542015-11-16 07:34:50 -0800131 using testing::DoAll;
solenberg3a941542015-11-16 07:34:50 -0800132 using testing::SetArgReferee;
133
solenberg566ef242015-11-06 15:34:49 -0800134 std::vector<ReportBlock> report_blocks;
135 webrtc::ReportBlock block = kReportBlock;
136 report_blocks.push_back(block); // Has wrong SSRC.
137 block.source_SSRC = kSsrc;
138 report_blocks.push_back(block); // Correct block.
139 block.fraction_lost = 0;
140 report_blocks.push_back(block); // Duplicate SSRC, bad fraction_lost.
141
solenberg358057b2015-11-27 10:46:42 -0800142 EXPECT_TRUE(channel_proxy_);
143 EXPECT_CALL(*channel_proxy_, GetRTCPStatistics())
144 .WillRepeatedly(Return(kCallStats));
145 EXPECT_CALL(*channel_proxy_, GetRemoteRTCPReportBlocks())
146 .WillRepeatedly(Return(report_blocks));
147
solenberg566ef242015-11-06 15:34:49 -0800148 EXPECT_CALL(voice_engine_, GetSendCodec(kChannelId, _))
149 .WillRepeatedly(DoAll(SetArgReferee<1>(kCodecInst), Return(0)));
solenberg566ef242015-11-06 15:34:49 -0800150 EXPECT_CALL(voice_engine_, GetSpeechInputLevelFullRange(_))
151 .WillRepeatedly(DoAll(SetArgReferee<0>(kSpeechInputLevel), Return(0)));
152 EXPECT_CALL(voice_engine_, GetEcMetricsStatus(_))
153 .WillRepeatedly(DoAll(SetArgReferee<0>(true), Return(0)));
154 EXPECT_CALL(voice_engine_, GetEchoMetrics(_, _, _, _))
155 .WillRepeatedly(DoAll(SetArgReferee<0>(kEchoReturnLoss),
156 SetArgReferee<1>(kEchoReturnLossEnhancement),
157 Return(0)));
158 EXPECT_CALL(voice_engine_, GetEcDelayMetrics(_, _, _))
159 .WillRepeatedly(DoAll(SetArgReferee<0>(kEchoDelayMedian),
160 SetArgReferee<1>(kEchoDelayStdDev), Return(0)));
161 }
162
163 private:
Stefan Holmer58c664c2016-02-08 14:31:30 +0100164 SimulatedClock simulated_clock_;
solenberg3a941542015-11-16 07:34:50 -0800165 testing::StrictMock<MockVoiceEngine> voice_engine_;
solenberg566ef242015-11-06 15:34:49 -0800166 rtc::scoped_refptr<AudioState> audio_state_;
167 AudioSendStream::Config stream_config_;
solenberg13725082015-11-25 08:16:52 -0800168 testing::StrictMock<MockVoEChannelProxy>* channel_proxy_ = nullptr;
perkjec81bcd2016-05-11 06:01:13 -0700169 testing::NiceMock<MockCongestionObserver> bitrate_observer_;
Stefan Holmer58c664c2016-02-08 14:31:30 +0100170 testing::NiceMock<MockRemoteBitrateObserver> remote_bitrate_observer_;
Stefan Holmerb86d4e42015-12-07 10:26:18 +0100171 CongestionController congestion_controller_;
ivoc14d5dbe2016-07-04 07:06:55 -0700172 MockRtcEventLog event_log_;
solenberg566ef242015-11-06 15:34:49 -0800173};
Fredrik Solenberg0ccae132015-11-03 10:15:49 +0100174} // namespace
solenbergc7a8b082015-10-16 14:35:07 -0700175
176TEST(AudioSendStreamTest, ConfigToString) {
solenbergc7a8b082015-10-16 14:35:07 -0700177 AudioSendStream::Config config(nullptr);
Fredrik Solenberg0ccae132015-11-03 10:15:49 +0100178 config.rtp.ssrc = kSsrc;
solenbergc7a8b082015-10-16 14:35:07 -0700179 config.rtp.extensions.push_back(
isheriff6f8d6862016-05-26 11:24:55 -0700180 RtpExtension(RtpExtension::kAbsSendTimeUri, kAbsSendTimeId));
solenberg3a941542015-11-16 07:34:50 -0800181 config.rtp.c_name = kCName;
Fredrik Solenberg0ccae132015-11-03 10:15:49 +0100182 config.voe_channel_id = kChannelId;
solenbergc7a8b082015-10-16 14:35:07 -0700183 config.cng_payload_type = 42;
Fredrik Solenberg0ccae132015-11-03 10:15:49 +0100184 EXPECT_EQ(
isheriff6f8d6862016-05-26 11:24:55 -0700185 "{rtp: {ssrc: 1234, extensions: [{uri: "
solenberg3a941542015-11-16 07:34:50 -0800186 "http://www.webrtc.org/experiments/rtp-hdrext/abs-send-time, id: 3}], "
solenberg971cab02016-06-14 10:02:41 -0700187 "nack: {rtp_history_ms: 0}, c_name: foo_name}, voe_channel_id: 1, "
188 "cng_payload_type: 42}",
solenberg85a04962015-10-27 03:35:21 -0700189 config.ToString());
solenbergc7a8b082015-10-16 14:35:07 -0700190}
191
192TEST(AudioSendStreamTest, ConstructDestruct) {
solenberg566ef242015-11-06 15:34:49 -0800193 ConfigHelper helper;
Stefan Holmerb86d4e42015-12-07 10:26:18 +0100194 internal::AudioSendStream send_stream(helper.config(), helper.audio_state(),
195 helper.congestion_controller());
solenbergc7a8b082015-10-16 14:35:07 -0700196}
solenberg85a04962015-10-27 03:35:21 -0700197
Fredrik Solenbergb5727682015-12-04 15:22:19 +0100198TEST(AudioSendStreamTest, SendTelephoneEvent) {
199 ConfigHelper helper;
Stefan Holmerb86d4e42015-12-07 10:26:18 +0100200 internal::AudioSendStream send_stream(helper.config(), helper.audio_state(),
201 helper.congestion_controller());
Fredrik Solenbergb5727682015-12-04 15:22:19 +0100202 helper.SetupMockForSendTelephoneEvent();
203 EXPECT_TRUE(send_stream.SendTelephoneEvent(kTelephoneEventPayloadType,
204 kTelephoneEventCode, kTelephoneEventDuration));
205}
206
solenberg94218532016-06-16 10:53:22 -0700207TEST(AudioSendStreamTest, SetMuted) {
208 ConfigHelper helper;
209 internal::AudioSendStream send_stream(helper.config(), helper.audio_state(),
210 helper.congestion_controller());
211 EXPECT_CALL(*helper.channel_proxy(), SetInputMute(true));
212 send_stream.SetMuted(true);
213}
214
solenberg85a04962015-10-27 03:35:21 -0700215TEST(AudioSendStreamTest, GetStats) {
solenberg566ef242015-11-06 15:34:49 -0800216 ConfigHelper helper;
Stefan Holmerb86d4e42015-12-07 10:26:18 +0100217 internal::AudioSendStream send_stream(helper.config(), helper.audio_state(),
218 helper.congestion_controller());
solenberg566ef242015-11-06 15:34:49 -0800219 helper.SetupMockForGetStats();
solenberg85a04962015-10-27 03:35:21 -0700220 AudioSendStream::Stats stats = send_stream.GetStats();
Fredrik Solenberg0ccae132015-11-03 10:15:49 +0100221 EXPECT_EQ(kSsrc, stats.local_ssrc);
222 EXPECT_EQ(static_cast<int64_t>(kCallStats.bytesSent), stats.bytes_sent);
223 EXPECT_EQ(kCallStats.packetsSent, stats.packets_sent);
224 EXPECT_EQ(static_cast<int32_t>(kReportBlock.cumulative_num_packets_lost),
solenberg85a04962015-10-27 03:35:21 -0700225 stats.packets_lost);
Fredrik Solenberg0ccae132015-11-03 10:15:49 +0100226 EXPECT_EQ(Q8ToFloat(kReportBlock.fraction_lost), stats.fraction_lost);
227 EXPECT_EQ(std::string(kCodecInst.plname), stats.codec_name);
228 EXPECT_EQ(static_cast<int32_t>(kReportBlock.extended_highest_sequence_number),
solenberg85a04962015-10-27 03:35:21 -0700229 stats.ext_seqnum);
Fredrik Solenberg0ccae132015-11-03 10:15:49 +0100230 EXPECT_EQ(static_cast<int32_t>(kReportBlock.interarrival_jitter /
231 (kCodecInst.plfreq / 1000)),
232 stats.jitter_ms);
233 EXPECT_EQ(kCallStats.rttMs, stats.rtt_ms);
234 EXPECT_EQ(static_cast<int32_t>(kSpeechInputLevel), stats.audio_level);
solenberg85a04962015-10-27 03:35:21 -0700235 EXPECT_EQ(-1, stats.aec_quality_min);
Fredrik Solenberg0ccae132015-11-03 10:15:49 +0100236 EXPECT_EQ(kEchoDelayMedian, stats.echo_delay_median_ms);
237 EXPECT_EQ(kEchoDelayStdDev, stats.echo_delay_std_ms);
238 EXPECT_EQ(kEchoReturnLoss, stats.echo_return_loss);
239 EXPECT_EQ(kEchoReturnLossEnhancement, stats.echo_return_loss_enhancement);
solenberg85a04962015-10-27 03:35:21 -0700240 EXPECT_FALSE(stats.typing_noise_detected);
241}
solenberg566ef242015-11-06 15:34:49 -0800242
243TEST(AudioSendStreamTest, GetStatsTypingNoiseDetected) {
244 ConfigHelper helper;
Stefan Holmerb86d4e42015-12-07 10:26:18 +0100245 internal::AudioSendStream send_stream(helper.config(), helper.audio_state(),
246 helper.congestion_controller());
solenberg566ef242015-11-06 15:34:49 -0800247 helper.SetupMockForGetStats();
248 EXPECT_FALSE(send_stream.GetStats().typing_noise_detected);
249
250 internal::AudioState* internal_audio_state =
251 static_cast<internal::AudioState*>(helper.audio_state().get());
252 VoiceEngineObserver* voe_observer =
253 static_cast<VoiceEngineObserver*>(internal_audio_state);
254 voe_observer->CallbackOnError(-1, VE_TYPING_NOISE_WARNING);
255 EXPECT_TRUE(send_stream.GetStats().typing_noise_detected);
256 voe_observer->CallbackOnError(-1, VE_TYPING_NOISE_OFF_WARNING);
257 EXPECT_FALSE(send_stream.GetStats().typing_noise_detected);
258}
solenberg85a04962015-10-27 03:35:21 -0700259} // namespace test
solenbergc7a8b082015-10-16 14:35:07 -0700260} // namespace webrtc