1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
|
/*
* Copyright (c) 2019 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_PEER_CONNECTION_QUALITY_TEST_H_
#define TEST_PC_E2E_PEER_CONNECTION_QUALITY_TEST_H_
#include <memory>
#include <queue>
#include <string>
#include <vector>
#include "absl/strings/string_view.h"
#include "api/task_queue/task_queue_factory.h"
#include "api/test/audio_quality_analyzer_interface.h"
#include "api/test/metrics/metrics_logger.h"
#include "api/test/pclf/media_configuration.h"
#include "api/test/pclf/media_quality_test_params.h"
#include "api/test/pclf/peer_configurer.h"
#include "api/test/peerconnection_quality_test_fixture.h"
#include "api/test/time_controller.h"
#include "api/units/time_delta.h"
#include "api/units/timestamp.h"
#include "rtc_base/synchronization/mutex.h"
#include "rtc_base/task_queue_for_test.h"
#include "rtc_base/thread.h"
#include "rtc_base/thread_annotations.h"
#include "system_wrappers/include/clock.h"
#include "test/pc/e2e/analyzer/video/single_process_encoded_image_data_injector.h"
#include "test/pc/e2e/analyzer/video/video_quality_analyzer_injection_helper.h"
#include "test/pc/e2e/analyzer_helper.h"
#include "test/pc/e2e/media/media_helper.h"
#include "test/pc/e2e/sdp/sdp_changer.h"
#include "test/pc/e2e/test_activities_executor.h"
#include "test/pc/e2e/test_peer.h"
namespace webrtc {
namespace webrtc_pc_e2e {
class PeerConnectionE2EQualityTest
: public PeerConnectionE2EQualityTestFixture {
public:
using QualityMetricsReporter =
PeerConnectionE2EQualityTestFixture::QualityMetricsReporter;
PeerConnectionE2EQualityTest(
std::string test_case_name,
TimeController& time_controller,
std::unique_ptr<AudioQualityAnalyzerInterface> audio_quality_analyzer,
std::unique_ptr<VideoQualityAnalyzerInterface> video_quality_analyzer);
PeerConnectionE2EQualityTest(
std::string test_case_name,
TimeController& time_controller,
std::unique_ptr<AudioQualityAnalyzerInterface> audio_quality_analyzer,
std::unique_ptr<VideoQualityAnalyzerInterface> video_quality_analyzer,
test::MetricsLogger* metrics_logger);
~PeerConnectionE2EQualityTest() override = default;
void ExecuteAt(TimeDelta target_time_since_start,
std::function<void(TimeDelta)> func) override;
void ExecuteEvery(TimeDelta initial_delay_since_start,
TimeDelta interval,
std::function<void(TimeDelta)> func) override;
void AddQualityMetricsReporter(std::unique_ptr<QualityMetricsReporter>
quality_metrics_reporter) override;
PeerHandle* AddPeer(std::unique_ptr<PeerConfigurer> configurer) override;
void Run(RunParams run_params) override;
TimeDelta GetRealTestDuration() const override {
MutexLock lock(&lock_);
RTC_CHECK_NE(real_test_duration_, TimeDelta::Zero());
return real_test_duration_;
}
private:
class PeerHandleImpl : public PeerHandle {
public:
~PeerHandleImpl() override = default;
};
// For some functionality some field trials have to be enabled, they will be
// enabled in Run().
std::string GetFieldTrials(const RunParams& run_params);
void OnTrackCallback(absl::string_view peer_name,
VideoSubscription peer_subscription,
rtc::scoped_refptr<RtpTransceiverInterface> transceiver,
std::vector<VideoConfig> remote_video_configs);
// Have to be run on the signaling thread.
void SetupCallOnSignalingThread(const RunParams& run_params);
void TearDownCallOnSignalingThread();
void SetPeerCodecPreferences(TestPeer* peer);
std::unique_ptr<SignalingInterceptor> CreateSignalingInterceptor(
const RunParams& run_params);
void WaitUntilIceCandidatesGathered(rtc::Thread* signaling_thread);
void WaitUntilPeersAreConnected(rtc::Thread* signaling_thread);
void ExchangeOfferAnswer(SignalingInterceptor* signaling_interceptor);
void ExchangeIceCandidates(SignalingInterceptor* signaling_interceptor);
void StartVideo(
const std::vector<rtc::scoped_refptr<TestVideoCapturerVideoTrackSource>>&
sources);
void TearDownCall();
void ReportGeneralTestResults();
Timestamp Now() const;
TimeController& time_controller_;
const std::unique_ptr<TaskQueueFactory> task_queue_factory_;
std::string test_case_name_;
std::unique_ptr<VideoQualityAnalyzerInjectionHelper>
video_quality_analyzer_injection_helper_;
std::unique_ptr<MediaHelper> media_helper_;
std::unique_ptr<EncodedImageDataPropagator> encoded_image_data_propagator_;
std::unique_ptr<AudioQualityAnalyzerInterface> audio_quality_analyzer_;
std::unique_ptr<TestActivitiesExecutor> executor_;
test::MetricsLogger* const metrics_logger_;
std::vector<std::unique_ptr<PeerConfigurer>> peer_configurations_;
std::vector<PeerHandleImpl> peer_handles_;
std::unique_ptr<TestPeer> alice_;
std::unique_ptr<TestPeer> bob_;
std::vector<std::unique_ptr<QualityMetricsReporter>>
quality_metrics_reporters_;
std::vector<rtc::scoped_refptr<TestVideoCapturerVideoTrackSource>>
alice_video_sources_;
std::vector<rtc::scoped_refptr<TestVideoCapturerVideoTrackSource>>
bob_video_sources_;
std::vector<std::unique_ptr<rtc::VideoSinkInterface<VideoFrame>>>
output_video_sinks_;
AnalyzerHelper analyzer_helper_;
mutable Mutex lock_;
TimeDelta real_test_duration_ RTC_GUARDED_BY(lock_) = TimeDelta::Zero();
// Task queue, that is used for running activities during test call.
// This task queue will be created before call set up and will be destroyed
// immediately before call tear down.
std::unique_ptr<TaskQueueForTest> task_queue_;
bool alice_connected_ = false;
bool bob_connected_ = false;
};
} // namespace webrtc_pc_e2e
} // namespace webrtc
#endif // TEST_PC_E2E_PEER_CONNECTION_QUALITY_TEST_H_
|
