From 36d22d82aa202bb199967e9512281e9a53db42c9 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 21:33:14 +0200 Subject: Adding upstream version 115.7.0esr. Signed-off-by: Daniel Baumann --- .../audio/audio_receive_stream_unittest.cc | 439 +++++++++++++++++++++ 1 file changed, 439 insertions(+) create mode 100644 third_party/libwebrtc/audio/audio_receive_stream_unittest.cc (limited to 'third_party/libwebrtc/audio/audio_receive_stream_unittest.cc') diff --git a/third_party/libwebrtc/audio/audio_receive_stream_unittest.cc b/third_party/libwebrtc/audio/audio_receive_stream_unittest.cc new file mode 100644 index 0000000000..2cee6a4bae --- /dev/null +++ b/third_party/libwebrtc/audio/audio_receive_stream_unittest.cc @@ -0,0 +1,439 @@ +/* + * Copyright (c) 2015 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#include "audio/audio_receive_stream.h" + +#include +#include +#include +#include + +#include "api/test/mock_audio_mixer.h" +#include "api/test/mock_frame_decryptor.h" +#include "audio/conversion.h" +#include "audio/mock_voe_channel_proxy.h" +#include "call/rtp_stream_receiver_controller.h" +#include "logging/rtc_event_log/mock/mock_rtc_event_log.h" +#include "modules/audio_device/include/mock_audio_device.h" +#include "modules/audio_processing/include/mock_audio_processing.h" +#include "modules/pacing/packet_router.h" +#include "modules/rtp_rtcp/source/byte_io.h" +#include "rtc_base/time_utils.h" +#include "test/gtest.h" +#include "test/mock_audio_decoder_factory.h" +#include "test/mock_transport.h" + +namespace webrtc { +namespace test { +namespace { + +using ::testing::_; +using ::testing::FloatEq; +using ::testing::NiceMock; +using ::testing::Return; + +AudioDecodingCallStats MakeAudioDecodeStatsForTest() { + AudioDecodingCallStats audio_decode_stats; + audio_decode_stats.calls_to_silence_generator = 234; + audio_decode_stats.calls_to_neteq = 567; + audio_decode_stats.decoded_normal = 890; + audio_decode_stats.decoded_neteq_plc = 123; + audio_decode_stats.decoded_codec_plc = 124; + audio_decode_stats.decoded_cng = 456; + audio_decode_stats.decoded_plc_cng = 789; + audio_decode_stats.decoded_muted_output = 987; + return audio_decode_stats; +} + +const uint32_t kRemoteSsrc = 1234; +const uint32_t kLocalSsrc = 5678; +const int kAudioLevelId = 3; +const int kTransportSequenceNumberId = 4; +const int kJitterBufferDelay = -7; +const int kPlayoutBufferDelay = 302; +const unsigned int kSpeechOutputLevel = 99; +const double kTotalOutputEnergy = 0.25; +const double kTotalOutputDuration = 0.5; +const int64_t kPlayoutNtpTimestampMs = 5678; + +const CallReceiveStatistics kCallStats = {678, 234, -12, 567, 78, 890, 123}; +const std::pair kReceiveCodec = { + 123, + {"codec_name_recv", 96000, 0}}; +const NetworkStatistics kNetworkStats = { + /*currentBufferSize=*/123, + /*preferredBufferSize=*/456, + /*jitterPeaksFound=*/false, + /*totalSamplesReceived=*/789012, + /*concealedSamples=*/3456, + /*silentConcealedSamples=*/123, + /*concealmentEvents=*/456, + /*jitterBufferDelayMs=*/789, + /*jitterBufferEmittedCount=*/543, + /*jitterBufferTargetDelayMs=*/123, + /*jitterBufferMinimumDelayMs=*/222, + /*insertedSamplesForDeceleration=*/432, + /*removedSamplesForAcceleration=*/321, + /*fecPacketsReceived=*/123, + /*fecPacketsDiscarded=*/101, + /*packetsDiscarded=*/989, + /*currentExpandRate=*/789, + /*currentSpeechExpandRate=*/12, + /*currentPreemptiveRate=*/345, + /*currentAccelerateRate =*/678, + /*currentSecondaryDecodedRate=*/901, + /*currentSecondaryDiscardedRate=*/0, + /*meanWaitingTimeMs=*/-1, + /*maxWaitingTimeMs=*/-1, + /*packetBufferFlushes=*/0, + /*delayedPacketOutageSamples=*/0, + /*relativePacketArrivalDelayMs=*/135, + /*interruptionCount=*/-1, + /*totalInterruptionDurationMs=*/-1}; +const AudioDecodingCallStats kAudioDecodeStats = MakeAudioDecodeStatsForTest(); + +struct ConfigHelper { + explicit ConfigHelper(bool use_null_audio_processing) + : ConfigHelper(rtc::make_ref_counted(), + use_null_audio_processing) {} + + ConfigHelper(rtc::scoped_refptr audio_mixer, + bool use_null_audio_processing) + : audio_mixer_(audio_mixer) { + using ::testing::Invoke; + + AudioState::Config config; + config.audio_mixer = audio_mixer_; + config.audio_processing = + use_null_audio_processing + ? nullptr + : rtc::make_ref_counted>(); + config.audio_device_module = + rtc::make_ref_counted>(); + audio_state_ = AudioState::Create(config); + + channel_receive_ = new ::testing::StrictMock(); + EXPECT_CALL(*channel_receive_, SetNACKStatus(true, 15)).Times(1); + EXPECT_CALL(*channel_receive_, + RegisterReceiverCongestionControlObjects(&packet_router_)) + .Times(1); + EXPECT_CALL(*channel_receive_, ResetReceiverCongestionControlObjects()) + .Times(1); + EXPECT_CALL(*channel_receive_, SetAssociatedSendChannel(nullptr)).Times(1); + EXPECT_CALL(*channel_receive_, SetReceiveCodecs(_)) + .WillRepeatedly(Invoke([](const std::map& codecs) { + EXPECT_THAT(codecs, ::testing::IsEmpty()); + })); + EXPECT_CALL(*channel_receive_, SetSourceTracker(_)); + EXPECT_CALL(*channel_receive_, GetLocalSsrc()) + .WillRepeatedly(Return(kLocalSsrc)); + + stream_config_.rtp.local_ssrc = kLocalSsrc; + stream_config_.rtp.remote_ssrc = kRemoteSsrc; + stream_config_.rtp.nack.rtp_history_ms = 300; + stream_config_.rtp.extensions.push_back( + RtpExtension(RtpExtension::kAudioLevelUri, kAudioLevelId)); + stream_config_.rtp.extensions.push_back(RtpExtension( + RtpExtension::kTransportSequenceNumberUri, kTransportSequenceNumberId)); + stream_config_.rtcp_send_transport = &rtcp_send_transport_; + stream_config_.decoder_factory = + rtc::make_ref_counted(); + } + + std::unique_ptr CreateAudioReceiveStream() { + auto ret = std::make_unique( + Clock::GetRealTimeClock(), &packet_router_, stream_config_, + audio_state_, &event_log_, + std::unique_ptr(channel_receive_)); + ret->RegisterWithTransport(&rtp_stream_receiver_controller_); + return ret; + } + + AudioReceiveStreamInterface::Config& config() { return stream_config_; } + rtc::scoped_refptr audio_mixer() { return audio_mixer_; } + MockChannelReceive* channel_receive() { return channel_receive_; } + + void SetupMockForGetStats() { + using ::testing::DoAll; + using ::testing::SetArgPointee; + + ASSERT_TRUE(channel_receive_); + EXPECT_CALL(*channel_receive_, GetRTCPStatistics()) + .WillOnce(Return(kCallStats)); + EXPECT_CALL(*channel_receive_, GetDelayEstimate()) + .WillOnce(Return(kJitterBufferDelay + kPlayoutBufferDelay)); + EXPECT_CALL(*channel_receive_, GetSpeechOutputLevelFullRange()) + .WillOnce(Return(kSpeechOutputLevel)); + EXPECT_CALL(*channel_receive_, GetTotalOutputEnergy()) + .WillOnce(Return(kTotalOutputEnergy)); + EXPECT_CALL(*channel_receive_, GetTotalOutputDuration()) + .WillOnce(Return(kTotalOutputDuration)); + EXPECT_CALL(*channel_receive_, GetNetworkStatistics(_)) + .WillOnce(Return(kNetworkStats)); + EXPECT_CALL(*channel_receive_, GetDecodingCallStatistics()) + .WillOnce(Return(kAudioDecodeStats)); + EXPECT_CALL(*channel_receive_, GetReceiveCodec()) + .WillOnce(Return(kReceiveCodec)); + EXPECT_CALL(*channel_receive_, GetCurrentEstimatedPlayoutNtpTimestampMs(_)) + .WillOnce(Return(kPlayoutNtpTimestampMs)); + } + + private: + PacketRouter packet_router_; + MockRtcEventLog event_log_; + rtc::scoped_refptr audio_state_; + rtc::scoped_refptr audio_mixer_; + AudioReceiveStreamInterface::Config stream_config_; + ::testing::StrictMock* channel_receive_ = nullptr; + RtpStreamReceiverController rtp_stream_receiver_controller_; + MockTransport rtcp_send_transport_; +}; + +const std::vector CreateRtcpSenderReport() { + std::vector packet; + const size_t kRtcpSrLength = 28; // In bytes. + packet.resize(kRtcpSrLength); + packet[0] = 0x80; // Version 2. + packet[1] = 0xc8; // PT = 200, SR. + // Length in number of 32-bit words - 1. + ByteWriter::WriteBigEndian(&packet[2], 6); + ByteWriter::WriteBigEndian(&packet[4], kLocalSsrc); + return packet; +} +} // namespace + +TEST(AudioReceiveStreamTest, ConfigToString) { + AudioReceiveStreamInterface::Config config; + config.rtp.remote_ssrc = kRemoteSsrc; + config.rtp.local_ssrc = kLocalSsrc; + config.rtp.extensions.push_back( + RtpExtension(RtpExtension::kAudioLevelUri, kAudioLevelId)); + EXPECT_EQ( + "{rtp: {remote_ssrc: 1234, local_ssrc: 5678, nack: " + "{rtp_history_ms: 0}, extensions: [{uri: " + "urn:ietf:params:rtp-hdrext:ssrc-audio-level, id: 3}]}, " + "rtcp_send_transport: null}", + config.ToString()); +} + +TEST(AudioReceiveStreamTest, ConstructDestruct) { + for (bool use_null_audio_processing : {false, true}) { + ConfigHelper helper(use_null_audio_processing); + auto recv_stream = helper.CreateAudioReceiveStream(); + recv_stream->UnregisterFromTransport(); + } +} + +TEST(AudioReceiveStreamTest, ReceiveRtcpPacket) { + for (bool use_null_audio_processing : {false, true}) { + ConfigHelper helper(use_null_audio_processing); + auto recv_stream = helper.CreateAudioReceiveStream(); + std::vector rtcp_packet = CreateRtcpSenderReport(); + EXPECT_CALL(*helper.channel_receive(), + ReceivedRTCPPacket(&rtcp_packet[0], rtcp_packet.size())) + .WillOnce(Return()); + recv_stream->DeliverRtcp(&rtcp_packet[0], rtcp_packet.size()); + recv_stream->UnregisterFromTransport(); + } +} + +TEST(AudioReceiveStreamTest, GetStats) { + for (bool use_null_audio_processing : {false, true}) { + ConfigHelper helper(use_null_audio_processing); + auto recv_stream = helper.CreateAudioReceiveStream(); + helper.SetupMockForGetStats(); + AudioReceiveStreamInterface::Stats stats = + recv_stream->GetStats(/*get_and_clear_legacy_stats=*/true); + EXPECT_EQ(kRemoteSsrc, stats.remote_ssrc); + EXPECT_EQ(kCallStats.payload_bytes_rcvd, stats.payload_bytes_rcvd); + EXPECT_EQ(kCallStats.header_and_padding_bytes_rcvd, + stats.header_and_padding_bytes_rcvd); + EXPECT_EQ(static_cast(kCallStats.packetsReceived), + stats.packets_rcvd); + EXPECT_EQ(kCallStats.cumulativeLost, stats.packets_lost); + EXPECT_EQ(kReceiveCodec.second.name, stats.codec_name); + EXPECT_EQ( + kCallStats.jitterSamples / (kReceiveCodec.second.clockrate_hz / 1000), + stats.jitter_ms); + EXPECT_EQ(kNetworkStats.currentBufferSize, stats.jitter_buffer_ms); + EXPECT_EQ(kNetworkStats.preferredBufferSize, + stats.jitter_buffer_preferred_ms); + EXPECT_EQ(static_cast(kJitterBufferDelay + kPlayoutBufferDelay), + stats.delay_estimate_ms); + EXPECT_EQ(static_cast(kSpeechOutputLevel), stats.audio_level); + EXPECT_EQ(kTotalOutputEnergy, stats.total_output_energy); + EXPECT_EQ(kNetworkStats.totalSamplesReceived, stats.total_samples_received); + EXPECT_EQ(kTotalOutputDuration, stats.total_output_duration); + EXPECT_EQ(kNetworkStats.concealedSamples, stats.concealed_samples); + EXPECT_EQ(kNetworkStats.concealmentEvents, stats.concealment_events); + EXPECT_EQ(static_cast(kNetworkStats.jitterBufferDelayMs) / + static_cast(rtc::kNumMillisecsPerSec), + stats.jitter_buffer_delay_seconds); + EXPECT_EQ(kNetworkStats.jitterBufferEmittedCount, + stats.jitter_buffer_emitted_count); + EXPECT_EQ(static_cast(kNetworkStats.jitterBufferTargetDelayMs) / + static_cast(rtc::kNumMillisecsPerSec), + stats.jitter_buffer_target_delay_seconds); + EXPECT_EQ(static_cast(kNetworkStats.jitterBufferMinimumDelayMs) / + static_cast(rtc::kNumMillisecsPerSec), + stats.jitter_buffer_minimum_delay_seconds); + EXPECT_EQ(kNetworkStats.insertedSamplesForDeceleration, + stats.inserted_samples_for_deceleration); + EXPECT_EQ(kNetworkStats.removedSamplesForAcceleration, + stats.removed_samples_for_acceleration); + EXPECT_EQ(kNetworkStats.fecPacketsReceived, stats.fec_packets_received); + EXPECT_EQ(kNetworkStats.fecPacketsDiscarded, stats.fec_packets_discarded); + EXPECT_EQ(kNetworkStats.packetsDiscarded, stats.packets_discarded); + EXPECT_EQ(Q14ToFloat(kNetworkStats.currentExpandRate), stats.expand_rate); + EXPECT_EQ(Q14ToFloat(kNetworkStats.currentSpeechExpandRate), + stats.speech_expand_rate); + EXPECT_EQ(Q14ToFloat(kNetworkStats.currentSecondaryDecodedRate), + stats.secondary_decoded_rate); + EXPECT_EQ(Q14ToFloat(kNetworkStats.currentSecondaryDiscardedRate), + stats.secondary_discarded_rate); + EXPECT_EQ(Q14ToFloat(kNetworkStats.currentAccelerateRate), + stats.accelerate_rate); + EXPECT_EQ(Q14ToFloat(kNetworkStats.currentPreemptiveRate), + stats.preemptive_expand_rate); + EXPECT_EQ(kNetworkStats.packetBufferFlushes, stats.jitter_buffer_flushes); + EXPECT_EQ(kNetworkStats.delayedPacketOutageSamples, + stats.delayed_packet_outage_samples); + EXPECT_EQ(static_cast(kNetworkStats.relativePacketArrivalDelayMs) / + static_cast(rtc::kNumMillisecsPerSec), + stats.relative_packet_arrival_delay_seconds); + EXPECT_EQ(kNetworkStats.interruptionCount, stats.interruption_count); + EXPECT_EQ(kNetworkStats.totalInterruptionDurationMs, + stats.total_interruption_duration_ms); + + EXPECT_EQ(kAudioDecodeStats.calls_to_silence_generator, + stats.decoding_calls_to_silence_generator); + EXPECT_EQ(kAudioDecodeStats.calls_to_neteq, stats.decoding_calls_to_neteq); + EXPECT_EQ(kAudioDecodeStats.decoded_normal, stats.decoding_normal); + EXPECT_EQ(kAudioDecodeStats.decoded_neteq_plc, stats.decoding_plc); + EXPECT_EQ(kAudioDecodeStats.decoded_codec_plc, stats.decoding_codec_plc); + EXPECT_EQ(kAudioDecodeStats.decoded_cng, stats.decoding_cng); + EXPECT_EQ(kAudioDecodeStats.decoded_plc_cng, stats.decoding_plc_cng); + EXPECT_EQ(kAudioDecodeStats.decoded_muted_output, + stats.decoding_muted_output); + EXPECT_EQ(kCallStats.capture_start_ntp_time_ms_, + stats.capture_start_ntp_time_ms); + EXPECT_EQ(kPlayoutNtpTimestampMs, stats.estimated_playout_ntp_timestamp_ms); + recv_stream->UnregisterFromTransport(); + } +} + +TEST(AudioReceiveStreamTest, SetGain) { + for (bool use_null_audio_processing : {false, true}) { + ConfigHelper helper(use_null_audio_processing); + auto recv_stream = helper.CreateAudioReceiveStream(); + EXPECT_CALL(*helper.channel_receive(), + SetChannelOutputVolumeScaling(FloatEq(0.765f))); + recv_stream->SetGain(0.765f); + recv_stream->UnregisterFromTransport(); + } +} + +TEST(AudioReceiveStreamTest, StreamsShouldBeAddedToMixerOnceOnStart) { + for (bool use_null_audio_processing : {false, true}) { + ConfigHelper helper1(use_null_audio_processing); + ConfigHelper helper2(helper1.audio_mixer(), use_null_audio_processing); + auto recv_stream1 = helper1.CreateAudioReceiveStream(); + auto recv_stream2 = helper2.CreateAudioReceiveStream(); + + EXPECT_CALL(*helper1.channel_receive(), StartPlayout()).Times(1); + EXPECT_CALL(*helper2.channel_receive(), StartPlayout()).Times(1); + EXPECT_CALL(*helper1.channel_receive(), StopPlayout()).Times(1); + EXPECT_CALL(*helper2.channel_receive(), StopPlayout()).Times(1); + EXPECT_CALL(*helper1.audio_mixer(), AddSource(recv_stream1.get())) + .WillOnce(Return(true)); + EXPECT_CALL(*helper1.audio_mixer(), AddSource(recv_stream2.get())) + .WillOnce(Return(true)); + EXPECT_CALL(*helper1.audio_mixer(), RemoveSource(recv_stream1.get())) + .Times(1); + EXPECT_CALL(*helper1.audio_mixer(), RemoveSource(recv_stream2.get())) + .Times(1); + + recv_stream1->Start(); + recv_stream2->Start(); + + // One more should not result in any more mixer sources added. + recv_stream1->Start(); + + // Stop stream before it is being destructed. + recv_stream2->Stop(); + + recv_stream1->UnregisterFromTransport(); + recv_stream2->UnregisterFromTransport(); + } +} + +TEST(AudioReceiveStreamTest, ReconfigureWithUpdatedConfig) { + for (bool use_null_audio_processing : {false, true}) { + ConfigHelper helper(use_null_audio_processing); + auto recv_stream = helper.CreateAudioReceiveStream(); + + auto new_config = helper.config(); + + new_config.rtp.extensions.clear(); + new_config.rtp.extensions.push_back( + RtpExtension(RtpExtension::kAudioLevelUri, kAudioLevelId + 1)); + new_config.rtp.extensions.push_back( + RtpExtension(RtpExtension::kTransportSequenceNumberUri, + kTransportSequenceNumberId + 1)); + + MockChannelReceive& channel_receive = *helper.channel_receive(); + + // TODO(tommi, nisse): This applies new extensions to the internal config, + // but there's nothing that actually verifies that the changes take effect. + // In fact Call manages the extensions separately in Call::ReceiveRtpConfig + // and changing this config value (there seem to be a few copies), doesn't + // affect that logic. + recv_stream->ReconfigureForTesting(new_config); + + new_config.decoder_map.emplace(1, SdpAudioFormat("foo", 8000, 1)); + EXPECT_CALL(channel_receive, SetReceiveCodecs(new_config.decoder_map)); + recv_stream->SetDecoderMap(new_config.decoder_map); + + EXPECT_CALL(channel_receive, SetNACKStatus(true, 15 + 1)).Times(1); + recv_stream->SetNackHistory(300 + 20); + + recv_stream->UnregisterFromTransport(); + } +} + +TEST(AudioReceiveStreamTest, ReconfigureWithFrameDecryptor) { + for (bool use_null_audio_processing : {false, true}) { + ConfigHelper helper(use_null_audio_processing); + auto recv_stream = helper.CreateAudioReceiveStream(); + + auto new_config_0 = helper.config(); + rtc::scoped_refptr mock_frame_decryptor_0( + rtc::make_ref_counted()); + new_config_0.frame_decryptor = mock_frame_decryptor_0; + + // TODO(tommi): While this changes the internal config value, it doesn't + // actually change what frame_decryptor is used. WebRtcAudioReceiveStream + // recreates the whole instance in order to change this value. + // So, it's not clear if changing this post initialization needs to be + // supported. + recv_stream->ReconfigureForTesting(new_config_0); + + auto new_config_1 = helper.config(); + rtc::scoped_refptr mock_frame_decryptor_1( + rtc::make_ref_counted()); + new_config_1.frame_decryptor = mock_frame_decryptor_1; + new_config_1.crypto_options.sframe.require_frame_encryption = true; + recv_stream->ReconfigureForTesting(new_config_1); + recv_stream->UnregisterFromTransport(); + } +} + +} // namespace test +} // namespace webrtc -- cgit v1.2.3