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
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
|
/*
* Copyright (c) 2022 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_VIDEO_CODEC_TESTER_H_
#define TEST_VIDEO_CODEC_TESTER_H_
#include <limits>
#include <map>
#include <memory>
#include <string>
#include <vector>
#include "absl/types/optional.h"
#include "api/numerics/samples_stats_counter.h"
#include "api/test/metrics/metric.h"
#include "api/test/metrics/metrics_logger.h"
#include "api/units/data_rate.h"
#include "api/units/data_size.h"
#include "api/units/frequency.h"
#include "api/video/encoded_image.h"
#include "api/video/resolution.h"
#include "api/video_codecs/video_decoder_factory.h"
#include "api/video_codecs/video_encoder_factory.h"
namespace webrtc {
namespace test {
class VideoCodecTester {
public:
struct LayerId {
int spatial_idx = 0;
int temporal_idx = 0;
bool operator==(const LayerId& o) const {
return spatial_idx == o.spatial_idx && temporal_idx == o.temporal_idx;
}
bool operator<(const LayerId& o) const {
return spatial_idx < o.spatial_idx ||
(spatial_idx == o.spatial_idx && temporal_idx < o.temporal_idx);
}
};
struct EncodingSettings {
SdpVideoFormat sdp_video_format = SdpVideoFormat("VP8");
ScalabilityMode scalability_mode = ScalabilityMode::kL1T1;
struct LayerSettings {
Resolution resolution;
Frequency framerate;
DataRate bitrate;
};
std::map<LayerId, LayerSettings> layers_settings;
};
class VideoCodecStats {
public:
struct Filter {
uint32_t min_timestamp_rtp = std::numeric_limits<uint32_t>::min();
uint32_t max_timestamp_rtp = std::numeric_limits<uint32_t>::max();
absl::optional<LayerId> layer_id;
};
struct Frame {
uint32_t timestamp_rtp = 0;
LayerId layer_id;
bool encoded = false;
bool decoded = false;
int width = 0;
int height = 0;
DataSize frame_size = DataSize::Zero();
bool keyframe = false;
absl::optional<int> qp;
Timestamp encode_start = Timestamp::Zero();
TimeDelta encode_time = TimeDelta::Zero();
Timestamp decode_start = Timestamp::Zero();
TimeDelta decode_time = TimeDelta::Zero();
absl::optional<DataRate> target_bitrate;
absl::optional<Frequency> target_framerate;
struct Psnr {
double y = 0.0;
double u = 0.0;
double v = 0.0;
};
absl::optional<Psnr> psnr;
};
struct Stream {
SamplesStatsCounter width;
SamplesStatsCounter height;
SamplesStatsCounter frame_size_bytes;
SamplesStatsCounter keyframe;
SamplesStatsCounter qp;
SamplesStatsCounter encode_time_ms;
SamplesStatsCounter decode_time_ms;
SamplesStatsCounter target_bitrate_kbps;
SamplesStatsCounter target_framerate_fps;
SamplesStatsCounter encoded_bitrate_kbps;
SamplesStatsCounter encoded_framerate_fps;
SamplesStatsCounter bitrate_mismatch_pct;
SamplesStatsCounter framerate_mismatch_pct;
SamplesStatsCounter transmission_time_ms;
struct Psnr {
SamplesStatsCounter y;
SamplesStatsCounter u;
SamplesStatsCounter v;
} psnr;
// Logs `Stream` metrics to provided `MetricsLogger`.
void LogMetrics(MetricsLogger* logger,
std::string test_case_name,
std::string prefix,
std::map<std::string, std::string> metadata = {}) const;
};
virtual ~VideoCodecStats() = default;
// Returns frames for the slice specified by `filter`. If `merge` is true,
// also merges frames belonging to the same temporal unit into one
// superframe.
virtual std::vector<Frame> Slice(Filter filter, bool merge) const = 0;
// Returns video statistics aggregated for the slice specified by `filter`.
virtual Stream Aggregate(Filter filter) const = 0;
// Write metrics to a CSV file.
virtual void LogMetrics(
absl::string_view csv_path,
std::vector<Frame> frames,
std::map<std::string, std::string> metadata) const = 0;
};
// Pacing settings for codec input.
struct PacingSettings {
enum PacingMode {
// Pacing is not used. Frames are sent to codec back-to-back.
kNoPacing,
// Pace with the rate equal to the target video frame rate. Pacing time is
// derived from RTP timestamp.
kRealTime,
// Pace with the explicitly provided rate.
kConstantRate,
};
PacingMode mode = PacingMode::kNoPacing;
// Pacing rate for `kConstantRate` mode.
Frequency constant_rate = Frequency::Zero();
};
struct VideoSourceSettings {
std::string file_path;
Resolution resolution;
Frequency framerate;
};
struct DecoderSettings {
PacingSettings pacing_settings;
absl::optional<std::string> decoder_input_base_path;
absl::optional<std::string> decoder_output_base_path;
};
struct EncoderSettings {
PacingSettings pacing_settings;
absl::optional<std::string> encoder_input_base_path;
absl::optional<std::string> encoder_output_base_path;
};
virtual ~VideoCodecTester() = default;
// Interface for a coded video frames source.
class CodedVideoSource {
public:
virtual ~CodedVideoSource() = default;
// Returns next frame. Returns `absl::nullopt` if the end-of-stream is
// reached. Frames should have RTP timestamps representing desired frame
// rate.
virtual absl::optional<EncodedImage> PullFrame() = 0;
};
// A helper function that creates `EncodingSettings` for `num_frames` frames,
// wraps the settings into RTP timestamp -> settings map and returns the map.
static std::map<uint32_t, EncodingSettings> CreateEncodingSettings(
std::string codec_type,
std::string scalability_name,
int width,
int height,
std::vector<int> bitrates_kbps,
double framerate_fps,
int num_frames,
uint32_t first_timestamp_rtp = 90000);
// Decodes video, collects and returns decode metrics.
static std::unique_ptr<VideoCodecStats> RunDecodeTest(
CodedVideoSource* video_source,
VideoDecoderFactory* decoder_factory,
const DecoderSettings& decoder_settings,
const SdpVideoFormat& sdp_video_format);
// Encodes video, collects and returns encode metrics.
static std::unique_ptr<VideoCodecStats> RunEncodeTest(
const VideoSourceSettings& source_settings,
VideoEncoderFactory* encoder_factory,
const EncoderSettings& encoder_settings,
const std::map<uint32_t, EncodingSettings>& encoding_settings);
// Encodes and decodes video, collects and returns encode and decode metrics.
static std::unique_ptr<VideoCodecStats> RunEncodeDecodeTest(
const VideoSourceSettings& source_settings,
VideoEncoderFactory* encoder_factory,
VideoDecoderFactory* decoder_factory,
const EncoderSettings& encoder_settings,
const DecoderSettings& decoder_settings,
const std::map<uint32_t, EncodingSettings>& encoding_settings);
};
} // namespace test
} // namespace webrtc
#endif // TEST_VIDEO_CODEC_TESTER_H_
|
