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_interface.h" | 19 #include "webrtc/call/rtp_transport_controller_send_interface.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 10 matching lines...) Expand all Loading... |
169 EnableSendTransportSequenceNumber(kTransportSequenceNumberId)) | 229 EnableSendTransportSequenceNumber(kTransportSequenceNumberId)) |
170 .Times(1); | 230 .Times(1); |
171 EXPECT_CALL(*channel_proxy_, RegisterSenderCongestionControlObjects( | 231 EXPECT_CALL(*channel_proxy_, RegisterSenderCongestionControlObjects( |
172 &fake_transport_, Ne(nullptr))) | 232 &fake_transport_, Ne(nullptr))) |
173 .Times(1); | 233 .Times(1); |
174 } else { | 234 } else { |
175 EXPECT_CALL(*channel_proxy_, RegisterSenderCongestionControlObjects( | 235 EXPECT_CALL(*channel_proxy_, RegisterSenderCongestionControlObjects( |
176 &fake_transport_, Eq(nullptr))) | 236 &fake_transport_, Eq(nullptr))) |
177 .Times(1); | 237 .Times(1); |
178 } | 238 } |
| 239 EXPECT_CALL(*channel_proxy_, SetBitrate(_, _)) |
| 240 .Times(1); |
179 EXPECT_CALL(*channel_proxy_, ResetSenderCongestionControlObjects()) | 241 EXPECT_CALL(*channel_proxy_, ResetSenderCongestionControlObjects()) |
180 .Times(1); | 242 .Times(1); |
181 EXPECT_CALL(*channel_proxy_, RegisterExternalTransport(nullptr)).Times(1); | 243 EXPECT_CALL(*channel_proxy_, RegisterExternalTransport(nullptr)).Times(1); |
182 EXPECT_CALL(*channel_proxy_, DeRegisterExternalTransport()).Times(1); | 244 EXPECT_CALL(*channel_proxy_, DeRegisterExternalTransport()).Times(1); |
183 EXPECT_CALL(*channel_proxy_, SetRtcEventLog(testing::NotNull())).Times(1); | 245 EXPECT_CALL(*channel_proxy_, SetRtcEventLog(testing::NotNull())).Times(1); |
184 EXPECT_CALL(*channel_proxy_, SetRtcEventLog(testing::IsNull())) | 246 EXPECT_CALL(*channel_proxy_, SetRtcEventLog(testing::IsNull())) |
185 .Times(1); // Destructor resets the event log | 247 .Times(1); // Destructor resets the event log |
186 EXPECT_CALL(*channel_proxy_, SetRtcpRttStats(&rtcp_rtt_stats_)).Times(1); | 248 EXPECT_CALL(*channel_proxy_, SetRtcpRttStats(&rtcp_rtt_stats_)).Times(1); |
187 EXPECT_CALL(*channel_proxy_, SetRtcpRttStats(testing::IsNull())) | 249 EXPECT_CALL(*channel_proxy_, SetRtcpRttStats(testing::IsNull())) |
188 .Times(1); // Destructor resets the rtt stats. | 250 .Times(1); // Destructor resets the rtt stats. |
189 } | 251 } |
190 | 252 |
191 void SetupMockForSetupSendCodec() { | 253 void SetupMockForSetupSendCodec(bool expect_set_encoder_call) { |
192 EXPECT_CALL(*channel_proxy_, SetVADStatus(false)) | 254 if (expect_set_encoder_call) { |
193 .WillOnce(Return(true)); | 255 EXPECT_CALL(*channel_proxy_, SetEncoderForMock(_, _)) |
194 EXPECT_CALL(*channel_proxy_, SetCodecFECStatus(false)) | 256 .WillOnce(Return(true)); |
195 .WillOnce(Return(true)); | 257 } |
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 } | 258 } |
| 259 |
202 RtcpRttStats* rtcp_rtt_stats() { return &rtcp_rtt_stats_; } | 260 RtcpRttStats* rtcp_rtt_stats() { return &rtcp_rtt_stats_; } |
203 | 261 |
204 void SetupMockForSendTelephoneEvent() { | 262 void SetupMockForSendTelephoneEvent() { |
205 EXPECT_TRUE(channel_proxy_); | 263 EXPECT_TRUE(channel_proxy_); |
206 EXPECT_CALL(*channel_proxy_, | 264 EXPECT_CALL(*channel_proxy_, |
207 SetSendTelephoneEventPayloadType(kTelephoneEventPayloadType, | 265 SetSendTelephoneEventPayloadType(kTelephoneEventPayloadType, |
208 kTelephoneEventPayloadFrequency)) | 266 kTelephoneEventPayloadFrequency)) |
209 .WillOnce(Return(true)); | 267 .WillOnce(Return(true)); |
210 EXPECT_CALL(*channel_proxy_, | 268 EXPECT_CALL(*channel_proxy_, |
211 SendTelephoneEventOutband(kTelephoneEventCode, kTelephoneEventDuration)) | 269 SendTelephoneEventOutband(kTelephoneEventCode, kTelephoneEventDuration)) |
(...skipping 11 matching lines...) Expand all Loading... |
223 block.source_SSRC = kSsrc; | 281 block.source_SSRC = kSsrc; |
224 report_blocks.push_back(block); // Correct block. | 282 report_blocks.push_back(block); // Correct block. |
225 block.fraction_lost = 0; | 283 block.fraction_lost = 0; |
226 report_blocks.push_back(block); // Duplicate SSRC, bad fraction_lost. | 284 report_blocks.push_back(block); // Duplicate SSRC, bad fraction_lost. |
227 | 285 |
228 EXPECT_TRUE(channel_proxy_); | 286 EXPECT_TRUE(channel_proxy_); |
229 EXPECT_CALL(*channel_proxy_, GetRTCPStatistics()) | 287 EXPECT_CALL(*channel_proxy_, GetRTCPStatistics()) |
230 .WillRepeatedly(Return(kCallStats)); | 288 .WillRepeatedly(Return(kCallStats)); |
231 EXPECT_CALL(*channel_proxy_, GetRemoteRTCPReportBlocks()) | 289 EXPECT_CALL(*channel_proxy_, GetRemoteRTCPReportBlocks()) |
232 .WillRepeatedly(Return(report_blocks)); | 290 .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()) | 291 EXPECT_CALL(voice_engine_, transmit_mixer()) |
236 .WillRepeatedly(Return(&transmit_mixer_)); | 292 .WillRepeatedly(Return(&transmit_mixer_)); |
237 EXPECT_CALL(voice_engine_, audio_processing()) | 293 EXPECT_CALL(voice_engine_, audio_processing()) |
238 .WillRepeatedly(Return(&audio_processing_)); | 294 .WillRepeatedly(Return(&audio_processing_)); |
239 | 295 |
240 EXPECT_CALL(transmit_mixer_, AudioLevelFullRange()) | 296 EXPECT_CALL(transmit_mixer_, AudioLevelFullRange()) |
241 .WillRepeatedly(Return(kSpeechInputLevel)); | 297 .WillRepeatedly(Return(kSpeechInputLevel)); |
242 | 298 |
243 // We have to set the instantaneous value, the average, min and max. We only | 299 // 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. | 300 // care about the instantaneous value, so we set all to the same value. |
(...skipping 29 matching lines...) Expand all Loading... |
274 }; | 330 }; |
275 } // namespace | 331 } // namespace |
276 | 332 |
277 TEST(AudioSendStreamTest, ConfigToString) { | 333 TEST(AudioSendStreamTest, ConfigToString) { |
278 AudioSendStream::Config config(nullptr); | 334 AudioSendStream::Config config(nullptr); |
279 config.rtp.ssrc = kSsrc; | 335 config.rtp.ssrc = kSsrc; |
280 config.rtp.c_name = kCName; | 336 config.rtp.c_name = kCName; |
281 config.voe_channel_id = kChannelId; | 337 config.voe_channel_id = kChannelId; |
282 config.min_bitrate_bps = 12000; | 338 config.min_bitrate_bps = 12000; |
283 config.max_bitrate_bps = 34000; | 339 config.max_bitrate_bps = 34000; |
284 config.send_codec_spec.nack_enabled = true; | 340 config.send_codec_spec = |
285 config.send_codec_spec.transport_cc_enabled = false; | 341 rtc::Optional<AudioSendStream::Config::SendCodecSpec>( |
286 config.send_codec_spec.enable_codec_fec = true; | 342 {kIsacPayloadType, kIsacFormat}); |
287 config.send_codec_spec.enable_opus_dtx = false; | 343 config.send_codec_spec->nack_enabled = true; |
288 config.send_codec_spec.opus_max_playback_rate = 32000; | 344 config.send_codec_spec->transport_cc_enabled = false; |
289 config.send_codec_spec.cng_payload_type = 42; | 345 config.send_codec_spec->cng_payload_type = rtc::Optional<int>(42); |
290 config.send_codec_spec.cng_plfreq = 56; | 346 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( | 347 config.rtp.extensions.push_back( |
295 RtpExtension(RtpExtension::kAudioLevelUri, kAudioLevelId)); | 348 RtpExtension(RtpExtension::kAudioLevelUri, kAudioLevelId)); |
296 EXPECT_EQ( | 349 EXPECT_EQ( |
297 "{rtp: {ssrc: 1234, extensions: [{uri: " | 350 "{rtp: {ssrc: 1234, extensions: [{uri: " |
298 "urn:ietf:params:rtp-hdrext:ssrc-audio-level, id: 2}], nack: " | 351 "urn:ietf:params:rtp-hdrext:ssrc-audio-level, id: 2}], nack: " |
299 "{rtp_history_ms: 0}, c_name: foo_name}, send_transport: null, " | 352 "{rtp_history_ms: 0}, c_name: foo_name}, send_transport: null, " |
300 "voe_channel_id: 1, min_bitrate_bps: 12000, max_bitrate_bps: 34000, " | 353 "voe_channel_id: 1, min_bitrate_bps: 12000, max_bitrate_bps: 34000, " |
301 "send_codec_spec: {nack_enabled: true, transport_cc_enabled: false, " | 354 "send_codec_spec: {nack_enabled: true, transport_cc_enabled: false, " |
302 "enable_codec_fec: true, enable_opus_dtx: false, opus_max_playback_rate: " | 355 "cng_payload_type: 42, payload_type: 103, " |
303 "32000, cng_payload_type: 42, cng_plfreq: 56, min_ptime: 20, max_ptime: " | 356 "format: {name: isac, clockrate_hz: 16000, num_channels: 1, " |
304 "60, codec_inst: {pltype: 103, plname: \"isac\", plfreq: 16000, pacsize: " | 357 "parameters: {}}}}", |
305 "320, channels: 1, rate: 32000}}}", | |
306 config.ToString()); | 358 config.ToString()); |
307 } | 359 } |
308 | 360 |
309 TEST(AudioSendStreamTest, ConstructDestruct) { | 361 TEST(AudioSendStreamTest, ConstructDestruct) { |
310 ConfigHelper helper(false); | 362 ConfigHelper helper(false, true); |
311 internal::AudioSendStream send_stream( | 363 internal::AudioSendStream send_stream( |
312 helper.config(), helper.audio_state(), helper.worker_queue(), | 364 helper.config(), helper.audio_state(), helper.worker_queue(), |
313 helper.transport(), helper.bitrate_allocator(), helper.event_log(), | 365 helper.transport(), helper.bitrate_allocator(), helper.event_log(), |
314 helper.rtcp_rtt_stats()); | 366 helper.rtcp_rtt_stats()); |
315 } | 367 } |
316 | 368 |
317 TEST(AudioSendStreamTest, SendTelephoneEvent) { | 369 TEST(AudioSendStreamTest, SendTelephoneEvent) { |
318 ConfigHelper helper(false); | 370 ConfigHelper helper(false, true); |
319 internal::AudioSendStream send_stream( | 371 internal::AudioSendStream send_stream( |
320 helper.config(), helper.audio_state(), helper.worker_queue(), | 372 helper.config(), helper.audio_state(), helper.worker_queue(), |
321 helper.transport(), helper.bitrate_allocator(), helper.event_log(), | 373 helper.transport(), helper.bitrate_allocator(), helper.event_log(), |
322 helper.rtcp_rtt_stats()); | 374 helper.rtcp_rtt_stats()); |
323 helper.SetupMockForSendTelephoneEvent(); | 375 helper.SetupMockForSendTelephoneEvent(); |
324 EXPECT_TRUE(send_stream.SendTelephoneEvent(kTelephoneEventPayloadType, | 376 EXPECT_TRUE(send_stream.SendTelephoneEvent(kTelephoneEventPayloadType, |
325 kTelephoneEventPayloadFrequency, kTelephoneEventCode, | 377 kTelephoneEventPayloadFrequency, kTelephoneEventCode, |
326 kTelephoneEventDuration)); | 378 kTelephoneEventDuration)); |
327 } | 379 } |
328 | 380 |
329 TEST(AudioSendStreamTest, SetMuted) { | 381 TEST(AudioSendStreamTest, SetMuted) { |
330 ConfigHelper helper(false); | 382 ConfigHelper helper(false, true); |
331 internal::AudioSendStream send_stream( | 383 internal::AudioSendStream send_stream( |
332 helper.config(), helper.audio_state(), helper.worker_queue(), | 384 helper.config(), helper.audio_state(), helper.worker_queue(), |
333 helper.transport(), helper.bitrate_allocator(), helper.event_log(), | 385 helper.transport(), helper.bitrate_allocator(), helper.event_log(), |
334 helper.rtcp_rtt_stats()); | 386 helper.rtcp_rtt_stats()); |
335 EXPECT_CALL(*helper.channel_proxy(), SetInputMute(true)); | 387 EXPECT_CALL(*helper.channel_proxy(), SetInputMute(true)); |
336 send_stream.SetMuted(true); | 388 send_stream.SetMuted(true); |
337 } | 389 } |
338 | 390 |
339 TEST(AudioSendStreamTest, AudioBweCorrectObjectsOnChannelProxy) { | 391 TEST(AudioSendStreamTest, AudioBweCorrectObjectsOnChannelProxy) { |
340 ConfigHelper helper(true); | 392 ConfigHelper helper(true, true); |
341 internal::AudioSendStream send_stream( | 393 internal::AudioSendStream send_stream( |
342 helper.config(), helper.audio_state(), helper.worker_queue(), | 394 helper.config(), helper.audio_state(), helper.worker_queue(), |
343 helper.transport(), helper.bitrate_allocator(), helper.event_log(), | 395 helper.transport(), helper.bitrate_allocator(), helper.event_log(), |
344 helper.rtcp_rtt_stats()); | 396 helper.rtcp_rtt_stats()); |
345 } | 397 } |
346 | 398 |
347 TEST(AudioSendStreamTest, NoAudioBweCorrectObjectsOnChannelProxy) { | 399 TEST(AudioSendStreamTest, NoAudioBweCorrectObjectsOnChannelProxy) { |
348 ConfigHelper helper(false); | 400 ConfigHelper helper(false, true); |
349 internal::AudioSendStream send_stream( | 401 internal::AudioSendStream send_stream( |
350 helper.config(), helper.audio_state(), helper.worker_queue(), | 402 helper.config(), helper.audio_state(), helper.worker_queue(), |
351 helper.transport(), helper.bitrate_allocator(), helper.event_log(), | 403 helper.transport(), helper.bitrate_allocator(), helper.event_log(), |
352 helper.rtcp_rtt_stats()); | 404 helper.rtcp_rtt_stats()); |
353 } | 405 } |
354 | 406 |
355 TEST(AudioSendStreamTest, GetStats) { | 407 TEST(AudioSendStreamTest, GetStats) { |
356 ConfigHelper helper(false); | 408 ConfigHelper helper(false, true); |
357 internal::AudioSendStream send_stream( | 409 internal::AudioSendStream send_stream( |
358 helper.config(), helper.audio_state(), helper.worker_queue(), | 410 helper.config(), helper.audio_state(), helper.worker_queue(), |
359 helper.transport(), helper.bitrate_allocator(), helper.event_log(), | 411 helper.transport(), helper.bitrate_allocator(), helper.event_log(), |
360 helper.rtcp_rtt_stats()); | 412 helper.rtcp_rtt_stats()); |
361 helper.SetupMockForGetStats(); | 413 helper.SetupMockForGetStats(); |
362 AudioSendStream::Stats stats = send_stream.GetStats(); | 414 AudioSendStream::Stats stats = send_stream.GetStats(); |
363 EXPECT_EQ(kSsrc, stats.local_ssrc); | 415 EXPECT_EQ(kSsrc, stats.local_ssrc); |
364 EXPECT_EQ(static_cast<int64_t>(kCallStats.bytesSent), stats.bytes_sent); | 416 EXPECT_EQ(static_cast<int64_t>(kCallStats.bytesSent), stats.bytes_sent); |
365 EXPECT_EQ(kCallStats.packetsSent, stats.packets_sent); | 417 EXPECT_EQ(kCallStats.packetsSent, stats.packets_sent); |
366 EXPECT_EQ(static_cast<int32_t>(kReportBlock.cumulative_num_packets_lost), | 418 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); | 429 EXPECT_EQ(-1, stats.aec_quality_min); |
378 EXPECT_EQ(kEchoDelayMedian, stats.echo_delay_median_ms); | 430 EXPECT_EQ(kEchoDelayMedian, stats.echo_delay_median_ms); |
379 EXPECT_EQ(kEchoDelayStdDev, stats.echo_delay_std_ms); | 431 EXPECT_EQ(kEchoDelayStdDev, stats.echo_delay_std_ms); |
380 EXPECT_EQ(kEchoReturnLoss, stats.echo_return_loss); | 432 EXPECT_EQ(kEchoReturnLoss, stats.echo_return_loss); |
381 EXPECT_EQ(kEchoReturnLossEnhancement, stats.echo_return_loss_enhancement); | 433 EXPECT_EQ(kEchoReturnLossEnhancement, stats.echo_return_loss_enhancement); |
382 EXPECT_EQ(kResidualEchoLikelihood, stats.residual_echo_likelihood); | 434 EXPECT_EQ(kResidualEchoLikelihood, stats.residual_echo_likelihood); |
383 EXPECT_FALSE(stats.typing_noise_detected); | 435 EXPECT_FALSE(stats.typing_noise_detected); |
384 } | 436 } |
385 | 437 |
386 TEST(AudioSendStreamTest, GetStatsTypingNoiseDetected) { | 438 TEST(AudioSendStreamTest, GetStatsTypingNoiseDetected) { |
387 ConfigHelper helper(false); | 439 ConfigHelper helper(false, true); |
388 internal::AudioSendStream send_stream( | 440 internal::AudioSendStream send_stream( |
389 helper.config(), helper.audio_state(), helper.worker_queue(), | 441 helper.config(), helper.audio_state(), helper.worker_queue(), |
390 helper.transport(), helper.bitrate_allocator(), helper.event_log(), | 442 helper.transport(), helper.bitrate_allocator(), helper.event_log(), |
391 helper.rtcp_rtt_stats()); | 443 helper.rtcp_rtt_stats()); |
392 helper.SetupMockForGetStats(); | 444 helper.SetupMockForGetStats(); |
393 EXPECT_FALSE(send_stream.GetStats().typing_noise_detected); | 445 EXPECT_FALSE(send_stream.GetStats().typing_noise_detected); |
394 | 446 |
395 internal::AudioState* internal_audio_state = | 447 internal::AudioState* internal_audio_state = |
396 static_cast<internal::AudioState*>(helper.audio_state().get()); | 448 static_cast<internal::AudioState*>(helper.audio_state().get()); |
397 VoiceEngineObserver* voe_observer = | 449 VoiceEngineObserver* voe_observer = |
398 static_cast<VoiceEngineObserver*>(internal_audio_state); | 450 static_cast<VoiceEngineObserver*>(internal_audio_state); |
399 voe_observer->CallbackOnError(-1, VE_TYPING_NOISE_WARNING); | 451 voe_observer->CallbackOnError(-1, VE_TYPING_NOISE_WARNING); |
400 EXPECT_TRUE(send_stream.GetStats().typing_noise_detected); | 452 EXPECT_TRUE(send_stream.GetStats().typing_noise_detected); |
401 voe_observer->CallbackOnError(-1, VE_TYPING_NOISE_OFF_WARNING); | 453 voe_observer->CallbackOnError(-1, VE_TYPING_NOISE_OFF_WARNING); |
402 EXPECT_FALSE(send_stream.GetStats().typing_noise_detected); | 454 EXPECT_FALSE(send_stream.GetStats().typing_noise_detected); |
403 } | 455 } |
404 | 456 |
405 TEST(AudioSendStreamTest, SendCodecAppliesConfigParams) { | 457 TEST(AudioSendStreamTest, SendCodecAppliesNetworkAdaptor) { |
406 ConfigHelper helper(false); | 458 ConfigHelper helper(false, true); |
407 auto stream_config = helper.config(); | 459 auto stream_config = helper.config(); |
408 const CodecInst kOpusCodec = {111, "opus", 48000, 960, 2, 64000}; | 460 stream_config.send_codec_spec = |
409 stream_config.send_codec_spec.codec_inst = kOpusCodec; | 461 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 = | 462 stream_config.audio_network_adaptor_config = |
418 rtc::Optional<std::string>("abced"); | 463 rtc::Optional<std::string>("abced"); |
419 EXPECT_CALL(*helper.channel_proxy(), SetCodecFECStatus(true)) | 464 |
420 .WillOnce(Return(true)); | 465 EXPECT_CALL(helper.mock_encoder_factory(), MakeAudioEncoderMock(_, _, _)) |
421 EXPECT_CALL( | 466 .WillOnce(Invoke([](int payload_type, const SdpAudioFormat& format, |
422 *helper.channel_proxy(), | 467 std::unique_ptr<AudioEncoder>* return_value) { |
423 SetOpusDtx(stream_config.send_codec_spec.enable_opus_dtx)) | 468 auto mock_encoder = SetupAudioEncoderMock(payload_type, format); |
424 .WillOnce(Return(true)); | 469 EXPECT_CALL(*mock_encoder.get(), EnableAudioNetworkAdaptor(_, _)) |
425 EXPECT_CALL( | 470 .WillOnce(Return(true)); |
426 *helper.channel_proxy(), | 471 *return_value = std::move(mock_encoder); |
427 SetOpusMaxPlaybackRate( | 472 })); |
428 stream_config.send_codec_spec.opus_max_playback_rate)) | 473 |
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( | 474 internal::AudioSendStream send_stream( |
443 stream_config, helper.audio_state(), helper.worker_queue(), | 475 stream_config, helper.audio_state(), helper.worker_queue(), |
444 helper.transport(), helper.bitrate_allocator(), helper.event_log(), | 476 helper.transport(), helper.bitrate_allocator(), helper.event_log(), |
445 helper.rtcp_rtt_stats()); | 477 helper.rtcp_rtt_stats()); |
446 } | 478 } |
447 | 479 |
448 // VAD is applied when codec is mono and the CNG frequency matches the codec | 480 // VAD is applied when codec is mono and the CNG frequency matches the codec |
449 // sample rate. | 481 // clock rate. |
450 TEST(AudioSendStreamTest, SendCodecCanApplyVad) { | 482 TEST(AudioSendStreamTest, SendCodecCanApplyVad) { |
451 ConfigHelper helper(false); | 483 ConfigHelper helper(false, false); |
452 auto stream_config = helper.config(); | 484 auto stream_config = helper.config(); |
453 const CodecInst kG722Codec = {9, "g722", 8000, 160, 1, 16000}; | 485 stream_config.send_codec_spec = |
454 stream_config.send_codec_spec.codec_inst = kG722Codec; | 486 rtc::Optional<AudioSendStream::Config::SendCodecSpec>({9, kG722Format}); |
455 stream_config.send_codec_spec.cng_plfreq = 8000; | 487 stream_config.send_codec_spec->cng_payload_type = rtc::Optional<int>(105); |
456 stream_config.send_codec_spec.cng_payload_type = 105; | 488 using ::testing::Invoke; |
457 EXPECT_CALL(*helper.channel_proxy(), SetVADStatus(true)) | 489 std::unique_ptr<AudioEncoder> stolen_encoder; |
458 .WillOnce(Return(true)); | 490 EXPECT_CALL(*helper.channel_proxy(), SetEncoderForMock(_, _)) |
| 491 .WillOnce( |
| 492 Invoke([&stolen_encoder](int payload_type, |
| 493 std::unique_ptr<AudioEncoder>* encoder) { |
| 494 stolen_encoder = std::move(*encoder); |
| 495 return true; |
| 496 })); |
| 497 |
459 internal::AudioSendStream send_stream( | 498 internal::AudioSendStream send_stream( |
460 stream_config, helper.audio_state(), helper.worker_queue(), | 499 stream_config, helper.audio_state(), helper.worker_queue(), |
461 helper.transport(), helper.bitrate_allocator(), helper.event_log(), | 500 helper.transport(), helper.bitrate_allocator(), helper.event_log(), |
462 helper.rtcp_rtt_stats()); | 501 helper.rtcp_rtt_stats()); |
| 502 |
| 503 // We cannot truly determine if the encoder created is an AudioEncoderCng. It |
| 504 // is the only reasonable implementation that will return something from |
| 505 // ReclaimContainedEncoders, though. |
| 506 ASSERT_TRUE(stolen_encoder); |
| 507 EXPECT_FALSE(stolen_encoder->ReclaimContainedEncoders().empty()); |
463 } | 508 } |
464 | 509 |
465 TEST(AudioSendStreamTest, DoesNotPassHigherBitrateThanMaxBitrate) { | 510 TEST(AudioSendStreamTest, DoesNotPassHigherBitrateThanMaxBitrate) { |
466 ConfigHelper helper(false); | 511 ConfigHelper helper(false, true); |
467 internal::AudioSendStream send_stream( | 512 internal::AudioSendStream send_stream( |
468 helper.config(), helper.audio_state(), helper.worker_queue(), | 513 helper.config(), helper.audio_state(), helper.worker_queue(), |
469 helper.transport(), helper.bitrate_allocator(), helper.event_log(), | 514 helper.transport(), helper.bitrate_allocator(), helper.event_log(), |
470 helper.rtcp_rtt_stats()); | 515 helper.rtcp_rtt_stats()); |
471 EXPECT_CALL(*helper.channel_proxy(), | 516 EXPECT_CALL(*helper.channel_proxy(), |
472 SetBitrate(helper.config().max_bitrate_bps, _)); | 517 SetBitrate(helper.config().max_bitrate_bps, _)); |
473 send_stream.OnBitrateUpdated(helper.config().max_bitrate_bps + 5000, 0.0, 50, | 518 send_stream.OnBitrateUpdated(helper.config().max_bitrate_bps + 5000, 0.0, 50, |
474 6000); | 519 6000); |
475 } | 520 } |
476 | 521 |
477 TEST(AudioSendStreamTest, ProbingIntervalOnBitrateUpdated) { | 522 TEST(AudioSendStreamTest, ProbingIntervalOnBitrateUpdated) { |
478 ConfigHelper helper(false); | 523 ConfigHelper helper(false, true); |
479 internal::AudioSendStream send_stream( | 524 internal::AudioSendStream send_stream( |
480 helper.config(), helper.audio_state(), helper.worker_queue(), | 525 helper.config(), helper.audio_state(), helper.worker_queue(), |
481 helper.transport(), helper.bitrate_allocator(), helper.event_log(), | 526 helper.transport(), helper.bitrate_allocator(), helper.event_log(), |
482 helper.rtcp_rtt_stats()); | 527 helper.rtcp_rtt_stats()); |
483 EXPECT_CALL(*helper.channel_proxy(), SetBitrate(_, 5000)); | 528 EXPECT_CALL(*helper.channel_proxy(), SetBitrate(_, 5000)); |
484 send_stream.OnBitrateUpdated(50000, 0.0, 50, 5000); | 529 send_stream.OnBitrateUpdated(50000, 0.0, 50, 5000); |
485 } | 530 } |
486 | 531 |
| 532 // Test that AudioSendStream doesn't recreate the encoder unnecessarily. |
| 533 TEST(AudioSendStreamTest, DontRecreateEncoder) { |
| 534 ConfigHelper helper(false, false); |
| 535 // WillOnce is (currently) the default used by ConfigHelper if asked to set an |
| 536 // expectation for SetEncoder. Since this behavior is essential for this test |
| 537 // to be correct, it's instead set-up manually here. Otherwise a simple change |
| 538 // to ConfigHelper (say to WillRepeatedly) would silently make this test |
| 539 // useless. |
| 540 EXPECT_CALL(*helper.channel_proxy(), SetEncoderForMock(_, _)) |
| 541 .WillOnce(Return(true)); |
| 542 |
| 543 auto stream_config = helper.config(); |
| 544 stream_config.send_codec_spec = |
| 545 rtc::Optional<AudioSendStream::Config::SendCodecSpec>({9, kG722Format}); |
| 546 stream_config.send_codec_spec->cng_payload_type = rtc::Optional<int>(105); |
| 547 internal::AudioSendStream send_stream( |
| 548 stream_config, helper.audio_state(), helper.worker_queue(), |
| 549 helper.transport(), helper.bitrate_allocator(), helper.event_log(), |
| 550 helper.rtcp_rtt_stats()); |
| 551 send_stream.Reconfigure(stream_config); |
| 552 } |
| 553 |
487 } // namespace test | 554 } // namespace test |
488 } // namespace webrtc | 555 } // namespace webrtc |
OLD | NEW |