diff options
Diffstat (limited to 'third_party/libwebrtc/test/call_test.h')
| -rw-r--r-- | third_party/libwebrtc/test/call_test.h | 359 |
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_ |