test/pc/e2e/api/peerconnection_quality_test_fixture.h - src - Git at Google

 /*
  *  Copyright (c) 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_PC_E2E_API_PEERCONNECTION_QUALITY_TEST_FIXTURE_H_
 #define TEST_PC_E2E_API_PEERCONNECTION_QUALITY_TEST_FIXTURE_H_

 #include <memory>
 #include <string>
 #include <vector>

 #include "absl/memory/memory.h"
 #include "api/async_resolver_factory.h"
 #include "api/call/call_factory_interface.h"
 #include "api/fec_controller.h"
 #include "api/media_transport_interface.h"
 #include "api/peer_connection_interface.h"
 #include "api/test/simulated_network.h"
 #include "api/transport/network_control.h"
 #include "api/units/time_delta.h"
 #include "api/video_codecs/video_decoder_factory.h"
 #include "api/video_codecs/video_encoder.h"
 #include "api/video_codecs/video_encoder_factory.h"
 #include "logging/rtc_event_log/rtc_event_log_factory_interface.h"
 #include "rtc_base/network.h"
 #include "rtc_base/rtc_certificate_generator.h"
 #include "rtc_base/ssl_certificate.h"
 #include "rtc_base/thread.h"
 #include "test/pc/e2e/api/audio_quality_analyzer_interface.h"
 #include "test/pc/e2e/api/video_quality_analyzer_interface.h"

 namespace webrtc {
 namespace webrtc_pc_e2e {

 // TODO(titovartem) move to API when it will be stabilized.
 class PeerConnectionE2EQualityTestFixture {
  public:
   // Contains most part from PeerConnectionFactoryDependencies. Also all fields
   // are optional and defaults will be provided by fixture implementation if
   // any will be omitted.
   //
   // Separate class was introduced to clarify which components can be
   // overridden. For example worker and signaling threads will be provided by
   // fixture implementation. The same is applicable to the media engine. So user
   // can override only some parts of media engine like video encoder/decoder
   // factories.
   struct PeerConnectionFactoryComponents {
     std::unique_ptr<CallFactoryInterface> call_factory;
     std::unique_ptr<RtcEventLogFactoryInterface> event_log_factory;
     std::unique_ptr<FecControllerFactoryInterface> fec_controller_factory;
     std::unique_ptr<NetworkControllerFactoryInterface>
         network_controller_factory;
     std::unique_ptr<MediaTransportFactory> media_transport_factory;

     // Will be passed to MediaEngineInterface, that will be used in
     // PeerConnectionFactory.
     std::unique_ptr<VideoEncoderFactory> video_encoder_factory;
     std::unique_ptr<VideoDecoderFactory> video_decoder_factory;
   };

   // Contains most parts from PeerConnectionDependencies. Also all fields are
   // optional and defaults will be provided by fixture implementation if any
   // will be omitted.
   //
   // Separate class was introduced to clarify which components can be
   // overridden. For example observer, which is required to
   // PeerConnectionDependencies, will be provided by fixture implementation,
   // so client can't inject its own. Also only network manager can be overridden
   // inside port allocator.
   struct PeerConnectionComponents {
     PeerConnectionComponents(rtc::NetworkManager* network_manager)
         : network_manager(network_manager) {
       RTC_CHECK(network_manager);
     }

     rtc::NetworkManager* const network_manager;
     std::unique_ptr<webrtc::AsyncResolverFactory> async_resolver_factory;
     std::unique_ptr<rtc::RTCCertificateGeneratorInterface> cert_generator;
     std::unique_ptr<rtc::SSLCertificateVerifier> tls_cert_verifier;
   };

   // Contains all components, that can be overridden in peer connection. Also
   // has a network thread, that will be used to communicate with another peers.
   struct InjectableComponents {
     explicit InjectableComponents(rtc::Thread* network_thread,
                                   rtc::NetworkManager* network_manager)
         : network_thread(network_thread),
           pcf_dependencies(
               absl::make_unique<PeerConnectionFactoryComponents>()),
           pc_dependencies(
               absl::make_unique<PeerConnectionComponents>(network_manager)) {
       RTC_CHECK(network_thread);
     }

     rtc::Thread* const network_thread;

     std::unique_ptr<PeerConnectionFactoryComponents> pcf_dependencies;
     std::unique_ptr<PeerConnectionComponents> pc_dependencies;
   };

   // Contains screen share video stream properties.
   struct ScreenShareConfig {
     // If true, slides will be generated programmatically.
     bool generate_slides;
     // Shows how long one slide should be presented on the screen during
     // slide generation.
     TimeDelta slide_change_interval;
     // If equal to 0, no scrolling will be applied.
     TimeDelta scroll_duration;
     // If empty, default set of slides will be used.
     std::vector<std::string> slides_yuv_file_names;
   };

   enum VideoGeneratorType { kDefault, kI420A, kI010 };

   // Contains properties of single video stream.
   struct VideoConfig {
     VideoConfig(size_t width, size_t height, int32_t fps)
         : width(width), height(height), fps(fps) {}

     const size_t width;
     const size_t height;
     const int32_t fps;
     // Have to be unique among all specified configs for all peers in the call.
     // Will be auto generated if omitted.
     absl::optional<std::string> stream_label;
     // Only 1 from |generator|, |input_file_name| and |screen_share_config| can
     // be specified. If none of them are specified, then |generator| will be set
     // to VideoGeneratorType::kDefault.
     // If specified generator of this type will be used to produce input video.
     absl::optional<VideoGeneratorType> generator;
     // If specified this file will be used as input. Input video will be played
     // in a circle.
     absl::optional<std::string> input_file_name;
     // If specified screen share video stream will be created as input.
     absl::optional<ScreenShareConfig> screen_share_config;
     // Specifies spatial index of the video stream to analyze.
     // There are 3 cases:
     // 1. |target_spatial_index| omitted: in such case it will be assumed that
     //    video stream has not spatial layers and simulcast streams.
     // 2. |target_spatial_index| presented and simulcast encoder is used:
     //    in such case |target_spatial_index| will specify the index of
     //    simulcast stream, that should be analyzed. Other streams will be
     //    dropped.
     // 3. |target_spatial_index| presented and SVP encoder is used:
     //    in such case |target_spatial_index| will specify the top interesting
     //    spatial layer and all layers bellow, including target one will be
     //    processed. All layers above target one will be dropped.
     absl::optional<int> target_spatial_index;
     // If specified the input stream will be also copied to specified file.
     // It is actually one of the test's output file, which contains copy of what
     // was captured during the test for this video stream on sender side.
     // It is useful when generator is used as input.
     absl::optional<std::string> input_dump_file_name;
     // If specified this file will be used as output on the receiver side for
     // this stream. If multiple streams will be produced by input stream,
     // output files will be appended with indexes. The produced files contains
     // what was rendered for this video stream on receiver side.
     absl::optional<std::string> output_dump_file_name;
   };

   // Contains properties for audio in the call.
   struct AudioConfig {
     enum Mode {
       kGenerated,
       kFile,
     };
     // Have to be unique among all specified configs for all peers in the call.
     // Will be auto generated if omitted.
     absl::optional<std::string> stream_label;
     Mode mode = kGenerated;
     // Have to be specified only if mode = kFile
     absl::optional<std::string> input_file_name;
     // If specified the input stream will be also copied to specified file.
     absl::optional<std::string> input_dump_file_name;
     // If specified the output stream will be copied to specified file.
     absl::optional<std::string> output_dump_file_name;
     // Audio options to use.
     cricket::AudioOptions audio_options;
   };

   // Contains information about call media streams (up to 1 audio stream and
   // unlimited amount of video streams) and rtc configuration, that will be used
   // to set up peer connection.
   struct Params {
     // If |video_configs| is empty - no video should be added to the test call.
     std::vector<VideoConfig> video_configs;
     // If |audio_config| is set audio stream will be configured
     absl::optional<AudioConfig> audio_config;
     // If |rtc_event_log_path| is set, an RTCEventLog will be saved in that
     // location and it will be available for further analysis.
     absl::optional<std::string> rtc_event_log_path;

     PeerConnectionInterface::RTCConfiguration rtc_configuration;
   };

   // Contains parameters, that describe how long framework should run quality
   // test.
   struct RunParams {
     // Specifies how long the test should be run. This time shows how long
     // the media should flow after connection was established and before
     // it will be shut downed.
     TimeDelta run_duration;
   };

   // Add activity that will be executed on the best effort at least after
   // |target_time_since_start| after call will be set up (after offer/answer
   // exchange, ICE gathering will be done and ICE candidates will passed to
   // remote side). |func| param is amount of time spent from the call set up.
   virtual void ExecuteAt(TimeDelta target_time_since_start,
                          std::function<void(TimeDelta)> func) = 0;
   // Add activity that will be executed every |interval| with first execution
   // on the best effort at least after |initial_delay_since_start| after call
   // will be set up (after all participants will be connected). |func| param is
   // amount of time spent from the call set up.
   virtual void ExecuteEvery(TimeDelta initial_delay_since_start,
                             TimeDelta interval,
                             std::function<void(TimeDelta)> func) = 0;

   virtual void Run(std::unique_ptr<InjectableComponents> alice_components,
                    std::unique_ptr<Params> alice_params,
                    std::unique_ptr<InjectableComponents> bob_components,
                    std::unique_ptr<Params> bob_params,
                    RunParams run_params) = 0;
   virtual ~PeerConnectionE2EQualityTestFixture() = default;
 };

 }  // namespace webrtc_pc_e2e
 }  // namespace webrtc

 #endif  // TEST_PC_E2E_API_PEERCONNECTION_QUALITY_TEST_FIXTURE_H_
	/*
	* Copyright (c) 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_PC_E2E_API_PEERCONNECTION_QUALITY_TEST_FIXTURE_H_
	#define TEST_PC_E2E_API_PEERCONNECTION_QUALITY_TEST_FIXTURE_H_

	#include <memory>
	#include <string>
	#include <vector>

	#include "absl/memory/memory.h"
	#include "api/async_resolver_factory.h"
	#include "api/call/call_factory_interface.h"
	#include "api/fec_controller.h"
	#include "api/media_transport_interface.h"
	#include "api/peer_connection_interface.h"
	#include "api/test/simulated_network.h"
	#include "api/transport/network_control.h"
	#include "api/units/time_delta.h"
	#include "api/video_codecs/video_decoder_factory.h"
	#include "api/video_codecs/video_encoder.h"
	#include "api/video_codecs/video_encoder_factory.h"
	#include "logging/rtc_event_log/rtc_event_log_factory_interface.h"
	#include "rtc_base/network.h"
	#include "rtc_base/rtc_certificate_generator.h"
	#include "rtc_base/ssl_certificate.h"
	#include "rtc_base/thread.h"
	#include "test/pc/e2e/api/audio_quality_analyzer_interface.h"
	#include "test/pc/e2e/api/video_quality_analyzer_interface.h"

	namespace webrtc {
	namespace webrtc_pc_e2e {

	// TODO(titovartem) move to API when it will be stabilized.
	class PeerConnectionE2EQualityTestFixture {
	public:
	// Contains most part from PeerConnectionFactoryDependencies. Also all fields
	// are optional and defaults will be provided by fixture implementation if
	// any will be omitted.
	//
	// Separate class was introduced to clarify which components can be
	// overridden. For example worker and signaling threads will be provided by
	// fixture implementation. The same is applicable to the media engine. So user
	// can override only some parts of media engine like video encoder/decoder
	// factories.
	struct PeerConnectionFactoryComponents {
	std::unique_ptr<CallFactoryInterface> call_factory;
	std::unique_ptr<RtcEventLogFactoryInterface> event_log_factory;
	std::unique_ptr<FecControllerFactoryInterface> fec_controller_factory;
	std::unique_ptr<NetworkControllerFactoryInterface>
	network_controller_factory;
	std::unique_ptr<MediaTransportFactory> media_transport_factory;

	// Will be passed to MediaEngineInterface, that will be used in
	// PeerConnectionFactory.
	std::unique_ptr<VideoEncoderFactory> video_encoder_factory;
	std::unique_ptr<VideoDecoderFactory> video_decoder_factory;
	};

	// Contains most parts from PeerConnectionDependencies. Also all fields are
	// optional and defaults will be provided by fixture implementation if any
	// will be omitted.
	//
	// Separate class was introduced to clarify which components can be
	// overridden. For example observer, which is required to
	// PeerConnectionDependencies, will be provided by fixture implementation,
	// so client can't inject its own. Also only network manager can be overridden
	// inside port allocator.
	struct PeerConnectionComponents {
	PeerConnectionComponents(rtc::NetworkManager* network_manager)
	: network_manager(network_manager) {
	RTC_CHECK(network_manager);
	}

	rtc::NetworkManager* const network_manager;
	std::unique_ptr<webrtc::AsyncResolverFactory> async_resolver_factory;
	std::unique_ptr<rtc::RTCCertificateGeneratorInterface> cert_generator;
	std::unique_ptr<rtc::SSLCertificateVerifier> tls_cert_verifier;
	};

	// Contains all components, that can be overridden in peer connection. Also
	// has a network thread, that will be used to communicate with another peers.
	struct InjectableComponents {
	explicit InjectableComponents(rtc::Thread* network_thread,
	rtc::NetworkManager* network_manager)
	: network_thread(network_thread),
	pcf_dependencies(
	absl::make_unique<PeerConnectionFactoryComponents>()),
	pc_dependencies(
	absl::make_unique<PeerConnectionComponents>(network_manager)) {
	RTC_CHECK(network_thread);
	}

	rtc::Thread* const network_thread;

	std::unique_ptr<PeerConnectionFactoryComponents> pcf_dependencies;
	std::unique_ptr<PeerConnectionComponents> pc_dependencies;
	};

	// Contains screen share video stream properties.
	struct ScreenShareConfig {
	// If true, slides will be generated programmatically.
	bool generate_slides;
	// Shows how long one slide should be presented on the screen during
	// slide generation.
	TimeDelta slide_change_interval;
	// If equal to 0, no scrolling will be applied.
	TimeDelta scroll_duration;
	// If empty, default set of slides will be used.
	std::vector<std::string> slides_yuv_file_names;
	};

	enum VideoGeneratorType { kDefault, kI420A, kI010 };

	// Contains properties of single video stream.
	struct VideoConfig {
	VideoConfig(size_t width, size_t height, int32_t fps)
	: width(width), height(height), fps(fps) {}

	const size_t width;
	const size_t height;
	const int32_t fps;
	// Have to be unique among all specified configs for all peers in the call.
	// Will be auto generated if omitted.
	absl::optional<std::string> stream_label;
	// Only 1 from \|generator\|, \|input_file_name\| and \|screen_share_config\| can
	// be specified. If none of them are specified, then \|generator\| will be set
	// to VideoGeneratorType::kDefault.
	// If specified generator of this type will be used to produce input video.
	absl::optional<VideoGeneratorType> generator;
	// If specified this file will be used as input. Input video will be played
	// in a circle.
	absl::optional<std::string> input_file_name;
	// If specified screen share video stream will be created as input.
	absl::optional<ScreenShareConfig> screen_share_config;
	// Specifies spatial index of the video stream to analyze.
	// There are 3 cases:
	// 1. \|target_spatial_index\| omitted: in such case it will be assumed that
	// video stream has not spatial layers and simulcast streams.
	// 2. \|target_spatial_index\| presented and simulcast encoder is used:
	// in such case \|target_spatial_index\| will specify the index of
	// simulcast stream, that should be analyzed. Other streams will be
	// dropped.
	// 3. \|target_spatial_index\| presented and SVP encoder is used:
	// in such case \|target_spatial_index\| will specify the top interesting
	// spatial layer and all layers bellow, including target one will be
	// processed. All layers above target one will be dropped.
	absl::optional<int> target_spatial_index;
	// If specified the input stream will be also copied to specified file.
	// It is actually one of the test's output file, which contains copy of what
	// was captured during the test for this video stream on sender side.
	// It is useful when generator is used as input.
	absl::optional<std::string> input_dump_file_name;
	// If specified this file will be used as output on the receiver side for
	// this stream. If multiple streams will be produced by input stream,
	// output files will be appended with indexes. The produced files contains
	// what was rendered for this video stream on receiver side.
	absl::optional<std::string> output_dump_file_name;
	};

	// Contains properties for audio in the call.
	struct AudioConfig {
	enum Mode {
	kGenerated,
	kFile,
	};
	// Have to be unique among all specified configs for all peers in the call.
	// Will be auto generated if omitted.
	absl::optional<std::string> stream_label;
	Mode mode = kGenerated;
	// Have to be specified only if mode = kFile
	absl::optional<std::string> input_file_name;
	// If specified the input stream will be also copied to specified file.
	absl::optional<std::string> input_dump_file_name;
	// If specified the output stream will be copied to specified file.
	absl::optional<std::string> output_dump_file_name;
	// Audio options to use.
	cricket::AudioOptions audio_options;
	};

	// Contains information about call media streams (up to 1 audio stream and
	// unlimited amount of video streams) and rtc configuration, that will be used
	// to set up peer connection.
	struct Params {
	// If \|video_configs\| is empty - no video should be added to the test call.
	std::vector<VideoConfig> video_configs;
	// If \|audio_config\| is set audio stream will be configured
	absl::optional<AudioConfig> audio_config;
	// If \|rtc_event_log_path\| is set, an RTCEventLog will be saved in that
	// location and it will be available for further analysis.
	absl::optional<std::string> rtc_event_log_path;

	PeerConnectionInterface::RTCConfiguration rtc_configuration;
	};

	// Contains parameters, that describe how long framework should run quality
	// test.
	struct RunParams {
	// Specifies how long the test should be run. This time shows how long
	// the media should flow after connection was established and before
	// it will be shut downed.
	TimeDelta run_duration;
	};

	// Add activity that will be executed on the best effort at least after
	// \|target_time_since_start\| after call will be set up (after offer/answer
	// exchange, ICE gathering will be done and ICE candidates will passed to
	// remote side). \|func\| param is amount of time spent from the call set up.
	virtual void ExecuteAt(TimeDelta target_time_since_start,
	std::function<void(TimeDelta)> func) = 0;
	// Add activity that will be executed every \|interval\| with first execution
	// on the best effort at least after \|initial_delay_since_start\| after call
	// will be set up (after all participants will be connected). \|func\| param is
	// amount of time spent from the call set up.
	virtual void ExecuteEvery(TimeDelta initial_delay_since_start,
	TimeDelta interval,
	std::function<void(TimeDelta)> func) = 0;

	virtual void Run(std::unique_ptr<InjectableComponents> alice_components,
	std::unique_ptr<Params> alice_params,
	std::unique_ptr<InjectableComponents> bob_components,
	std::unique_ptr<Params> bob_params,
	RunParams run_params) = 0;
	virtual ~PeerConnectionE2EQualityTestFixture() = default;
	};

	} // namespace webrtc_pc_e2e
	} // namespace webrtc

	#endif // TEST_PC_E2E_API_PEERCONNECTION_QUALITY_TEST_FIXTURE_H_