Adding upstream version 115.7.0esr.upstream/115.7.0esr

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 359 insertions, 0 deletions

diff --git a/third_party/libwebrtc/test/call_test.h b/third_party/libwebrtc/test/call_test.h
new file mode 100644
index 0000000000..3324bc4b5e
--- /dev/null
+++ b/third_party/libwebrtc/test/call_test.h
@@ -0,0 +1,359 @@
+/*
+ *  Copyright (c) 2014 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_CALL_TEST_H_
+#define TEST_CALL_TEST_H_
+
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "absl/types/optional.h"
+#include "api/array_view.h"
+#include "api/rtc_event_log/rtc_event_log.h"
+#include "api/task_queue/task_queue_base.h"
+#include "api/task_queue/task_queue_factory.h"
+#include "api/test/simulated_network.h"
+#include "api/test/video/function_video_decoder_factory.h"
+#include "api/test/video/function_video_encoder_factory.h"
+#include "api/units/time_delta.h"
+#include "api/video/video_bitrate_allocator_factory.h"
+#include "call/call.h"
+#include "modules/audio_device/include/test_audio_device.h"
+#include "test/encoder_settings.h"
+#include "test/fake_decoder.h"
+#include "test/fake_videorenderer.h"
+#include "test/fake_vp8_encoder.h"
+#include "test/frame_generator_capturer.h"
+#include "test/rtp_rtcp_observer.h"
+#include "test/run_loop.h"
+#include "test/scoped_key_value_config.h"
+
+namespace webrtc {
+namespace test {
+
+class BaseTest;
+
+class CallTest : public ::testing::Test, public RtpPacketSinkInterface {
+ public:
+  CallTest();
+  virtual ~CallTest();
+
+  static constexpr size_t kNumSsrcs = 6;
+  static const int kNumSimulcastStreams = 3;
+  static const int kDefaultWidth = 320;
+  static const int kDefaultHeight = 180;
+  static const int kDefaultFramerate = 30;
+  static constexpr TimeDelta kDefaultTimeout = TimeDelta::Seconds(30);
+  static constexpr TimeDelta kLongTimeout = TimeDelta::Seconds(120);
+  enum classPayloadTypes : uint8_t {
+    kSendRtxPayloadType = 98,
+    kRtxRedPayloadType = 99,
+    kVideoSendPayloadType = 100,
+    kAudioSendPayloadType = 103,
+    kRedPayloadType = 118,
+    kUlpfecPayloadType = 119,
+    kFlexfecPayloadType = 120,
+    kPayloadTypeH264 = 122,
+    kPayloadTypeVP8 = 123,
+    kPayloadTypeVP9 = 124,
+    kPayloadTypeGeneric = 125,
+    kFakeVideoSendPayloadType = 126,
+  };
+  static const uint32_t kSendRtxSsrcs[kNumSsrcs];
+  static const uint32_t kVideoSendSsrcs[kNumSsrcs];
+  static const uint32_t kAudioSendSsrc;
+  static const uint32_t kFlexfecSendSsrc;
+  static const uint32_t kReceiverLocalVideoSsrc;
+  static const uint32_t kReceiverLocalAudioSsrc;
+  static const int kNackRtpHistoryMs;
+  static const std::map<uint8_t, MediaType> payload_type_map_;
+
+ protected:
+  void RegisterRtpExtension(const RtpExtension& extension);
+  // Returns header extensions that can be parsed by the transport.
+  rtc::ArrayView<const RtpExtension> GetRegisteredExtensions() {
+    return rtp_extensions_;
+  }
+
+  // RunBaseTest overwrites the audio_state of the send and receive Call configs
+  // to simplify test code.
+  void RunBaseTest(BaseTest* test);
+
+  void CreateCalls();
+  void CreateCalls(const Call::Config& sender_config,
+                   const Call::Config& receiver_config);
+  void CreateSenderCall();
+  void CreateSenderCall(const Call::Config& config);
+  void CreateReceiverCall(const Call::Config& config);
+  void DestroyCalls();
+
+  void CreateVideoSendConfig(VideoSendStream::Config* video_config,
+                             size_t num_video_streams,
+                             size_t num_used_ssrcs,
+                             Transport* send_transport);
+  void CreateAudioAndFecSendConfigs(size_t num_audio_streams,
+                                    size_t num_flexfec_streams,
+                                    Transport* send_transport);
+  void SetAudioConfig(const AudioSendStream::Config& config);
+
+  void SetSendFecConfig(std::vector<uint32_t> video_send_ssrcs);
+  void SetSendUlpFecConfig(VideoSendStream::Config* send_config);
+  void SetReceiveUlpFecConfig(
+      VideoReceiveStreamInterface::Config* receive_config);
+
+  void CreateSendConfig(size_t num_video_streams,
+                        size_t num_audio_streams,
+                        size_t num_flexfec_streams) {
+    CreateSendConfig(num_video_streams, num_audio_streams, num_flexfec_streams,
+                     send_transport_.get());
+  }
+  void CreateSendConfig(size_t num_video_streams,
+                        size_t num_audio_streams,
+                        size_t num_flexfec_streams,
+                        Transport* send_transport);
+
+  void CreateMatchingVideoReceiveConfigs(
+      const VideoSendStream::Config& video_send_config) {
+    CreateMatchingVideoReceiveConfigs(video_send_config,
+                                      receive_transport_.get());
+  }
+  void CreateMatchingVideoReceiveConfigs(
+      const VideoSendStream::Config& video_send_config,
+      Transport* rtcp_send_transport);
+  void CreateMatchingVideoReceiveConfigs(
+      const VideoSendStream::Config& video_send_config,
+      Transport* rtcp_send_transport,
+      VideoDecoderFactory* decoder_factory,
+      absl::optional<size_t> decode_sub_stream,
+      bool receiver_reference_time_report,
+      int rtp_history_ms);
+  void AddMatchingVideoReceiveConfigs(
+      std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
+      const VideoSendStream::Config& video_send_config,
+      Transport* rtcp_send_transport,
+      VideoDecoderFactory* decoder_factory,
+      absl::optional<size_t> decode_sub_stream,
+      bool receiver_reference_time_report,
+      int rtp_history_ms);
+
+  void CreateMatchingAudioAndFecConfigs(Transport* rtcp_send_transport);
+  void CreateMatchingAudioConfigs(Transport* transport, std::string sync_group);
+  static AudioReceiveStreamInterface::Config CreateMatchingAudioConfig(
+      const AudioSendStream::Config& send_config,
+      rtc::scoped_refptr<AudioDecoderFactory> audio_decoder_factory,
+      Transport* transport,
+      std::string sync_group);
+  void CreateMatchingFecConfig(
+      Transport* transport,
+      const VideoSendStream::Config& video_send_config);
+  void CreateMatchingReceiveConfigs() {
+    CreateMatchingReceiveConfigs(receive_transport_.get());
+  }
+  void CreateMatchingReceiveConfigs(Transport* rtcp_send_transport);
+
+  void CreateFrameGeneratorCapturerWithDrift(Clock* drift_clock,
+                                             float speed,
+                                             int framerate,
+                                             int width,
+                                             int height);
+  void CreateFrameGeneratorCapturer(int framerate, int width, int height);
+  void CreateFakeAudioDevices(
+      std::unique_ptr<TestAudioDeviceModule::Capturer> capturer,
+      std::unique_ptr<TestAudioDeviceModule::Renderer> renderer);
+
+  void CreateVideoStreams();
+  void CreateVideoSendStreams();
+  void CreateVideoSendStream(const VideoEncoderConfig& encoder_config);
+  void CreateAudioStreams();
+  void CreateFlexfecStreams();
+
+  // Receiver call must be created before calling CreateSendTransport in order
+  // to set a receiver.
+  // Rtp header extensions must be registered (RegisterRtpExtension(..)) before
+  // the transport is created in order for the receiving call object receive RTP
+  // packets with extensions.
+  void CreateSendTransport(const BuiltInNetworkBehaviorConfig& config,
+                           RtpRtcpObserver* observer);
+  void CreateReceiveTransport(const BuiltInNetworkBehaviorConfig& config,
+                              RtpRtcpObserver* observer);
+
+  void ConnectVideoSourcesToStreams();
+
+  void Start();
+  void StartVideoStreams();
+  void Stop();
+  void StopVideoStreams();
+  void DestroyStreams();
+  void DestroyVideoSendStreams();
+  void SetFakeVideoCaptureRotation(VideoRotation rotation);
+
+  void SetVideoDegradation(DegradationPreference preference);
+
+  VideoSendStream::Config* GetVideoSendConfig();
+  void SetVideoSendConfig(const VideoSendStream::Config& config);
+  VideoEncoderConfig* GetVideoEncoderConfig();
+  void SetVideoEncoderConfig(const VideoEncoderConfig& config);
+  VideoSendStream* GetVideoSendStream();
+  FlexfecReceiveStream::Config* GetFlexFecConfig();
+  TaskQueueBase* task_queue() { return task_queue_.get(); }
+
+  // RtpPacketSinkInterface implementation.
+  void OnRtpPacket(const RtpPacketReceived& packet) override;
+
+  test::RunLoop loop_;
+
+  Clock* const clock_;
+  test::ScopedKeyValueConfig field_trials_;
+
+  std::unique_ptr<TaskQueueFactory> task_queue_factory_;
+  std::unique_ptr<webrtc::RtcEventLog> send_event_log_;
+  std::unique_ptr<webrtc::RtcEventLog> recv_event_log_;
+  std::unique_ptr<Call> sender_call_;
+  std::unique_ptr<PacketTransport> send_transport_;
+  SimulatedNetworkInterface* send_simulated_network_ = nullptr;
+  std::vector<VideoSendStream::Config> video_send_configs_;
+  std::vector<VideoEncoderConfig> video_encoder_configs_;
+  std::vector<VideoSendStream*> video_send_streams_;
+  AudioSendStream::Config audio_send_config_;
+  AudioSendStream* audio_send_stream_;
+
+  std::unique_ptr<Call> receiver_call_;
+  std::unique_ptr<PacketTransport> receive_transport_;
+  SimulatedNetworkInterface* receive_simulated_network_ = nullptr;
+  std::vector<VideoReceiveStreamInterface::Config> video_receive_configs_;
+  std::vector<VideoReceiveStreamInterface*> video_receive_streams_;
+  std::vector<AudioReceiveStreamInterface::Config> audio_receive_configs_;
+  std::vector<AudioReceiveStreamInterface*> audio_receive_streams_;
+  std::vector<FlexfecReceiveStream::Config> flexfec_receive_configs_;
+  std::vector<FlexfecReceiveStream*> flexfec_receive_streams_;
+
+  test::FrameGeneratorCapturer* frame_generator_capturer_;
+  std::vector<std::unique_ptr<rtc::VideoSourceInterface<VideoFrame>>>
+      video_sources_;
+  DegradationPreference degradation_preference_ =
+      DegradationPreference::MAINTAIN_FRAMERATE;
+
+  std::unique_ptr<FecControllerFactoryInterface> fec_controller_factory_;
+  std::unique_ptr<NetworkStatePredictorFactoryInterface>
+      network_state_predictor_factory_;
+  std::unique_ptr<NetworkControllerFactoryInterface>
+      network_controller_factory_;
+
+  test::FunctionVideoEncoderFactory fake_encoder_factory_;
+  int fake_encoder_max_bitrate_ = -1;
+  test::FunctionVideoDecoderFactory fake_decoder_factory_;
+  std::unique_ptr<VideoBitrateAllocatorFactory> bitrate_allocator_factory_;
+  // Number of simulcast substreams.
+  size_t num_video_streams_;
+  size_t num_audio_streams_;
+  size_t num_flexfec_streams_;
+  rtc::scoped_refptr<AudioDecoderFactory> audio_decoder_factory_;
+  rtc::scoped_refptr<AudioEncoderFactory> audio_encoder_factory_;
+  test::FakeVideoRenderer fake_renderer_;
+
+
+ private:
+  absl::optional<RtpExtension> GetRtpExtensionByUri(
+      const std::string& uri) const;
+
+  void AddRtpExtensionByUri(const std::string& uri,
+                            std::vector<RtpExtension>* extensions) const;
+
+  std::unique_ptr<TaskQueueBase, TaskQueueDeleter> task_queue_;
+  std::vector<RtpExtension> rtp_extensions_;
+  rtc::scoped_refptr<AudioProcessing> apm_send_;
+  rtc::scoped_refptr<AudioProcessing> apm_recv_;
+  rtc::scoped_refptr<TestAudioDeviceModule> fake_send_audio_device_;
+  rtc::scoped_refptr<TestAudioDeviceModule> fake_recv_audio_device_;
+};
+
+class BaseTest : public RtpRtcpObserver {
+ public:
+  BaseTest();
+  explicit BaseTest(TimeDelta timeout);
+  virtual ~BaseTest();
+
+  virtual void PerformTest() = 0;
+  virtual bool ShouldCreateReceivers() const = 0;
+
+  virtual size_t GetNumVideoStreams() const;
+  virtual size_t GetNumAudioStreams() const;
+  virtual size_t GetNumFlexfecStreams() const;
+
+  virtual std::unique_ptr<TestAudioDeviceModule::Capturer> CreateCapturer();
+  virtual std::unique_ptr<TestAudioDeviceModule::Renderer> CreateRenderer();
+  virtual void OnFakeAudioDevicesCreated(
+      TestAudioDeviceModule* send_audio_device,
+      TestAudioDeviceModule* recv_audio_device);
+
+  virtual void ModifySenderBitrateConfig(BitrateConstraints* bitrate_config);
+  virtual void ModifyReceiverBitrateConfig(BitrateConstraints* bitrate_config);
+
+  virtual void OnCallsCreated(Call* sender_call, Call* receiver_call);
+  virtual void OnTransportCreated(PacketTransport* to_receiver,
+                                  SimulatedNetworkInterface* sender_network,
+                                  PacketTransport* to_sender,
+                                  SimulatedNetworkInterface* receiver_network);
+
+  virtual BuiltInNetworkBehaviorConfig GetSendTransportConfig() const;
+  virtual BuiltInNetworkBehaviorConfig GetReceiveTransportConfig() const;
+
+  virtual void ModifyVideoConfigs(
+      VideoSendStream::Config* send_config,
+      std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
+      VideoEncoderConfig* encoder_config);
+  virtual void ModifyVideoCaptureStartResolution(int* width,
+                                                 int* heigt,
+                                                 int* frame_rate);
+  virtual void ModifyVideoDegradationPreference(
+      DegradationPreference* degradation_preference);
+
+  virtual void OnVideoStreamsCreated(
+      VideoSendStream* send_stream,
+      const std::vector<VideoReceiveStreamInterface*>& receive_streams);
+
+  virtual void ModifyAudioConfigs(
+      AudioSendStream::Config* send_config,
+      std::vector<AudioReceiveStreamInterface::Config>* receive_configs);
+  virtual void OnAudioStreamsCreated(
+      AudioSendStream* send_stream,
+      const std::vector<AudioReceiveStreamInterface*>& receive_streams);
+
+  virtual void ModifyFlexfecConfigs(
+      std::vector<FlexfecReceiveStream::Config>* receive_configs);
+  virtual void OnFlexfecStreamsCreated(
+      const std::vector<FlexfecReceiveStream*>& receive_streams);
+
+  virtual void OnFrameGeneratorCapturerCreated(
+      FrameGeneratorCapturer* frame_generator_capturer);
+
+  virtual void OnStreamsStopped();
+};
+
+class SendTest : public BaseTest {
+ public:
+  explicit SendTest(TimeDelta timeout);
+
+  bool ShouldCreateReceivers() const override;
+};
+
+class EndToEndTest : public BaseTest {
+ public:
+  EndToEndTest();
+  explicit EndToEndTest(TimeDelta timeout);
+
+  bool ShouldCreateReceivers() const override;
+};
+
+}  // namespace test
+}  // namespace webrtc
+
+#endif  // TEST_CALL_TEST_H_