summaryrefslogtreecommitdiffstats
path: root/third_party/libwebrtc/test/call_test.h
diff options
context:
space:
mode:
Diffstat (limited to 'third_party/libwebrtc/test/call_test.h')
-rw-r--r--third_party/libwebrtc/test/call_test.h359
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_