| /* |
| * Copyright (c) 2015 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 VIDEO_VIDEO_QUALITY_TEST_H_ |
| #define VIDEO_VIDEO_QUALITY_TEST_H_ |
| |
| #include <map> |
| #include <memory> |
| #include <string> |
| #include <vector> |
| |
| #include "media/engine/internalencoderfactory.h" |
| #include "test/call_test.h" |
| #include "test/frame_generator.h" |
| #include "test/layer_filtering_transport.h" |
| |
| namespace webrtc { |
| |
| class VideoQualityTest : public test::CallTest { |
| public: |
| // Parameters are grouped into smaller structs to make it easier to set |
| // the desired elements and skip unused, using aggregate initialization. |
| // Unfortunately, C++11 (as opposed to C11) doesn't support unnamed structs, |
| // which makes the implementation of VideoQualityTest a bit uglier. |
| struct Params { |
| Params(); |
| ~Params(); |
| struct CallConfig { |
| bool send_side_bwe; |
| BitrateConstraints call_bitrate_config; |
| int num_thumbnails; |
| // Indicates if secondary_(video|ss|screenshare) structures are used. |
| bool dual_video; |
| } call; |
| struct Video { |
| bool enabled; |
| size_t width; |
| size_t height; |
| int32_t fps; |
| int min_bitrate_bps; |
| int target_bitrate_bps; |
| int max_bitrate_bps; |
| bool suspend_below_min_bitrate; |
| std::string codec; |
| int num_temporal_layers; |
| int selected_tl; |
| int min_transmit_bps; |
| bool ulpfec; |
| bool flexfec; |
| std::string clip_name; // "Generator" to generate frames instead. |
| size_t capture_device_index; |
| } video[2]; |
| struct Audio { |
| bool enabled; |
| bool sync_video; |
| bool dtx; |
| } audio; |
| struct Screenshare { |
| bool enabled; |
| bool generate_slides; |
| int32_t slide_change_interval; |
| int32_t scroll_duration; |
| std::vector<std::string> slides; |
| } screenshare[2]; |
| struct Analyzer { |
| std::string test_label; |
| double avg_psnr_threshold; // (*) |
| double avg_ssim_threshold; // (*) |
| int test_durations_secs; |
| std::string graph_data_output_filename; |
| std::string graph_title; |
| } analyzer; |
| FakeNetworkPipe::Config pipe; |
| struct SS { // Spatial scalability. |
| std::vector<VideoStream> streams; // If empty, one stream is assumed. |
| size_t selected_stream; |
| int num_spatial_layers; |
| int selected_sl; |
| // 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; |
| } ss[2]; |
| struct Logging { |
| bool logs; |
| std::string rtc_event_log_name; |
| std::string rtp_dump_name; |
| std::string encoded_frame_base_path; |
| } logging; |
| }; |
| |
| VideoQualityTest(); |
| explicit VideoQualityTest( |
| std::unique_ptr<FecControllerFactoryInterface> fec_controller_factory); |
| void RunWithAnalyzer(const Params& params); |
| void RunWithRenderers(const Params& params); |
| |
| static void FillScalabilitySettings( |
| Params* params, |
| size_t video_idx, |
| const std::vector<std::string>& stream_descriptors, |
| int num_streams, |
| size_t selected_stream, |
| int num_spatial_layers, |
| int selected_sl, |
| const std::vector<std::string>& sl_descriptors); |
| |
| protected: |
| std::map<uint8_t, webrtc::MediaType> payload_type_map_; |
| std::unique_ptr<FecControllerFactoryInterface> fec_controller_factory_; |
| |
| // No-op implementation to be able to instantiate this class from non-TEST_F |
| // locations. |
| void TestBody() override; |
| |
| // Helper methods accessing only params_. |
| std::string GenerateGraphTitle() const; |
| void CheckParams(); |
| |
| // Helper static methods. |
| static VideoStream DefaultVideoStream(const Params& params, size_t video_idx); |
| static VideoStream DefaultThumbnailStream(); |
| static std::vector<int> ParseCSV(const std::string& str); |
| |
| // Helper methods for setting up the call. |
| void CreateVideoStreams(); |
| void DestroyStreams(); |
| void CreateCapturers(); |
| std::unique_ptr<test::FrameGenerator> CreateFrameGenerator(size_t video_idx); |
| void SetupThumbnailCapturers(size_t num_thumbnail_streams); |
| void SetupVideo(Transport* send_transport, Transport* recv_transport); |
| void SetupThumbnails(Transport* send_transport, Transport* recv_transport); |
| void DestroyThumbnailStreams(); |
| void SetupAudio(Transport* transport, |
| AudioReceiveStream** audio_receive_stream); |
| |
| void StartEncodedFrameLogs(VideoSendStream* stream); |
| void StartEncodedFrameLogs(VideoReceiveStream* stream); |
| |
| virtual std::unique_ptr<test::LayerFilteringTransport> CreateSendTransport(); |
| virtual std::unique_ptr<test::DirectTransport> CreateReceiveTransport(); |
| |
| std::vector<std::unique_ptr<test::VideoCapturer>> video_capturers_; |
| std::vector<std::unique_ptr<test::VideoCapturer>> thumbnail_capturers_; |
| InternalEncoderFactory internal_encoder_factory_; |
| std::vector<std::unique_ptr<VideoEncoder>> video_encoders_; |
| |
| std::vector<std::unique_ptr<VideoEncoder>> thumbnail_encoders_; |
| std::vector<VideoSendStream::Config> thumbnail_send_configs_; |
| std::vector<VideoEncoderConfig> thumbnail_encoder_configs_; |
| std::vector<VideoSendStream*> thumbnail_send_streams_; |
| std::vector<VideoReceiveStream::Config> thumbnail_receive_configs_; |
| std::vector<VideoReceiveStream*> thumbnail_receive_streams_; |
| |
| std::vector<VideoSendStream::Config> video_send_configs_; |
| std::vector<VideoEncoderConfig> video_encoder_configs_; |
| std::vector<VideoSendStream*> video_send_streams_; |
| |
| Clock* const clock_; |
| |
| int receive_logs_; |
| int send_logs_; |
| |
| VideoSendStream::DegradationPreference degradation_preference_ = |
| VideoSendStream::DegradationPreference::kMaintainFramerate; |
| Params params_; |
| |
| std::unique_ptr<webrtc::RtcEventLog> recv_event_log_; |
| std::unique_ptr<webrtc::RtcEventLog> send_event_log_; |
| |
| size_t num_video_streams_; |
| }; |
| |
| } // namespace webrtc |
| |
| #endif // VIDEO_VIDEO_QUALITY_TEST_H_ |