summaryrefslogtreecommitdiffstats
path: root/third_party/libwebrtc/test/scenario/call_client.h
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 00:47:55 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 00:47:55 +0000
commit26a029d407be480d791972afb5975cf62c9360a6 (patch)
treef435a8308119effd964b339f76abb83a57c29483 /third_party/libwebrtc/test/scenario/call_client.h
parentInitial commit. (diff)
downloadfirefox-26a029d407be480d791972afb5975cf62c9360a6.tar.xz
firefox-26a029d407be480d791972afb5975cf62c9360a6.zip
Adding upstream version 124.0.1.upstream/124.0.1
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'third_party/libwebrtc/test/scenario/call_client.h')
-rw-r--r--third_party/libwebrtc/test/scenario/call_client.h204
1 files changed, 204 insertions, 0 deletions
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..3717a7e796
--- /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 <map>
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#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/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<NetworkControllerInterface> 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<NetworkControllerInterface> 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<NetworkControllerInterface> 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<AudioProcessing> apm;
+ rtc::scoped_refptr<AudioDeviceModule> fake_audio_device;
+ rtc::scoped_refptr<AudioState> 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<LogWriterFactoryInterface> 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<RtpExtension> extensions);
+ void SetVideoReceiveRtpHeaderExtensions(
+ rtc::ArrayView<RtpExtension> extensions);
+
+ void OnPacketReceived(EmulatedIpPacket packet) override;
+ std::unique_ptr<RtcEventLogOutput> 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<void()> 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<LogWriterFactoryInterface> log_writer_factory_;
+ std::unique_ptr<RtcEventLog> event_log_;
+ LoggingNetworkControllerFactory network_controller_factory_;
+ CallClientFakeAudio fake_audio_setup_;
+ std::unique_ptr<Call> call_;
+ std::unique_ptr<NetworkNodeTransport> transport_;
+ std::vector<std::pair<EmulatedEndpoint*, uint16_t>> 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<uint32_t, MediaType> 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<CallClient*, CallClient*> forward() { return {first(), second()}; }
+ std::pair<CallClient*, CallClient*> 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_