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
|
/*
* 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 "api/fec_controller.h"
#include "api/rtc_event_log/rtc_event_log_factory.h"
#include "api/task_queue/task_queue_base.h"
#include "api/task_queue/task_queue_factory.h"
#include "api/test/frame_generator_interface.h"
#include "api/test/video_quality_test_fixture.h"
#include "api/video/video_bitrate_allocator_factory.h"
#include "call/fake_network_pipe.h"
#include "media/engine/internal_decoder_factory.h"
#include "media/engine/internal_encoder_factory.h"
#include "test/call_test.h"
#include "test/layer_filtering_transport.h"
#include "video/video_analyzer.h"
#ifdef WEBRTC_WIN
#include "modules/audio_device/win/core_audio_utility_win.h"
#include "rtc_base/win/scoped_com_initializer.h"
#endif
namespace webrtc {
class VideoQualityTest : public test::CallTest,
public VideoQualityTestFixtureInterface {
public:
explicit VideoQualityTest(
std::unique_ptr<InjectionComponents> injection_components);
void RunWithAnalyzer(const Params& params) override;
void RunWithRenderers(const Params& params) override;
const std::map<uint8_t, webrtc::MediaType>& payload_type_map() override {
return payload_type_map_;
}
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,
InterLayerPredMode inter_layer_pred,
const std::vector<std::string>& sl_descriptors);
// 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);
protected:
// 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 CheckParamsAndInjectionComponents();
// Helper methods for setting up the call.
void CreateCapturers();
std::unique_ptr<test::FrameGeneratorInterface> CreateFrameGenerator(
size_t video_idx);
void SetupThumbnailCapturers(size_t num_thumbnail_streams);
std::unique_ptr<VideoDecoder> CreateVideoDecoder(
const SdpVideoFormat& format);
std::unique_ptr<VideoEncoder> CreateVideoEncoder(const SdpVideoFormat& format,
VideoAnalyzer* analyzer);
void SetupVideo(Transport* send_transport, Transport* recv_transport);
void SetupThumbnails(Transport* send_transport, Transport* recv_transport);
void StartAudioStreams();
void StartThumbnails();
void StopThumbnails();
void DestroyThumbnailStreams();
// Helper method for creating a real ADM (using hardware) for all platforms.
rtc::scoped_refptr<AudioDeviceModule> CreateAudioDevice();
void InitializeAudioDevice(Call::Config* send_call_config,
Call::Config* recv_call_config,
bool use_real_adm);
void SetupAudio(Transport* transport);
void StartEncodedFrameLogs(VideoReceiveStreamInterface* stream);
virtual std::unique_ptr<test::LayerFilteringTransport> CreateSendTransport();
virtual std::unique_ptr<test::DirectTransport> CreateReceiveTransport();
std::vector<std::unique_ptr<rtc::VideoSourceInterface<VideoFrame>>>
thumbnail_capturers_;
Clock* const clock_;
const std::unique_ptr<TaskQueueFactory> task_queue_factory_;
RtcEventLogFactory rtc_event_log_factory_;
test::FunctionVideoDecoderFactory video_decoder_factory_;
std::unique_ptr<VideoDecoderFactory> decoder_factory_;
test::FunctionVideoEncoderFactory video_encoder_factory_;
test::FunctionVideoEncoderFactory video_encoder_factory_with_analyzer_;
std::unique_ptr<VideoBitrateAllocatorFactory>
video_bitrate_allocator_factory_;
std::unique_ptr<VideoEncoderFactory> encoder_factory_;
std::vector<VideoSendStream::Config> thumbnail_send_configs_;
std::vector<VideoEncoderConfig> thumbnail_encoder_configs_;
std::vector<VideoSendStream*> thumbnail_send_streams_;
std::vector<VideoReceiveStreamInterface::Config> thumbnail_receive_configs_;
std::vector<VideoReceiveStreamInterface*> thumbnail_receive_streams_;
int receive_logs_;
int send_logs_;
Params params_;
std::unique_ptr<InjectionComponents> injection_components_;
// Set non-null when running with analyzer.
std::unique_ptr<VideoAnalyzer> analyzer_;
// Note: not same as similarly named member in CallTest. This is the number of
// separate send streams, the one in CallTest is the number of substreams for
// a single send stream.
size_t num_video_streams_;
#ifdef WEBRTC_WIN
// Windows Core Audio based ADM needs to run on a COM initialized thread.
// Only referenced in combination with --audio --use_real_adm flags.
std::unique_ptr<ScopedCOMInitializer> com_initializer_;
#endif
};
} // namespace webrtc
#endif // VIDEO_VIDEO_QUALITY_TEST_H_
|
