Adding upstream version 124.0.1.upstream/124.0.1

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

1 files changed, 231 insertions, 0 deletions

diff --git a/third_party/libwebrtc/test/scenario/scenario_config.h b/third_party/libwebrtc/test/scenario/scenario_config.h
new file mode 100644
index 0000000000..9ce99401d7
--- /dev/null
+++ b/third_party/libwebrtc/test/scenario/scenario_config.h
@@ -0,0 +1,231 @@
+/*
+ *  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_SCENARIO_CONFIG_H_
+#define TEST_SCENARIO_SCENARIO_CONFIG_H_
+
+#include <stddef.h>
+
+#include <string>
+
+#include "absl/types/optional.h"
+#include "api/fec_controller.h"
+#include "api/rtp_parameters.h"
+#include "api/test/frame_generator_interface.h"
+#include "api/transport/network_control.h"
+#include "api/units/data_rate.h"
+#include "api/units/data_size.h"
+#include "api/units/time_delta.h"
+#include "api/video/video_codec_type.h"
+#include "api/video_codecs/scalability_mode.h"
+#include "test/scenario/performance_stats.h"
+
+namespace webrtc {
+namespace test {
+struct PacketOverhead {
+  static constexpr size_t kSrtp = 10;
+  static constexpr size_t kStun = 4;
+  // TURN messages can be sent either with or without an establieshed channel.
+  // In the latter case, a TURN Send/Data Indication is sent which has
+  // significantly more overhead.
+  static constexpr size_t kTurnChannelMessage = 4;
+  static constexpr size_t kTurnIndicationMessage = 36;
+  static constexpr size_t kDefault = kSrtp;
+};
+struct TransportControllerConfig {
+  struct Rates {
+    Rates();
+    Rates(const Rates&);
+    ~Rates();
+    DataRate min_rate = DataRate::KilobitsPerSec(30);
+    DataRate max_rate = DataRate::KilobitsPerSec(3000);
+    DataRate start_rate = DataRate::KilobitsPerSec(300);
+  } rates;
+  NetworkControllerFactoryInterface* cc_factory = nullptr;
+  TimeDelta state_log_interval = TimeDelta::Millis(100);
+};
+
+struct CallClientConfig {
+  TransportControllerConfig transport;
+  // Allows the pacer to send out multiple packets in a burst.
+  // The number of bites that can be sent in one burst is pacer_burst_interval *
+  // current bwe. 40ms is the default Chrome setting.
+  TimeDelta pacer_burst_interval = TimeDelta::Millis(40);
+  const FieldTrialsView* field_trials = nullptr;
+};
+
+struct PacketStreamConfig {
+  PacketStreamConfig();
+  PacketStreamConfig(const PacketStreamConfig&);
+  ~PacketStreamConfig();
+  int frame_rate = 30;
+  DataRate max_data_rate = DataRate::Infinity();
+  DataSize max_packet_size = DataSize::Bytes(1400);
+  DataSize min_frame_size = DataSize::Bytes(100);
+  double keyframe_multiplier = 1;
+  DataSize packet_overhead = DataSize::Bytes(PacketOverhead::kDefault);
+};
+
+struct VideoStreamConfig {
+  bool autostart = true;
+  struct Source {
+    enum Capture {
+      kGenerator,
+      kVideoFile,
+      kGenerateSlides,
+      kImageSlides,
+      // Support for explicit frame triggers should be added here if needed.
+    } capture = Capture::kGenerator;
+    struct Slides {
+      TimeDelta change_interval = TimeDelta::Seconds(10);
+      struct Generator {
+        int width = 1600;
+        int height = 1200;
+      } generator;
+      struct Images {
+        struct Crop {
+          TimeDelta scroll_duration = TimeDelta::Seconds(0);
+          absl::optional<int> width;
+          absl::optional<int> height;
+        } crop;
+        int width = 1850;
+        int height = 1110;
+        std::vector<std::string> paths = {
+            "web_screenshot_1850_1110",
+            "presentation_1850_1110",
+            "photo_1850_1110",
+            "difficult_photo_1850_1110",
+        };
+      } images;
+    } slides;
+    struct Generator {
+      using PixelFormat = FrameGeneratorInterface::OutputType;
+      PixelFormat pixel_format = PixelFormat::kI420;
+      int width = 320;
+      int height = 180;
+    } generator;
+    struct VideoFile {
+      std::string name;
+      // Must be set to width and height of the source video file.
+      int width = 0;
+      int height = 0;
+    } video_file;
+    int framerate = 30;
+  } source;
+  struct Encoder {
+    Encoder();
+    Encoder(const Encoder&);
+    ~Encoder();
+    enum class ContentType {
+      kVideo,
+      kScreen,
+    } content_type = ContentType::kVideo;
+    enum Implementation { kFake, kSoftware, kHardware } implementation = kFake;
+    struct Fake {
+      DataRate max_rate = DataRate::Infinity();
+    } fake;
+
+    using Codec = VideoCodecType;
+    Codec codec = Codec::kVideoCodecGeneric;
+    absl::optional<DataRate> max_data_rate;
+    absl::optional<DataRate> min_data_rate;
+    absl::optional<int> max_framerate;
+    // Counted in frame count.
+    absl::optional<int> key_frame_interval = 3000;
+    bool frame_dropping = true;
+    struct SingleLayer {
+      bool denoising = true;
+      bool automatic_scaling = true;
+    } single;
+    std::vector<webrtc::ScalabilityMode> simulcast_streams = {
+        webrtc::ScalabilityMode::kL1T1};
+
+    DegradationPreference degradation_preference =
+        DegradationPreference::MAINTAIN_FRAMERATE;
+    bool suspend_below_min_bitrate = false;
+  } encoder;
+  struct Stream {
+    Stream();
+    Stream(const Stream&);
+    ~Stream();
+    bool abs_send_time = false;
+    bool packet_feedback = true;
+    bool use_rtx = true;
+    DataRate pad_to_rate = DataRate::Zero();
+    TimeDelta nack_history_time = TimeDelta::Millis(1000);
+    bool use_flexfec = false;
+    bool use_ulpfec = false;
+    FecControllerFactoryInterface* fec_controller_factory = nullptr;
+  } stream;
+  struct Rendering {
+    enum Type { kFake } type = kFake;
+    std::string sync_group;
+  } render;
+  struct Hooks {
+    std::vector<std::function<void(const VideoFramePair&)>> frame_pair_handlers;
+  } hooks;
+};
+
+struct AudioStreamConfig {
+  AudioStreamConfig();
+  AudioStreamConfig(const AudioStreamConfig&);
+  ~AudioStreamConfig();
+  bool autostart = true;
+  struct Source {
+    int channels = 1;
+  } source;
+  bool network_adaptation = false;
+  struct NetworkAdaptation {
+    struct FrameLength {
+      double min_packet_loss_for_decrease = 0;
+      double max_packet_loss_for_increase = 1;
+      DataRate min_rate_for_20_ms = DataRate::Zero();
+      DataRate max_rate_for_60_ms = DataRate::Infinity();
+      DataRate min_rate_for_60_ms = DataRate::Zero();
+      DataRate max_rate_for_120_ms = DataRate::Infinity();
+    } frame;
+    std::string binary_proto;
+  } adapt;
+  struct Encoder {
+    Encoder();
+    Encoder(const Encoder&);
+    ~Encoder();
+    bool allocate_bitrate = false;
+    bool enable_dtx = false;
+    DataRate fixed_rate = DataRate::KilobitsPerSec(32);
+    // Overrides fixed rate.
+    absl::optional<DataRate> min_rate;
+    absl::optional<DataRate> max_rate;
+    TimeDelta initial_frame_length = TimeDelta::Millis(20);
+  } encoder;
+  struct Stream {
+    Stream();
+    Stream(const Stream&);
+    ~Stream();
+    bool abs_send_time = true;
+    bool in_bandwidth_estimation = true;
+  } stream;
+  struct Rendering {
+    std::string sync_group;
+  } render;
+};
+
+// TODO(srte): Merge this with BuiltInNetworkBehaviorConfig.
+struct NetworkSimulationConfig {
+  DataRate bandwidth = DataRate::Infinity();
+  TimeDelta delay = TimeDelta::Zero();
+  TimeDelta delay_std_dev = TimeDelta::Zero();
+  double loss_rate = 0;
+  absl::optional<int> packet_queue_length_limit;
+  DataSize packet_overhead = DataSize::Zero();
+};
+}  // namespace test
+}  // namespace webrtc
+
+#endif  // TEST_SCENARIO_SCENARIO_CONFIG_H_