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
|
/*
* 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 API_TEST_VIDEO_QUALITY_TEST_FIXTURE_H_
#define API_TEST_VIDEO_QUALITY_TEST_FIXTURE_H_
#include <cstddef>
#include <cstdint>
#include <map>
#include <memory>
#include <optional>
#include <string>
#include <vector>
#include "api/fec_controller.h"
#include "api/media_types.h"
#include "api/network_state_predictor.h"
#include "api/rtp_parameters.h"
#include "api/test/simulated_network.h"
#include "api/transport/bitrate_settings.h"
#include "api/transport/network_control.h"
#include "api/video_codecs/spatial_layer.h"
#include "api/video_codecs/video_codec.h"
#include "api/video_codecs/video_decoder_factory.h"
#include "api/video_codecs/video_encoder_factory.h"
#include "video/config/video_encoder_config.h"
namespace webrtc {
class VideoQualityTestFixtureInterface {
public:
// Parameters are grouped into smaller structs to make it easier to set
// the desired elements and skip unused.
struct Params {
struct CallConfig {
bool send_side_bwe = false;
bool generic_descriptor = false;
bool dependency_descriptor = false;
BitrateConstraints call_bitrate_config;
int num_thumbnails = 0;
// Indicates if secondary_(video|ss|screenshare) structures are used.
bool dual_video = false;
} call;
struct Video {
bool enabled = false;
size_t width = 640;
size_t height = 480;
int32_t fps = 30;
int min_bitrate_bps = 50;
int target_bitrate_bps = 800;
int max_bitrate_bps = 800;
bool suspend_below_min_bitrate = false;
std::string codec = "VP8";
int num_temporal_layers = 1;
int selected_tl = -1;
int min_transmit_bps = 0;
bool ulpfec = false;
bool flexfec = false;
bool automatic_scaling = false;
std::string clip_path; // "Generator" to generate frames instead.
size_t capture_device_index = 0;
CodecParameterMap sdp_params;
double encoder_overshoot_factor = 0.0;
} video[2];
struct Audio {
bool enabled = false;
bool sync_video = false;
bool dtx = false;
bool use_real_adm = false;
std::optional<std::string> ana_config;
} audio;
struct Screenshare {
bool enabled = false;
bool generate_slides = false;
int32_t slide_change_interval = 10;
int32_t scroll_duration = 0;
std::vector<std::string> slides;
} screenshare[2];
struct Analyzer {
std::string test_label;
double avg_psnr_threshold = 0.0; // (*)
double avg_ssim_threshold = 0.0; // (*)
int test_durations_secs = 0;
std::string graph_data_output_filename;
std::string graph_title;
} analyzer;
// Config for default simulation implementation. Must be nullopt if
// `sender_network` and `receiver_network` in InjectionComponents are
// non-null. May be nullopt even if `sender_network` and `receiver_network`
// are null; in that case, a default config will be used.
std::optional<BuiltInNetworkBehaviorConfig> config;
struct SS { // Spatial scalability.
std::vector<VideoStream> streams; // If empty, one stream is assumed.
size_t selected_stream = 0;
int num_spatial_layers = 0;
int selected_sl = -1;
InterLayerPredMode inter_layer_pred = InterLayerPredMode::kOn;
// If empty, bitrates are generated in VP9Impl automatically.
std::vector<SpatialLayer> spatial_layers;
// If set, default parameters will be used instead of `streams`.
bool infer_streams = false;
} ss[2];
struct Logging {
std::string rtc_event_log_name;
std::string rtp_dump_name;
std::string encoded_frame_base_path;
} logging;
};
// Contains objects, that will be injected on different layers of test
// framework to override the behavior of system parts.
struct InjectionComponents {
// Simulations of sender and receiver networks. They must either both be
// null (in which case `config` from Params is used), or both be non-null
// (in which case `config` from Params must be nullopt).
std::unique_ptr<NetworkBehaviorInterface> sender_network;
std::unique_ptr<NetworkBehaviorInterface> receiver_network;
std::string field_trials;
std::unique_ptr<FecControllerFactoryInterface> fec_controller_factory;
std::unique_ptr<VideoEncoderFactory> video_encoder_factory;
std::unique_ptr<VideoDecoderFactory> video_decoder_factory;
std::unique_ptr<NetworkStatePredictorFactoryInterface>
network_state_predictor_factory;
std::unique_ptr<NetworkControllerFactoryInterface>
network_controller_factory;
};
virtual ~VideoQualityTestFixtureInterface() = default;
virtual void RunWithAnalyzer(const Params& params) = 0;
virtual void RunWithRenderers(const Params& params) = 0;
virtual const std::map<uint8_t, MediaType>& payload_type_map() = 0;
};
} // namespace webrtc
#endif // API_TEST_VIDEO_QUALITY_TEST_FIXTURE_H_
|
