1 /*
2  *  Copyright (c) 2018 The WebRTC project authors. All Rights Reserved.
3  *
4  *  Use of this source code is governed by a BSD-style license
5  *  that can be found in the LICENSE file in the root of the source
6  *  tree. An additional intellectual property rights grant can be found
7  *  in the file PATENTS.  All contributing project authors may
8  *  be found in the AUTHORS file in the root of the source tree.
9  */
10 
11 #ifndef API_TEST_VIDEOCODEC_TEST_FIXTURE_H_
12 #define API_TEST_VIDEOCODEC_TEST_FIXTURE_H_
13 
14 #include <string>
15 #include <vector>
16 
17 #include "api/test/videocodec_test_stats.h"
18 #include "api/video_codecs/video_decoder_factory.h"
19 #include "api/video_codecs/video_encoder_factory.h"
20 #include "modules/video_coding/include/video_codec_interface.h"
21 
22 namespace webrtc {
23 namespace test {
24 
25 // Rates for the encoder and the frame number when to apply profile.
26 struct RateProfile {
27   size_t target_kbps;
28   double input_fps;
29   size_t frame_num;
30 };
31 
32 struct RateControlThresholds {
33   double max_avg_bitrate_mismatch_percent;
34   double max_time_to_reach_target_bitrate_sec;
35   // TODO(ssilkin): Use absolute threshold for framerate.
36   double max_avg_framerate_mismatch_percent;
37   double max_avg_buffer_level_sec;
38   double max_max_key_frame_delay_sec;
39   double max_max_delta_frame_delay_sec;
40   size_t max_num_spatial_resizes;
41   size_t max_num_key_frames;
42 };
43 
44 struct QualityThresholds {
45   double min_avg_psnr;
46   double min_min_psnr;
47   double min_avg_ssim;
48   double min_min_ssim;
49 };
50 
51 struct BitstreamThresholds {
52   size_t max_max_nalu_size_bytes;
53 };
54 
55 // NOTE: This class is still under development and may change without notice.
56 class VideoCodecTestFixture {
57  public:
58   class EncodedFrameChecker {
59    public:
60     virtual ~EncodedFrameChecker() = default;
61     virtual void CheckEncodedFrame(webrtc::VideoCodecType codec,
62                                    const EncodedImage& encoded_frame) const = 0;
63   };
64 
65   struct Config {
66     Config();
67     void SetCodecSettings(std::string codec_name,
68                           size_t num_simulcast_streams,
69                           size_t num_spatial_layers,
70                           size_t num_temporal_layers,
71                           bool denoising_on,
72                           bool frame_dropper_on,
73                           bool spatial_resize_on,
74                           size_t width,
75                           size_t height);
76 
77     size_t NumberOfCores() const;
78     size_t NumberOfTemporalLayers() const;
79     size_t NumberOfSpatialLayers() const;
80     size_t NumberOfSimulcastStreams() const;
81 
82     std::string ToString() const;
83     std::string CodecName() const;
84 
85     // Name of this config, to be used for accounting by the test runner.
86     std::string test_name;
87 
88     // Plain name of YUV file to process without file extension.
89     std::string filename;
90 
91     // File to process. This must be a video file in the YUV format.
92     std::string filepath;
93 
94     // Number of frames to process.
95     size_t num_frames = 0;
96 
97     // Bitstream constraints.
98     size_t max_payload_size_bytes = 1440;
99 
100     // Should we decode the encoded frames?
101     bool decode = true;
102 
103     // Force the encoder and decoder to use a single core for processing.
104     bool use_single_core = false;
105 
106     // Should cpu usage be measured?
107     // If set to true, the encoding will run in real-time.
108     bool measure_cpu = false;
109 
110     // Simulate frames arriving in real-time by adding delays between frames.
111     bool encode_in_real_time = false;
112 
113     // Codec settings to use.
114     webrtc::VideoCodec codec_settings;
115 
116     // Name of the codec being tested.
117     std::string codec_name;
118 
119     // H.264 specific settings.
120     struct H264CodecSettings {
121       H264::Profile profile = H264::kProfileConstrainedBaseline;
122       H264PacketizationMode packetization_mode =
123           webrtc::H264PacketizationMode::NonInterleaved;
124     } h264_codec_settings;
125 
126     // Custom checker that will be called for each frame.
127     const EncodedFrameChecker* encoded_frame_checker = nullptr;
128 
129     // Print out frame level stats.
130     bool print_frame_level_stats = false;
131 
132     // Path to a directory where encoded or/and decoded video should be saved.
133     std::string output_path;
134 
135     // Should video be saved persistently to disk for post-run visualization?
136     struct VisualizationParams {
137       bool save_encoded_ivf = false;
138       bool save_decoded_y4m = false;
139     } visualization_params;
140   };
141 
142   virtual ~VideoCodecTestFixture() = default;
143 
144   virtual void RunTest(const std::vector<RateProfile>& rate_profiles,
145                        const std::vector<RateControlThresholds>* rc_thresholds,
146                        const std::vector<QualityThresholds>* quality_thresholds,
147                        const BitstreamThresholds* bs_thresholds) = 0;
148   virtual VideoCodecTestStats& GetStats() = 0;
149 };
150 
151 }  // namespace test
152 }  // namespace webrtc
153 
154 #endif  // API_TEST_VIDEOCODEC_TEST_FIXTURE_H_
155