OLD | NEW |
1 /* | 1 /* |
2 * Copyright (c) 2015 The WebRTC project authors. All Rights Reserved. | 2 * Copyright (c) 2015 The WebRTC project authors. All Rights Reserved. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license | 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 | 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 | 6 * tree. An additional intellectual property rights grant can be found |
7 * in the file PATENTS. All contributing project authors may | 7 * in the file PATENTS. All contributing project authors may |
8 * be found in the AUTHORS file in the root of the source tree. | 8 * be found in the AUTHORS file in the root of the source tree. |
9 */ | 9 */ |
10 | 10 |
11 #include <string> | 11 #include <string> |
| 12 #include <utility> |
12 #include <vector> | 13 #include <vector> |
13 | 14 |
14 #include "webrtc/audio/audio_send_stream.h" | 15 #include "webrtc/audio/audio_send_stream.h" |
15 #include "webrtc/audio/audio_state.h" | 16 #include "webrtc/audio/audio_state.h" |
16 #include "webrtc/audio/conversion.h" | 17 #include "webrtc/audio/conversion.h" |
17 #include "webrtc/base/task_queue.h" | 18 #include "webrtc/base/task_queue.h" |
18 #include "webrtc/call/rtp_transport_controller_send.h" | 19 #include "webrtc/call/rtp_transport_controller_send.h" |
19 #include "webrtc/logging/rtc_event_log/mock/mock_rtc_event_log.h" | 20 #include "webrtc/logging/rtc_event_log/mock/mock_rtc_event_log.h" |
| 21 #include "webrtc/modules/audio_coding/codecs/mock/mock_audio_encoder.h" |
| 22 #include "webrtc/modules/audio_coding/codecs/mock/mock_audio_encoder_factory.h" |
20 #include "webrtc/modules/audio_mixer/audio_mixer_impl.h" | 23 #include "webrtc/modules/audio_mixer/audio_mixer_impl.h" |
21 #include "webrtc/modules/audio_processing/include/mock_audio_processing.h" | 24 #include "webrtc/modules/audio_processing/include/mock_audio_processing.h" |
22 #include "webrtc/modules/congestion_controller/include/mock/mock_congestion_obse
rver.h" | 25 #include "webrtc/modules/congestion_controller/include/mock/mock_congestion_obse
rver.h" |
23 #include "webrtc/modules/congestion_controller/include/send_side_congestion_cont
roller.h" | 26 #include "webrtc/modules/congestion_controller/include/send_side_congestion_cont
roller.h" |
24 #include "webrtc/modules/pacing/paced_sender.h" | 27 #include "webrtc/modules/pacing/paced_sender.h" |
25 #include "webrtc/modules/rtp_rtcp/mocks/mock_rtcp_rtt_stats.h" | 28 #include "webrtc/modules/rtp_rtcp/mocks/mock_rtcp_rtt_stats.h" |
26 #include "webrtc/test/gtest.h" | 29 #include "webrtc/test/gtest.h" |
27 #include "webrtc/test/mock_voe_channel_proxy.h" | 30 #include "webrtc/test/mock_voe_channel_proxy.h" |
28 #include "webrtc/test/mock_voice_engine.h" | 31 #include "webrtc/test/mock_voice_engine.h" |
29 #include "webrtc/voice_engine/transmit_mixer.h" | 32 #include "webrtc/voice_engine/transmit_mixer.h" |
30 | 33 |
31 namespace webrtc { | 34 namespace webrtc { |
32 namespace test { | 35 namespace test { |
33 namespace { | 36 namespace { |
34 | 37 |
35 using testing::_; | 38 using testing::_; |
36 using testing::Eq; | 39 using testing::Eq; |
37 using testing::Ne; | 40 using testing::Ne; |
| 41 using testing::Invoke; |
38 using testing::Return; | 42 using testing::Return; |
39 | 43 |
40 const int kChannelId = 1; | 44 const int kChannelId = 1; |
41 const uint32_t kSsrc = 1234; | 45 const uint32_t kSsrc = 1234; |
42 const char* kCName = "foo_name"; | 46 const char* kCName = "foo_name"; |
43 const int kAudioLevelId = 2; | 47 const int kAudioLevelId = 2; |
44 const int kTransportSequenceNumberId = 4; | 48 const int kTransportSequenceNumberId = 4; |
45 const int kEchoDelayMedian = 254; | 49 const int kEchoDelayMedian = 254; |
46 const int kEchoDelayStdDev = -3; | 50 const int kEchoDelayStdDev = -3; |
47 const int kEchoReturnLoss = -65; | 51 const int kEchoReturnLoss = -65; |
48 const int kEchoReturnLossEnhancement = 101; | 52 const int kEchoReturnLossEnhancement = 101; |
49 const float kResidualEchoLikelihood = -1.0f; | 53 const float kResidualEchoLikelihood = -1.0f; |
50 const int32_t kSpeechInputLevel = 96; | 54 const int32_t kSpeechInputLevel = 96; |
51 const CallStatistics kCallStats = { | 55 const CallStatistics kCallStats = { |
52 1345, 1678, 1901, 1234, 112, 13456, 17890, 1567, -1890, -1123}; | 56 1345, 1678, 1901, 1234, 112, 13456, 17890, 1567, -1890, -1123}; |
53 const ReportBlock kReportBlock = {456, 780, 123, 567, 890, 132, 143, 13354}; | 57 const ReportBlock kReportBlock = {456, 780, 123, 567, 890, 132, 143, 13354}; |
54 const int kTelephoneEventPayloadType = 123; | 58 const int kTelephoneEventPayloadType = 123; |
55 const int kTelephoneEventPayloadFrequency = 65432; | 59 const int kTelephoneEventPayloadFrequency = 65432; |
56 const int kTelephoneEventCode = 45; | 60 const int kTelephoneEventCode = 45; |
57 const int kTelephoneEventDuration = 6789; | 61 const int kTelephoneEventDuration = 6789; |
58 const CodecInst kIsacCodec = {103, "isac", 16000, 320, 1, 32000}; | 62 const CodecInst kIsacCodec = {103, "isac", 16000, 320, 1, 32000}; |
| 63 constexpr int kIsacPayloadType = 103; |
| 64 const SdpAudioFormat kIsacFormat = {"isac", 16000, 1}; |
| 65 const SdpAudioFormat kOpusFormat = {"opus", 48000, 2}; |
| 66 const SdpAudioFormat kG722Format = {"g722", 8000, 1}; |
| 67 const AudioCodecSpec kCodecSpecs[] = { |
| 68 {kIsacFormat, {16000, 1, 32000, 10000, 32000}}, |
| 69 {kOpusFormat, {48000, 1, 32000, 6000, 510000}}, |
| 70 {kG722Format, {16000, 1, 64000}}}; |
59 | 71 |
60 class MockLimitObserver : public BitrateAllocator::LimitObserver { | 72 class MockLimitObserver : public BitrateAllocator::LimitObserver { |
61 public: | 73 public: |
62 MOCK_METHOD2(OnAllocationLimitsChanged, | 74 MOCK_METHOD2(OnAllocationLimitsChanged, |
63 void(uint32_t min_send_bitrate_bps, | 75 void(uint32_t min_send_bitrate_bps, |
64 uint32_t max_padding_bitrate_bps)); | 76 uint32_t max_padding_bitrate_bps)); |
65 }; | 77 }; |
66 | 78 |
67 class MockTransmitMixer : public voe::TransmitMixer { | 79 class MockTransmitMixer : public voe::TransmitMixer { |
68 public: | 80 public: |
69 MOCK_CONST_METHOD0(AudioLevelFullRange, int16_t()); | 81 MOCK_CONST_METHOD0(AudioLevelFullRange, int16_t()); |
70 }; | 82 }; |
71 | 83 |
| 84 std::unique_ptr<MockAudioEncoder> SetupAudioEncoderMock( |
| 85 int payload_type, |
| 86 const SdpAudioFormat& format) { |
| 87 for (const auto& spec : kCodecSpecs) { |
| 88 if (format == spec.format) { |
| 89 std::unique_ptr<MockAudioEncoder> encoder(new MockAudioEncoder); |
| 90 ON_CALL(*encoder.get(), SampleRateHz()) |
| 91 .WillByDefault(Return(spec.info.sample_rate_hz)); |
| 92 ON_CALL(*encoder.get(), NumChannels()) |
| 93 .WillByDefault(Return(spec.info.num_channels)); |
| 94 ON_CALL(*encoder.get(), RtpTimestampRateHz()) |
| 95 .WillByDefault(Return(spec.format.clockrate_hz)); |
| 96 return encoder; |
| 97 } |
| 98 } |
| 99 return nullptr; |
| 100 } |
| 101 |
| 102 rtc::scoped_refptr<MockAudioEncoderFactory> SetupEncoderFactoryMock() { |
| 103 rtc::scoped_refptr<MockAudioEncoderFactory> factory = |
| 104 new rtc::RefCountedObject<MockAudioEncoderFactory>(); |
| 105 ON_CALL(*factory.get(), GetSupportedEncoders()) |
| 106 .WillByDefault(Return(std::vector<AudioCodecSpec>( |
| 107 std::begin(kCodecSpecs), std::end(kCodecSpecs)))); |
| 108 ON_CALL(*factory.get(), QueryAudioEncoder(_)) |
| 109 .WillByDefault(Invoke([](const SdpAudioFormat& format) { |
| 110 for (const auto& spec : kCodecSpecs) { |
| 111 if (format == spec.format) { |
| 112 return rtc::Optional<AudioCodecInfo>(spec.info); |
| 113 } |
| 114 } |
| 115 return rtc::Optional<AudioCodecInfo>(); |
| 116 })); |
| 117 ON_CALL(*factory.get(), MakeAudioEncoderMock(_, _, _)) |
| 118 .WillByDefault(Invoke([](int payload_type, const SdpAudioFormat& format, |
| 119 std::unique_ptr<AudioEncoder>* return_value) { |
| 120 *return_value = SetupAudioEncoderMock(payload_type, format); |
| 121 })); |
| 122 return factory; |
| 123 } |
| 124 |
72 struct ConfigHelper { | 125 struct ConfigHelper { |
73 class FakeRtpTransportController | 126 class FakeRtpTransportController |
74 : public RtpTransportControllerSendInterface { | 127 : public RtpTransportControllerSendInterface { |
75 public: | 128 public: |
76 explicit FakeRtpTransportController(RtcEventLog* event_log) | 129 explicit FakeRtpTransportController(RtcEventLog* event_log) |
77 : simulated_clock_(123456), | 130 : simulated_clock_(123456), |
78 send_side_cc_(&simulated_clock_, | 131 send_side_cc_(&simulated_clock_, |
79 &bitrate_observer_, | 132 &bitrate_observer_, |
80 event_log, | 133 event_log, |
81 &packet_router_) {} | 134 &packet_router_) {} |
82 PacketRouter* packet_router() override { return &packet_router_; } | 135 PacketRouter* packet_router() override { return &packet_router_; } |
83 | 136 |
84 SendSideCongestionController* send_side_cc() override { | 137 SendSideCongestionController* send_side_cc() override { |
85 return &send_side_cc_; | 138 return &send_side_cc_; |
86 } | 139 } |
87 TransportFeedbackObserver* transport_feedback_observer() override { | 140 TransportFeedbackObserver* transport_feedback_observer() override { |
88 return &send_side_cc_; | 141 return &send_side_cc_; |
89 } | 142 } |
90 | 143 |
91 RtpPacketSender* packet_sender() override { return send_side_cc_.pacer(); } | 144 RtpPacketSender* packet_sender() override { return send_side_cc_.pacer(); } |
92 | 145 |
93 private: | 146 private: |
94 SimulatedClock simulated_clock_; | 147 SimulatedClock simulated_clock_; |
95 testing::NiceMock<MockCongestionObserver> bitrate_observer_; | 148 testing::NiceMock<MockCongestionObserver> bitrate_observer_; |
96 PacketRouter packet_router_; | 149 PacketRouter packet_router_; |
97 SendSideCongestionController send_side_cc_; | 150 SendSideCongestionController send_side_cc_; |
98 }; | 151 }; |
99 | 152 |
100 explicit ConfigHelper(bool audio_bwe_enabled) | 153 ConfigHelper(bool audio_bwe_enabled, bool expect_set_encoder_call) |
101 : stream_config_(nullptr), | 154 : stream_config_(nullptr), |
102 fake_transport_(&event_log_), | 155 fake_transport_(&event_log_), |
103 bitrate_allocator_(&limit_observer_), | 156 bitrate_allocator_(&limit_observer_), |
104 worker_queue_("ConfigHelper_worker_queue") { | 157 worker_queue_("ConfigHelper_worker_queue") { |
105 using testing::Invoke; | 158 using testing::Invoke; |
106 | 159 |
107 EXPECT_CALL(voice_engine_, | 160 EXPECT_CALL(voice_engine_, |
108 RegisterVoiceEngineObserver(_)).WillOnce(Return(0)); | 161 RegisterVoiceEngineObserver(_)).WillOnce(Return(0)); |
109 EXPECT_CALL(voice_engine_, | 162 EXPECT_CALL(voice_engine_, |
110 DeRegisterVoiceEngineObserver()).WillOnce(Return(0)); | 163 DeRegisterVoiceEngineObserver()).WillOnce(Return(0)); |
111 EXPECT_CALL(voice_engine_, audio_device_module()); | 164 EXPECT_CALL(voice_engine_, audio_device_module()); |
112 EXPECT_CALL(voice_engine_, audio_processing()); | 165 EXPECT_CALL(voice_engine_, audio_processing()); |
113 EXPECT_CALL(voice_engine_, audio_transport()); | 166 EXPECT_CALL(voice_engine_, audio_transport()); |
114 | 167 |
115 AudioState::Config config; | 168 AudioState::Config config; |
116 config.voice_engine = &voice_engine_; | 169 config.voice_engine = &voice_engine_; |
117 config.audio_mixer = AudioMixerImpl::Create(); | 170 config.audio_mixer = AudioMixerImpl::Create(); |
118 audio_state_ = AudioState::Create(config); | 171 audio_state_ = AudioState::Create(config); |
119 | 172 |
120 SetupDefaultChannelProxy(audio_bwe_enabled); | 173 SetupDefaultChannelProxy(audio_bwe_enabled); |
121 | 174 |
122 EXPECT_CALL(voice_engine_, ChannelProxyFactory(kChannelId)) | 175 EXPECT_CALL(voice_engine_, ChannelProxyFactory(kChannelId)) |
123 .WillOnce(Invoke([this](int channel_id) { | 176 .WillOnce(Invoke([this](int channel_id) { |
124 return channel_proxy_; | 177 return channel_proxy_; |
125 })); | 178 })); |
126 | 179 |
127 SetupMockForSetupSendCodec(); | 180 SetupMockForSetupSendCodec(expect_set_encoder_call); |
128 | 181 |
| 182 // Use ISAC as default codec so as to prevent unnecessary |voice_engine_| |
| 183 // calls from the default ctor behavior. |
| 184 stream_config_.send_codec_spec = |
| 185 rtc::Optional<AudioSendStream::Config::SendCodecSpec>( |
| 186 {kIsacPayloadType, kIsacFormat}); |
129 stream_config_.voe_channel_id = kChannelId; | 187 stream_config_.voe_channel_id = kChannelId; |
130 stream_config_.rtp.ssrc = kSsrc; | 188 stream_config_.rtp.ssrc = kSsrc; |
131 stream_config_.rtp.nack.rtp_history_ms = 200; | 189 stream_config_.rtp.nack.rtp_history_ms = 200; |
132 stream_config_.rtp.c_name = kCName; | 190 stream_config_.rtp.c_name = kCName; |
133 stream_config_.rtp.extensions.push_back( | 191 stream_config_.rtp.extensions.push_back( |
134 RtpExtension(RtpExtension::kAudioLevelUri, kAudioLevelId)); | 192 RtpExtension(RtpExtension::kAudioLevelUri, kAudioLevelId)); |
135 if (audio_bwe_enabled) { | 193 if (audio_bwe_enabled) { |
136 stream_config_.rtp.extensions.push_back( | 194 stream_config_.rtp.extensions.push_back( |
137 RtpExtension(RtpExtension::kTransportSequenceNumberUri, | 195 RtpExtension(RtpExtension::kTransportSequenceNumberUri, |
138 kTransportSequenceNumberId)); | 196 kTransportSequenceNumberId)); |
139 stream_config_.send_codec_spec.transport_cc_enabled = true; | 197 stream_config_.send_codec_spec->transport_cc_enabled = true; |
140 } | 198 } |
141 // Use ISAC as default codec so as to prevent unnecessary |voice_engine_| | 199 stream_config_.encoder_factory = SetupEncoderFactoryMock(); |
142 // calls from the default ctor behavior. | |
143 stream_config_.send_codec_spec.codec_inst = kIsacCodec; | |
144 stream_config_.min_bitrate_bps = 10000; | 200 stream_config_.min_bitrate_bps = 10000; |
145 stream_config_.max_bitrate_bps = 65000; | 201 stream_config_.max_bitrate_bps = 65000; |
146 } | 202 } |
147 | 203 |
148 AudioSendStream::Config& config() { return stream_config_; } | 204 AudioSendStream::Config& config() { return stream_config_; } |
| 205 MockAudioEncoderFactory& mock_encoder_factory() { |
| 206 return *static_cast<MockAudioEncoderFactory*>( |
| 207 stream_config_.encoder_factory.get()); |
| 208 } |
149 rtc::scoped_refptr<AudioState> audio_state() { return audio_state_; } | 209 rtc::scoped_refptr<AudioState> audio_state() { return audio_state_; } |
150 MockVoEChannelProxy* channel_proxy() { return channel_proxy_; } | 210 MockVoEChannelProxy* channel_proxy() { return channel_proxy_; } |
151 RtpTransportControllerSendInterface* transport() { return &fake_transport_; } | 211 RtpTransportControllerSendInterface* transport() { return &fake_transport_; } |
152 BitrateAllocator* bitrate_allocator() { return &bitrate_allocator_; } | 212 BitrateAllocator* bitrate_allocator() { return &bitrate_allocator_; } |
153 rtc::TaskQueue* worker_queue() { return &worker_queue_; } | 213 rtc::TaskQueue* worker_queue() { return &worker_queue_; } |
154 RtcEventLog* event_log() { return &event_log_; } | 214 RtcEventLog* event_log() { return &event_log_; } |
155 MockVoiceEngine* voice_engine() { return &voice_engine_; } | 215 MockVoiceEngine* voice_engine() { return &voice_engine_; } |
156 | 216 |
157 void SetupDefaultChannelProxy(bool audio_bwe_enabled) { | 217 void SetupDefaultChannelProxy(bool audio_bwe_enabled) { |
158 using testing::StrEq; | 218 using testing::StrEq; |
(...skipping 22 matching lines...) Expand all Loading... |
181 EXPECT_CALL(*channel_proxy_, RegisterExternalTransport(nullptr)).Times(1); | 241 EXPECT_CALL(*channel_proxy_, RegisterExternalTransport(nullptr)).Times(1); |
182 EXPECT_CALL(*channel_proxy_, DeRegisterExternalTransport()).Times(1); | 242 EXPECT_CALL(*channel_proxy_, DeRegisterExternalTransport()).Times(1); |
183 EXPECT_CALL(*channel_proxy_, SetRtcEventLog(testing::NotNull())).Times(1); | 243 EXPECT_CALL(*channel_proxy_, SetRtcEventLog(testing::NotNull())).Times(1); |
184 EXPECT_CALL(*channel_proxy_, SetRtcEventLog(testing::IsNull())) | 244 EXPECT_CALL(*channel_proxy_, SetRtcEventLog(testing::IsNull())) |
185 .Times(1); // Destructor resets the event log | 245 .Times(1); // Destructor resets the event log |
186 EXPECT_CALL(*channel_proxy_, SetRtcpRttStats(&rtcp_rtt_stats_)).Times(1); | 246 EXPECT_CALL(*channel_proxy_, SetRtcpRttStats(&rtcp_rtt_stats_)).Times(1); |
187 EXPECT_CALL(*channel_proxy_, SetRtcpRttStats(testing::IsNull())) | 247 EXPECT_CALL(*channel_proxy_, SetRtcpRttStats(testing::IsNull())) |
188 .Times(1); // Destructor resets the rtt stats. | 248 .Times(1); // Destructor resets the rtt stats. |
189 } | 249 } |
190 | 250 |
191 void SetupMockForSetupSendCodec() { | 251 void SetupMockForSetupSendCodec(bool expect_set_encoder_call) { |
192 EXPECT_CALL(*channel_proxy_, SetVADStatus(false)) | 252 if (expect_set_encoder_call) { |
193 .WillOnce(Return(true)); | 253 EXPECT_CALL(*channel_proxy_, SetEncoderForMock(_, _)) |
194 EXPECT_CALL(*channel_proxy_, SetCodecFECStatus(false)) | 254 .WillOnce(Return(true)); |
195 .WillOnce(Return(true)); | 255 } |
196 EXPECT_CALL(*channel_proxy_, DisableAudioNetworkAdaptor()); | |
197 // Let |GetSendCodec| return false for the first time to indicate that no | |
198 // send codec has been set. | |
199 EXPECT_CALL(*channel_proxy_, GetSendCodec(_)).WillOnce(Return(false)); | |
200 EXPECT_CALL(*channel_proxy_, SetSendCodec(_)).WillOnce(Return(true)); | |
201 } | 256 } |
| 257 |
202 RtcpRttStats* rtcp_rtt_stats() { return &rtcp_rtt_stats_; } | 258 RtcpRttStats* rtcp_rtt_stats() { return &rtcp_rtt_stats_; } |
203 | 259 |
204 void SetupMockForSendTelephoneEvent() { | 260 void SetupMockForSendTelephoneEvent() { |
205 EXPECT_TRUE(channel_proxy_); | 261 EXPECT_TRUE(channel_proxy_); |
206 EXPECT_CALL(*channel_proxy_, | 262 EXPECT_CALL(*channel_proxy_, |
207 SetSendTelephoneEventPayloadType(kTelephoneEventPayloadType, | 263 SetSendTelephoneEventPayloadType(kTelephoneEventPayloadType, |
208 kTelephoneEventPayloadFrequency)) | 264 kTelephoneEventPayloadFrequency)) |
209 .WillOnce(Return(true)); | 265 .WillOnce(Return(true)); |
210 EXPECT_CALL(*channel_proxy_, | 266 EXPECT_CALL(*channel_proxy_, |
211 SendTelephoneEventOutband(kTelephoneEventCode, kTelephoneEventDuration)) | 267 SendTelephoneEventOutband(kTelephoneEventCode, kTelephoneEventDuration)) |
(...skipping 11 matching lines...) Expand all Loading... |
223 block.source_SSRC = kSsrc; | 279 block.source_SSRC = kSsrc; |
224 report_blocks.push_back(block); // Correct block. | 280 report_blocks.push_back(block); // Correct block. |
225 block.fraction_lost = 0; | 281 block.fraction_lost = 0; |
226 report_blocks.push_back(block); // Duplicate SSRC, bad fraction_lost. | 282 report_blocks.push_back(block); // Duplicate SSRC, bad fraction_lost. |
227 | 283 |
228 EXPECT_TRUE(channel_proxy_); | 284 EXPECT_TRUE(channel_proxy_); |
229 EXPECT_CALL(*channel_proxy_, GetRTCPStatistics()) | 285 EXPECT_CALL(*channel_proxy_, GetRTCPStatistics()) |
230 .WillRepeatedly(Return(kCallStats)); | 286 .WillRepeatedly(Return(kCallStats)); |
231 EXPECT_CALL(*channel_proxy_, GetRemoteRTCPReportBlocks()) | 287 EXPECT_CALL(*channel_proxy_, GetRemoteRTCPReportBlocks()) |
232 .WillRepeatedly(Return(report_blocks)); | 288 .WillRepeatedly(Return(report_blocks)); |
233 EXPECT_CALL(*channel_proxy_, GetSendCodec(_)) | |
234 .WillRepeatedly(DoAll(SetArgPointee<0>(kIsacCodec), Return(true))); | |
235 EXPECT_CALL(voice_engine_, transmit_mixer()) | 289 EXPECT_CALL(voice_engine_, transmit_mixer()) |
236 .WillRepeatedly(Return(&transmit_mixer_)); | 290 .WillRepeatedly(Return(&transmit_mixer_)); |
237 EXPECT_CALL(voice_engine_, audio_processing()) | 291 EXPECT_CALL(voice_engine_, audio_processing()) |
238 .WillRepeatedly(Return(&audio_processing_)); | 292 .WillRepeatedly(Return(&audio_processing_)); |
239 | 293 |
240 EXPECT_CALL(transmit_mixer_, AudioLevelFullRange()) | 294 EXPECT_CALL(transmit_mixer_, AudioLevelFullRange()) |
241 .WillRepeatedly(Return(kSpeechInputLevel)); | 295 .WillRepeatedly(Return(kSpeechInputLevel)); |
242 | 296 |
243 // We have to set the instantaneous value, the average, min and max. We only | 297 // We have to set the instantaneous value, the average, min and max. We only |
244 // care about the instantaneous value, so we set all to the same value. | 298 // care about the instantaneous value, so we set all to the same value. |
(...skipping 29 matching lines...) Expand all Loading... |
274 }; | 328 }; |
275 } // namespace | 329 } // namespace |
276 | 330 |
277 TEST(AudioSendStreamTest, ConfigToString) { | 331 TEST(AudioSendStreamTest, ConfigToString) { |
278 AudioSendStream::Config config(nullptr); | 332 AudioSendStream::Config config(nullptr); |
279 config.rtp.ssrc = kSsrc; | 333 config.rtp.ssrc = kSsrc; |
280 config.rtp.c_name = kCName; | 334 config.rtp.c_name = kCName; |
281 config.voe_channel_id = kChannelId; | 335 config.voe_channel_id = kChannelId; |
282 config.min_bitrate_bps = 12000; | 336 config.min_bitrate_bps = 12000; |
283 config.max_bitrate_bps = 34000; | 337 config.max_bitrate_bps = 34000; |
284 config.send_codec_spec.nack_enabled = true; | 338 config.send_codec_spec = |
285 config.send_codec_spec.transport_cc_enabled = false; | 339 rtc::Optional<AudioSendStream::Config::SendCodecSpec>( |
286 config.send_codec_spec.enable_codec_fec = true; | 340 {kIsacPayloadType, kIsacFormat}); |
287 config.send_codec_spec.enable_opus_dtx = false; | 341 config.send_codec_spec->nack_enabled = true; |
288 config.send_codec_spec.opus_max_playback_rate = 32000; | 342 config.send_codec_spec->transport_cc_enabled = false; |
289 config.send_codec_spec.cng_payload_type = 42; | 343 config.send_codec_spec->cng_payload_type = rtc::Optional<int>(42); |
290 config.send_codec_spec.cng_plfreq = 56; | 344 config.encoder_factory = MockAudioEncoderFactory::CreateUnusedFactory(); |
291 config.send_codec_spec.min_ptime_ms = 20; | |
292 config.send_codec_spec.max_ptime_ms = 60; | |
293 config.send_codec_spec.codec_inst = kIsacCodec; | |
294 config.rtp.extensions.push_back( | 345 config.rtp.extensions.push_back( |
295 RtpExtension(RtpExtension::kAudioLevelUri, kAudioLevelId)); | 346 RtpExtension(RtpExtension::kAudioLevelUri, kAudioLevelId)); |
296 EXPECT_EQ( | 347 EXPECT_EQ( |
297 "{rtp: {ssrc: 1234, extensions: [{uri: " | 348 "{rtp: {ssrc: 1234, extensions: [{uri: " |
298 "urn:ietf:params:rtp-hdrext:ssrc-audio-level, id: 2}], nack: " | 349 "urn:ietf:params:rtp-hdrext:ssrc-audio-level, id: 2}], nack: " |
299 "{rtp_history_ms: 0}, c_name: foo_name}, send_transport: null, " | 350 "{rtp_history_ms: 0}, c_name: foo_name}, send_transport: null, " |
300 "voe_channel_id: 1, min_bitrate_bps: 12000, max_bitrate_bps: 34000, " | 351 "voe_channel_id: 1, min_bitrate_bps: 12000, max_bitrate_bps: 34000, " |
301 "send_codec_spec: {nack_enabled: true, transport_cc_enabled: false, " | 352 "send_codec_spec: {nack_enabled: true, transport_cc_enabled: false, " |
302 "enable_codec_fec: true, enable_opus_dtx: false, opus_max_playback_rate: " | 353 "cng_payload_type: 42, payload_type: 103, " |
303 "32000, cng_payload_type: 42, cng_plfreq: 56, min_ptime: 20, max_ptime: " | 354 "format: {name: isac, clockrate_hz: 16000, num_channels: 1, " |
304 "60, codec_inst: {pltype: 103, plname: \"isac\", plfreq: 16000, pacsize: " | 355 "parameters: {}}}}", |
305 "320, channels: 1, rate: 32000}}}", | |
306 config.ToString()); | 356 config.ToString()); |
307 } | 357 } |
308 | 358 |
309 TEST(AudioSendStreamTest, ConstructDestruct) { | 359 TEST(AudioSendStreamTest, ConstructDestruct) { |
310 ConfigHelper helper(false); | 360 ConfigHelper helper(false, true); |
311 internal::AudioSendStream send_stream( | 361 internal::AudioSendStream send_stream( |
312 helper.config(), helper.audio_state(), helper.worker_queue(), | 362 helper.config(), helper.audio_state(), helper.worker_queue(), |
313 helper.transport(), helper.bitrate_allocator(), helper.event_log(), | 363 helper.transport(), helper.bitrate_allocator(), helper.event_log(), |
314 helper.rtcp_rtt_stats()); | 364 helper.rtcp_rtt_stats()); |
315 } | 365 } |
316 | 366 |
317 TEST(AudioSendStreamTest, SendTelephoneEvent) { | 367 TEST(AudioSendStreamTest, SendTelephoneEvent) { |
318 ConfigHelper helper(false); | 368 ConfigHelper helper(false, true); |
319 internal::AudioSendStream send_stream( | 369 internal::AudioSendStream send_stream( |
320 helper.config(), helper.audio_state(), helper.worker_queue(), | 370 helper.config(), helper.audio_state(), helper.worker_queue(), |
321 helper.transport(), helper.bitrate_allocator(), helper.event_log(), | 371 helper.transport(), helper.bitrate_allocator(), helper.event_log(), |
322 helper.rtcp_rtt_stats()); | 372 helper.rtcp_rtt_stats()); |
323 helper.SetupMockForSendTelephoneEvent(); | 373 helper.SetupMockForSendTelephoneEvent(); |
324 EXPECT_TRUE(send_stream.SendTelephoneEvent(kTelephoneEventPayloadType, | 374 EXPECT_TRUE(send_stream.SendTelephoneEvent(kTelephoneEventPayloadType, |
325 kTelephoneEventPayloadFrequency, kTelephoneEventCode, | 375 kTelephoneEventPayloadFrequency, kTelephoneEventCode, |
326 kTelephoneEventDuration)); | 376 kTelephoneEventDuration)); |
327 } | 377 } |
328 | 378 |
329 TEST(AudioSendStreamTest, SetMuted) { | 379 TEST(AudioSendStreamTest, SetMuted) { |
330 ConfigHelper helper(false); | 380 ConfigHelper helper(false, true); |
331 internal::AudioSendStream send_stream( | 381 internal::AudioSendStream send_stream( |
332 helper.config(), helper.audio_state(), helper.worker_queue(), | 382 helper.config(), helper.audio_state(), helper.worker_queue(), |
333 helper.transport(), helper.bitrate_allocator(), helper.event_log(), | 383 helper.transport(), helper.bitrate_allocator(), helper.event_log(), |
334 helper.rtcp_rtt_stats()); | 384 helper.rtcp_rtt_stats()); |
335 EXPECT_CALL(*helper.channel_proxy(), SetInputMute(true)); | 385 EXPECT_CALL(*helper.channel_proxy(), SetInputMute(true)); |
336 send_stream.SetMuted(true); | 386 send_stream.SetMuted(true); |
337 } | 387 } |
338 | 388 |
339 TEST(AudioSendStreamTest, AudioBweCorrectObjectsOnChannelProxy) { | 389 TEST(AudioSendStreamTest, AudioBweCorrectObjectsOnChannelProxy) { |
340 ConfigHelper helper(true); | 390 ConfigHelper helper(true, true); |
341 internal::AudioSendStream send_stream( | 391 internal::AudioSendStream send_stream( |
342 helper.config(), helper.audio_state(), helper.worker_queue(), | 392 helper.config(), helper.audio_state(), helper.worker_queue(), |
343 helper.transport(), helper.bitrate_allocator(), helper.event_log(), | 393 helper.transport(), helper.bitrate_allocator(), helper.event_log(), |
344 helper.rtcp_rtt_stats()); | 394 helper.rtcp_rtt_stats()); |
345 } | 395 } |
346 | 396 |
347 TEST(AudioSendStreamTest, NoAudioBweCorrectObjectsOnChannelProxy) { | 397 TEST(AudioSendStreamTest, NoAudioBweCorrectObjectsOnChannelProxy) { |
348 ConfigHelper helper(false); | 398 ConfigHelper helper(false, true); |
349 internal::AudioSendStream send_stream( | 399 internal::AudioSendStream send_stream( |
350 helper.config(), helper.audio_state(), helper.worker_queue(), | 400 helper.config(), helper.audio_state(), helper.worker_queue(), |
351 helper.transport(), helper.bitrate_allocator(), helper.event_log(), | 401 helper.transport(), helper.bitrate_allocator(), helper.event_log(), |
352 helper.rtcp_rtt_stats()); | 402 helper.rtcp_rtt_stats()); |
353 } | 403 } |
354 | 404 |
355 TEST(AudioSendStreamTest, GetStats) { | 405 TEST(AudioSendStreamTest, GetStats) { |
356 ConfigHelper helper(false); | 406 ConfigHelper helper(false, true); |
357 internal::AudioSendStream send_stream( | 407 internal::AudioSendStream send_stream( |
358 helper.config(), helper.audio_state(), helper.worker_queue(), | 408 helper.config(), helper.audio_state(), helper.worker_queue(), |
359 helper.transport(), helper.bitrate_allocator(), helper.event_log(), | 409 helper.transport(), helper.bitrate_allocator(), helper.event_log(), |
360 helper.rtcp_rtt_stats()); | 410 helper.rtcp_rtt_stats()); |
361 helper.SetupMockForGetStats(); | 411 helper.SetupMockForGetStats(); |
362 AudioSendStream::Stats stats = send_stream.GetStats(); | 412 AudioSendStream::Stats stats = send_stream.GetStats(); |
363 EXPECT_EQ(kSsrc, stats.local_ssrc); | 413 EXPECT_EQ(kSsrc, stats.local_ssrc); |
364 EXPECT_EQ(static_cast<int64_t>(kCallStats.bytesSent), stats.bytes_sent); | 414 EXPECT_EQ(static_cast<int64_t>(kCallStats.bytesSent), stats.bytes_sent); |
365 EXPECT_EQ(kCallStats.packetsSent, stats.packets_sent); | 415 EXPECT_EQ(kCallStats.packetsSent, stats.packets_sent); |
366 EXPECT_EQ(static_cast<int32_t>(kReportBlock.cumulative_num_packets_lost), | 416 EXPECT_EQ(static_cast<int32_t>(kReportBlock.cumulative_num_packets_lost), |
(...skipping 10 matching lines...) Expand all Loading... |
377 EXPECT_EQ(-1, stats.aec_quality_min); | 427 EXPECT_EQ(-1, stats.aec_quality_min); |
378 EXPECT_EQ(kEchoDelayMedian, stats.echo_delay_median_ms); | 428 EXPECT_EQ(kEchoDelayMedian, stats.echo_delay_median_ms); |
379 EXPECT_EQ(kEchoDelayStdDev, stats.echo_delay_std_ms); | 429 EXPECT_EQ(kEchoDelayStdDev, stats.echo_delay_std_ms); |
380 EXPECT_EQ(kEchoReturnLoss, stats.echo_return_loss); | 430 EXPECT_EQ(kEchoReturnLoss, stats.echo_return_loss); |
381 EXPECT_EQ(kEchoReturnLossEnhancement, stats.echo_return_loss_enhancement); | 431 EXPECT_EQ(kEchoReturnLossEnhancement, stats.echo_return_loss_enhancement); |
382 EXPECT_EQ(kResidualEchoLikelihood, stats.residual_echo_likelihood); | 432 EXPECT_EQ(kResidualEchoLikelihood, stats.residual_echo_likelihood); |
383 EXPECT_FALSE(stats.typing_noise_detected); | 433 EXPECT_FALSE(stats.typing_noise_detected); |
384 } | 434 } |
385 | 435 |
386 TEST(AudioSendStreamTest, GetStatsTypingNoiseDetected) { | 436 TEST(AudioSendStreamTest, GetStatsTypingNoiseDetected) { |
387 ConfigHelper helper(false); | 437 ConfigHelper helper(false, true); |
388 internal::AudioSendStream send_stream( | 438 internal::AudioSendStream send_stream( |
389 helper.config(), helper.audio_state(), helper.worker_queue(), | 439 helper.config(), helper.audio_state(), helper.worker_queue(), |
390 helper.transport(), helper.bitrate_allocator(), helper.event_log(), | 440 helper.transport(), helper.bitrate_allocator(), helper.event_log(), |
391 helper.rtcp_rtt_stats()); | 441 helper.rtcp_rtt_stats()); |
392 helper.SetupMockForGetStats(); | 442 helper.SetupMockForGetStats(); |
393 EXPECT_FALSE(send_stream.GetStats().typing_noise_detected); | 443 EXPECT_FALSE(send_stream.GetStats().typing_noise_detected); |
394 | 444 |
395 internal::AudioState* internal_audio_state = | 445 internal::AudioState* internal_audio_state = |
396 static_cast<internal::AudioState*>(helper.audio_state().get()); | 446 static_cast<internal::AudioState*>(helper.audio_state().get()); |
397 VoiceEngineObserver* voe_observer = | 447 VoiceEngineObserver* voe_observer = |
398 static_cast<VoiceEngineObserver*>(internal_audio_state); | 448 static_cast<VoiceEngineObserver*>(internal_audio_state); |
399 voe_observer->CallbackOnError(-1, VE_TYPING_NOISE_WARNING); | 449 voe_observer->CallbackOnError(-1, VE_TYPING_NOISE_WARNING); |
400 EXPECT_TRUE(send_stream.GetStats().typing_noise_detected); | 450 EXPECT_TRUE(send_stream.GetStats().typing_noise_detected); |
401 voe_observer->CallbackOnError(-1, VE_TYPING_NOISE_OFF_WARNING); | 451 voe_observer->CallbackOnError(-1, VE_TYPING_NOISE_OFF_WARNING); |
402 EXPECT_FALSE(send_stream.GetStats().typing_noise_detected); | 452 EXPECT_FALSE(send_stream.GetStats().typing_noise_detected); |
403 } | 453 } |
404 | 454 |
405 TEST(AudioSendStreamTest, SendCodecAppliesConfigParams) { | 455 TEST(AudioSendStreamTest, SendCodecAppliesNetworkAdaptor) { |
406 ConfigHelper helper(false); | 456 ConfigHelper helper(false, true); |
407 auto stream_config = helper.config(); | 457 auto stream_config = helper.config(); |
408 const CodecInst kOpusCodec = {111, "opus", 48000, 960, 2, 64000}; | 458 stream_config.send_codec_spec = |
409 stream_config.send_codec_spec.codec_inst = kOpusCodec; | 459 rtc::Optional<AudioSendStream::Config::SendCodecSpec>({0, kOpusFormat}); |
410 stream_config.send_codec_spec.enable_codec_fec = true; | |
411 stream_config.send_codec_spec.enable_opus_dtx = true; | |
412 stream_config.send_codec_spec.opus_max_playback_rate = 12345; | |
413 stream_config.send_codec_spec.cng_plfreq = 16000; | |
414 stream_config.send_codec_spec.cng_payload_type = 105; | |
415 stream_config.send_codec_spec.min_ptime_ms = 10; | |
416 stream_config.send_codec_spec.max_ptime_ms = 60; | |
417 stream_config.audio_network_adaptor_config = | 460 stream_config.audio_network_adaptor_config = |
418 rtc::Optional<std::string>("abced"); | 461 rtc::Optional<std::string>("abced"); |
419 EXPECT_CALL(*helper.channel_proxy(), SetCodecFECStatus(true)) | 462 |
420 .WillOnce(Return(true)); | 463 EXPECT_CALL(helper.mock_encoder_factory(), MakeAudioEncoderMock(_, _, _)) |
421 EXPECT_CALL( | 464 .WillOnce(Invoke([](int payload_type, const SdpAudioFormat& format, |
422 *helper.channel_proxy(), | 465 std::unique_ptr<AudioEncoder>* return_value) { |
423 SetOpusDtx(stream_config.send_codec_spec.enable_opus_dtx)) | 466 auto mock_encoder = SetupAudioEncoderMock(payload_type, format); |
424 .WillOnce(Return(true)); | 467 EXPECT_CALL(*mock_encoder.get(), EnableAudioNetworkAdaptor(_, _, _)) |
425 EXPECT_CALL( | 468 .WillOnce(Return(true)); |
426 *helper.channel_proxy(), | 469 *return_value = std::move(mock_encoder); |
427 SetOpusMaxPlaybackRate( | 470 })); |
428 stream_config.send_codec_spec.opus_max_playback_rate)) | 471 |
429 .WillOnce(Return(true)); | |
430 EXPECT_CALL(*helper.channel_proxy(), | |
431 SetSendCNPayloadType( | |
432 stream_config.send_codec_spec.cng_payload_type, | |
433 webrtc::kFreq16000Hz)) | |
434 .WillOnce(Return(true)); | |
435 EXPECT_CALL( | |
436 *helper.channel_proxy(), | |
437 SetReceiverFrameLengthRange(stream_config.send_codec_spec.min_ptime_ms, | |
438 stream_config.send_codec_spec.max_ptime_ms)); | |
439 EXPECT_CALL( | |
440 *helper.channel_proxy(), | |
441 EnableAudioNetworkAdaptor(*stream_config.audio_network_adaptor_config)); | |
442 internal::AudioSendStream send_stream( | 472 internal::AudioSendStream send_stream( |
443 stream_config, helper.audio_state(), helper.worker_queue(), | 473 stream_config, helper.audio_state(), helper.worker_queue(), |
444 helper.transport(), helper.bitrate_allocator(), helper.event_log(), | 474 helper.transport(), helper.bitrate_allocator(), helper.event_log(), |
445 helper.rtcp_rtt_stats()); | 475 helper.rtcp_rtt_stats()); |
446 } | 476 } |
447 | 477 |
448 // VAD is applied when codec is mono and the CNG frequency matches the codec | 478 // VAD is applied when codec is mono and the CNG frequency matches the codec |
449 // sample rate. | 479 // clock rate. |
450 TEST(AudioSendStreamTest, SendCodecCanApplyVad) { | 480 TEST(AudioSendStreamTest, SendCodecCanApplyVad) { |
451 ConfigHelper helper(false); | 481 ConfigHelper helper(false, false); |
452 auto stream_config = helper.config(); | 482 auto stream_config = helper.config(); |
453 const CodecInst kG722Codec = {9, "g722", 8000, 160, 1, 16000}; | 483 stream_config.send_codec_spec = |
454 stream_config.send_codec_spec.codec_inst = kG722Codec; | 484 rtc::Optional<AudioSendStream::Config::SendCodecSpec>({9, kG722Format}); |
455 stream_config.send_codec_spec.cng_plfreq = 8000; | 485 stream_config.send_codec_spec->cng_payload_type = rtc::Optional<int>(105); |
456 stream_config.send_codec_spec.cng_payload_type = 105; | 486 using ::testing::Invoke; |
457 EXPECT_CALL(*helper.channel_proxy(), SetVADStatus(true)) | 487 std::unique_ptr<AudioEncoder> stolen_encoder; |
458 .WillOnce(Return(true)); | 488 EXPECT_CALL(*helper.channel_proxy(), SetEncoderForMock(_, _)) |
| 489 .WillOnce( |
| 490 Invoke([&stolen_encoder](int payload_type, |
| 491 std::unique_ptr<AudioEncoder>* encoder) { |
| 492 stolen_encoder = std::move(*encoder); |
| 493 return true; |
| 494 })); |
| 495 |
459 internal::AudioSendStream send_stream( | 496 internal::AudioSendStream send_stream( |
460 stream_config, helper.audio_state(), helper.worker_queue(), | 497 stream_config, helper.audio_state(), helper.worker_queue(), |
461 helper.transport(), helper.bitrate_allocator(), helper.event_log(), | 498 helper.transport(), helper.bitrate_allocator(), helper.event_log(), |
462 helper.rtcp_rtt_stats()); | 499 helper.rtcp_rtt_stats()); |
| 500 |
| 501 // We cannot truly determine if the encoder created is an AudioEncoderCng. It |
| 502 // is the only reasonable implementation that will return something from |
| 503 // ReclaimContainedEncoders, though. |
| 504 ASSERT_TRUE(stolen_encoder); |
| 505 EXPECT_FALSE(stolen_encoder->ReclaimContainedEncoders().empty()); |
463 } | 506 } |
464 | 507 |
465 TEST(AudioSendStreamTest, DoesNotPassHigherBitrateThanMaxBitrate) { | 508 TEST(AudioSendStreamTest, DoesNotPassHigherBitrateThanMaxBitrate) { |
466 ConfigHelper helper(false); | 509 ConfigHelper helper(false, true); |
467 internal::AudioSendStream send_stream( | 510 internal::AudioSendStream send_stream( |
468 helper.config(), helper.audio_state(), helper.worker_queue(), | 511 helper.config(), helper.audio_state(), helper.worker_queue(), |
469 helper.transport(), helper.bitrate_allocator(), helper.event_log(), | 512 helper.transport(), helper.bitrate_allocator(), helper.event_log(), |
470 helper.rtcp_rtt_stats()); | 513 helper.rtcp_rtt_stats()); |
471 EXPECT_CALL(*helper.channel_proxy(), | 514 EXPECT_CALL(*helper.channel_proxy(), |
472 SetBitrate(helper.config().max_bitrate_bps, _)); | 515 SetBitrate(helper.config().max_bitrate_bps, _)); |
473 send_stream.OnBitrateUpdated(helper.config().max_bitrate_bps + 5000, 0.0, 50, | 516 send_stream.OnBitrateUpdated(helper.config().max_bitrate_bps + 5000, 0.0, 50, |
474 6000); | 517 6000); |
475 } | 518 } |
476 | 519 |
477 TEST(AudioSendStreamTest, ProbingIntervalOnBitrateUpdated) { | 520 TEST(AudioSendStreamTest, ProbingIntervalOnBitrateUpdated) { |
478 ConfigHelper helper(false); | 521 ConfigHelper helper(false, true); |
479 internal::AudioSendStream send_stream( | 522 internal::AudioSendStream send_stream( |
480 helper.config(), helper.audio_state(), helper.worker_queue(), | 523 helper.config(), helper.audio_state(), helper.worker_queue(), |
481 helper.transport(), helper.bitrate_allocator(), helper.event_log(), | 524 helper.transport(), helper.bitrate_allocator(), helper.event_log(), |
482 helper.rtcp_rtt_stats()); | 525 helper.rtcp_rtt_stats()); |
483 EXPECT_CALL(*helper.channel_proxy(), SetBitrate(_, 5000)); | 526 EXPECT_CALL(*helper.channel_proxy(), SetBitrate(_, 5000)); |
484 send_stream.OnBitrateUpdated(50000, 0.0, 50, 5000); | 527 send_stream.OnBitrateUpdated(50000, 0.0, 50, 5000); |
485 } | 528 } |
486 | 529 |
| 530 // Test that AudioSendStream doesn't recreate the encoder unnecessarily. |
| 531 TEST(AudioSendStreamTest, DontRecreateEncoder) { |
| 532 ConfigHelper helper(false, false); |
| 533 // WillOnce is (currently) the default used by ConfigHelper if asked to set an |
| 534 // expectation for SetEncoder. Since this behavior is essential for this test |
| 535 // to be correct, it's instead set-up manually here. Otherwise a simple change |
| 536 // to ConfigHelper (say to WillRepeatedly) would silently make this test |
| 537 // useless. |
| 538 EXPECT_CALL(*helper.channel_proxy(), SetEncoderForMock(_, _)) |
| 539 .WillOnce(Return(true)); |
| 540 |
| 541 auto stream_config = helper.config(); |
| 542 stream_config.send_codec_spec = |
| 543 rtc::Optional<AudioSendStream::Config::SendCodecSpec>({9, kG722Format}); |
| 544 stream_config.send_codec_spec->cng_payload_type = rtc::Optional<int>(105); |
| 545 internal::AudioSendStream send_stream( |
| 546 stream_config, helper.audio_state(), helper.worker_queue(), |
| 547 helper.transport(), helper.bitrate_allocator(), helper.event_log(), |
| 548 helper.rtcp_rtt_stats()); |
| 549 send_stream.Reconfigure(stream_config); |
| 550 } |
| 551 |
487 } // namespace test | 552 } // namespace test |
488 } // namespace webrtc | 553 } // namespace webrtc |
OLD | NEW |