From 6bf0a5cb5034a7e684dcc3500e841785237ce2dd Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 19:32:43 +0200 Subject: Adding upstream version 1:115.7.0. Signed-off-by: Daniel Baumann --- third_party/libwebrtc/test/scenario/call_client.h | 204 ++++++++++++++++++++++ 1 file changed, 204 insertions(+) create mode 100644 third_party/libwebrtc/test/scenario/call_client.h (limited to 'third_party/libwebrtc/test/scenario/call_client.h') diff --git a/third_party/libwebrtc/test/scenario/call_client.h b/third_party/libwebrtc/test/scenario/call_client.h new file mode 100644 index 0000000000..5d62fc75e7 --- /dev/null +++ b/third_party/libwebrtc/test/scenario/call_client.h @@ -0,0 +1,204 @@ +/* + * Copyright 2018 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. + */ +#ifndef TEST_SCENARIO_CALL_CLIENT_H_ +#define TEST_SCENARIO_CALL_CLIENT_H_ + +#include +#include +#include +#include +#include + +#include "api/array_view.h" +#include "api/rtc_event_log/rtc_event_log.h" +#include "api/rtp_parameters.h" +#include "api/test/time_controller.h" +#include "api/units/data_rate.h" +#include "call/call.h" +#include "modules/audio_device/include/test_audio_device.h" +#include "modules/congestion_controller/goog_cc/test/goog_cc_printer.h" +#include "modules/rtp_rtcp/include/rtp_header_extension_map.h" +#include "rtc_base/task_queue_for_test.h" +#include "test/logging/log_writer.h" +#include "test/network/network_emulation.h" +#include "test/scenario/column_printer.h" +#include "test/scenario/network_node.h" +#include "test/scenario/scenario_config.h" + +namespace webrtc { + +namespace test { +// Helper class to capture network controller state. +class NetworkControleUpdateCache : public NetworkControllerInterface { + public: + explicit NetworkControleUpdateCache( + std::unique_ptr controller); + + NetworkControlUpdate OnNetworkAvailability(NetworkAvailability msg) override; + NetworkControlUpdate OnNetworkRouteChange(NetworkRouteChange msg) override; + NetworkControlUpdate OnProcessInterval(ProcessInterval msg) override; + NetworkControlUpdate OnRemoteBitrateReport(RemoteBitrateReport msg) override; + NetworkControlUpdate OnRoundTripTimeUpdate(RoundTripTimeUpdate msg) override; + NetworkControlUpdate OnSentPacket(SentPacket msg) override; + NetworkControlUpdate OnReceivedPacket(ReceivedPacket msg) override; + NetworkControlUpdate OnStreamsConfig(StreamsConfig msg) override; + NetworkControlUpdate OnTargetRateConstraints( + TargetRateConstraints msg) override; + NetworkControlUpdate OnTransportLossReport(TransportLossReport msg) override; + NetworkControlUpdate OnTransportPacketsFeedback( + TransportPacketsFeedback msg) override; + NetworkControlUpdate OnNetworkStateEstimate( + NetworkStateEstimate msg) override; + + NetworkControlUpdate update_state() const; + + private: + NetworkControlUpdate Update(NetworkControlUpdate update); + const std::unique_ptr controller_; + NetworkControlUpdate update_state_; +}; + +class LoggingNetworkControllerFactory + : public NetworkControllerFactoryInterface { + public: + LoggingNetworkControllerFactory(LogWriterFactoryInterface* log_writer_factory, + TransportControllerConfig config); + + ~LoggingNetworkControllerFactory(); + + LoggingNetworkControllerFactory(const LoggingNetworkControllerFactory&) = + delete; + LoggingNetworkControllerFactory& operator=( + const LoggingNetworkControllerFactory&) = delete; + + std::unique_ptr Create( + NetworkControllerConfig config) override; + TimeDelta GetProcessInterval() const override; + // TODO(srte): Consider using the Columnprinter interface for this. + void LogCongestionControllerStats(Timestamp at_time); + void SetRemoteBitrateEstimate(RemoteBitrateReport msg); + + NetworkControlUpdate GetUpdate() const; + + private: + GoogCcDebugFactory goog_cc_factory_; + NetworkControllerFactoryInterface* cc_factory_ = nullptr; + bool print_cc_state_ = false; + NetworkControleUpdateCache* last_controller_ = nullptr; +}; + +struct CallClientFakeAudio { + rtc::scoped_refptr apm; + rtc::scoped_refptr fake_audio_device; + rtc::scoped_refptr audio_state; +}; +// CallClient represents a participant in a call scenario. It is created by the +// Scenario class and is used as sender and receiver when setting up a media +// stream session. +class CallClient : public EmulatedNetworkReceiverInterface { + public: + CallClient(TimeController* time_controller, + std::unique_ptr log_writer_factory, + CallClientConfig config); + + ~CallClient(); + + CallClient(const CallClient&) = delete; + CallClient& operator=(const CallClient&) = delete; + + ColumnPrinter StatsPrinter(); + Call::Stats GetStats(); + DataRate send_bandwidth() { + return DataRate::BitsPerSec(GetStats().send_bandwidth_bps); + } + DataRate target_rate() const; + DataRate stable_target_rate() const; + DataRate padding_rate() const; + void UpdateBitrateConstraints(const BitrateConstraints& constraints); + void SetRemoteBitrate(DataRate bitrate); + + void SetAudioReceiveRtpHeaderExtensions( + rtc::ArrayView extensions); + void SetVideoReceiveRtpHeaderExtensions( + rtc::ArrayView extensions); + + void OnPacketReceived(EmulatedIpPacket packet) override; + std::unique_ptr GetLogWriter(std::string name); + + // Exposed publicly so that tests can execute tasks such as querying stats + // for media streams in the expected runtime environment (essentially what + // CallClient does internally for GetStats()). + void SendTask(std::function task); + + private: + friend class Scenario; + friend class CallClientPair; + friend class SendVideoStream; + friend class VideoStreamPair; + friend class ReceiveVideoStream; + friend class SendAudioStream; + friend class ReceiveAudioStream; + friend class AudioStreamPair; + friend class NetworkNodeTransport; + uint32_t GetNextVideoSsrc(); + uint32_t GetNextVideoLocalSsrc(); + uint32_t GetNextAudioSsrc(); + uint32_t GetNextAudioLocalSsrc(); + uint32_t GetNextRtxSsrc(); + int16_t Bind(EmulatedEndpoint* endpoint); + void UnBind(); + + TimeController* const time_controller_; + Clock* clock_; + const std::unique_ptr log_writer_factory_; + std::unique_ptr event_log_; + LoggingNetworkControllerFactory network_controller_factory_; + CallClientFakeAudio fake_audio_setup_; + std::unique_ptr call_; + std::unique_ptr transport_; + std::vector> endpoints_; + RtpHeaderExtensionMap audio_extensions_; + RtpHeaderExtensionMap video_extensions_; + + int next_video_ssrc_index_ = 0; + int next_video_local_ssrc_index_ = 0; + int next_rtx_ssrc_index_ = 0; + int next_audio_ssrc_index_ = 0; + int next_audio_local_ssrc_index_ = 0; + std::map ssrc_media_types_; + // Defined last so it's destroyed first. + TaskQueueForTest task_queue_; + + const FieldTrialBasedConfig field_trials_; +}; + +class CallClientPair { + public: + ~CallClientPair(); + + CallClientPair(const CallClientPair&) = delete; + CallClientPair& operator=(const CallClientPair&) = delete; + + CallClient* first() { return first_; } + CallClient* second() { return second_; } + std::pair forward() { return {first(), second()}; } + std::pair reverse() { return {second(), first()}; } + + private: + friend class Scenario; + CallClientPair(CallClient* first, CallClient* second) + : first_(first), second_(second) {} + CallClient* const first_; + CallClient* const second_; +}; +} // namespace test +} // namespace webrtc + +#endif // TEST_SCENARIO_CALL_CLIENT_H_ -- cgit v1.2.3