Stefan Holmer | 8bffba7 | 2015-09-23 13:53:52 | [diff] [blame] | 1 | /* |
| 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 Olsson | a4d8737 | 2019-07-05 17:08:33 | [diff] [blame] | 11 | #include "audio/audio_receive_stream.h" |
| 12 | |
Jakob Ivarsson | 75dc9c9 | 2025-01-10 12:29:00 | [diff] [blame] | 13 | #include <cstddef> |
| 14 | #include <cstdint> |
kwiberg | 1c07c70 | 2017-03-27 14:15:49 | [diff] [blame] | 15 | #include <map> |
Jakob Ivarsson | 75dc9c9 | 2025-01-10 12:29:00 | [diff] [blame] | 16 | #include <memory> |
Fredrik Solenberg | f693bfa | 2018-12-11 11:22:10 | [diff] [blame] | 17 | #include <utility> |
stefan | 3313ec9 | 2016-01-21 14:32:43 | [diff] [blame] | 18 | #include <vector> |
Fredrik Solenberg | ea07373 | 2015-12-01 10:26:34 | [diff] [blame] | 19 | |
Jakob Ivarsson | 75dc9c9 | 2025-01-10 12:29:00 | [diff] [blame] | 20 | #include "api/audio_codecs/audio_format.h" |
| 21 | #include "api/crypto/frame_decryptor_interface.h" |
Danil Chapovalov | 3732b84 | 2024-07-18 16:24:32 | [diff] [blame] | 22 | #include "api/environment/environment_factory.h" |
Jakob Ivarsson | 75dc9c9 | 2025-01-10 12:29:00 | [diff] [blame] | 23 | #include "api/make_ref_counted.h" |
| 24 | #include "api/rtp_headers.h" |
| 25 | #include "api/scoped_refptr.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 04:47:31 | [diff] [blame] | 26 | #include "api/test/mock_audio_mixer.h" |
Benjamin Wright | 78410ad | 2018-10-25 16:52:57 | [diff] [blame] | 27 | #include "api/test/mock_frame_decryptor.h" |
Jakob Ivarsson | 75dc9c9 | 2025-01-10 12:29:00 | [diff] [blame] | 28 | #include "audio/channel_receive.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 04:47:31 | [diff] [blame] | 29 | #include "audio/conversion.h" |
Fredrik Solenberg | a8b7c7f | 2018-01-17 10:18:31 | [diff] [blame] | 30 | #include "audio/mock_voe_channel_proxy.h" |
Jakob Ivarsson | 75dc9c9 | 2025-01-10 12:29:00 | [diff] [blame] | 31 | #include "call/audio_receive_stream.h" |
| 32 | #include "call/audio_state.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 04:47:31 | [diff] [blame] | 33 | #include "call/rtp_stream_receiver_controller.h" |
Jakob Ivarsson | 75dc9c9 | 2025-01-10 12:29:00 | [diff] [blame] | 34 | #include "modules/audio_coding/include/audio_coding_module_typedefs.h" |
Fredrik Solenberg | 2a87797 | 2017-12-15 15:42:15 | [diff] [blame] | 35 | #include "modules/audio_device/include/mock_audio_device.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 04:47:31 | [diff] [blame] | 36 | #include "modules/audio_processing/include/mock_audio_processing.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 04:47:31 | [diff] [blame] | 37 | #include "modules/pacing/packet_router.h" |
| 38 | #include "modules/rtp_rtcp/source/byte_io.h" |
Bjorn Terelius | 5c2f1f0 | 2019-01-16 16:45:05 | [diff] [blame] | 39 | #include "rtc_base/time_utils.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 04:47:31 | [diff] [blame] | 40 | #include "test/gtest.h" |
| 41 | #include "test/mock_audio_decoder_factory.h" |
Niels Möller | ae4237e | 2018-10-05 09:28:38 | [diff] [blame] | 42 | #include "test/mock_transport.h" |
Tommi | cde4b67 | 2023-04-25 06:53:42 | [diff] [blame] | 43 | #include "test/run_loop.h" |
Stefan Holmer | 8bffba7 | 2015-09-23 13:53:52 | [diff] [blame] | 44 | |
Fredrik Solenberg | 0ccae13 | 2015-11-03 09:15:49 | [diff] [blame] | 45 | namespace webrtc { |
| 46 | namespace test { |
Fredrik Solenberg | 4f4ec0a | 2015-10-22 08:49:27 | [diff] [blame] | 47 | namespace { |
| 48 | |
Mirko Bonadei | 6a489f2 | 2019-04-09 13:11:12 | [diff] [blame] | 49 | using ::testing::_; |
| 50 | using ::testing::FloatEq; |
Alex Konradi | c20baf6 | 2020-12-03 16:30:34 | [diff] [blame] | 51 | using ::testing::NiceMock; |
Mirko Bonadei | 6a489f2 | 2019-04-09 13:11:12 | [diff] [blame] | 52 | using ::testing::Return; |
solenberg | 3a94154 | 2015-11-16 15:34:50 | [diff] [blame] | 53 | |
solenberg | 566ef24 | 2015-11-06 23:34:49 | [diff] [blame] | 54 | AudioDecodingCallStats MakeAudioDecodeStatsForTest() { |
| 55 | AudioDecodingCallStats audio_decode_stats; |
| 56 | audio_decode_stats.calls_to_silence_generator = 234; |
| 57 | audio_decode_stats.calls_to_neteq = 567; |
| 58 | audio_decode_stats.decoded_normal = 890; |
Alex Narest | 5b5d97c | 2019-08-07 16:15:08 | [diff] [blame] | 59 | audio_decode_stats.decoded_neteq_plc = 123; |
| 60 | audio_decode_stats.decoded_codec_plc = 124; |
solenberg | 566ef24 | 2015-11-06 23:34:49 | [diff] [blame] | 61 | audio_decode_stats.decoded_cng = 456; |
| 62 | audio_decode_stats.decoded_plc_cng = 789; |
henrik.lundin | 6348978 | 2016-09-20 08:47:12 | [diff] [blame] | 63 | audio_decode_stats.decoded_muted_output = 987; |
solenberg | 566ef24 | 2015-11-06 23:34:49 | [diff] [blame] | 64 | return audio_decode_stats; |
| 65 | } |
| 66 | |
Fredrik Solenberg | 0ccae13 | 2015-11-03 09:15:49 | [diff] [blame] | 67 | const uint32_t kRemoteSsrc = 1234; |
| 68 | const uint32_t kLocalSsrc = 5678; |
solenberg | 566ef24 | 2015-11-06 23:34:49 | [diff] [blame] | 69 | const int kJitterBufferDelay = -7; |
| 70 | const int kPlayoutBufferDelay = 302; |
| 71 | const unsigned int kSpeechOutputLevel = 99; |
zstein | e76bd3a | 2017-07-14 19:17:49 | [diff] [blame] | 72 | const double kTotalOutputEnergy = 0.25; |
| 73 | const double kTotalOutputDuration = 0.5; |
Åsa Persson | fcf79cc | 2019-10-22 13:23:44 | [diff] [blame] | 74 | const int64_t kPlayoutNtpTimestampMs = 5678; |
zstein | e76bd3a | 2017-07-14 19:17:49 | [diff] [blame] | 75 | |
Niels Möller | ac0a4cb | 2019-10-09 13:01:33 | [diff] [blame] | 76 | const CallReceiveStatistics kCallStats = {678, 234, -12, 567, 78, 890, 123}; |
Benjamin Wright | 17b050f | 2019-03-14 00:35:46 | [diff] [blame] | 77 | const std::pair<int, SdpAudioFormat> kReceiveCodec = { |
| 78 | 123, |
| 79 | {"codec_name_recv", 96000, 0}}; |
Gustaf Ullberg | b0a0207 | 2017-10-02 10:00:34 | [diff] [blame] | 80 | const NetworkStatistics kNetworkStats = { |
Minyue Li | 28a2c63 | 2021-07-07 13:53:38 | [diff] [blame] | 81 | /*currentBufferSize=*/123, |
| 82 | /*preferredBufferSize=*/456, |
| 83 | /*jitterPeaksFound=*/false, |
| 84 | /*totalSamplesReceived=*/789012, |
| 85 | /*concealedSamples=*/3456, |
| 86 | /*silentConcealedSamples=*/123, |
| 87 | /*concealmentEvents=*/456, |
| 88 | /*jitterBufferDelayMs=*/789, |
| 89 | /*jitterBufferEmittedCount=*/543, |
| 90 | /*jitterBufferTargetDelayMs=*/123, |
Ivo Creusen | 1a84b56 | 2022-07-19 14:33:10 | [diff] [blame] | 91 | /*jitterBufferMinimumDelayMs=*/222, |
Minyue Li | 28a2c63 | 2021-07-07 13:53:38 | [diff] [blame] | 92 | /*insertedSamplesForDeceleration=*/432, |
| 93 | /*removedSamplesForAcceleration=*/321, |
| 94 | /*fecPacketsReceived=*/123, |
| 95 | /*fecPacketsDiscarded=*/101, |
Jesús de Vicente Peña | fc6df05 | 2024-06-04 08:05:31 | [diff] [blame] | 96 | /*totalProcessingDelayMs=*/154, |
Minyue Li | 28a2c63 | 2021-07-07 13:53:38 | [diff] [blame] | 97 | /*packetsDiscarded=*/989, |
| 98 | /*currentExpandRate=*/789, |
| 99 | /*currentSpeechExpandRate=*/12, |
| 100 | /*currentPreemptiveRate=*/345, |
| 101 | /*currentAccelerateRate =*/678, |
| 102 | /*currentSecondaryDecodedRate=*/901, |
| 103 | /*currentSecondaryDiscardedRate=*/0, |
| 104 | /*meanWaitingTimeMs=*/-1, |
| 105 | /*maxWaitingTimeMs=*/-1, |
| 106 | /*packetBufferFlushes=*/0, |
| 107 | /*delayedPacketOutageSamples=*/0, |
| 108 | /*relativePacketArrivalDelayMs=*/135, |
| 109 | /*interruptionCount=*/-1, |
| 110 | /*totalInterruptionDurationMs=*/-1}; |
solenberg | 566ef24 | 2015-11-06 23:34:49 | [diff] [blame] | 111 | const AudioDecodingCallStats kAudioDecodeStats = MakeAudioDecodeStatsForTest(); |
| 112 | |
| 113 | struct ConfigHelper { |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 114 | explicit ConfigHelper(bool use_null_audio_processing) |
Tomas Gunnarsson | c1d5891 | 2021-04-22 17:21:43 | [diff] [blame] | 115 | : ConfigHelper(rtc::make_ref_counted<MockAudioMixer>(), |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 116 | use_null_audio_processing) {} |
Fredrik Solenberg | 8f5787a | 2018-01-11 12:52:30 | [diff] [blame] | 117 | |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 118 | ConfigHelper(rtc::scoped_refptr<MockAudioMixer> audio_mixer, |
| 119 | bool use_null_audio_processing) |
Fredrik Solenberg | 8f5787a | 2018-01-11 12:52:30 | [diff] [blame] | 120 | : audio_mixer_(audio_mixer) { |
Mirko Bonadei | 6a489f2 | 2019-04-09 13:11:12 | [diff] [blame] | 121 | using ::testing::Invoke; |
solenberg | 1372508 | 2015-11-25 16:16:52 | [diff] [blame] | 122 | |
solenberg | 566ef24 | 2015-11-06 23:34:49 | [diff] [blame] | 123 | AudioState::Config config; |
aleloi | 04c0722 | 2016-11-22 14:42:53 | [diff] [blame] | 124 | config.audio_mixer = audio_mixer_; |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 125 | config.audio_processing = |
| 126 | use_null_audio_processing |
| 127 | ? nullptr |
Tomas Gunnarsson | c1d5891 | 2021-04-22 17:21:43 | [diff] [blame] | 128 | : rtc::make_ref_counted<NiceMock<MockAudioProcessing>>(); |
Fredrik Solenberg | 2a87797 | 2017-12-15 15:42:15 | [diff] [blame] | 129 | config.audio_device_module = |
Tomas Gunnarsson | c1d5891 | 2021-04-22 17:21:43 | [diff] [blame] | 130 | rtc::make_ref_counted<testing::NiceMock<MockAudioDeviceModule>>(); |
solenberg | 566ef24 | 2015-11-06 23:34:49 | [diff] [blame] | 131 | audio_state_ = AudioState::Create(config); |
solenberg | 7add058 | 2015-11-20 17:59:34 | [diff] [blame] | 132 | |
Mirko Bonadei | 6a489f2 | 2019-04-09 13:11:12 | [diff] [blame] | 133 | channel_receive_ = new ::testing::StrictMock<MockChannelReceive>(); |
Niels Möller | 349ade3 | 2018-11-16 08:50:42 | [diff] [blame] | 134 | EXPECT_CALL(*channel_receive_, SetNACKStatus(true, 15)).Times(1); |
Philipp Hancke | bad99ab | 2024-05-13 15:49:42 | [diff] [blame] | 135 | EXPECT_CALL(*channel_receive_, SetRtcpMode(_)).Times(1); |
Niels Möller | 349ade3 | 2018-11-16 08:50:42 | [diff] [blame] | 136 | EXPECT_CALL(*channel_receive_, |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 137 | RegisterReceiverCongestionControlObjects(&packet_router_)) |
| 138 | .Times(1); |
Niels Möller | 349ade3 | 2018-11-16 08:50:42 | [diff] [blame] | 139 | EXPECT_CALL(*channel_receive_, ResetReceiverCongestionControlObjects()) |
Fredrik Solenberg | 8f5787a | 2018-01-11 12:52:30 | [diff] [blame] | 140 | .Times(1); |
Niels Möller | 349ade3 | 2018-11-16 08:50:42 | [diff] [blame] | 141 | EXPECT_CALL(*channel_receive_, SetReceiveCodecs(_)) |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 142 | .WillRepeatedly(Invoke([](const std::map<int, SdpAudioFormat>& codecs) { |
Mirko Bonadei | 6a489f2 | 2019-04-09 13:11:12 | [diff] [blame] | 143 | EXPECT_THAT(codecs, ::testing::IsEmpty()); |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 144 | })); |
Tommi | cc50b04 | 2022-05-09 10:22:48 | [diff] [blame] | 145 | EXPECT_CALL(*channel_receive_, GetLocalSsrc()) |
| 146 | .WillRepeatedly(Return(kLocalSsrc)); |
Fredrik Solenberg | 8f5787a | 2018-01-11 12:52:30 | [diff] [blame] | 147 | |
solenberg | 566ef24 | 2015-11-06 23:34:49 | [diff] [blame] | 148 | stream_config_.rtp.local_ssrc = kLocalSsrc; |
| 149 | stream_config_.rtp.remote_ssrc = kRemoteSsrc; |
solenberg | 8189b02 | 2016-06-14 19:13:00 | [diff] [blame] | 150 | stream_config_.rtp.nack.rtp_history_ms = 300; |
Niels Möller | ae4237e | 2018-10-05 09:28:38 | [diff] [blame] | 151 | stream_config_.rtcp_send_transport = &rtcp_send_transport_; |
Fredrik Solenberg | 8f5787a | 2018-01-11 12:52:30 | [diff] [blame] | 152 | stream_config_.decoder_factory = |
Tomas Gunnarsson | c1d5891 | 2021-04-22 17:21:43 | [diff] [blame] | 153 | rtc::make_ref_counted<MockAudioDecoderFactory>(); |
solenberg | 1372508 | 2015-11-25 16:16:52 | [diff] [blame] | 154 | } |
solenberg | 566ef24 | 2015-11-06 23:34:49 | [diff] [blame] | 155 | |
Tommi | dddbbeb | 2022-05-20 13:21:33 | [diff] [blame] | 156 | std::unique_ptr<AudioReceiveStreamImpl> CreateAudioReceiveStream() { |
| 157 | auto ret = std::make_unique<AudioReceiveStreamImpl>( |
Danil Chapovalov | 3732b84 | 2024-07-18 16:24:32 | [diff] [blame] | 158 | CreateEnvironment(), &packet_router_, stream_config_, audio_state_, |
Tommi | 02df2eb | 2021-05-31 10:57:53 | [diff] [blame] | 159 | std::unique_ptr<voe::ChannelReceiveInterface>(channel_receive_)); |
| 160 | ret->RegisterWithTransport(&rtp_stream_receiver_controller_); |
| 161 | return ret; |
nisse | 0f15f92 | 2017-06-21 08:05:22 | [diff] [blame] | 162 | } |
solenberg | 566ef24 | 2015-11-06 23:34:49 | [diff] [blame] | 163 | |
Tommi | 3176ef7 | 2022-05-22 18:47:28 | [diff] [blame] | 164 | AudioReceiveStreamInterface::Config& config() { return stream_config_; } |
Fredrik Solenberg | 8f5787a | 2018-01-11 12:52:30 | [diff] [blame] | 165 | rtc::scoped_refptr<MockAudioMixer> audio_mixer() { return audio_mixer_; } |
Niels Möller | 349ade3 | 2018-11-16 08:50:42 | [diff] [blame] | 166 | MockChannelReceive* channel_receive() { return channel_receive_; } |
Fredrik Solenberg | 8f5787a | 2018-01-11 12:52:30 | [diff] [blame] | 167 | |
solenberg | 566ef24 | 2015-11-06 23:34:49 | [diff] [blame] | 168 | void SetupMockForGetStats() { |
Mirko Bonadei | 6a489f2 | 2019-04-09 13:11:12 | [diff] [blame] | 169 | using ::testing::DoAll; |
| 170 | using ::testing::SetArgPointee; |
solenberg | 1372508 | 2015-11-25 16:16:52 | [diff] [blame] | 171 | |
Niels Möller | 349ade3 | 2018-11-16 08:50:42 | [diff] [blame] | 172 | ASSERT_TRUE(channel_receive_); |
| 173 | EXPECT_CALL(*channel_receive_, GetRTCPStatistics()) |
solenberg | 358057b | 2015-11-27 18:46:42 | [diff] [blame] | 174 | .WillOnce(Return(kCallStats)); |
Niels Möller | 349ade3 | 2018-11-16 08:50:42 | [diff] [blame] | 175 | EXPECT_CALL(*channel_receive_, GetDelayEstimate()) |
solenberg | 358057b | 2015-11-27 18:46:42 | [diff] [blame] | 176 | .WillOnce(Return(kJitterBufferDelay + kPlayoutBufferDelay)); |
Niels Möller | 349ade3 | 2018-11-16 08:50:42 | [diff] [blame] | 177 | EXPECT_CALL(*channel_receive_, GetSpeechOutputLevelFullRange()) |
solenberg | 358057b | 2015-11-27 18:46:42 | [diff] [blame] | 178 | .WillOnce(Return(kSpeechOutputLevel)); |
Niels Möller | 349ade3 | 2018-11-16 08:50:42 | [diff] [blame] | 179 | EXPECT_CALL(*channel_receive_, GetTotalOutputEnergy()) |
zstein | e76bd3a | 2017-07-14 19:17:49 | [diff] [blame] | 180 | .WillOnce(Return(kTotalOutputEnergy)); |
Niels Möller | 349ade3 | 2018-11-16 08:50:42 | [diff] [blame] | 181 | EXPECT_CALL(*channel_receive_, GetTotalOutputDuration()) |
zstein | e76bd3a | 2017-07-14 19:17:49 | [diff] [blame] | 182 | .WillOnce(Return(kTotalOutputDuration)); |
Niels Möller | 6b4d962 | 2020-09-14 08:47:50 | [diff] [blame] | 183 | EXPECT_CALL(*channel_receive_, GetNetworkStatistics(_)) |
solenberg | 358057b | 2015-11-27 18:46:42 | [diff] [blame] | 184 | .WillOnce(Return(kNetworkStats)); |
Niels Möller | 349ade3 | 2018-11-16 08:50:42 | [diff] [blame] | 185 | EXPECT_CALL(*channel_receive_, GetDecodingCallStatistics()) |
solenberg | 358057b | 2015-11-27 18:46:42 | [diff] [blame] | 186 | .WillOnce(Return(kAudioDecodeStats)); |
Fredrik Solenberg | f693bfa | 2018-12-11 11:22:10 | [diff] [blame] | 187 | EXPECT_CALL(*channel_receive_, GetReceiveCodec()) |
| 188 | .WillOnce(Return(kReceiveCodec)); |
Åsa Persson | fcf79cc | 2019-10-22 13:23:44 | [diff] [blame] | 189 | EXPECT_CALL(*channel_receive_, GetCurrentEstimatedPlayoutNtpTimestampMs(_)) |
| 190 | .WillOnce(Return(kPlayoutNtpTimestampMs)); |
solenberg | 566ef24 | 2015-11-06 23:34:49 | [diff] [blame] | 191 | } |
| 192 | |
| 193 | private: |
Stefan Holmer | 3842c5c | 2016-01-12 12:55:00 | [diff] [blame] | 194 | PacketRouter packet_router_; |
solenberg | 566ef24 | 2015-11-06 23:34:49 | [diff] [blame] | 195 | rtc::scoped_refptr<AudioState> audio_state_; |
aleloi | 04c0722 | 2016-11-22 14:42:53 | [diff] [blame] | 196 | rtc::scoped_refptr<MockAudioMixer> audio_mixer_; |
Tommi | 3176ef7 | 2022-05-22 18:47:28 | [diff] [blame] | 197 | AudioReceiveStreamInterface::Config stream_config_; |
Mirko Bonadei | 6a489f2 | 2019-04-09 13:11:12 | [diff] [blame] | 198 | ::testing::StrictMock<MockChannelReceive>* channel_receive_ = nullptr; |
nisse | 0f15f92 | 2017-06-21 08:05:22 | [diff] [blame] | 199 | RtpStreamReceiverController rtp_stream_receiver_controller_; |
Niels Möller | ae4237e | 2018-10-05 09:28:38 | [diff] [blame] | 200 | MockTransport rtcp_send_transport_; |
solenberg | 566ef24 | 2015-11-06 23:34:49 | [diff] [blame] | 201 | }; |
Stefan Holmer | 8bffba7 | 2015-09-23 13:53:52 | [diff] [blame] | 202 | |
Jakob Ivarsson | 75dc9c9 | 2025-01-10 12:29:00 | [diff] [blame] | 203 | std::vector<uint8_t> CreateRtcpSenderReport() { |
mflodman | 3d7db26 | 2016-04-29 07:57:13 | [diff] [blame] | 204 | std::vector<uint8_t> packet; |
| 205 | const size_t kRtcpSrLength = 28; // In bytes. |
| 206 | packet.resize(kRtcpSrLength); |
| 207 | packet[0] = 0x80; // Version 2. |
| 208 | packet[1] = 0xc8; // PT = 200, SR. |
| 209 | // Length in number of 32-bit words - 1. |
| 210 | ByteWriter<uint16_t>::WriteBigEndian(&packet[2], 6); |
| 211 | ByteWriter<uint32_t>::WriteBigEndian(&packet[4], kLocalSsrc); |
| 212 | return packet; |
| 213 | } |
Fredrik Solenberg | 4f4ec0a | 2015-10-22 08:49:27 | [diff] [blame] | 214 | } // namespace |
| 215 | |
solenberg | 85a0496 | 2015-10-27 10:35:21 | [diff] [blame] | 216 | TEST(AudioReceiveStreamTest, ConfigToString) { |
Tommi | 3176ef7 | 2022-05-22 18:47:28 | [diff] [blame] | 217 | AudioReceiveStreamInterface::Config config; |
Fredrik Solenberg | 0ccae13 | 2015-11-03 09:15:49 | [diff] [blame] | 218 | config.rtp.remote_ssrc = kRemoteSsrc; |
| 219 | config.rtp.local_ssrc = kLocalSsrc; |
Philipp Hancke | bad99ab | 2024-05-13 15:49:42 | [diff] [blame] | 220 | config.rtp.rtcp_mode = RtcpMode::kOff; |
Fredrik Solenberg | 0ccae13 | 2015-11-03 09:15:49 | [diff] [blame] | 221 | EXPECT_EQ( |
Per K | 9253240 | 2023-01-02 15:57:18 | [diff] [blame] | 222 | "{rtp: {remote_ssrc: 1234, local_ssrc: 5678, nack: " |
Philipp Hancke | bad99ab | 2024-05-13 15:49:42 | [diff] [blame] | 223 | "{rtp_history_ms: 0}, rtcp: off}, " |
Bjorn A Mellem | 7a9a092 | 2019-11-26 17:19:40 | [diff] [blame] | 224 | "rtcp_send_transport: null}", |
Fredrik Solenberg | 0ccae13 | 2015-11-03 09:15:49 | [diff] [blame] | 225 | config.ToString()); |
solenberg | 85a0496 | 2015-10-27 10:35:21 | [diff] [blame] | 226 | } |
| 227 | |
| 228 | TEST(AudioReceiveStreamTest, ConstructDestruct) { |
Tommi | cde4b67 | 2023-04-25 06:53:42 | [diff] [blame] | 229 | test::RunLoop loop; |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 230 | for (bool use_null_audio_processing : {false, true}) { |
| 231 | ConfigHelper helper(use_null_audio_processing); |
| 232 | auto recv_stream = helper.CreateAudioReceiveStream(); |
Tommi | 02df2eb | 2021-05-31 10:57:53 | [diff] [blame] | 233 | recv_stream->UnregisterFromTransport(); |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 234 | } |
Stefan Holmer | 3842c5c | 2016-01-12 12:55:00 | [diff] [blame] | 235 | } |
| 236 | |
mflodman | 3d7db26 | 2016-04-29 07:57:13 | [diff] [blame] | 237 | TEST(AudioReceiveStreamTest, ReceiveRtcpPacket) { |
Tommi | cde4b67 | 2023-04-25 06:53:42 | [diff] [blame] | 238 | test::RunLoop loop; |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 239 | for (bool use_null_audio_processing : {false, true}) { |
| 240 | ConfigHelper helper(use_null_audio_processing); |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 241 | auto recv_stream = helper.CreateAudioReceiveStream(); |
| 242 | std::vector<uint8_t> rtcp_packet = CreateRtcpSenderReport(); |
| 243 | EXPECT_CALL(*helper.channel_receive(), |
| 244 | ReceivedRTCPPacket(&rtcp_packet[0], rtcp_packet.size())) |
| 245 | .WillOnce(Return()); |
| 246 | recv_stream->DeliverRtcp(&rtcp_packet[0], rtcp_packet.size()); |
Tommi | 02df2eb | 2021-05-31 10:57:53 | [diff] [blame] | 247 | recv_stream->UnregisterFromTransport(); |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 248 | } |
mflodman | 3d7db26 | 2016-04-29 07:57:13 | [diff] [blame] | 249 | } |
| 250 | |
Fredrik Solenberg | 4f4ec0a | 2015-10-22 08:49:27 | [diff] [blame] | 251 | TEST(AudioReceiveStreamTest, GetStats) { |
Tommi | cde4b67 | 2023-04-25 06:53:42 | [diff] [blame] | 252 | test::RunLoop loop; |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 253 | for (bool use_null_audio_processing : {false, true}) { |
| 254 | ConfigHelper helper(use_null_audio_processing); |
| 255 | auto recv_stream = helper.CreateAudioReceiveStream(); |
| 256 | helper.SetupMockForGetStats(); |
Tommi | 3176ef7 | 2022-05-22 18:47:28 | [diff] [blame] | 257 | AudioReceiveStreamInterface::Stats stats = |
Niels Möller | 6b4d962 | 2020-09-14 08:47:50 | [diff] [blame] | 258 | recv_stream->GetStats(/*get_and_clear_legacy_stats=*/true); |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 259 | EXPECT_EQ(kRemoteSsrc, stats.remote_ssrc); |
Philipp Hancke | 6a7bf10 | 2023-04-21 17:32:42 | [diff] [blame] | 260 | EXPECT_EQ(kCallStats.payload_bytes_received, stats.payload_bytes_received); |
| 261 | EXPECT_EQ(kCallStats.header_and_padding_bytes_received, |
| 262 | stats.header_and_padding_bytes_received); |
Jakob Ivarsson | 8da15c4 | 2024-11-21 15:35:46 | [diff] [blame] | 263 | EXPECT_EQ(static_cast<uint32_t>(kCallStats.packets_received), |
Philipp Hancke | 6a7bf10 | 2023-04-21 17:32:42 | [diff] [blame] | 264 | stats.packets_received); |
Jakob Ivarsson | 8da15c4 | 2024-11-21 15:35:46 | [diff] [blame] | 265 | EXPECT_EQ(kCallStats.packets_lost, stats.packets_lost); |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 266 | EXPECT_EQ(kReceiveCodec.second.name, stats.codec_name); |
Jakob Ivarsson | 8da15c4 | 2024-11-21 15:35:46 | [diff] [blame] | 267 | EXPECT_EQ(kCallStats.jitter_ms, stats.jitter_ms); |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 268 | EXPECT_EQ(kNetworkStats.currentBufferSize, stats.jitter_buffer_ms); |
| 269 | EXPECT_EQ(kNetworkStats.preferredBufferSize, |
| 270 | stats.jitter_buffer_preferred_ms); |
| 271 | EXPECT_EQ(static_cast<uint32_t>(kJitterBufferDelay + kPlayoutBufferDelay), |
| 272 | stats.delay_estimate_ms); |
| 273 | EXPECT_EQ(static_cast<int32_t>(kSpeechOutputLevel), stats.audio_level); |
| 274 | EXPECT_EQ(kTotalOutputEnergy, stats.total_output_energy); |
| 275 | EXPECT_EQ(kNetworkStats.totalSamplesReceived, stats.total_samples_received); |
| 276 | EXPECT_EQ(kTotalOutputDuration, stats.total_output_duration); |
| 277 | EXPECT_EQ(kNetworkStats.concealedSamples, stats.concealed_samples); |
| 278 | EXPECT_EQ(kNetworkStats.concealmentEvents, stats.concealment_events); |
| 279 | EXPECT_EQ(static_cast<double>(kNetworkStats.jitterBufferDelayMs) / |
| 280 | static_cast<double>(rtc::kNumMillisecsPerSec), |
| 281 | stats.jitter_buffer_delay_seconds); |
| 282 | EXPECT_EQ(kNetworkStats.jitterBufferEmittedCount, |
| 283 | stats.jitter_buffer_emitted_count); |
| 284 | EXPECT_EQ(static_cast<double>(kNetworkStats.jitterBufferTargetDelayMs) / |
| 285 | static_cast<double>(rtc::kNumMillisecsPerSec), |
| 286 | stats.jitter_buffer_target_delay_seconds); |
Ivo Creusen | 1a84b56 | 2022-07-19 14:33:10 | [diff] [blame] | 287 | EXPECT_EQ(static_cast<double>(kNetworkStats.jitterBufferMinimumDelayMs) / |
| 288 | static_cast<double>(rtc::kNumMillisecsPerSec), |
| 289 | stats.jitter_buffer_minimum_delay_seconds); |
Minyue Li | 28a2c63 | 2021-07-07 13:53:38 | [diff] [blame] | 290 | EXPECT_EQ(kNetworkStats.insertedSamplesForDeceleration, |
| 291 | stats.inserted_samples_for_deceleration); |
| 292 | EXPECT_EQ(kNetworkStats.removedSamplesForAcceleration, |
| 293 | stats.removed_samples_for_acceleration); |
| 294 | EXPECT_EQ(kNetworkStats.fecPacketsReceived, stats.fec_packets_received); |
| 295 | EXPECT_EQ(kNetworkStats.fecPacketsDiscarded, stats.fec_packets_discarded); |
Jesús de Vicente Peña | fc6df05 | 2024-06-04 08:05:31 | [diff] [blame] | 296 | EXPECT_EQ(static_cast<double>(kNetworkStats.totalProcessingDelayUs) / |
| 297 | static_cast<double>(rtc::kNumMicrosecsPerSec), |
| 298 | stats.total_processing_delay_seconds); |
Minyue Li | 28a2c63 | 2021-07-07 13:53:38 | [diff] [blame] | 299 | EXPECT_EQ(kNetworkStats.packetsDiscarded, stats.packets_discarded); |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 300 | EXPECT_EQ(Q14ToFloat(kNetworkStats.currentExpandRate), stats.expand_rate); |
| 301 | EXPECT_EQ(Q14ToFloat(kNetworkStats.currentSpeechExpandRate), |
| 302 | stats.speech_expand_rate); |
| 303 | EXPECT_EQ(Q14ToFloat(kNetworkStats.currentSecondaryDecodedRate), |
| 304 | stats.secondary_decoded_rate); |
| 305 | EXPECT_EQ(Q14ToFloat(kNetworkStats.currentSecondaryDiscardedRate), |
| 306 | stats.secondary_discarded_rate); |
| 307 | EXPECT_EQ(Q14ToFloat(kNetworkStats.currentAccelerateRate), |
| 308 | stats.accelerate_rate); |
| 309 | EXPECT_EQ(Q14ToFloat(kNetworkStats.currentPreemptiveRate), |
| 310 | stats.preemptive_expand_rate); |
Minyue Li | 28a2c63 | 2021-07-07 13:53:38 | [diff] [blame] | 311 | EXPECT_EQ(kNetworkStats.packetBufferFlushes, stats.jitter_buffer_flushes); |
| 312 | EXPECT_EQ(kNetworkStats.delayedPacketOutageSamples, |
| 313 | stats.delayed_packet_outage_samples); |
| 314 | EXPECT_EQ(static_cast<double>(kNetworkStats.relativePacketArrivalDelayMs) / |
| 315 | static_cast<double>(rtc::kNumMillisecsPerSec), |
| 316 | stats.relative_packet_arrival_delay_seconds); |
| 317 | EXPECT_EQ(kNetworkStats.interruptionCount, stats.interruption_count); |
| 318 | EXPECT_EQ(kNetworkStats.totalInterruptionDurationMs, |
| 319 | stats.total_interruption_duration_ms); |
| 320 | |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 321 | EXPECT_EQ(kAudioDecodeStats.calls_to_silence_generator, |
| 322 | stats.decoding_calls_to_silence_generator); |
| 323 | EXPECT_EQ(kAudioDecodeStats.calls_to_neteq, stats.decoding_calls_to_neteq); |
| 324 | EXPECT_EQ(kAudioDecodeStats.decoded_normal, stats.decoding_normal); |
| 325 | EXPECT_EQ(kAudioDecodeStats.decoded_neteq_plc, stats.decoding_plc); |
| 326 | EXPECT_EQ(kAudioDecodeStats.decoded_codec_plc, stats.decoding_codec_plc); |
| 327 | EXPECT_EQ(kAudioDecodeStats.decoded_cng, stats.decoding_cng); |
| 328 | EXPECT_EQ(kAudioDecodeStats.decoded_plc_cng, stats.decoding_plc_cng); |
| 329 | EXPECT_EQ(kAudioDecodeStats.decoded_muted_output, |
| 330 | stats.decoding_muted_output); |
Jakob Ivarsson | 8da15c4 | 2024-11-21 15:35:46 | [diff] [blame] | 331 | EXPECT_EQ(kCallStats.capture_start_ntp_time_ms, |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 332 | stats.capture_start_ntp_time_ms); |
| 333 | EXPECT_EQ(kPlayoutNtpTimestampMs, stats.estimated_playout_ntp_timestamp_ms); |
Tommi | 02df2eb | 2021-05-31 10:57:53 | [diff] [blame] | 334 | recv_stream->UnregisterFromTransport(); |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 335 | } |
Fredrik Solenberg | 4f4ec0a | 2015-10-22 08:49:27 | [diff] [blame] | 336 | } |
solenberg | 217fb66 | 2016-06-17 15:30:54 | [diff] [blame] | 337 | |
| 338 | TEST(AudioReceiveStreamTest, SetGain) { |
Tommi | cde4b67 | 2023-04-25 06:53:42 | [diff] [blame] | 339 | test::RunLoop loop; |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 340 | for (bool use_null_audio_processing : {false, true}) { |
| 341 | ConfigHelper helper(use_null_audio_processing); |
| 342 | auto recv_stream = helper.CreateAudioReceiveStream(); |
| 343 | EXPECT_CALL(*helper.channel_receive(), |
| 344 | SetChannelOutputVolumeScaling(FloatEq(0.765f))); |
| 345 | recv_stream->SetGain(0.765f); |
Tommi | 02df2eb | 2021-05-31 10:57:53 | [diff] [blame] | 346 | recv_stream->UnregisterFromTransport(); |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 347 | } |
solenberg | 217fb66 | 2016-06-17 15:30:54 | [diff] [blame] | 348 | } |
aleloi | 04c0722 | 2016-11-22 14:42:53 | [diff] [blame] | 349 | |
Fredrik Solenberg | d524751 | 2017-12-18 21:41:03 | [diff] [blame] | 350 | TEST(AudioReceiveStreamTest, StreamsShouldBeAddedToMixerOnceOnStart) { |
Tommi | cde4b67 | 2023-04-25 06:53:42 | [diff] [blame] | 351 | test::RunLoop loop; |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 352 | for (bool use_null_audio_processing : {false, true}) { |
| 353 | ConfigHelper helper1(use_null_audio_processing); |
| 354 | ConfigHelper helper2(helper1.audio_mixer(), use_null_audio_processing); |
| 355 | auto recv_stream1 = helper1.CreateAudioReceiveStream(); |
| 356 | auto recv_stream2 = helper2.CreateAudioReceiveStream(); |
aleloi | 04c0722 | 2016-11-22 14:42:53 | [diff] [blame] | 357 | |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 358 | EXPECT_CALL(*helper1.channel_receive(), StartPlayout()).Times(1); |
| 359 | EXPECT_CALL(*helper2.channel_receive(), StartPlayout()).Times(1); |
| 360 | EXPECT_CALL(*helper1.channel_receive(), StopPlayout()).Times(1); |
| 361 | EXPECT_CALL(*helper2.channel_receive(), StopPlayout()).Times(1); |
| 362 | EXPECT_CALL(*helper1.audio_mixer(), AddSource(recv_stream1.get())) |
| 363 | .WillOnce(Return(true)); |
| 364 | EXPECT_CALL(*helper1.audio_mixer(), AddSource(recv_stream2.get())) |
| 365 | .WillOnce(Return(true)); |
| 366 | EXPECT_CALL(*helper1.audio_mixer(), RemoveSource(recv_stream1.get())) |
| 367 | .Times(1); |
| 368 | EXPECT_CALL(*helper1.audio_mixer(), RemoveSource(recv_stream2.get())) |
| 369 | .Times(1); |
aleloi | 04c0722 | 2016-11-22 14:42:53 | [diff] [blame] | 370 | |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 371 | recv_stream1->Start(); |
| 372 | recv_stream2->Start(); |
Fredrik Solenberg | d524751 | 2017-12-18 21:41:03 | [diff] [blame] | 373 | |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 374 | // One more should not result in any more mixer sources added. |
| 375 | recv_stream1->Start(); |
Fredrik Solenberg | d524751 | 2017-12-18 21:41:03 | [diff] [blame] | 376 | |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 377 | // Stop stream before it is being destructed. |
| 378 | recv_stream2->Stop(); |
Tommi | 02df2eb | 2021-05-31 10:57:53 | [diff] [blame] | 379 | |
| 380 | recv_stream1->UnregisterFromTransport(); |
| 381 | recv_stream2->UnregisterFromTransport(); |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 382 | } |
aleloi | 04c0722 | 2016-11-22 14:42:53 | [diff] [blame] | 383 | } |
Fredrik Solenberg | 3b903d0 | 2018-01-10 14:17:10 | [diff] [blame] | 384 | |
Fredrik Solenberg | 3b903d0 | 2018-01-10 14:17:10 | [diff] [blame] | 385 | TEST(AudioReceiveStreamTest, ReconfigureWithUpdatedConfig) { |
Tommi | cde4b67 | 2023-04-25 06:53:42 | [diff] [blame] | 386 | test::RunLoop loop; |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 387 | for (bool use_null_audio_processing : {false, true}) { |
| 388 | ConfigHelper helper(use_null_audio_processing); |
| 389 | auto recv_stream = helper.CreateAudioReceiveStream(); |
Fredrik Solenberg | 3b903d0 | 2018-01-10 14:17:10 | [diff] [blame] | 390 | |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 391 | auto new_config = helper.config(); |
Tommi | 6eda26c | 2021-06-09 11:46:28 | [diff] [blame] | 392 | |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 393 | MockChannelReceive& channel_receive = *helper.channel_receive(); |
Tommi | e2561e1 | 2021-06-08 14:55:47 | [diff] [blame] | 394 | |
Tommi | 6eda26c | 2021-06-09 11:46:28 | [diff] [blame] | 395 | // TODO(tommi, nisse): This applies new extensions to the internal config, |
| 396 | // but there's nothing that actually verifies that the changes take effect. |
| 397 | // In fact Call manages the extensions separately in Call::ReceiveRtpConfig |
| 398 | // and changing this config value (there seem to be a few copies), doesn't |
| 399 | // affect that logic. |
| 400 | recv_stream->ReconfigureForTesting(new_config); |
| 401 | |
| 402 | new_config.decoder_map.emplace(1, SdpAudioFormat("foo", 8000, 1)); |
| 403 | EXPECT_CALL(channel_receive, SetReceiveCodecs(new_config.decoder_map)); |
| 404 | recv_stream->SetDecoderMap(new_config.decoder_map); |
| 405 | |
| 406 | EXPECT_CALL(channel_receive, SetNACKStatus(true, 15 + 1)).Times(1); |
Tommi | a136ed4 | 2022-05-30 13:08:13 | [diff] [blame] | 407 | recv_stream->SetNackHistory(300 + 20); |
Tommi | 6eda26c | 2021-06-09 11:46:28 | [diff] [blame] | 408 | |
Tommi | 02df2eb | 2021-05-31 10:57:53 | [diff] [blame] | 409 | recv_stream->UnregisterFromTransport(); |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 410 | } |
Fredrik Solenberg | 3b903d0 | 2018-01-10 14:17:10 | [diff] [blame] | 411 | } |
Benjamin Wright | 78410ad | 2018-10-25 16:52:57 | [diff] [blame] | 412 | |
| 413 | TEST(AudioReceiveStreamTest, ReconfigureWithFrameDecryptor) { |
Tommi | cde4b67 | 2023-04-25 06:53:42 | [diff] [blame] | 414 | test::RunLoop loop; |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 415 | for (bool use_null_audio_processing : {false, true}) { |
| 416 | ConfigHelper helper(use_null_audio_processing); |
| 417 | auto recv_stream = helper.CreateAudioReceiveStream(); |
Benjamin Wright | 78410ad | 2018-10-25 16:52:57 | [diff] [blame] | 418 | |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 419 | auto new_config_0 = helper.config(); |
| 420 | rtc::scoped_refptr<FrameDecryptorInterface> mock_frame_decryptor_0( |
Tomas Gunnarsson | c1d5891 | 2021-04-22 17:21:43 | [diff] [blame] | 421 | rtc::make_ref_counted<MockFrameDecryptor>()); |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 422 | new_config_0.frame_decryptor = mock_frame_decryptor_0; |
Benjamin Wright | 78410ad | 2018-10-25 16:52:57 | [diff] [blame] | 423 | |
Tommi | 6eda26c | 2021-06-09 11:46:28 | [diff] [blame] | 424 | // TODO(tommi): While this changes the internal config value, it doesn't |
| 425 | // actually change what frame_decryptor is used. WebRtcAudioReceiveStream |
| 426 | // recreates the whole instance in order to change this value. |
| 427 | // So, it's not clear if changing this post initialization needs to be |
| 428 | // supported. |
| 429 | recv_stream->ReconfigureForTesting(new_config_0); |
Benjamin Wright | 78410ad | 2018-10-25 16:52:57 | [diff] [blame] | 430 | |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 431 | auto new_config_1 = helper.config(); |
| 432 | rtc::scoped_refptr<FrameDecryptorInterface> mock_frame_decryptor_1( |
Tomas Gunnarsson | c1d5891 | 2021-04-22 17:21:43 | [diff] [blame] | 433 | rtc::make_ref_counted<MockFrameDecryptor>()); |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 434 | new_config_1.frame_decryptor = mock_frame_decryptor_1; |
| 435 | new_config_1.crypto_options.sframe.require_frame_encryption = true; |
Tommi | 6eda26c | 2021-06-09 11:46:28 | [diff] [blame] | 436 | recv_stream->ReconfigureForTesting(new_config_1); |
Tommi | 02df2eb | 2021-05-31 10:57:53 | [diff] [blame] | 437 | recv_stream->UnregisterFromTransport(); |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 438 | } |
Benjamin Wright | 78410ad | 2018-10-25 16:52:57 | [diff] [blame] | 439 | } |
| 440 | |
Fredrik Solenberg | 4f4ec0a | 2015-10-22 08:49:27 | [diff] [blame] | 441 | } // namespace test |
Stefan Holmer | 8bffba7 | 2015-09-23 13:53:52 | [diff] [blame] | 442 | } // namespace webrtc |