blob: e89dffa497f04eeb442aa9fbf221185e25e2728f [file] [log] [blame]
solenbergc7a8b082015-10-16 21:35:071/*
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
Jonas Olssona4d87372019-07-05 17:08:3311#include "audio/audio_send_stream.h"
12
Harald Alvestrand75223522024-11-18 07:18:3513#include <cstddef>
14#include <cstdint>
Mirko Bonadei317a1f02019-09-17 15:06:1815#include <memory>
Harald Alvestrand75223522024-11-18 07:18:3516#include <optional>
Fredrik Solenbergea073732015-12-01 10:26:3417#include <string>
ossu20a4b3f2017-04-27 09:08:5218#include <utility>
Fredrik Solenbergea073732015-12-01 10:26:3419#include <vector>
20
Harald Alvestrand75223522024-11-18 07:18:3521#include "api/audio/audio_frame.h"
Florent Castelli0afde762024-04-19 15:07:0822#include "api/audio/audio_processing_statistics.h"
Harald Alvestrand75223522024-11-18 07:18:3523#include "api/audio_codecs/audio_encoder.h"
24#include "api/audio_codecs/audio_format.h"
25#include "api/call/bitrate_allocation.h"
26#include "api/crypto/frame_encryptor_interface.h"
Danil Chapovalovc157f292024-05-28 16:16:5327#include "api/environment/environment_factory.h"
Harald Alvestrand75223522024-11-18 07:18:3528#include "api/function_view.h"
29#include "api/make_ref_counted.h"
30#include "api/rtp_parameters.h"
31#include "api/scoped_refptr.h"
Benjamin Wright78410ad2018-10-25 16:52:5732#include "api/test/mock_frame_encryptor.h"
Harald Alvestrand75223522024-11-18 07:18:3533#include "api/transport/network_types.h"
34#include "api/units/data_rate.h"
35#include "api/units/data_size.h"
36#include "api/units/time_delta.h"
Mirko Bonadei92ea95e2017-09-15 04:47:3137#include "audio/audio_state.h"
Harald Alvestrand75223522024-11-18 07:18:3538#include "audio/channel_send.h"
Mirko Bonadei92ea95e2017-09-15 04:47:3139#include "audio/conversion.h"
Fredrik Solenberga8b7c7f2018-01-17 10:18:3140#include "audio/mock_voe_channel_proxy.h"
Harald Alvestrand75223522024-11-18 07:18:3541#include "call/audio_state.h"
42#include "call/bitrate_allocator.h"
Dan Tan68e85b82024-01-29 23:02:5943#include "call/test/mock_bitrate_allocator.h"
Sebastian Janssonef9daee2018-02-22 13:49:0244#include "call/test/mock_rtp_transport_controller_send.h"
Fredrik Solenberg2a877972017-12-15 15:42:1545#include "modules/audio_device/include/mock_audio_device.h"
Mirko Bonadei92ea95e2017-09-15 04:47:3146#include "modules/audio_mixer/audio_mixer_impl.h"
Henrik Boströmd2c336f2019-07-03 15:11:1047#include "modules/audio_mixer/sine_wave_generator.h"
Mirko Bonadei92ea95e2017-09-15 04:47:3148#include "modules/audio_processing/include/mock_audio_processing.h"
Harald Alvestrand75223522024-11-18 07:18:3549#include "modules/rtp_rtcp/include/report_block_data.h"
Danil Chapovalov3e392542023-05-17 11:25:3950#include "modules/rtp_rtcp/mocks/mock_network_link_rtcp_observer.h"
Mirko Bonadei92ea95e2017-09-15 04:47:3151#include "modules/rtp_rtcp/mocks/mock_rtp_rtcp.h"
Harald Alvestrand75223522024-11-18 07:18:3552#include "modules/rtp_rtcp/source/rtp_header_extensions.h"
53#include "test/gmock.h"
Mirko Bonadei92ea95e2017-09-15 04:47:3154#include "test/gtest.h"
55#include "test/mock_audio_encoder.h"
56#include "test/mock_audio_encoder_factory.h"
Jonas Orelanda943e732022-03-16 12:50:5857#include "test/scoped_key_value_config.h"
Per Kjellander828ef912022-10-10 10:53:4158#include "test/time_controller/real_time_controller.h"
solenbergc7a8b082015-10-16 21:35:0759
60namespace webrtc {
solenberg85a04962015-10-27 10:35:2161namespace test {
Fredrik Solenberg0ccae132015-11-03 09:15:4962namespace {
63
Mirko Bonadei6a489f22019-04-09 13:11:1264using ::testing::_;
Henrik Boströmd2c336f2019-07-03 15:11:1065using ::testing::AnyNumber;
Mirko Bonadei6a489f22019-04-09 13:11:1266using ::testing::Eq;
67using ::testing::Field;
Jakob Ivarssonfde2b242020-08-20 14:48:4968using ::testing::InSequence;
Mirko Bonadei6a489f22019-04-09 13:11:1269using ::testing::Invoke;
70using ::testing::Ne;
Alex Konradic20baf62020-12-03 16:30:3471using ::testing::NiceMock;
Mirko Bonadei6a489f22019-04-09 13:11:1272using ::testing::Return;
73using ::testing::StrEq;
Danil Chapovalov954e72b2024-07-10 17:22:0774using ::testing::WithArg;
solenberg3a941542015-11-16 15:34:5075
Henrik Boströmd2c336f2019-07-03 15:11:1076static const float kTolerance = 0.0001f;
77
Fredrik Solenberg0ccae132015-11-03 09:15:4978const uint32_t kSsrc = 1234;
solenberg3a941542015-11-16 15:34:5079const char* kCName = "foo_name";
80const int kAudioLevelId = 2;
Stefan Holmerb86d4e42015-12-07 09:26:1881const int kTransportSequenceNumberId = 4;
Ivo Creusen56d460902017-11-24 16:29:5982const int32_t kEchoDelayMedian = 254;
83const int32_t kEchoDelayStdDev = -3;
84const double kDivergentFilterFraction = 0.2f;
85const double kEchoReturnLoss = -65;
86const double kEchoReturnLossEnhancement = 101;
87const double kResidualEchoLikelihood = -1.0f;
88const double kResidualEchoLikelihoodMax = 23.0f;
Niels Möllerac0a4cb2019-10-09 13:01:3389const CallSendStatistics kCallStats = {112, 12, 13456, 17890};
Danil Chapovalova9b9d4e2023-05-03 11:20:1190constexpr int kFractionLost = 123;
91constexpr int kCumulativeLost = 567;
92constexpr uint32_t kInterarrivalJitter = 132;
Fredrik Solenbergb5727682015-12-04 14:22:1993const int kTelephoneEventPayloadType = 123;
solenbergffbbcac2016-11-17 13:25:3794const int kTelephoneEventPayloadFrequency = 65432;
solenberg8842c3e2016-03-11 11:06:4195const int kTelephoneEventCode = 45;
96const int kTelephoneEventDuration = 6789;
ossu20a4b3f2017-04-27 09:08:5297constexpr int kIsacPayloadType = 103;
98const SdpAudioFormat kIsacFormat = {"isac", 16000, 1};
99const SdpAudioFormat kOpusFormat = {"opus", 48000, 2};
100const SdpAudioFormat kG722Format = {"g722", 8000, 1};
101const AudioCodecSpec kCodecSpecs[] = {
102 {kIsacFormat, {16000, 1, 32000, 10000, 32000}},
103 {kOpusFormat, {48000, 1, 32000, 6000, 510000}},
104 {kG722Format, {16000, 1, 64000}}};
solenberg566ef242015-11-06 23:34:49105
Daniel Lee93562522019-05-03 12:40:13106// TODO(dklee): This mirrors calculation in audio_send_stream.cc, which
107// should be made more precise in the future. This can be changed when that
108// logic is more accurate.
Danil Chapovalovcad3e0e2020-02-17 17:46:07109const DataSize kOverheadPerPacket = DataSize::Bytes(20 + 8 + 10 + 12);
Danil Chapovalov0c626af2020-02-10 10:16:00110const TimeDelta kMinFrameLength = TimeDelta::Millis(20);
111const TimeDelta kMaxFrameLength = TimeDelta::Millis(120);
Sebastian Jansson62aee932019-10-02 10:27:06112const DataRate kMinOverheadRate = kOverheadPerPacket / kMaxFrameLength;
113const DataRate kMaxOverheadRate = kOverheadPerPacket / kMinFrameLength;
Daniel Lee93562522019-05-03 12:40:13114
mflodman86cc6ff2016-07-26 11:44:06115class MockLimitObserver : public BitrateAllocator::LimitObserver {
116 public:
Danil Chapovalovf9c6b682020-05-15 09:40:44117 MOCK_METHOD(void,
118 OnAllocationLimitsChanged,
119 (BitrateAllocationLimits),
120 (override));
mflodman86cc6ff2016-07-26 11:44:06121};
122
ossu20a4b3f2017-04-27 09:08:52123std::unique_ptr<MockAudioEncoder> SetupAudioEncoderMock(
ossu20a4b3f2017-04-27 09:08:52124 const SdpAudioFormat& format) {
125 for (const auto& spec : kCodecSpecs) {
126 if (format == spec.format) {
Danil Chapovalov954e72b2024-07-10 17:22:07127 auto encoder = std::make_unique<NiceMock<MockAudioEncoder>>();
128 ON_CALL(*encoder, SampleRateHz)
ossu20a4b3f2017-04-27 09:08:52129 .WillByDefault(Return(spec.info.sample_rate_hz));
Danil Chapovalov954e72b2024-07-10 17:22:07130 ON_CALL(*encoder, NumChannels)
ossu20a4b3f2017-04-27 09:08:52131 .WillByDefault(Return(spec.info.num_channels));
Danil Chapovalov954e72b2024-07-10 17:22:07132 ON_CALL(*encoder, RtpTimestampRateHz)
ossu20a4b3f2017-04-27 09:08:52133 .WillByDefault(Return(spec.format.clockrate_hz));
Danil Chapovalov954e72b2024-07-10 17:22:07134 ON_CALL(*encoder, GetFrameLengthRange)
135 .WillByDefault(Return(
136 std::make_pair(TimeDelta::Millis(20), TimeDelta::Millis(120))));
ossu20a4b3f2017-04-27 09:08:52137 return encoder;
138 }
139 }
140 return nullptr;
141}
142
143rtc::scoped_refptr<MockAudioEncoderFactory> SetupEncoderFactoryMock() {
144 rtc::scoped_refptr<MockAudioEncoderFactory> factory =
Tomas Gunnarssonc1d58912021-04-22 17:21:43145 rtc::make_ref_counted<MockAudioEncoderFactory>();
Danil Chapovalov954e72b2024-07-10 17:22:07146 ON_CALL(*factory, GetSupportedEncoders)
ossu20a4b3f2017-04-27 09:08:52147 .WillByDefault(Return(std::vector<AudioCodecSpec>(
148 std::begin(kCodecSpecs), std::end(kCodecSpecs))));
Danil Chapovalov954e72b2024-07-10 17:22:07149 ON_CALL(*factory, QueryAudioEncoder)
150 .WillByDefault(
Florent Castelli8037fc62024-08-29 13:00:40151 [](const SdpAudioFormat& format) -> std::optional<AudioCodecInfo> {
Oskar Sundbom2707fb22017-11-16 09:57:35152 for (const auto& spec : kCodecSpecs) {
153 if (format == spec.format) {
154 return spec.info;
155 }
156 }
Florent Castelli8037fc62024-08-29 13:00:40157 return std::nullopt;
Danil Chapovalov954e72b2024-07-10 17:22:07158 });
159 ON_CALL(*factory, Create).WillByDefault(WithArg<1>(&SetupAudioEncoderMock));
ossu20a4b3f2017-04-27 09:08:52160 return factory;
161}
162
solenberg566ef242015-11-06 23:34:49163struct ConfigHelper {
Per Åhgrencc73ed32020-04-26 21:56:17164 ConfigHelper(bool audio_bwe_enabled,
165 bool expect_set_encoder_call,
166 bool use_null_audio_processing)
Per Kjellander828ef912022-10-10 10:53:41167 : stream_config_(/*send_transport=*/nullptr),
Per Åhgrencc73ed32020-04-26 21:56:17168 audio_processing_(
169 use_null_audio_processing
170 ? nullptr
Tomas Gunnarssonc1d58912021-04-22 17:21:43171 : rtc::make_ref_counted<NiceMock<MockAudioProcessing>>()),
minyue-webrtc8de18262017-07-26 12:18:40172 audio_encoder_(nullptr) {
Mirko Bonadei6a489f22019-04-09 13:11:12173 using ::testing::Invoke;
solenberg3a941542015-11-16 15:34:50174
solenberg566ef242015-11-06 23:34:49175 AudioState::Config config;
aleloi10111bc2016-11-17 14:48:48176 config.audio_mixer = AudioMixerImpl::Create();
peaha9cc40b2017-06-29 15:32:09177 config.audio_processing = audio_processing_;
Tomas Gunnarssonc1d58912021-04-22 17:21:43178 config.audio_device_module = rtc::make_ref_counted<MockAudioDeviceModule>();
solenberg566ef242015-11-06 23:34:49179 audio_state_ = AudioState::Create(config);
solenberg3a941542015-11-16 15:34:50180
Niels Möllerdced9f62018-11-19 09:27:07181 SetupDefaultChannelSend(audio_bwe_enabled);
ossu20a4b3f2017-04-27 09:08:52182 SetupMockForSetupSendCodec(expect_set_encoder_call);
Jakob Ivarssond14525e2020-03-06 08:49:29183 SetupMockForCallEncoder();
minyue6b825df2016-10-31 11:08:32184
Artem Titovb0ea6372021-07-26 09:47:07185 // Use ISAC as default codec so as to prevent unnecessary `channel_proxy_`
ossu20a4b3f2017-04-27 09:08:52186 // calls from the default ctor behavior.
187 stream_config_.send_codec_spec =
Oskar Sundbom2707fb22017-11-16 09:57:35188 AudioSendStream::Config::SendCodecSpec(kIsacPayloadType, kIsacFormat);
solenberg566ef242015-11-06 23:34:49189 stream_config_.rtp.ssrc = kSsrc;
solenberg3a941542015-11-16 15:34:50190 stream_config_.rtp.c_name = kCName;
191 stream_config_.rtp.extensions.push_back(
isheriff6f8d6862016-05-26 18:24:55192 RtpExtension(RtpExtension::kAudioLevelUri, kAudioLevelId));
stefan7de8d642017-02-07 15:14:08193 if (audio_bwe_enabled) {
ossu1129df22017-06-30 08:38:56194 AddBweToConfig(&stream_config_);
stefan7de8d642017-02-07 15:14:08195 }
ossu20a4b3f2017-04-27 09:08:52196 stream_config_.encoder_factory = SetupEncoderFactoryMock();
minyue78b4d562016-11-30 12:47:39197 stream_config_.min_bitrate_bps = 10000;
198 stream_config_.max_bitrate_bps = 65000;
solenberg566ef242015-11-06 23:34:49199 }
200
Fredrik Solenberg8f5787a2018-01-11 12:52:30201 std::unique_ptr<internal::AudioSendStream> CreateAudioSendStream() {
Danil Chapovalovc157f292024-05-28 16:16:53202 return std::make_unique<internal::AudioSendStream>(
203 CreateEnvironment(&field_trials, time_controller_.GetClock(),
204 time_controller_.GetTaskQueueFactory()),
205 stream_config_, audio_state_, &rtp_transport_, &bitrate_allocator_,
Florent Castelli8037fc62024-08-29 13:00:40206 std::nullopt,
Danil Chapovalovc157f292024-05-28 16:16:53207 std::unique_ptr<voe::ChannelSendInterface>(channel_send_));
Fredrik Solenberg8f5787a2018-01-11 12:52:30208 }
209
solenberg566ef242015-11-06 23:34:49210 AudioSendStream::Config& config() { return stream_config_; }
ossu20a4b3f2017-04-27 09:08:52211 MockAudioEncoderFactory& mock_encoder_factory() {
212 return *static_cast<MockAudioEncoderFactory*>(
213 stream_config_.encoder_factory.get());
214 }
Tomas Gunnarssonf25761d2020-06-03 20:55:33215 MockRtpRtcpInterface* rtp_rtcp() { return &rtp_rtcp_; }
Niels Möllerdced9f62018-11-19 09:27:07216 MockChannelSend* channel_send() { return channel_send_; }
Sebastian Jansson1896cec2018-02-20 08:06:11217 RtpTransportControllerSendInterface* transport() { return &rtp_transport_; }
Dan Tan68e85b82024-01-29 23:02:59218 MockBitrateAllocator* bitrate_allocator() { return &bitrate_allocator_; }
minyue7a973442016-10-20 10:27:12219
ossu1129df22017-06-30 08:38:56220 static void AddBweToConfig(AudioSendStream::Config* config) {
Yves Gerey665174f2018-06-19 13:03:05221 config->rtp.extensions.push_back(RtpExtension(
222 RtpExtension::kTransportSequenceNumberUri, kTransportSequenceNumberId));
ossu1129df22017-06-30 08:38:56223 }
224
Niels Möllerdced9f62018-11-19 09:27:07225 void SetupDefaultChannelSend(bool audio_bwe_enabled) {
226 EXPECT_TRUE(channel_send_ == nullptr);
Mirko Bonadei6a489f22019-04-09 13:11:12227 channel_send_ = new ::testing::StrictMock<MockChannelSend>();
Niels Möllerdced9f62018-11-19 09:27:07228 EXPECT_CALL(*channel_send_, GetRtpRtcp()).WillRepeatedly(Invoke([this]() {
Niels Möller848d6d32018-08-08 08:49:16229 return &this->rtp_rtcp_;
230 }));
Erik Språng70efdde2019-08-21 11:36:20231 EXPECT_CALL(rtp_rtcp_, SSRC).WillRepeatedly(Return(kSsrc));
Niels Möllerdced9f62018-11-19 09:27:07232 EXPECT_CALL(*channel_send_, SetRTCP_CNAME(StrEq(kCName))).Times(1);
Niels Möllerdced9f62018-11-19 09:27:07233 EXPECT_CALL(*channel_send_, SetFrameEncryptor(_)).Times(1);
Marina Ciocead2aa8f92020-03-31 09:29:56234 EXPECT_CALL(*channel_send_, SetEncoderToPacketizerFrameTransformer(_))
235 .Times(1);
Sebastian Jansson6298b562020-01-14 16:55:19236 EXPECT_CALL(rtp_rtcp_, SetExtmapAllowMixed(false)).Times(1);
Niels Möllerdced9f62018-11-19 09:27:07237 EXPECT_CALL(*channel_send_,
minyue6b825df2016-10-31 11:08:32238 SetSendAudioLevelIndicationStatus(true, kAudioLevelId))
239 .Times(1);
Danil Chapovalov3e392542023-05-17 11:25:39240 EXPECT_CALL(rtp_transport_, GetRtcpObserver)
241 .WillRepeatedly(Return(&rtcp_observer_));
stefan7de8d642017-02-07 15:14:08242 if (audio_bwe_enabled) {
Sebastian Jansson6298b562020-01-14 16:55:19243 EXPECT_CALL(rtp_rtcp_,
Danil Chapovalovd0321c52021-09-14 10:58:51244 RegisterRtpHeaderExtension(TransportSequenceNumber::Uri(),
Sebastian Jansson6298b562020-01-14 16:55:19245 kTransportSequenceNumberId))
stefan7de8d642017-02-07 15:14:08246 .Times(1);
stefan7de8d642017-02-07 15:14:08247 }
Danil Chapovalova2cf8ee2023-05-16 11:26:33248 EXPECT_CALL(*channel_send_,
249 RegisterSenderCongestionControlObjects(&rtp_transport_))
250 .Times(1);
Niels Möllerdced9f62018-11-19 09:27:07251 EXPECT_CALL(*channel_send_, ResetSenderCongestionControlObjects()).Times(1);
minyue6b825df2016-10-31 11:08:32252 }
253
ossu20a4b3f2017-04-27 09:08:52254 void SetupMockForSetupSendCodec(bool expect_set_encoder_call) {
255 if (expect_set_encoder_call) {
Danil Chapovalovf9c6b682020-05-15 09:40:44256 EXPECT_CALL(*channel_send_, SetEncoder)
Dor Henb52416e2024-10-27 13:59:51257 .WillOnce([this](int /* payload_type */,
258 const SdpAudioFormat& /* format */,
Philipp Hancked2098932023-11-01 18:18:32259 std::unique_ptr<AudioEncoder> encoder) {
260 this->audio_encoder_ = std::move(encoder);
261 return true;
262 });
ossu20a4b3f2017-04-27 09:08:52263 }
minyue7a973442016-10-20 10:27:12264 }
ossu20a4b3f2017-04-27 09:08:52265
Sebastian Jansson14a7cf92019-02-13 14:11:42266 void SetupMockForCallEncoder() {
minyue-webrtc8de18262017-07-26 12:18:40267 // Let ModifyEncoder to invoke mock audio encoder.
Sebastian Jansson14a7cf92019-02-13 14:11:42268 EXPECT_CALL(*channel_send_, CallEncoder(_))
Artem Titove7d08df2019-01-16 13:49:44269 .WillRepeatedly(
Sebastian Jansson14a7cf92019-02-13 14:11:42270 [this](rtc::FunctionView<void(AudioEncoder*)> modifier) {
minyue-webrtc8de18262017-07-26 12:18:40271 if (this->audio_encoder_)
Sebastian Jansson14a7cf92019-02-13 14:11:42272 modifier(this->audio_encoder_.get());
Artem Titove7d08df2019-01-16 13:49:44273 });
minyue-webrtc8de18262017-07-26 12:18:40274 }
275
Fredrik Solenbergb5727682015-12-04 14:22:19276 void SetupMockForSendTelephoneEvent() {
Niels Möllerdced9f62018-11-19 09:27:07277 EXPECT_TRUE(channel_send_);
278 EXPECT_CALL(*channel_send_, SetSendTelephoneEventPayloadType(
279 kTelephoneEventPayloadType,
Niels Möller8fb1a6a2019-03-05 13:29:42280 kTelephoneEventPayloadFrequency));
Yves Gerey665174f2018-06-19 13:03:05281 EXPECT_CALL(
Niels Möllerdced9f62018-11-19 09:27:07282 *channel_send_,
Fredrik Solenbergb5727682015-12-04 14:22:19283 SendTelephoneEventOutband(kTelephoneEventCode, kTelephoneEventDuration))
Yves Gerey665174f2018-06-19 13:03:05284 .WillOnce(Return(true));
Fredrik Solenbergb5727682015-12-04 14:22:19285 }
286
Per Åhgrencc73ed32020-04-26 21:56:17287 void SetupMockForGetStats(bool use_null_audio_processing) {
Mirko Bonadei6a489f22019-04-09 13:11:12288 using ::testing::DoAll;
289 using ::testing::SetArgPointee;
290 using ::testing::SetArgReferee;
solenberg3a941542015-11-16 15:34:50291
Danil Chapovalova9b9d4e2023-05-03 11:20:11292 std::vector<ReportBlockData> report_blocks;
293 ReportBlockData block;
294 block.set_source_ssrc(780);
295 block.set_fraction_lost_raw(kFractionLost);
296 block.set_cumulative_lost(kCumulativeLost);
297 block.set_jitter(kInterarrivalJitter);
solenberg566ef242015-11-06 23:34:49298 report_blocks.push_back(block); // Has wrong SSRC.
Danil Chapovalova9b9d4e2023-05-03 11:20:11299 block.set_source_ssrc(kSsrc);
solenberg566ef242015-11-06 23:34:49300 report_blocks.push_back(block); // Correct block.
Danil Chapovalova9b9d4e2023-05-03 11:20:11301 block.set_fraction_lost_raw(0);
solenberg566ef242015-11-06 23:34:49302 report_blocks.push_back(block); // Duplicate SSRC, bad fraction_lost.
303
Niels Möllerdced9f62018-11-19 09:27:07304 EXPECT_TRUE(channel_send_);
305 EXPECT_CALL(*channel_send_, GetRTCPStatistics())
solenberg358057b2015-11-27 18:46:42306 .WillRepeatedly(Return(kCallStats));
Niels Möllerdced9f62018-11-19 09:27:07307 EXPECT_CALL(*channel_send_, GetRemoteRTCPReportBlocks())
solenberg358057b2015-11-27 18:46:42308 .WillRepeatedly(Return(report_blocks));
Niels Möllerdced9f62018-11-19 09:27:07309 EXPECT_CALL(*channel_send_, GetANAStatistics())
ivoce1198e02017-09-08 15:13:19310 .WillRepeatedly(Return(ANAStats()));
Jakob Ivarssonbf087452021-11-11 12:43:49311 EXPECT_CALL(*channel_send_, GetTargetBitrate()).WillRepeatedly(Return(0));
solenberg796b8f92017-03-02 01:02:23312
Ivo Creusen56d460902017-11-24 16:29:59313 audio_processing_stats_.echo_return_loss = kEchoReturnLoss;
314 audio_processing_stats_.echo_return_loss_enhancement =
315 kEchoReturnLossEnhancement;
316 audio_processing_stats_.delay_median_ms = kEchoDelayMedian;
317 audio_processing_stats_.delay_standard_deviation_ms = kEchoDelayStdDev;
318 audio_processing_stats_.divergent_filter_fraction =
319 kDivergentFilterFraction;
320 audio_processing_stats_.residual_echo_likelihood = kResidualEchoLikelihood;
321 audio_processing_stats_.residual_echo_likelihood_recent_max =
322 kResidualEchoLikelihoodMax;
Per Åhgrencc73ed32020-04-26 21:56:17323 if (!use_null_audio_processing) {
324 ASSERT_TRUE(audio_processing_);
325 EXPECT_CALL(*audio_processing_, GetStatistics(true))
326 .WillRepeatedly(Return(audio_processing_stats_));
327 }
solenberg566ef242015-11-06 23:34:49328 }
Per Åhgrencc73ed32020-04-26 21:56:17329
Jonas Orelanda943e732022-03-16 12:50:58330 test::ScopedKeyValueConfig field_trials;
331
solenberg566ef242015-11-06 23:34:49332 private:
Per Kjellander828ef912022-10-10 10:53:41333 RealTimeController time_controller_;
solenberg566ef242015-11-06 23:34:49334 rtc::scoped_refptr<AudioState> audio_state_;
335 AudioSendStream::Config stream_config_;
Mirko Bonadei6a489f22019-04-09 13:11:12336 ::testing::StrictMock<MockChannelSend>* channel_send_ = nullptr;
peaha9cc40b2017-06-29 15:32:09337 rtc::scoped_refptr<MockAudioProcessing> audio_processing_;
Ivo Creusen56d460902017-11-24 16:29:59338 AudioProcessingStats audio_processing_stats_;
Danil Chapovalov3e392542023-05-17 11:25:39339 ::testing::StrictMock<MockNetworkLinkRtcpObserver> rtcp_observer_;
Mirko Bonadei6a489f22019-04-09 13:11:12340 ::testing::NiceMock<MockRtpTransportControllerSend> rtp_transport_;
Tomas Gunnarssonf25761d2020-06-03 20:55:33341 ::testing::NiceMock<MockRtpRtcpInterface> rtp_rtcp_;
Mirko Bonadei6a489f22019-04-09 13:11:12342 ::testing::NiceMock<MockLimitObserver> limit_observer_;
Dan Tan68e85b82024-01-29 23:02:59343 ::testing::NiceMock<MockBitrateAllocator> bitrate_allocator_;
minyue-webrtc8de18262017-07-26 12:18:40344 std::unique_ptr<AudioEncoder> audio_encoder_;
solenberg566ef242015-11-06 23:34:49345};
Henrik Boströmd2c336f2019-07-03 15:11:10346
347// The audio level ranges linearly [0,32767].
348std::unique_ptr<AudioFrame> CreateAudioFrame1kHzSineWave(int16_t audio_level,
349 int duration_ms,
350 int sample_rate_hz,
351 size_t num_channels) {
352 size_t samples_per_channel = sample_rate_hz / (1000 / duration_ms);
353 std::vector<int16_t> audio_data(samples_per_channel * num_channels, 0);
Mirko Bonadei317a1f02019-09-17 15:06:18354 std::unique_ptr<AudioFrame> audio_frame = std::make_unique<AudioFrame>();
Henrik Boströmd2c336f2019-07-03 15:11:10355 audio_frame->UpdateFrame(0 /* RTP timestamp */, &audio_data[0],
356 samples_per_channel, sample_rate_hz,
357 AudioFrame::SpeechType::kNormalSpeech,
358 AudioFrame::VADActivity::kVadUnknown, num_channels);
359 SineWaveGenerator wave_generator(1000.0, audio_level);
360 wave_generator.GenerateNextFrame(audio_frame.get());
361 return audio_frame;
362}
363
Fredrik Solenberg0ccae132015-11-03 09:15:49364} // namespace
solenbergc7a8b082015-10-16 21:35:07365
366TEST(AudioSendStreamTest, ConfigToString) {
Bjorn A Mellem7a9a0922019-11-26 17:19:40367 AudioSendStream::Config config(/*send_transport=*/nullptr);
Fredrik Solenberg0ccae132015-11-03 09:15:49368 config.rtp.ssrc = kSsrc;
solenberg3a941542015-11-16 15:34:50369 config.rtp.c_name = kCName;
minyue10cbb462016-11-07 17:29:22370 config.min_bitrate_bps = 12000;
371 config.max_bitrate_bps = 34000;
Jakob Ivarssoned971162020-08-11 12:05:07372 config.has_dscp = true;
ossu20a4b3f2017-04-27 09:08:52373 config.send_codec_spec =
Oskar Sundbom2707fb22017-11-16 09:57:35374 AudioSendStream::Config::SendCodecSpec(kIsacPayloadType, kIsacFormat);
ossu20a4b3f2017-04-27 09:08:52375 config.send_codec_spec->nack_enabled = true;
Oskar Sundbom2707fb22017-11-16 09:57:35376 config.send_codec_spec->cng_payload_type = 42;
Philipp Hanckeedcd9662020-06-24 10:52:42377 config.send_codec_spec->red_payload_type = 43;
ossu20a4b3f2017-04-27 09:08:52378 config.encoder_factory = MockAudioEncoderFactory::CreateUnusedFactory();
Johannes Kron9190b822018-10-29 10:22:05379 config.rtp.extmap_allow_mixed = true;
stefanb521aa72016-11-01 10:17:16380 config.rtp.extensions.push_back(
381 RtpExtension(RtpExtension::kAudioLevelUri, kAudioLevelId));
Jiawei Ou55718122018-11-09 21:17:39382 config.rtcp_report_interval_ms = 2500;
Fredrik Solenberg0ccae132015-11-03 09:15:49383 EXPECT_EQ(
Johannes Kron9190b822018-10-29 10:22:05384 "{rtp: {ssrc: 1234, extmap-allow-mixed: true, extensions: [{uri: "
Fredrik Solenbergc69a56e2018-11-21 08:21:23385 "urn:ietf:params:rtp-hdrext:ssrc-audio-level, id: 2}], "
386 "c_name: foo_name}, rtcp_report_interval_ms: 2500, "
Bjorn A Mellem7a9a0922019-11-26 17:19:40387 "send_transport: null, "
Jakob Ivarssoned971162020-08-11 12:05:07388 "min_bitrate_bps: 12000, max_bitrate_bps: 34000, has "
389 "audio_network_adaptor_config: false, has_dscp: true, "
Harald Alvestrand75223522024-11-18 07:18:35390 "send_codec_spec: {nack_enabled: true, "
Ivo Creusen2562cf02021-09-03 14:51:22391 "enable_non_sender_rtt: false, cng_payload_type: 42, "
392 "red_payload_type: 43, payload_type: 103, "
ossu20a4b3f2017-04-27 09:08:52393 "format: {name: isac, clockrate_hz: 16000, num_channels: 1, "
394 "parameters: {}}}}",
solenberg85a04962015-10-27 10:35:21395 config.ToString());
solenbergc7a8b082015-10-16 21:35:07396}
397
398TEST(AudioSendStreamTest, ConstructDestruct) {
Per Åhgrencc73ed32020-04-26 21:56:17399 for (bool use_null_audio_processing : {false, true}) {
400 ConfigHelper helper(false, true, use_null_audio_processing);
401 auto send_stream = helper.CreateAudioSendStream();
402 }
solenbergc7a8b082015-10-16 21:35:07403}
solenberg85a04962015-10-27 10:35:21404
Fredrik Solenbergb5727682015-12-04 14:22:19405TEST(AudioSendStreamTest, SendTelephoneEvent) {
Per Åhgrencc73ed32020-04-26 21:56:17406 for (bool use_null_audio_processing : {false, true}) {
407 ConfigHelper helper(false, true, use_null_audio_processing);
408 auto send_stream = helper.CreateAudioSendStream();
409 helper.SetupMockForSendTelephoneEvent();
410 EXPECT_TRUE(send_stream->SendTelephoneEvent(
411 kTelephoneEventPayloadType, kTelephoneEventPayloadFrequency,
412 kTelephoneEventCode, kTelephoneEventDuration));
413 }
Fredrik Solenbergb5727682015-12-04 14:22:19414}
415
solenberg94218532016-06-16 17:53:22416TEST(AudioSendStreamTest, SetMuted) {
Per Åhgrencc73ed32020-04-26 21:56:17417 for (bool use_null_audio_processing : {false, true}) {
418 ConfigHelper helper(false, true, use_null_audio_processing);
419 auto send_stream = helper.CreateAudioSendStream();
420 EXPECT_CALL(*helper.channel_send(), SetInputMute(true));
421 send_stream->SetMuted(true);
422 }
solenberg94218532016-06-16 17:53:22423}
424
stefan7de8d642017-02-07 15:14:08425TEST(AudioSendStreamTest, AudioBweCorrectObjectsOnChannelProxy) {
Per Åhgrencc73ed32020-04-26 21:56:17426 for (bool use_null_audio_processing : {false, true}) {
427 ConfigHelper helper(true, true, use_null_audio_processing);
428 auto send_stream = helper.CreateAudioSendStream();
429 }
stefan7de8d642017-02-07 15:14:08430}
431
432TEST(AudioSendStreamTest, NoAudioBweCorrectObjectsOnChannelProxy) {
Per Åhgrencc73ed32020-04-26 21:56:17433 for (bool use_null_audio_processing : {false, true}) {
434 ConfigHelper helper(false, true, use_null_audio_processing);
435 auto send_stream = helper.CreateAudioSendStream();
436 }
stefan7de8d642017-02-07 15:14:08437}
438
solenberg85a04962015-10-27 10:35:21439TEST(AudioSendStreamTest, GetStats) {
Per Åhgrencc73ed32020-04-26 21:56:17440 for (bool use_null_audio_processing : {false, true}) {
441 ConfigHelper helper(false, true, use_null_audio_processing);
442 auto send_stream = helper.CreateAudioSendStream();
443 helper.SetupMockForGetStats(use_null_audio_processing);
444 AudioSendStream::Stats stats = send_stream->GetStats(true);
445 EXPECT_EQ(kSsrc, stats.local_ssrc);
446 EXPECT_EQ(kCallStats.payload_bytes_sent, stats.payload_bytes_sent);
447 EXPECT_EQ(kCallStats.header_and_padding_bytes_sent,
448 stats.header_and_padding_bytes_sent);
449 EXPECT_EQ(kCallStats.packetsSent, stats.packets_sent);
Danil Chapovalova9b9d4e2023-05-03 11:20:11450 EXPECT_EQ(stats.packets_lost, kCumulativeLost);
451 EXPECT_FLOAT_EQ(stats.fraction_lost, Q8ToFloat(kFractionLost));
Per Åhgrencc73ed32020-04-26 21:56:17452 EXPECT_EQ(kIsacFormat.name, stats.codec_name);
Danil Chapovalova9b9d4e2023-05-03 11:20:11453 EXPECT_EQ(stats.jitter_ms,
454 static_cast<int32_t>(kInterarrivalJitter /
455 (kIsacFormat.clockrate_hz / 1000)));
Per Åhgrencc73ed32020-04-26 21:56:17456 EXPECT_EQ(kCallStats.rttMs, stats.rtt_ms);
457 EXPECT_EQ(0, stats.audio_level);
458 EXPECT_EQ(0, stats.total_input_energy);
459 EXPECT_EQ(0, stats.total_input_duration);
460
461 if (!use_null_audio_processing) {
462 EXPECT_EQ(kEchoDelayMedian, stats.apm_statistics.delay_median_ms);
463 EXPECT_EQ(kEchoDelayStdDev,
464 stats.apm_statistics.delay_standard_deviation_ms);
465 EXPECT_EQ(kEchoReturnLoss, stats.apm_statistics.echo_return_loss);
466 EXPECT_EQ(kEchoReturnLossEnhancement,
467 stats.apm_statistics.echo_return_loss_enhancement);
468 EXPECT_EQ(kDivergentFilterFraction,
469 stats.apm_statistics.divergent_filter_fraction);
470 EXPECT_EQ(kResidualEchoLikelihood,
471 stats.apm_statistics.residual_echo_likelihood);
472 EXPECT_EQ(kResidualEchoLikelihoodMax,
473 stats.apm_statistics.residual_echo_likelihood_recent_max);
Per Åhgrencc73ed32020-04-26 21:56:17474 }
475 }
solenberg566ef242015-11-06 23:34:49476}
minyue7a973442016-10-20 10:27:12477
Henrik Boströmd2c336f2019-07-03 15:11:10478TEST(AudioSendStreamTest, GetStatsAudioLevel) {
Per Åhgrencc73ed32020-04-26 21:56:17479 for (bool use_null_audio_processing : {false, true}) {
480 ConfigHelper helper(false, true, use_null_audio_processing);
481 auto send_stream = helper.CreateAudioSendStream();
482 helper.SetupMockForGetStats(use_null_audio_processing);
Danil Chapovalovf9c6b682020-05-15 09:40:44483 EXPECT_CALL(*helper.channel_send(), ProcessAndEncodeAudio)
Per Åhgrencc73ed32020-04-26 21:56:17484 .Times(AnyNumber());
Henrik Boströmd2c336f2019-07-03 15:11:10485
Per Åhgrencc73ed32020-04-26 21:56:17486 constexpr int kSampleRateHz = 48000;
487 constexpr size_t kNumChannels = 1;
Henrik Boströmd2c336f2019-07-03 15:11:10488
Per Åhgrencc73ed32020-04-26 21:56:17489 constexpr int16_t kSilentAudioLevel = 0;
490 constexpr int16_t kMaxAudioLevel = 32767; // Audio level is [0,32767].
491 constexpr int kAudioFrameDurationMs = 10;
Henrik Boströmd2c336f2019-07-03 15:11:10492
Per Åhgrencc73ed32020-04-26 21:56:17493 // Process 10 audio frames (100 ms) of silence. After this, on the next
494 // (11-th) frame, the audio level will be updated with the maximum audio
495 // level of the first 11 frames. See AudioLevel.
496 for (size_t i = 0; i < 10; ++i) {
497 send_stream->SendAudioData(
498 CreateAudioFrame1kHzSineWave(kSilentAudioLevel, kAudioFrameDurationMs,
499 kSampleRateHz, kNumChannels));
500 }
501 AudioSendStream::Stats stats = send_stream->GetStats();
502 EXPECT_EQ(kSilentAudioLevel, stats.audio_level);
503 EXPECT_NEAR(0.0f, stats.total_input_energy, kTolerance);
504 EXPECT_NEAR(0.1f, stats.total_input_duration,
505 kTolerance); // 100 ms = 0.1 s
506
507 // Process 10 audio frames (100 ms) of maximum audio level.
508 // Note that AudioLevel updates the audio level every 11th frame, processing
509 // 10 frames above was needed to see a non-zero audio level here.
510 for (size_t i = 0; i < 10; ++i) {
511 send_stream->SendAudioData(CreateAudioFrame1kHzSineWave(
512 kMaxAudioLevel, kAudioFrameDurationMs, kSampleRateHz, kNumChannels));
513 }
514 stats = send_stream->GetStats();
515 EXPECT_EQ(kMaxAudioLevel, stats.audio_level);
516 // Energy increases by energy*duration, where energy is audio level in
517 // [0,1].
518 EXPECT_NEAR(0.1f, stats.total_input_energy, kTolerance); // 0.1 s of max
519 EXPECT_NEAR(0.2f, stats.total_input_duration,
520 kTolerance); // 200 ms = 0.2 s
Henrik Boströmd2c336f2019-07-03 15:11:10521 }
Henrik Boströmd2c336f2019-07-03 15:11:10522}
523
minyue-webrtc8de18262017-07-26 12:18:40524TEST(AudioSendStreamTest, SendCodecAppliesAudioNetworkAdaptor) {
Per Åhgrencc73ed32020-04-26 21:56:17525 for (bool use_null_audio_processing : {false, true}) {
Jakob Ivarsson47a03e82020-11-23 14:05:44526 ConfigHelper helper(true, true, use_null_audio_processing);
Per Åhgrencc73ed32020-04-26 21:56:17527 helper.config().send_codec_spec =
528 AudioSendStream::Config::SendCodecSpec(0, kOpusFormat);
529 const std::string kAnaConfigString = "abcde";
530 const std::string kAnaReconfigString = "12345";
minyue-webrtc8de18262017-07-26 12:18:40531
Per Åhgrencc73ed32020-04-26 21:56:17532 helper.config().audio_network_adaptor_config = kAnaConfigString;
ossu20a4b3f2017-04-27 09:08:52533
Danil Chapovalov954e72b2024-07-10 17:22:07534 EXPECT_CALL(helper.mock_encoder_factory(), Create)
535 .WillOnce(WithArg<1>([&kAnaConfigString, &kAnaReconfigString](
536 const SdpAudioFormat& format) {
537 auto mock_encoder = SetupAudioEncoderMock(format);
Per Åhgrencc73ed32020-04-26 21:56:17538 EXPECT_CALL(*mock_encoder,
539 EnableAudioNetworkAdaptor(StrEq(kAnaConfigString), _))
540 .WillOnce(Return(true));
541 EXPECT_CALL(*mock_encoder,
542 EnableAudioNetworkAdaptor(StrEq(kAnaReconfigString), _))
543 .WillOnce(Return(true));
Danil Chapovalov954e72b2024-07-10 17:22:07544 return mock_encoder;
Per Åhgrencc73ed32020-04-26 21:56:17545 }));
ossu20a4b3f2017-04-27 09:08:52546
Per Åhgrencc73ed32020-04-26 21:56:17547 auto send_stream = helper.CreateAudioSendStream();
minyue-webrtc8de18262017-07-26 12:18:40548
Per Åhgrencc73ed32020-04-26 21:56:17549 auto stream_config = helper.config();
550 stream_config.audio_network_adaptor_config = kAnaReconfigString;
minyue-webrtc8de18262017-07-26 12:18:40551
Florent Castelliacabb362022-10-18 15:05:16552 send_stream->Reconfigure(stream_config, nullptr);
Per Åhgrencc73ed32020-04-26 21:56:17553 }
minyue7a973442016-10-20 10:27:12554}
555
Jakob Ivarssonfde2b242020-08-20 14:48:49556TEST(AudioSendStreamTest, AudioNetworkAdaptorReceivesOverhead) {
557 for (bool use_null_audio_processing : {false, true}) {
Jakob Ivarsson47a03e82020-11-23 14:05:44558 ConfigHelper helper(true, true, use_null_audio_processing);
Jakob Ivarssonfde2b242020-08-20 14:48:49559 helper.config().send_codec_spec =
560 AudioSendStream::Config::SendCodecSpec(0, kOpusFormat);
561 const std::string kAnaConfigString = "abcde";
Jakob Ivarssonfde2b242020-08-20 14:48:49562
Danil Chapovalov954e72b2024-07-10 17:22:07563 EXPECT_CALL(helper.mock_encoder_factory(), Create)
564 .WillOnce(
565 WithArg<1>([&kAnaConfigString](const SdpAudioFormat& format) {
566 auto mock_encoder = SetupAudioEncoderMock(format);
Jakob Ivarssonfde2b242020-08-20 14:48:49567 InSequence s;
568 EXPECT_CALL(
569 *mock_encoder,
Jakob Ivarsson340d6c02024-01-22 13:49:15570 OnReceivedOverhead(Eq(kOverheadPerPacket.bytes<size_t>())));
Jakob Ivarssonfde2b242020-08-20 14:48:49571 EXPECT_CALL(*mock_encoder,
572 EnableAudioNetworkAdaptor(StrEq(kAnaConfigString), _))
573 .WillOnce(Return(true));
574 // Note: Overhead is received AFTER ANA has been enabled.
575 EXPECT_CALL(
576 *mock_encoder,
Danil Chapovalov954e72b2024-07-10 17:22:07577 OnReceivedOverhead(Eq(kOverheadPerPacket.bytes<size_t>())));
578 return mock_encoder;
Jakob Ivarssonfde2b242020-08-20 14:48:49579 }));
580 EXPECT_CALL(*helper.rtp_rtcp(), ExpectedPerPacketOverhead)
581 .WillRepeatedly(Return(kOverheadPerPacket.bytes<size_t>()));
Dan Tan2406aaf2024-08-05 20:53:31582 EXPECT_CALL(*helper.channel_send(), RegisterPacketOverhead);
Jakob Ivarssonfde2b242020-08-20 14:48:49583
584 auto send_stream = helper.CreateAudioSendStream();
585
586 auto stream_config = helper.config();
587 stream_config.audio_network_adaptor_config = kAnaConfigString;
588
Florent Castelliacabb362022-10-18 15:05:16589 send_stream->Reconfigure(stream_config, nullptr);
Jakob Ivarssonfde2b242020-08-20 14:48:49590 }
591}
592
minyue7a973442016-10-20 10:27:12593// VAD is applied when codec is mono and the CNG frequency matches the codec
ossu20a4b3f2017-04-27 09:08:52594// clock rate.
minyue7a973442016-10-20 10:27:12595TEST(AudioSendStreamTest, SendCodecCanApplyVad) {
Per Åhgrencc73ed32020-04-26 21:56:17596 for (bool use_null_audio_processing : {false, true}) {
597 ConfigHelper helper(false, false, use_null_audio_processing);
598 helper.config().send_codec_spec =
599 AudioSendStream::Config::SendCodecSpec(9, kG722Format);
600 helper.config().send_codec_spec->cng_payload_type = 105;
Per Åhgrencc73ed32020-04-26 21:56:17601 std::unique_ptr<AudioEncoder> stolen_encoder;
Danil Chapovalovf9c6b682020-05-15 09:40:44602 EXPECT_CALL(*helper.channel_send(), SetEncoder)
Dor Henb52416e2024-10-27 13:59:51603 .WillOnce([&stolen_encoder](int /* payload_type */,
604 const SdpAudioFormat& /* format */,
Danil Chapovalovf9c6b682020-05-15 09:40:44605 std::unique_ptr<AudioEncoder> encoder) {
606 stolen_encoder = std::move(encoder);
607 return true;
608 });
Per Åhgrencc73ed32020-04-26 21:56:17609 EXPECT_CALL(*helper.channel_send(), RegisterCngPayloadType(105, 8000));
ossu20a4b3f2017-04-27 09:08:52610
Per Åhgrencc73ed32020-04-26 21:56:17611 auto send_stream = helper.CreateAudioSendStream();
ossu20a4b3f2017-04-27 09:08:52612
Per Åhgrencc73ed32020-04-26 21:56:17613 // We cannot truly determine if the encoder created is an AudioEncoderCng.
614 // It is the only reasonable implementation that will return something from
615 // ReclaimContainedEncoders, though.
616 ASSERT_TRUE(stolen_encoder);
617 EXPECT_FALSE(stolen_encoder->ReclaimContainedEncoders().empty());
618 }
minyue7a973442016-10-20 10:27:12619}
620
minyue78b4d562016-11-30 12:47:39621TEST(AudioSendStreamTest, DoesNotPassHigherBitrateThanMaxBitrate) {
Per Åhgrencc73ed32020-04-26 21:56:17622 for (bool use_null_audio_processing : {false, true}) {
623 ConfigHelper helper(false, true, use_null_audio_processing);
624 auto send_stream = helper.CreateAudioSendStream();
625 EXPECT_CALL(
626 *helper.channel_send(),
627 OnBitrateAllocation(
628 Field(&BitrateAllocationUpdate::target_bitrate,
Danil Chapovalovcad3e0e2020-02-17 17:46:07629 Eq(DataRate::BitsPerSec(helper.config().max_bitrate_bps)))));
Per Åhgrencc73ed32020-04-26 21:56:17630 BitrateAllocationUpdate update;
631 update.target_bitrate =
632 DataRate::BitsPerSec(helper.config().max_bitrate_bps + 5000);
633 update.packet_loss_ratio = 0;
634 update.round_trip_time = TimeDelta::Millis(50);
635 update.bwe_period = TimeDelta::Millis(6000);
Per Kjellander50b0a762023-04-12 11:40:01636 send_stream->OnBitrateUpdated(update);
Per Åhgrencc73ed32020-04-26 21:56:17637 }
minyue78b4d562016-11-30 12:47:39638}
639
Daniel Lee93562522019-05-03 12:40:13640TEST(AudioSendStreamTest, SSBweTargetInRangeRespected) {
Per Åhgrencc73ed32020-04-26 21:56:17641 for (bool use_null_audio_processing : {false, true}) {
642 ConfigHelper helper(true, true, use_null_audio_processing);
643 auto send_stream = helper.CreateAudioSendStream();
644 EXPECT_CALL(
645 *helper.channel_send(),
646 OnBitrateAllocation(Field(
647 &BitrateAllocationUpdate::target_bitrate,
648 Eq(DataRate::BitsPerSec(helper.config().max_bitrate_bps - 5000)))));
649 BitrateAllocationUpdate update;
650 update.target_bitrate =
651 DataRate::BitsPerSec(helper.config().max_bitrate_bps - 5000);
Per Kjellander50b0a762023-04-12 11:40:01652 send_stream->OnBitrateUpdated(update);
Per Åhgrencc73ed32020-04-26 21:56:17653 }
Daniel Lee93562522019-05-03 12:40:13654}
655
656TEST(AudioSendStreamTest, SSBweFieldTrialMinRespected) {
Per Åhgrencc73ed32020-04-26 21:56:17657 for (bool use_null_audio_processing : {false, true}) {
658 ConfigHelper helper(true, true, use_null_audio_processing);
Jonas Orelanda943e732022-03-16 12:50:58659 ScopedKeyValueConfig field_trials(
660 helper.field_trials, "WebRTC-Audio-Allocation/min:6kbps,max:64kbps/");
Per Åhgrencc73ed32020-04-26 21:56:17661 auto send_stream = helper.CreateAudioSendStream();
662 EXPECT_CALL(
663 *helper.channel_send(),
664 OnBitrateAllocation(Field(&BitrateAllocationUpdate::target_bitrate,
665 Eq(DataRate::KilobitsPerSec(6)))));
666 BitrateAllocationUpdate update;
667 update.target_bitrate = DataRate::KilobitsPerSec(1);
Per Kjellander50b0a762023-04-12 11:40:01668 send_stream->OnBitrateUpdated(update);
Per Åhgrencc73ed32020-04-26 21:56:17669 }
Daniel Lee93562522019-05-03 12:40:13670}
671
672TEST(AudioSendStreamTest, SSBweFieldTrialMaxRespected) {
Per Åhgrencc73ed32020-04-26 21:56:17673 for (bool use_null_audio_processing : {false, true}) {
674 ConfigHelper helper(true, true, use_null_audio_processing);
Jonas Orelanda943e732022-03-16 12:50:58675 ScopedKeyValueConfig field_trials(
676 helper.field_trials, "WebRTC-Audio-Allocation/min:6kbps,max:64kbps/");
Per Åhgrencc73ed32020-04-26 21:56:17677 auto send_stream = helper.CreateAudioSendStream();
678 EXPECT_CALL(
679 *helper.channel_send(),
680 OnBitrateAllocation(Field(&BitrateAllocationUpdate::target_bitrate,
681 Eq(DataRate::KilobitsPerSec(64)))));
682 BitrateAllocationUpdate update;
683 update.target_bitrate = DataRate::KilobitsPerSec(128);
Per Kjellander50b0a762023-04-12 11:40:01684 send_stream->OnBitrateUpdated(update);
Per Åhgrencc73ed32020-04-26 21:56:17685 }
Daniel Lee93562522019-05-03 12:40:13686}
687
688TEST(AudioSendStreamTest, SSBweWithOverhead) {
Per Åhgrencc73ed32020-04-26 21:56:17689 for (bool use_null_audio_processing : {false, true}) {
690 ConfigHelper helper(true, true, use_null_audio_processing);
Jonas Orelanda943e732022-03-16 12:50:58691 ScopedKeyValueConfig field_trials(helper.field_trials,
692 "WebRTC-Audio-LegacyOverhead/Disabled/");
Erik Språng04e1bab2020-05-07 16:18:32693 EXPECT_CALL(*helper.rtp_rtcp(), ExpectedPerPacketOverhead)
694 .WillRepeatedly(Return(kOverheadPerPacket.bytes<size_t>()));
Dan Tan2406aaf2024-08-05 20:53:31695 EXPECT_CALL(*helper.channel_send(), RegisterPacketOverhead);
Per Åhgrencc73ed32020-04-26 21:56:17696 auto send_stream = helper.CreateAudioSendStream();
Per Åhgrencc73ed32020-04-26 21:56:17697 const DataRate bitrate =
698 DataRate::BitsPerSec(helper.config().max_bitrate_bps) +
699 kMaxOverheadRate;
700 EXPECT_CALL(*helper.channel_send(),
701 OnBitrateAllocation(Field(
702 &BitrateAllocationUpdate::target_bitrate, Eq(bitrate))));
703 BitrateAllocationUpdate update;
704 update.target_bitrate = bitrate;
Per Kjellander50b0a762023-04-12 11:40:01705 send_stream->OnBitrateUpdated(update);
Per Åhgrencc73ed32020-04-26 21:56:17706 }
Daniel Lee93562522019-05-03 12:40:13707}
708
709TEST(AudioSendStreamTest, SSBweWithOverheadMinRespected) {
Per Åhgrencc73ed32020-04-26 21:56:17710 for (bool use_null_audio_processing : {false, true}) {
711 ConfigHelper helper(true, true, use_null_audio_processing);
Jonas Orelanda943e732022-03-16 12:50:58712 ScopedKeyValueConfig field_trials(
713 helper.field_trials,
714 "WebRTC-Audio-LegacyOverhead/Disabled/"
715 "WebRTC-Audio-Allocation/min:6kbps,max:64kbps/");
Erik Språng04e1bab2020-05-07 16:18:32716 EXPECT_CALL(*helper.rtp_rtcp(), ExpectedPerPacketOverhead)
717 .WillRepeatedly(Return(kOverheadPerPacket.bytes<size_t>()));
Dan Tan2406aaf2024-08-05 20:53:31718 EXPECT_CALL(*helper.channel_send(), RegisterPacketOverhead);
Per Åhgrencc73ed32020-04-26 21:56:17719 auto send_stream = helper.CreateAudioSendStream();
Per Åhgrencc73ed32020-04-26 21:56:17720 const DataRate bitrate = DataRate::KilobitsPerSec(6) + kMinOverheadRate;
721 EXPECT_CALL(*helper.channel_send(),
722 OnBitrateAllocation(Field(
723 &BitrateAllocationUpdate::target_bitrate, Eq(bitrate))));
724 BitrateAllocationUpdate update;
725 update.target_bitrate = DataRate::KilobitsPerSec(1);
Per Kjellander50b0a762023-04-12 11:40:01726 send_stream->OnBitrateUpdated(update);
Per Åhgrencc73ed32020-04-26 21:56:17727 }
Daniel Lee93562522019-05-03 12:40:13728}
729
730TEST(AudioSendStreamTest, SSBweWithOverheadMaxRespected) {
Per Åhgrencc73ed32020-04-26 21:56:17731 for (bool use_null_audio_processing : {false, true}) {
732 ConfigHelper helper(true, true, use_null_audio_processing);
Jonas Orelanda943e732022-03-16 12:50:58733 ScopedKeyValueConfig field_trials(
734 helper.field_trials,
735 "WebRTC-Audio-LegacyOverhead/Disabled/"
736 "WebRTC-Audio-Allocation/min:6kbps,max:64kbps/");
Erik Språng04e1bab2020-05-07 16:18:32737 EXPECT_CALL(*helper.rtp_rtcp(), ExpectedPerPacketOverhead)
738 .WillRepeatedly(Return(kOverheadPerPacket.bytes<size_t>()));
Dan Tan2406aaf2024-08-05 20:53:31739 EXPECT_CALL(*helper.channel_send(), RegisterPacketOverhead);
Per Åhgrencc73ed32020-04-26 21:56:17740 auto send_stream = helper.CreateAudioSendStream();
Per Åhgrencc73ed32020-04-26 21:56:17741 const DataRate bitrate = DataRate::KilobitsPerSec(64) + kMaxOverheadRate;
742 EXPECT_CALL(*helper.channel_send(),
743 OnBitrateAllocation(Field(
744 &BitrateAllocationUpdate::target_bitrate, Eq(bitrate))));
745 BitrateAllocationUpdate update;
746 update.target_bitrate = DataRate::KilobitsPerSec(128);
Per Kjellander50b0a762023-04-12 11:40:01747 send_stream->OnBitrateUpdated(update);
Per Åhgrencc73ed32020-04-26 21:56:17748 }
Daniel Lee93562522019-05-03 12:40:13749}
750
minyue78b4d562016-11-30 12:47:39751TEST(AudioSendStreamTest, ProbingIntervalOnBitrateUpdated) {
Per Åhgrencc73ed32020-04-26 21:56:17752 for (bool use_null_audio_processing : {false, true}) {
753 ConfigHelper helper(false, true, use_null_audio_processing);
754 auto send_stream = helper.CreateAudioSendStream();
Sebastian Jansson254d8692018-11-21 18:19:00755
Per Åhgrencc73ed32020-04-26 21:56:17756 EXPECT_CALL(*helper.channel_send(),
757 OnBitrateAllocation(Field(&BitrateAllocationUpdate::bwe_period,
758 Eq(TimeDelta::Millis(5000)))));
759 BitrateAllocationUpdate update;
760 update.target_bitrate =
761 DataRate::BitsPerSec(helper.config().max_bitrate_bps + 5000);
762 update.packet_loss_ratio = 0;
763 update.round_trip_time = TimeDelta::Millis(50);
764 update.bwe_period = TimeDelta::Millis(5000);
Per Kjellander50b0a762023-04-12 11:40:01765 send_stream->OnBitrateUpdated(update);
Per Åhgrencc73ed32020-04-26 21:56:17766 }
minyue78b4d562016-11-30 12:47:39767}
768
ossu20a4b3f2017-04-27 09:08:52769// Test that AudioSendStream doesn't recreate the encoder unnecessarily.
770TEST(AudioSendStreamTest, DontRecreateEncoder) {
Per Åhgrencc73ed32020-04-26 21:56:17771 for (bool use_null_audio_processing : {false, true}) {
772 ConfigHelper helper(false, false, use_null_audio_processing);
773 // WillOnce is (currently) the default used by ConfigHelper if asked to set
774 // an expectation for SetEncoder. Since this behavior is essential for this
775 // test to be correct, it's instead set-up manually here. Otherwise a simple
776 // change to ConfigHelper (say to WillRepeatedly) would silently make this
777 // test useless.
Danil Chapovalovf9c6b682020-05-15 09:40:44778 EXPECT_CALL(*helper.channel_send(), SetEncoder).WillOnce(Return());
ossu20a4b3f2017-04-27 09:08:52779
Per Åhgrencc73ed32020-04-26 21:56:17780 EXPECT_CALL(*helper.channel_send(), RegisterCngPayloadType(105, 8000));
Niels Mölleree5ccbc2019-03-06 15:47:29781
Per Åhgrencc73ed32020-04-26 21:56:17782 helper.config().send_codec_spec =
783 AudioSendStream::Config::SendCodecSpec(9, kG722Format);
784 helper.config().send_codec_spec->cng_payload_type = 105;
785 auto send_stream = helper.CreateAudioSendStream();
Florent Castelliacabb362022-10-18 15:05:16786 send_stream->Reconfigure(helper.config(), nullptr);
Per Åhgrencc73ed32020-04-26 21:56:17787 }
ossu20a4b3f2017-04-27 09:08:52788}
789
ossu1129df22017-06-30 08:38:56790TEST(AudioSendStreamTest, ReconfigureTransportCcResetsFirst) {
Per Åhgrencc73ed32020-04-26 21:56:17791 for (bool use_null_audio_processing : {false, true}) {
792 ConfigHelper helper(false, true, use_null_audio_processing);
793 auto send_stream = helper.CreateAudioSendStream();
794 auto new_config = helper.config();
795 ConfigHelper::AddBweToConfig(&new_config);
Sebastian Jansson6298b562020-01-14 16:55:19796
Per Åhgrencc73ed32020-04-26 21:56:17797 EXPECT_CALL(*helper.rtp_rtcp(),
Danil Chapovalovd0321c52021-09-14 10:58:51798 RegisterRtpHeaderExtension(TransportSequenceNumber::Uri(),
Per Åhgrencc73ed32020-04-26 21:56:17799 kTransportSequenceNumberId))
ossu1129df22017-06-30 08:38:56800 .Times(1);
Per Åhgrencc73ed32020-04-26 21:56:17801 {
802 ::testing::InSequence seq;
803 EXPECT_CALL(*helper.channel_send(), ResetSenderCongestionControlObjects())
804 .Times(1);
805 EXPECT_CALL(*helper.channel_send(),
Danil Chapovalova2cf8ee2023-05-16 11:26:33806 RegisterSenderCongestionControlObjects(helper.transport()))
Per Åhgrencc73ed32020-04-26 21:56:17807 .Times(1);
808 }
809
Florent Castelliacabb362022-10-18 15:05:16810 send_stream->Reconfigure(new_config, nullptr);
ossu1129df22017-06-30 08:38:56811 }
ossu1129df22017-06-30 08:38:56812}
Sam Zackrisson06953ba2018-02-01 15:53:16813
Anton Sukhanov626015d2019-02-04 23:16:06814TEST(AudioSendStreamTest, OnTransportOverheadChanged) {
Per Åhgrencc73ed32020-04-26 21:56:17815 for (bool use_null_audio_processing : {false, true}) {
816 ConfigHelper helper(false, true, use_null_audio_processing);
817 auto send_stream = helper.CreateAudioSendStream();
818 auto new_config = helper.config();
Anton Sukhanov626015d2019-02-04 23:16:06819
Per Åhgrencc73ed32020-04-26 21:56:17820 // CallEncoder will be called on overhead change.
Erik Språngcf6544a2020-05-13 12:43:11821 EXPECT_CALL(*helper.channel_send(), CallEncoder);
Dan Tan2406aaf2024-08-05 20:53:31822 EXPECT_CALL(*helper.channel_send(), RegisterPacketOverhead);
Anton Sukhanov626015d2019-02-04 23:16:06823
Per Åhgrencc73ed32020-04-26 21:56:17824 const size_t transport_overhead_per_packet_bytes = 333;
825 send_stream->SetTransportOverhead(transport_overhead_per_packet_bytes);
Anton Sukhanov626015d2019-02-04 23:16:06826
Per Åhgrencc73ed32020-04-26 21:56:17827 EXPECT_EQ(transport_overhead_per_packet_bytes,
828 send_stream->TestOnlyGetPerPacketOverheadBytes());
829 }
Anton Sukhanov626015d2019-02-04 23:16:06830}
831
Erik Språngcf6544a2020-05-13 12:43:11832TEST(AudioSendStreamTest, DoesntCallEncoderWhenOverheadUnchanged) {
833 for (bool use_null_audio_processing : {false, true}) {
834 ConfigHelper helper(false, true, use_null_audio_processing);
835 auto send_stream = helper.CreateAudioSendStream();
836 auto new_config = helper.config();
837
Dan Tan2406aaf2024-08-05 20:53:31838 EXPECT_CALL(*helper.channel_send(), RegisterPacketOverhead).Times(2);
839
Erik Språngcf6544a2020-05-13 12:43:11840 // CallEncoder will be called on overhead change.
841 EXPECT_CALL(*helper.channel_send(), CallEncoder);
842 const size_t transport_overhead_per_packet_bytes = 333;
843 send_stream->SetTransportOverhead(transport_overhead_per_packet_bytes);
844
845 // Set the same overhead again, CallEncoder should not be called again.
846 EXPECT_CALL(*helper.channel_send(), CallEncoder).Times(0);
847 send_stream->SetTransportOverhead(transport_overhead_per_packet_bytes);
848
849 // New overhead, call CallEncoder again
850 EXPECT_CALL(*helper.channel_send(), CallEncoder);
851 send_stream->SetTransportOverhead(transport_overhead_per_packet_bytes + 1);
852 }
853}
854
Erik Språng04e1bab2020-05-07 16:18:32855TEST(AudioSendStreamTest, AudioOverheadChanged) {
Per Åhgrencc73ed32020-04-26 21:56:17856 for (bool use_null_audio_processing : {false, true}) {
857 ConfigHelper helper(false, true, use_null_audio_processing);
Erik Språng04e1bab2020-05-07 16:18:32858 const size_t audio_overhead_per_packet_bytes = 555;
859 EXPECT_CALL(*helper.rtp_rtcp(), ExpectedPerPacketOverhead)
860 .WillRepeatedly(Return(audio_overhead_per_packet_bytes));
Dan Tan2406aaf2024-08-05 20:53:31861 EXPECT_CALL(*helper.channel_send(), RegisterPacketOverhead).Times(2);
Per Åhgrencc73ed32020-04-26 21:56:17862 auto send_stream = helper.CreateAudioSendStream();
Anton Sukhanov626015d2019-02-04 23:16:06863
Erik Språng04e1bab2020-05-07 16:18:32864 BitrateAllocationUpdate update;
865 update.target_bitrate =
866 DataRate::BitsPerSec(helper.config().max_bitrate_bps) +
867 kMaxOverheadRate;
868 EXPECT_CALL(*helper.channel_send(), OnBitrateAllocation);
Per Kjellander50b0a762023-04-12 11:40:01869 send_stream->OnBitrateUpdated(update);
Anton Sukhanov626015d2019-02-04 23:16:06870
Per Åhgrencc73ed32020-04-26 21:56:17871 EXPECT_EQ(audio_overhead_per_packet_bytes,
872 send_stream->TestOnlyGetPerPacketOverheadBytes());
Erik Språng04e1bab2020-05-07 16:18:32873
874 EXPECT_CALL(*helper.rtp_rtcp(), ExpectedPerPacketOverhead)
875 .WillRepeatedly(Return(audio_overhead_per_packet_bytes + 20));
Jakob Ivarsson340d6c02024-01-22 13:49:15876 // RTP overhead can only change in response to RTCP or configuration change.
877 send_stream->Reconfigure(helper.config(), nullptr);
Erik Språng04e1bab2020-05-07 16:18:32878 EXPECT_CALL(*helper.channel_send(), OnBitrateAllocation);
Per Kjellander50b0a762023-04-12 11:40:01879 send_stream->OnBitrateUpdated(update);
Erik Språng04e1bab2020-05-07 16:18:32880
881 EXPECT_EQ(audio_overhead_per_packet_bytes + 20,
882 send_stream->TestOnlyGetPerPacketOverheadBytes());
Per Åhgrencc73ed32020-04-26 21:56:17883 }
Anton Sukhanov626015d2019-02-04 23:16:06884}
885
886TEST(AudioSendStreamTest, OnAudioAndTransportOverheadChanged) {
Per Åhgrencc73ed32020-04-26 21:56:17887 for (bool use_null_audio_processing : {false, true}) {
888 ConfigHelper helper(false, true, use_null_audio_processing);
Erik Språng04e1bab2020-05-07 16:18:32889 const size_t audio_overhead_per_packet_bytes = 555;
890 EXPECT_CALL(*helper.rtp_rtcp(), ExpectedPerPacketOverhead)
891 .WillRepeatedly(Return(audio_overhead_per_packet_bytes));
Dan Tan2406aaf2024-08-05 20:53:31892 EXPECT_CALL(*helper.channel_send(), RegisterPacketOverhead).Times(2);
Per Åhgrencc73ed32020-04-26 21:56:17893 auto send_stream = helper.CreateAudioSendStream();
894 auto new_config = helper.config();
Anton Sukhanov626015d2019-02-04 23:16:06895
Per Åhgrencc73ed32020-04-26 21:56:17896 const size_t transport_overhead_per_packet_bytes = 333;
897 send_stream->SetTransportOverhead(transport_overhead_per_packet_bytes);
Anton Sukhanov626015d2019-02-04 23:16:06898
Erik Språng04e1bab2020-05-07 16:18:32899 BitrateAllocationUpdate update;
900 update.target_bitrate =
901 DataRate::BitsPerSec(helper.config().max_bitrate_bps) +
902 kMaxOverheadRate;
903 EXPECT_CALL(*helper.channel_send(), OnBitrateAllocation);
Per Kjellander50b0a762023-04-12 11:40:01904 send_stream->OnBitrateUpdated(update);
Anton Sukhanov626015d2019-02-04 23:16:06905
Per Åhgrencc73ed32020-04-26 21:56:17906 EXPECT_EQ(
907 transport_overhead_per_packet_bytes + audio_overhead_per_packet_bytes,
908 send_stream->TestOnlyGetPerPacketOverheadBytes());
909 }
Anton Sukhanov626015d2019-02-04 23:16:06910}
911
Benjamin Wright78410ad2018-10-25 16:52:57912// Validates that reconfiguring the AudioSendStream with a Frame encryptor
913// correctly reconfigures on the object without crashing.
914TEST(AudioSendStreamTest, ReconfigureWithFrameEncryptor) {
Per Åhgrencc73ed32020-04-26 21:56:17915 for (bool use_null_audio_processing : {false, true}) {
916 ConfigHelper helper(false, true, use_null_audio_processing);
917 auto send_stream = helper.CreateAudioSendStream();
918 auto new_config = helper.config();
Benjamin Wright78410ad2018-10-25 16:52:57919
Per Åhgrencc73ed32020-04-26 21:56:17920 rtc::scoped_refptr<FrameEncryptorInterface> mock_frame_encryptor_0(
Tomas Gunnarssonc1d58912021-04-22 17:21:43921 rtc::make_ref_counted<MockFrameEncryptor>());
Per Åhgrencc73ed32020-04-26 21:56:17922 new_config.frame_encryptor = mock_frame_encryptor_0;
923 EXPECT_CALL(*helper.channel_send(), SetFrameEncryptor(Ne(nullptr)))
924 .Times(1);
Florent Castelliacabb362022-10-18 15:05:16925 send_stream->Reconfigure(new_config, nullptr);
Benjamin Wright78410ad2018-10-25 16:52:57926
Per Åhgrencc73ed32020-04-26 21:56:17927 // Not updating the frame encryptor shouldn't force it to reconfigure.
928 EXPECT_CALL(*helper.channel_send(), SetFrameEncryptor(_)).Times(0);
Florent Castelliacabb362022-10-18 15:05:16929 send_stream->Reconfigure(new_config, nullptr);
Benjamin Wright78410ad2018-10-25 16:52:57930
Per Åhgrencc73ed32020-04-26 21:56:17931 // Updating frame encryptor to a new object should force a call to the
932 // proxy.
933 rtc::scoped_refptr<FrameEncryptorInterface> mock_frame_encryptor_1(
Tomas Gunnarssonc1d58912021-04-22 17:21:43934 rtc::make_ref_counted<MockFrameEncryptor>());
Per Åhgrencc73ed32020-04-26 21:56:17935 new_config.frame_encryptor = mock_frame_encryptor_1;
936 new_config.crypto_options.sframe.require_frame_encryption = true;
937 EXPECT_CALL(*helper.channel_send(), SetFrameEncryptor(Ne(nullptr)))
938 .Times(1);
Florent Castelliacabb362022-10-18 15:05:16939 send_stream->Reconfigure(new_config, nullptr);
Per Åhgrencc73ed32020-04-26 21:56:17940 }
Benjamin Wright78410ad2018-10-25 16:52:57941}
Dan Tan68e85b82024-01-29 23:02:59942
943TEST(AudioSendStreamTest, DefaultsHonorsPriorityBitrate) {
944 ConfigHelper helper(true, true, true);
945 ScopedKeyValueConfig field_trials(helper.field_trials,
946 "WebRTC-Audio-Allocation/prio_rate:20/");
947 auto send_stream = helper.CreateAudioSendStream();
948 EXPECT_CALL(*helper.bitrate_allocator(), AddObserver(send_stream.get(), _))
949 .WillOnce(Invoke(
950 [&](BitrateAllocatorObserver*, MediaStreamAllocationConfig config) {
951 EXPECT_EQ(config.priority_bitrate_bps, 20000);
952 }));
953 EXPECT_CALL(*helper.channel_send(), StartSend());
954 send_stream->Start();
955 EXPECT_CALL(*helper.channel_send(), StopSend());
956 send_stream->Stop();
957}
958
Dan Tan96c1b9c2024-07-30 17:01:12959TEST(AudioSendStreamTest, DefaultsToContributeUnusedBitrate) {
960 ConfigHelper helper(true, true, true);
961 auto send_stream = helper.CreateAudioSendStream();
962 EXPECT_CALL(
963 *helper.bitrate_allocator(),
964 AddObserver(send_stream.get(),
965 Field(&MediaStreamAllocationConfig::rate_elasticity,
966 TrackRateElasticity::kCanContributeUnusedRate)));
967 EXPECT_CALL(*helper.channel_send(), StartSend());
968 send_stream->Start();
969 EXPECT_CALL(*helper.channel_send(), StopSend());
970 send_stream->Stop();
971}
972
Dan Tan68e85b82024-01-29 23:02:59973TEST(AudioSendStreamTest, OverridesPriorityBitrate) {
974 ConfigHelper helper(true, true, true);
975 ScopedKeyValueConfig field_trials(helper.field_trials,
976 "WebRTC-Audio-Allocation/prio_rate:20/"
977 "WebRTC-Audio-PriorityBitrate/Disabled/");
978 auto send_stream = helper.CreateAudioSendStream();
979 EXPECT_CALL(*helper.bitrate_allocator(), AddObserver(send_stream.get(), _))
980 .WillOnce(Invoke(
981 [&](BitrateAllocatorObserver*, MediaStreamAllocationConfig config) {
982 EXPECT_EQ(config.priority_bitrate_bps, 0);
983 }));
984 EXPECT_CALL(*helper.channel_send(), StartSend());
985 send_stream->Start();
986 EXPECT_CALL(*helper.channel_send(), StopSend());
987 send_stream->Stop();
988}
989
Jakob Ivarsson9d9b3a32024-02-07 08:44:31990TEST(AudioSendStreamTest, UseEncoderBitrateRange) {
991 ConfigHelper helper(true, true, true);
992 std::pair<DataRate, DataRate> bitrate_range{DataRate::BitsPerSec(5000),
993 DataRate::BitsPerSec(10000)};
Danil Chapovalov954e72b2024-07-10 17:22:07994 EXPECT_CALL(helper.mock_encoder_factory(), Create)
995 .WillOnce(WithArg<1>([&](const SdpAudioFormat& format) {
996 auto mock_encoder = SetupAudioEncoderMock(format);
997 EXPECT_CALL(*mock_encoder, GetBitrateRange)
Jakob Ivarsson9d9b3a32024-02-07 08:44:31998 .WillRepeatedly(Return(bitrate_range));
Danil Chapovalov954e72b2024-07-10 17:22:07999 return mock_encoder;
Jakob Ivarsson9d9b3a32024-02-07 08:44:311000 }));
1001 auto send_stream = helper.CreateAudioSendStream();
1002 EXPECT_CALL(*helper.bitrate_allocator(), AddObserver(send_stream.get(), _))
1003 .WillOnce(Invoke(
1004 [&](BitrateAllocatorObserver*, MediaStreamAllocationConfig config) {
1005 EXPECT_EQ(config.min_bitrate_bps, bitrate_range.first.bps());
1006 EXPECT_EQ(config.max_bitrate_bps, bitrate_range.second.bps());
1007 }));
1008 EXPECT_CALL(*helper.channel_send(), StartSend());
1009 send_stream->Start();
1010 EXPECT_CALL(*helper.channel_send(), StopSend());
1011 send_stream->Stop();
1012}
1013
solenberg85a04962015-10-27 10:35:211014} // namespace test
solenbergc7a8b082015-10-16 21:35:071015} // namespace webrtc