Repo created

TMessagesProj/jni/voip/webrtc/api/test/pclf/peer_configurer.h

@@ -0,0 +1,210 @@
+/*
+ *  Copyright (c) 2022 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 API_TEST_PCLF_PEER_CONFIGURER_H_
+#define API_TEST_PCLF_PEER_CONFIGURER_H_
+
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "absl/strings/string_view.h"
+#include "absl/types/variant.h"
+#include "api/async_dns_resolver.h"
+#include "api/audio/audio_mixer.h"
+#include "api/audio_codecs/audio_decoder_factory.h"
+#include "api/audio_codecs/audio_encoder_factory.h"
+#include "api/fec_controller.h"
+#include "api/field_trials_view.h"
+#include "api/ice_transport_interface.h"
+#include "api/neteq/neteq_factory.h"
+#include "api/peer_connection_interface.h"
+#include "api/rtc_event_log/rtc_event_log_factory_interface.h"
+#include "api/scoped_refptr.h"
+#include "api/test/frame_generator_interface.h"
+#include "api/test/pclf/media_configuration.h"
+#include "api/test/pclf/media_quality_test_params.h"
+#include "api/test/peer_network_dependencies.h"
+#include "api/transport/bitrate_settings.h"
+#include "api/transport/network_control.h"
+#include "api/video_codecs/video_decoder_factory.h"
+#include "api/video_codecs/video_encoder_factory.h"
+#include "modules/audio_processing/include/audio_processing.h"
+#include "rtc_base/rtc_certificate_generator.h"
+#include "rtc_base/ssl_certificate.h"
+
+namespace webrtc {
+namespace webrtc_pc_e2e {
+
+// This class is used to fully configure one peer inside a call.
+class PeerConfigurer {
+ public:
+  using VideoSource =
+      absl::variant<std::unique_ptr<test::FrameGeneratorInterface>,
+                    CapturingDeviceIndex>;
+
+  explicit PeerConfigurer(const PeerNetworkDependencies& network_dependencies);
+
+  // Sets peer name that will be used to report metrics related to this peer.
+  // If not set, some default name will be assigned. All names have to be
+  // unique.
+  PeerConfigurer* SetName(absl::string_view name);
+
+  // The parameters of the following 7 methods will be passed to the
+  // PeerConnectionFactoryInterface implementation that will be created for
+  // this peer.
+  PeerConfigurer* SetEventLogFactory(
+      std::unique_ptr<RtcEventLogFactoryInterface> event_log_factory);
+  PeerConfigurer* SetFecControllerFactory(
+      std::unique_ptr<FecControllerFactoryInterface> fec_controller_factory);
+  PeerConfigurer* SetNetworkControllerFactory(
+      std::unique_ptr<NetworkControllerFactoryInterface>
+          network_controller_factory);
+  PeerConfigurer* SetVideoEncoderFactory(
+      std::unique_ptr<VideoEncoderFactory> video_encoder_factory);
+  PeerConfigurer* SetVideoDecoderFactory(
+      std::unique_ptr<VideoDecoderFactory> video_decoder_factory);
+  PeerConfigurer* SetAudioEncoderFactory(
+      rtc::scoped_refptr<webrtc::AudioEncoderFactory> audio_encoder_factory);
+  PeerConfigurer* SetAudioDecoderFactory(
+      rtc::scoped_refptr<webrtc::AudioDecoderFactory> audio_decoder_factory);
+  // Set a custom NetEqFactory to be used in the call.
+  PeerConfigurer* SetNetEqFactory(std::unique_ptr<NetEqFactory> neteq_factory);
+  PeerConfigurer* SetAudioProcessing(
+      rtc::scoped_refptr<webrtc::AudioProcessing> audio_processing);
+  PeerConfigurer* SetAudioMixer(
+      rtc::scoped_refptr<webrtc::AudioMixer> audio_mixer);
+
+  // Forces the Peerconnection to use the network thread as the worker thread.
+  // Ie, worker thread and the network thread is the same thread.
+  PeerConfigurer* SetUseNetworkThreadAsWorkerThread();
+
+  // The parameters of the following 4 methods will be passed to the
+  // PeerConnectionInterface implementation that will be created for this
+  // peer.
+  PeerConfigurer* SetAsyncDnsResolverFactory(
+      std::unique_ptr<webrtc::AsyncDnsResolverFactoryInterface>
+          async_dns_resolver_factory);
+  PeerConfigurer* SetRTCCertificateGenerator(
+      std::unique_ptr<rtc::RTCCertificateGeneratorInterface> cert_generator);
+  PeerConfigurer* SetSSLCertificateVerifier(
+      std::unique_ptr<rtc::SSLCertificateVerifier> tls_cert_verifier);
+  PeerConfigurer* SetIceTransportFactory(
+      std::unique_ptr<IceTransportFactory> factory);
+  // Flags to set on `cricket::PortAllocator`. These flags will be added
+  // to the default ones that are presented on the port allocator.
+  // For possible values check p2p/base/port_allocator.h.
+  PeerConfigurer* SetPortAllocatorExtraFlags(uint32_t extra_flags);
+
+  // Add new video stream to the call that will be sent from this peer.
+  // Default implementation of video frames generator will be used.
+  PeerConfigurer* AddVideoConfig(VideoConfig config);
+  // Add new video stream to the call that will be sent from this peer with
+  // provided own implementation of video frames generator.
+  PeerConfigurer* AddVideoConfig(
+      VideoConfig config,
+      std::unique_ptr<test::FrameGeneratorInterface> generator);
+  // Add new video stream to the call that will be sent from this peer.
+  // Capturing device with specified index will be used to get input video.
+  PeerConfigurer* AddVideoConfig(VideoConfig config,
+                                 CapturingDeviceIndex capturing_device_index);
+  // Sets video subscription for the peer. By default subscription will
+  // include all streams with `VideoSubscription::kSameAsSendStream`
+  // resolution. To this behavior use this method.
+  PeerConfigurer* SetVideoSubscription(VideoSubscription subscription);
+  // Sets the list of video codecs used by the peer during the test. These
+  // codecs will be negotiated in SDP during offer/answer exchange. The order
+  // of these codecs during negotiation will be the same as in `video_codecs`.
+  // Codecs have to be available in codecs list provided by peer connection to
+  // be negotiated. If some of specified codecs won't be found, the test will
+  // crash.
+  PeerConfigurer* SetVideoCodecs(std::vector<VideoCodecConfig> video_codecs);
+  // Sets a list of RTP header extensions which will be enforced on all video
+  // streams added to this peer.
+  PeerConfigurer* SetExtraVideoRtpHeaderExtensions(
+      std::vector<std::string> extensions);
+  // Sets the audio stream for the call from this peer. If this method won't
+  // be invoked, this peer will send no audio.
+  PeerConfigurer* SetAudioConfig(AudioConfig config);
+  // Sets a list of RTP header extensions which will be enforced on all audio
+  // streams added to this peer.
+  PeerConfigurer* SetExtraAudioRtpHeaderExtensions(
+      std::vector<std::string> extensions);
+
+  // Set if ULP FEC should be used or not. False by default.
+  PeerConfigurer* SetUseUlpFEC(bool value);
+  // Set if Flex FEC should be used or not. False by default.
+  // Client also must enable `enable_flex_fec_support` in the `RunParams` to
+  // be able to use this feature.
+  PeerConfigurer* SetUseFlexFEC(bool value);
+  // Specifies how much video encoder target bitrate should be different than
+  // target bitrate, provided by WebRTC stack. Must be greater than 0. Can be
+  // used to emulate overshooting of video encoders. This multiplier will
+  // be applied for all video encoder on both sides for all layers. Bitrate
+  // estimated by WebRTC stack will be multiplied by this multiplier and then
+  // provided into VideoEncoder::SetRates(...). 1.0 by default.
+  PeerConfigurer* SetVideoEncoderBitrateMultiplier(double multiplier);
+
+  // If is set, an RTCEventLog will be saved in that location and it will be
+  // available for further analysis.
+  PeerConfigurer* SetRtcEventLogPath(absl::string_view path);
+  // If is set, an AEC dump will be saved in that location and it will be
+  // available for further analysis.
+  PeerConfigurer* SetAecDumpPath(absl::string_view path);
+  PeerConfigurer* SetPCFOptions(
+      PeerConnectionFactoryInterface::Options options);
+  PeerConfigurer* SetRTCConfiguration(
+      PeerConnectionInterface::RTCConfiguration configuration);
+  PeerConfigurer* SetRTCOfferAnswerOptions(
+      PeerConnectionInterface::RTCOfferAnswerOptions options);
+  // Set bitrate parameters on PeerConnection. This constraints will be
+  // applied to all summed RTP streams for this peer.
+  PeerConfigurer* SetBitrateSettings(BitrateSettings bitrate_settings);
+  // Set field trials used for this PeerConnection.
+  PeerConfigurer* SetFieldTrials(std::unique_ptr<FieldTrialsView> field_trials);
+
+  // Returns InjectableComponents and transfer ownership to the caller.
+  // Can be called once.
+  std::unique_ptr<InjectableComponents> ReleaseComponents();
+
+  // Returns Params and transfer ownership to the caller.
+  // Can be called once.
+  std::unique_ptr<Params> ReleaseParams();
+
+  // Returns ConfigurableParams and transfer ownership to the caller.
+  // Can be called once.
+  std::unique_ptr<ConfigurableParams> ReleaseConfigurableParams();
+
+  // Returns video sources and transfer frame generators ownership to the
+  // caller. Can be called once.
+  std::vector<VideoSource> ReleaseVideoSources();
+
+  InjectableComponents* components() { return components_.get(); }
+  Params* params() { return params_.get(); }
+  ConfigurableParams* configurable_params() {
+    return configurable_params_.get();
+  }
+  const Params& params() const { return *params_; }
+  const ConfigurableParams& configurable_params() const {
+    return *configurable_params_;
+  }
+  std::vector<VideoSource>* video_sources() { return &video_sources_; }
+
+ private:
+  std::unique_ptr<InjectableComponents> components_;
+  std::unique_ptr<Params> params_;
+  std::unique_ptr<ConfigurableParams> configurable_params_;
+  std::vector<VideoSource> video_sources_;
+};
+
+}  // namespace webrtc_pc_e2e
+}  // namespace webrtc
+
+#endif  // API_TEST_PCLF_PEER_CONFIGURER_H_