zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Revert of Separating video settings in VideoQualityTest. (patchset #2 id:20001 of https://codereview.webrtc.org/2312613003/ )

Browse Source 
Reason for revert:
Breaks webrtc_perf_tests on Windows, Mac and Linux (that test don't run on trybots):
https://build.chromium.org/p/client.webrtc/builders/Linux64%20Release%20%5Blarge%20tests%5D/builds/8841/steps/webrtc_perf_tests/logs/stdio

Example:
[ RUN      ] FullStackTest.ForemanCifWithoutPacketLossVp9

# Fatal error in ../../webrtc/video/video_quality_test.cc, line 1056
# last system error: 34
# Check failed: !params_.audio.enabled

Original issue's description:
> Separating video settings in VideoQualityTest.
>
> This is a simple refactoring of VideoQualityTest. It will help in adding audio related settings to VideoQualityTest.
>
> BUG=
>
> Committed: https://crrev.com/f07fb0013164bdb031dcc88dc83365a27643b2d9
> Cr-Commit-Position: refs/heads/master@{#14139}

TBR=stefan@webrtc.org,minyue@webrtc.org
# Skipping CQ checks because original CL landed less than 1 days ago.
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true
BUG=

Review-Url: https://codereview.webrtc.org/2325723002
Cr-Commit-Position: refs/heads/master@{#14142}
This commit is contained in:
kjellander
2016-09-08 10:52:38 -07:00
committed by Commit bot
parent 906f403088
commit 5865f48dcb
5 changed files with 192 additions and 202 deletions
Download Patch File Download Diff File Expand all files Collapse all files

189
webrtc/video/full_stack.cc
View File

@ -24,20 +24,22 @@ class FullStackTest : public VideoQualityTest {
void ForemanCifWithoutPacketLoss(const std::string& video_codec) {
// TODO(pbos): Decide on psnr/ssim thresholds for foreman_cif.
VideoQualityTest::Params foreman_cif;
foreman_cif.video = {true, 352, 288, 30, 700000, 700000, 700000, false,
video_codec, 1, 0, 0, false, "foreman_cif"};
foreman_cif.analyzer = {"foreman_cif_net_delay_0_0_plr_0_" + video_codec,
0.0, 0.0, kFullStackTestDurationSecs};
VideoQualityTest::Params foreman_cif = {
{352, 288, 30, 700000, 700000, 700000, false, video_codec, 1},
{"foreman_cif"},
{},
{"foreman_cif_net_delay_0_0_plr_0_" + video_codec, 0.0, 0.0,
kFullStackTestDurationSecs}};
RunTest(foreman_cif);
}
void ForemanCifPlr5(const std::string& video_codec) {
VideoQualityTest::Params foreman_cif;
foreman_cif.video = {true, 352, 288, 30, 30000, 500000, 2000000, false,
video_codec, 1, 0, 0, false, "foreman_cif"};
foreman_cif.analyzer = {"foreman_cif_delay_50_0_plr_5_" + video_codec, 0.0,
0.0, kFullStackTestDurationSecs};
VideoQualityTest::Params foreman_cif = {
{352, 288, 30, 30000, 500000, 2000000, false, video_codec, 1},
{"foreman_cif"},
{},
{"foreman_cif_delay_50_0_plr_5_" + video_codec, 0.0, 0.0,
kFullStackTestDurationSecs}};
foreman_cif.pipe.loss_percent = 5;
foreman_cif.pipe.queue_delay_ms = 50;
RunTest(foreman_cif);
@ -65,41 +67,42 @@ TEST_F(FullStackTest, ForemanCifPlr5Vp9) {
#endif // !defined(RTC_DISABLE_VP9)
TEST_F(FullStackTest, ParisQcifWithoutPacketLoss) {
VideoQualityTest::Params paris_qcif;
paris_qcif.video = {true, 176, 144, 30, 300000, 300000, 300000, false,
"VP8", 1, 0, 0, true, "paris_qcif"};
paris_qcif.analyzer = {"net_delay_0_0_plr_0", 36.0, 0.96,
kFullStackTestDurationSecs};
VideoQualityTest::Params paris_qcif = {
{176, 144, 30, 300000, 300000, 300000, false, "VP8", 1, 0, 0, true},
{"paris_qcif"},
{},
{"net_delay_0_0_plr_0", 36.0, 0.96, kFullStackTestDurationSecs}};
RunTest(paris_qcif);
}
TEST_F(FullStackTest, ForemanCifWithoutPacketLoss) {
// TODO(pbos): Decide on psnr/ssim thresholds for foreman_cif.
VideoQualityTest::Params foreman_cif;
foreman_cif.video = {true, 352, 288, 30, 700000, 700000, 700000, false, "VP8",
1, 0, 0, true, "foreman_cif"};
foreman_cif.analyzer = {"foreman_cif_net_delay_0_0_plr_0", 0.0, 0.0,
kFullStackTestDurationSecs};
VideoQualityTest::Params foreman_cif = {
{352, 288, 30, 700000, 700000, 700000, false, "VP8", 1, 0, 0, true},
{"foreman_cif"},
{},
{"foreman_cif_net_delay_0_0_plr_0", 0.0, 0.0,
kFullStackTestDurationSecs}};
RunTest(foreman_cif);
}
TEST_F(FullStackTest, ForemanCifPlr5) {
VideoQualityTest::Params foreman_cif;
foreman_cif.video = {true, 352, 288, 30, 30000, 500000, 2000000, false, "VP8",
1, 0, 0, true, "foreman_cif"};
foreman_cif.analyzer = {"foreman_cif_delay_50_0_plr_5", 0.0, 0.0,
kFullStackTestDurationSecs};
VideoQualityTest::Params foreman_cif = {
{352, 288, 30, 30000, 500000, 2000000, false, "VP8", 1, 0, 0, true},
{"foreman_cif"},
{},
{"foreman_cif_delay_50_0_plr_5", 0.0, 0.0, kFullStackTestDurationSecs}};
foreman_cif.pipe.loss_percent = 5;
foreman_cif.pipe.queue_delay_ms = 50;
RunTest(foreman_cif);
}
TEST_F(FullStackTest, ForemanCif500kbps) {
VideoQualityTest::Params foreman_cif;
foreman_cif.video = {true, 352, 288, 30, 30000, 500000, 2000000, false, "VP8",
1, 0, 0, true, "foreman_cif"};
foreman_cif.analyzer = {"foreman_cif_500kbps", 0.0, 0.0,
kFullStackTestDurationSecs};
VideoQualityTest::Params foreman_cif = {
{352, 288, 30, 30000, 500000, 2000000, false, "VP8", 1, 0, 0, true},
{"foreman_cif"},
{},
{"foreman_cif_500kbps", 0.0, 0.0, kFullStackTestDurationSecs}};
foreman_cif.pipe.queue_length_packets = 0;
foreman_cif.pipe.queue_delay_ms = 0;
foreman_cif.pipe.link_capacity_kbps = 500;
@ -107,11 +110,12 @@ TEST_F(FullStackTest, ForemanCif500kbps) {
}
TEST_F(FullStackTest, ForemanCif500kbpsLimitedQueue) {
VideoQualityTest::Params foreman_cif;
foreman_cif.video = {true, 352, 288, 30, 30000, 500000, 2000000, false, "VP8",
1, 0, 0, true, "foreman_cif"};
foreman_cif.analyzer = {"foreman_cif_500kbps_32pkts_queue", 0.0, 0.0,
kFullStackTestDurationSecs};
VideoQualityTest::Params foreman_cif = {
{352, 288, 30, 30000, 500000, 2000000, false, "VP8", 1, 0, 0, true},
{"foreman_cif"},
{},
{"foreman_cif_500kbps_32pkts_queue", 0.0, 0.0,
kFullStackTestDurationSecs}};
foreman_cif.pipe.queue_length_packets = 32;
foreman_cif.pipe.queue_delay_ms = 0;
foreman_cif.pipe.link_capacity_kbps = 500;
@ -119,11 +123,11 @@ TEST_F(FullStackTest, ForemanCif500kbpsLimitedQueue) {
}
TEST_F(FullStackTest, ForemanCif500kbps100ms) {
VideoQualityTest::Params foreman_cif;
foreman_cif.video = {true, 352, 288, 30, 30000, 500000, 2000000, false, "VP8",
1, 0, 0, true, "foreman_cif"};
foreman_cif.analyzer = {"foreman_cif_500kbps_100ms", 0.0, 0.0,
kFullStackTestDurationSecs};
VideoQualityTest::Params foreman_cif = {
{352, 288, 30, 30000, 500000, 2000000, false, "VP8", 1, 0, 0, true},
{"foreman_cif"},
{},
{"foreman_cif_500kbps_100ms", 0.0, 0.0, kFullStackTestDurationSecs}};
foreman_cif.pipe.queue_length_packets = 0;
foreman_cif.pipe.queue_delay_ms = 100;
foreman_cif.pipe.link_capacity_kbps = 500;
@ -131,11 +135,12 @@ TEST_F(FullStackTest, ForemanCif500kbps100ms) {
}
TEST_F(FullStackTest, ForemanCif500kbps100msLimitedQueue) {
VideoQualityTest::Params foreman_cif;
foreman_cif.video = {true, 352, 288, 30, 30000, 500000, 2000000, false, "VP8",
1, 0, 0, true, "foreman_cif"};
foreman_cif.analyzer = {"foreman_cif_500kbps_100ms_32pkts_queue", 0.0, 0.0,
kFullStackTestDurationSecs};
VideoQualityTest::Params foreman_cif = {
{352, 288, 30, 30000, 500000, 2000000, false, "VP8", 1, 0, 0, true},
{"foreman_cif"},
{},
{"foreman_cif_500kbps_100ms_32pkts_queue", 0.0, 0.0,
kFullStackTestDurationSecs}};
foreman_cif.pipe.queue_length_packets = 32;
foreman_cif.pipe.queue_delay_ms = 100;
foreman_cif.pipe.link_capacity_kbps = 500;
@ -143,11 +148,12 @@ TEST_F(FullStackTest, ForemanCif500kbps100msLimitedQueue) {
}
TEST_F(FullStackTest, ForemanCif500kbps100msLimitedQueueRecvBwe) {
VideoQualityTest::Params foreman_cif;
foreman_cif.video = {true, 352, 288, 30, 30000, 500000, 2000000, false, "VP8",
1, 0, 0, false, "foreman_cif"};
foreman_cif.analyzer = {"foreman_cif_500kbps_100ms_32pkts_queue", 0.0, 0.0,
kFullStackTestDurationSecs};
VideoQualityTest::Params foreman_cif = {
{352, 288, 30, 30000, 500000, 2000000, false, "VP8", 1, 0, 0, false},
{"foreman_cif"},
{},
{"foreman_cif_500kbps_100ms_32pkts_queue", 0.0, 0.0,
kFullStackTestDurationSecs}};
foreman_cif.pipe.queue_length_packets = 32;
foreman_cif.pipe.queue_delay_ms = 100;
foreman_cif.pipe.link_capacity_kbps = 500;
@ -155,11 +161,12 @@ TEST_F(FullStackTest, ForemanCif500kbps100msLimitedQueueRecvBwe) {
}
TEST_F(FullStackTest, ForemanCif1000kbps100msLimitedQueue) {
VideoQualityTest::Params foreman_cif;
foreman_cif.video = {true, 352, 288, 30, 30000, 2000000, 2000000, false,
"VP8", 1, 0, 0, true, "foreman_cif"};
foreman_cif.analyzer = {"foreman_cif_1000kbps_100ms_32pkts_queue", 0.0, 0.0,
kFullStackTestDurationSecs};
VideoQualityTest::Params foreman_cif = {
{352, 288, 30, 30000, 2000000, 2000000, false, "VP8", 1, 0, 0, true},
{"foreman_cif"},
{},
{"foreman_cif_1000kbps_100ms_32pkts_queue", 0.0, 0.0,
kFullStackTestDurationSecs}};
foreman_cif.pipe.queue_length_packets = 32;
foreman_cif.pipe.queue_delay_ms = 100;
foreman_cif.pipe.link_capacity_kbps = 1000;
@ -167,11 +174,12 @@ TEST_F(FullStackTest, ForemanCif1000kbps100msLimitedQueue) {
}
TEST_F(FullStackTest, ConferenceMotionHd2000kbps100msLimitedQueue) {
VideoQualityTest::Params conf_motion_hd;
conf_motion_hd.video = {true, 1280, 720, 50, 30000, 3000000, 3000000, false,
"VP8", 1, 0, 0, true, "ConferenceMotion_1280_720_50"};
conf_motion_hd.analyzer = {"conference_motion_hd_2000kbps_100ms_32pkts_queue",
0.0, 0.0, kFullStackTestDurationSecs};
VideoQualityTest::Params conf_motion_hd = {
{1280, 720, 50, 30000, 3000000, 3000000, false, "VP8", 1, 0, 0, true},
{"ConferenceMotion_1280_720_50"},
{},
{"conference_motion_hd_2000kbps_100ms_32pkts_queue", 0.0, 0.0,
kFullStackTestDurationSecs}};
conf_motion_hd.pipe.queue_length_packets = 32;
conf_motion_hd.pipe.queue_delay_ms = 100;
conf_motion_hd.pipe.link_capacity_kbps = 2000;
@ -179,32 +187,30 @@ TEST_F(FullStackTest, ConferenceMotionHd2000kbps100msLimitedQueue) {
}
TEST_F(FullStackTest, ScreenshareSlidesVP8_2TL) {
VideoQualityTest::Params screenshare;
screenshare.video = {true, 1850, 1110, 5, 50000, 200000, 2000000, false,
"VP8", 2, 1, 400000, true, ""};
screenshare.screenshare = {true, 10};
screenshare.analyzer = {"screenshare_slides", 0.0, 0.0,
kFullStackTestDurationSecs};
VideoQualityTest::Params screenshare = {
{1850, 1110, 5, 50000, 200000, 2000000, false, "VP8", 2, 1, 400000, true},
{},
{true, 10},
{"screenshare_slides", 0.0, 0.0, kFullStackTestDurationSecs}};
RunTest(screenshare);
}
TEST_F(FullStackTest, ScreenshareSlidesVP8_2TL_Scroll) {
VideoQualityTest::Params config;
config.video = {true, 1850, 1110 / 2, 5, 50000, 200000, 2000000, false,
"VP8", 2, 1, 400000, true, ""};
config.screenshare = {true, 10, 2};
config.analyzer = {"screenshare_slides_scrolling", 0.0, 0.0,
kFullStackTestDurationSecs};
VideoQualityTest::Params config = {
{1850, 1110 / 2, 5, 50000, 200000, 2000000, false, "VP8", 2, 1, 400000,
true},
{},
{true, 10, 2},
{"screenshare_slides_scrolling", 0.0, 0.0, kFullStackTestDurationSecs}};
RunTest(config);
}
TEST_F(FullStackTest, ScreenshareSlidesVP8_2TL_LossyNet) {
VideoQualityTest::Params screenshare;
screenshare.video = {true, 1850, 1110, 5, 50000, 200000, 2000000, false,
"VP8", 2, 1, 400000, true, ""};
screenshare.screenshare = {true, 10};
screenshare.analyzer = {"screenshare_slides_lossy_net", 0.0, 0.0,
kFullStackTestDurationSecs};
VideoQualityTest::Params screenshare = {
{1850, 1110, 5, 50000, 200000, 2000000, false, "VP8", 2, 1, 400000, true},
{}, // Video-specific.
{true, 10}, // Screenshare-specific.
{"screenshare_slides_lossy_net", 0.0, 0.0, kFullStackTestDurationSecs}};
screenshare.pipe.loss_percent = 5;
screenshare.pipe.queue_delay_ms = 200;
screenshare.pipe.link_capacity_kbps = 500;
@ -212,12 +218,11 @@ TEST_F(FullStackTest, ScreenshareSlidesVP8_2TL_LossyNet) {
}
TEST_F(FullStackTest, ScreenshareSlidesVP8_2TL_VeryLossyNet) {
VideoQualityTest::Params screenshare;
screenshare.video = {true, 1850, 1110, 5, 50000, 200000, 2000000, false,
"VP8", 2, 1, 400000, true, ""};
screenshare.screenshare = {true, 10};
screenshare.analyzer = {"screenshare_slides_very_lossy", 0.0, 0.0,
kFullStackTestDurationSecs};
VideoQualityTest::Params screenshare = {
{1850, 1110, 5, 50000, 200000, 2000000, false, "VP8", 2, 1, 400000, true},
{}, // Video-specific.
{true, 10}, // Screenshare-specific.
{"screenshare_slides_very_lossy", 0.0, 0.0, kFullStackTestDurationSecs}};
screenshare.pipe.loss_percent = 10;
screenshare.pipe.queue_delay_ms = 200;
screenshare.pipe.link_capacity_kbps = 500;
@ -226,14 +231,14 @@ TEST_F(FullStackTest, ScreenshareSlidesVP8_2TL_VeryLossyNet) {
#if !defined(RTC_DISABLE_VP9)
TEST_F(FullStackTest, ScreenshareSlidesVP9_2SL) {
VideoQualityTest::Params screenshare;
screenshare.video = {true, 1850, 1110, 5, 50000, 200000, 2000000, false,
"VP9", 1, 0, 400000, true, ""};
screenshare.screenshare = {true, 10};
screenshare.analyzer = {"screenshare_slides_vp9_2sl", 0.0, 0.0,
kFullStackTestDurationSecs};
screenshare.logs = false;
screenshare.ss = {std::vector<VideoStream>(), 0, 2, 1};
VideoQualityTest::Params screenshare = {
{1850, 1110, 5, 50000, 200000, 2000000, false, "VP9", 1, 0, 400000, true},
{},
{true, 10},
{"screenshare_slides_vp9_2sl", 0.0, 0.0, kFullStackTestDurationSecs},
{},
false,
{std::vector<VideoStream>(), 0, 2, 1}};
RunTest(screenshare);
}
#endif // !defined(RTC_DISABLE_VP9)

24
webrtc/video/screenshare_loopback.cc
View File

@ -224,28 +224,20 @@ void Loopback() {
call_bitrate_config.max_bitrate_bps = flags::MaxBitrateKbps() * 1000;
VideoQualityTest::Params params;
params.call = {flags::FLAGS_send_side_bwe, call_bitrate_config};
params.video = {true,
flags::Width(),
flags::Height(),
flags::Fps(),
flags::MinBitrateKbps() * 1000,
flags::TargetBitrateKbps() * 1000,
flags::MaxBitrateKbps() * 1000,
false,
flags::Codec(),
flags::NumTemporalLayers(),
flags::SelectedTL(),
flags::MinTransmitBitrateKbps() * 1000,
false,
""};
params.audio = {false, false};
params.common = {flags::Width(), flags::Height(), flags::Fps(),
flags::MinBitrateKbps() * 1000, flags::TargetBitrateKbps() * 1000,
flags::MaxBitrateKbps() * 1000, false, flags::Codec(),
flags::NumTemporalLayers(), flags::SelectedTL(),
flags::MinTransmitBitrateKbps() * 1000, flags::FLAGS_send_side_bwe,
false, call_bitrate_config};
params.screenshare = {true, flags::SlideChangeInterval(),
flags::ScrollDuration()};
params.analyzer = {"screenshare", 0.0, 0.0, flags::DurationSecs(),
flags::OutputFilename(), flags::GraphTitle()};
params.pipe = pipe_config;
params.logs = flags::FLAGS_logs;
params.audio = false;
params.audio_video_sync = false;
std::vector<std::string> stream_descriptors;
stream_descriptors.push_back(flags::Stream0());

25
webrtc/video/video_loopback.cc
View File

@ -230,26 +230,19 @@ void Loopback() {
call_bitrate_config.max_bitrate_bps = flags::MaxBitrateKbps() * 1000;
VideoQualityTest::Params params;
params.call = {flags::FLAGS_send_side_bwe, call_bitrate_config};
params.video = {true,
flags::Width(),
flags::Height(),
flags::Fps(),
flags::MinBitrateKbps() * 1000,
flags::TargetBitrateKbps() * 1000,
flags::MaxBitrateKbps() * 1000,
flags::FLAGS_suspend_below_min_bitrate,
flags::Codec(),
flags::NumTemporalLayers(),
flags::SelectedTL(),
0, // No min transmit bitrate.
flags::FLAGS_use_fec,
flags::Clip()};
params.audio = {flags::FLAGS_audio, flags::FLAGS_audio_video_sync};
params.common = {flags::Width(), flags::Height(), flags::Fps(),
flags::MinBitrateKbps() * 1000, flags::TargetBitrateKbps() * 1000,
flags::MaxBitrateKbps() * 1000, flags::FLAGS_suspend_below_min_bitrate,
flags::Codec(), flags::NumTemporalLayers(), flags::SelectedTL(),
0, // No min transmit bitrate.
flags::FLAGS_send_side_bwe, flags::FLAGS_use_fec, call_bitrate_config};
params.video = {flags::Clip()};
params.analyzer = {"video", 0.0, 0.0, flags::DurationSecs(),
flags::OutputFilename(), flags::GraphTitle()};
params.pipe = pipe_config;
params.logs = flags::FLAGS_logs;
params.audio = flags::FLAGS_audio,
params.audio_video_sync = flags::FLAGS_audio_video_sync;
std::vector<std::string> stream_descriptors;
stream_descriptors.push_back(flags::Stream0());

136
webrtc/video/video_quality_test.cc
View File

@ -751,9 +751,9 @@ void VideoQualityTest::TestBody() {}
std::string VideoQualityTest::GenerateGraphTitle() const {
std::stringstream ss;
ss << params_.video.codec;
ss << " (" << params_.video.target_bitrate_bps / 1000 << "kbps";
ss << ", " << params_.video.fps << " FPS";
ss << params_.common.codec;
ss << " (" << params_.common.target_bitrate_bps / 1000 << "kbps";
ss << ", " << params_.common.fps << " FPS";
if (params_.screenshare.scroll_duration)
ss << ", " << params_.screenshare.scroll_duration << "s scroll";
if (params_.ss.streams.size() > 1)
@ -778,23 +778,25 @@ void VideoQualityTest::CheckParams() {
// retransmitting the wrong packets.
RTC_CHECK(params_.ss.selected_sl == -1 ||
params_.ss.selected_sl == params_.ss.num_spatial_layers - 1);
RTC_CHECK(params_.video.selected_tl == -1 ||
params_.video.selected_tl ==
params_.video.num_temporal_layers - 1);
RTC_CHECK(params_.common.selected_tl == -1 ||
params_.common.selected_tl ==
params_.common.num_temporal_layers - 1);
}
// TODO(ivica): Should max_bitrate_bps == -1 represent inf max bitrate, as it
// does in some parts of the code?
RTC_CHECK_GE(params_.video.max_bitrate_bps, params_.video.target_bitrate_bps);
RTC_CHECK_GE(params_.video.target_bitrate_bps, params_.video.min_bitrate_bps);
RTC_CHECK_LT(params_.video.selected_tl, params_.video.num_temporal_layers);
RTC_CHECK_GE(params_.common.max_bitrate_bps,
params_.common.target_bitrate_bps);
RTC_CHECK_GE(params_.common.target_bitrate_bps,
params_.common.min_bitrate_bps);
RTC_CHECK_LT(params_.common.selected_tl, params_.common.num_temporal_layers);
RTC_CHECK_LT(params_.ss.selected_stream, params_.ss.streams.size());
for (const VideoStream& stream : params_.ss.streams) {
RTC_CHECK_GE(stream.min_bitrate_bps, 0);
RTC_CHECK_GE(stream.target_bitrate_bps, stream.min_bitrate_bps);
RTC_CHECK_GE(stream.max_bitrate_bps, stream.target_bitrate_bps);
RTC_CHECK_EQ(static_cast<int>(stream.temporal_layer_thresholds_bps.size()),
params_.video.num_temporal_layers - 1);
params_.common.num_temporal_layers - 1);
}
// TODO(ivica): Should we check if the sum of all streams/layers is equal to
// the total bitrate? We anyway have to update them in the case bitrate
@ -804,9 +806,9 @@ void VideoQualityTest::CheckParams() {
RTC_CHECK(params_.ss.spatial_layers.empty() ||
params_.ss.spatial_layers.size() ==
static_cast<size_t>(params_.ss.num_spatial_layers));
if (params_.video.codec == "VP8") {
if (params_.common.codec == "VP8") {
RTC_CHECK_EQ(params_.ss.num_spatial_layers, 1);
} else if (params_.video.codec == "VP9") {
} else if (params_.common.codec == "VP9") {
RTC_CHECK_EQ(params_.ss.streams.size(), 1u);
}
}
@ -842,14 +844,14 @@ std::vector<int> VideoQualityTest::ParseCSV(const std::string& str) {
// Static.
VideoStream VideoQualityTest::DefaultVideoStream(const Params& params) {
VideoStream stream;
stream.width = params.video.width;
stream.height = params.video.height;
stream.max_framerate = params.video.fps;
stream.min_bitrate_bps = params.video.min_bitrate_bps;
stream.target_bitrate_bps = params.video.target_bitrate_bps;
stream.max_bitrate_bps = params.video.max_bitrate_bps;
stream.width = params.common.width;
stream.height = params.common.height;
stream.max_framerate = params.common.fps;
stream.min_bitrate_bps = params.common.min_bitrate_bps;
stream.target_bitrate_bps = params.common.target_bitrate_bps;
stream.max_bitrate_bps = params.common.max_bitrate_bps;
stream.max_qp = 52;
if (params.video.num_temporal_layers == 2)
if (params.common.num_temporal_layers == 2)
stream.temporal_layer_thresholds_bps.push_back(stream.target_bitrate_bps);
return stream;
}
@ -892,7 +894,7 @@ void VideoQualityTest::FillScalabilitySettings(
stream.temporal_layer_thresholds_bps.end(), v.begin() + 7, v.end());
} else {
// Automatic TL thresholds for more than two layers not supported.
RTC_CHECK_LE(params->video.num_temporal_layers, 2);
RTC_CHECK_LE(params->common.num_temporal_layers, 2);
}
params->ss.streams.push_back(stream);
}
@ -924,13 +926,13 @@ void VideoQualityTest::SetupCommon(Transport* send_transport,
CreateSendConfig(num_streams, 0, send_transport);
int payload_type;
if (params_.video.codec == "H264") {
if (params_.common.codec == "H264") {
encoder_.reset(VideoEncoder::Create(VideoEncoder::kH264));
payload_type = kPayloadTypeH264;
} else if (params_.video.codec == "VP8") {
} else if (params_.common.codec == "VP8") {
encoder_.reset(VideoEncoder::Create(VideoEncoder::kVp8));
payload_type = kPayloadTypeVP8;
} else if (params_.video.codec == "VP9") {
} else if (params_.common.codec == "VP9") {
encoder_.reset(VideoEncoder::Create(VideoEncoder::kVp9));
payload_type = kPayloadTypeVP9;
} else {
@ -938,7 +940,7 @@ void VideoQualityTest::SetupCommon(Transport* send_transport,
return;
}
video_send_config_.encoder_settings.encoder = encoder_.get();
video_send_config_.encoder_settings.payload_name = params_.video.codec;
video_send_config_.encoder_settings.payload_name = params_.common.codec;
video_send_config_.encoder_settings.payload_type = payload_type;
video_send_config_.rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
video_send_config_.rtp.rtx.payload_type = kSendRtxPayloadType;
@ -946,7 +948,7 @@ void VideoQualityTest::SetupCommon(Transport* send_transport,
video_send_config_.rtp.rtx.ssrcs.push_back(kSendRtxSsrcs[i]);
video_send_config_.rtp.extensions.clear();
if (params_.call.send_side_bwe) {
if (params_.common.send_side_bwe) {
video_send_config_.rtp.extensions.push_back(
RtpExtension(RtpExtension::kTransportSequenceNumberUri,
test::kTransportSequenceNumberExtensionId));
@ -956,7 +958,7 @@ void VideoQualityTest::SetupCommon(Transport* send_transport,
}
video_encoder_config_.min_transmit_bitrate_bps =
params_.video.min_transmit_bps;
params_.common.min_transmit_bps;
video_encoder_config_.streams = params_.ss.streams;
video_encoder_config_.spatial_layers = params_.ss.spatial_layers;
@ -967,7 +969,7 @@ void VideoQualityTest::SetupCommon(Transport* send_transport,
video_receive_configs_[i].rtp.rtx[payload_type].ssrc = kSendRtxSsrcs[i];
video_receive_configs_[i].rtp.rtx[payload_type].payload_type =
kSendRtxPayloadType;
video_receive_configs_[i].rtp.transport_cc = params_.call.send_side_bwe;
video_receive_configs_[i].rtp.transport_cc = params_.common.send_side_bwe;
}
}
@ -976,19 +978,19 @@ void VideoQualityTest::SetupScreenshare() {
// Fill out codec settings.
video_encoder_config_.content_type = VideoEncoderConfig::ContentType::kScreen;
if (params_.video.codec == "VP8") {
if (params_.common.codec == "VP8") {
codec_settings_.VP8 = VideoEncoder::GetDefaultVp8Settings();
codec_settings_.VP8.denoisingOn = false;
codec_settings_.VP8.frameDroppingOn = false;
codec_settings_.VP8.numberOfTemporalLayers =
static_cast<unsigned char>(params_.video.num_temporal_layers);
static_cast<unsigned char>(params_.common.num_temporal_layers);
video_encoder_config_.encoder_specific_settings = &codec_settings_.VP8;
} else if (params_.video.codec == "VP9") {
} else if (params_.common.codec == "VP9") {
codec_settings_.VP9 = VideoEncoder::GetDefaultVp9Settings();
codec_settings_.VP9.denoisingOn = false;
codec_settings_.VP9.frameDroppingOn = false;
codec_settings_.VP9.numberOfTemporalLayers =
static_cast<unsigned char>(params_.video.num_temporal_layers);
static_cast<unsigned char>(params_.common.num_temporal_layers);
video_encoder_config_.encoder_specific_settings = &codec_settings_.VP9;
codec_settings_.VP9.numberOfSpatialLayers =
static_cast<unsigned char>(params_.ss.num_spatial_layers);
@ -1007,10 +1009,10 @@ void VideoQualityTest::SetupScreenshare() {
// Cycle image every slide_change_interval seconds.
frame_generator_.reset(test::FrameGenerator::CreateFromYuvFile(
slides, kWidth, kHeight,
params_.screenshare.slide_change_interval * params_.video.fps));
params_.screenshare.slide_change_interval * params_.common.fps));
} else {
RTC_CHECK_LE(params_.video.width, kWidth);
RTC_CHECK_LE(params_.video.height, kHeight);
RTC_CHECK_LE(params_.common.width, kWidth);
RTC_CHECK_LE(params_.common.height, kHeight);
RTC_CHECK_GT(params_.screenshare.slide_change_interval, 0);
const int kPauseDurationMs = (params_.screenshare.slide_change_interval -
params_.screenshare.scroll_duration) *
@ -1020,8 +1022,8 @@ void VideoQualityTest::SetupScreenshare() {
frame_generator_.reset(
test::FrameGenerator::CreateScrollingInputFromYuvFiles(
clock_, slides, kWidth, kHeight, params_.video.width,
params_.video.height, params_.screenshare.scroll_duration * 1000,
clock_, slides, kWidth, kHeight, params_.common.width,
params_.common.height, params_.screenshare.scroll_duration * 1000,
kPauseDurationMs));
}
}
@ -1030,18 +1032,18 @@ void VideoQualityTest::CreateCapturer(VideoCaptureInput* input) {
if (params_.screenshare.enabled) {
test::FrameGeneratorCapturer* frame_generator_capturer =
new test::FrameGeneratorCapturer(
clock_, input, frame_generator_.release(), params_.video.fps);
clock_, input, frame_generator_.release(), params_.common.fps);
EXPECT_TRUE(frame_generator_capturer->Init());
capturer_.reset(frame_generator_capturer);
} else {
if (params_.video.clip_name.empty()) {
capturer_.reset(test::VideoCapturer::Create(input, params_.video.width,
params_.video.height,
params_.video.fps, clock_));
capturer_.reset(test::VideoCapturer::Create(input, params_.common.width,
params_.common.height,
params_.common.fps, clock_));
} else {
capturer_.reset(test::FrameGeneratorCapturer::CreateFromYuvFile(
input, test::ResourcePath(params_.video.clip_name, "yuv"),
params_.video.width, params_.video.height, params_.video.fps,
params_.common.width, params_.common.height, params_.common.fps,
clock_));
ASSERT_TRUE(capturer_) << "Could not create capturer for "
<< params_.video.clip_name
@ -1053,7 +1055,7 @@ void VideoQualityTest::CreateCapturer(VideoCaptureInput* input) {
void VideoQualityTest::RunWithAnalyzer(const Params& params) {
params_ = params;
RTC_CHECK(!params_.audio.enabled);
RTC_CHECK(!params_.audio);
// TODO(ivica): Merge with RunWithRenderer and use a flag / argument to
// differentiate between the analyzer and the renderer case.
CheckParams();
@ -1068,13 +1070,13 @@ void VideoQualityTest::RunWithAnalyzer(const Params& params) {
}
Call::Config call_config;
call_config.bitrate_config = params_.call.call_bitrate_config;
call_config.bitrate_config = params.common.call_bitrate_config;
CreateCalls(call_config, call_config);
test::LayerFilteringTransport send_transport(
params_.pipe, sender_call_.get(), kPayloadTypeVP8, kPayloadTypeVP9,
params_.video.selected_tl, params_.ss.selected_sl);
test::DirectTransport recv_transport(params_.pipe, receiver_call_.get());
params.pipe, sender_call_.get(), kPayloadTypeVP8, kPayloadTypeVP9,
params.common.selected_tl, params_.ss.selected_sl);
test::DirectTransport recv_transport(params.pipe, receiver_call_.get());
std::string graph_title = params_.analyzer.graph_title;
if (graph_title.empty())
@ -1090,8 +1092,8 @@ void VideoQualityTest::RunWithAnalyzer(const Params& params) {
? params_.ss.selected_sl
: params_.ss.num_spatial_layers - 1;
bool disable_quality_check =
selected_stream.width != params_.video.width ||
selected_stream.height != params_.video.height ||
selected_stream.width != params_.common.width ||
selected_stream.height != params_.common.height ||
(!params_.ss.spatial_layers.empty() &&
params_.ss.spatial_layers[selected_sl].scaling_factor_num !=
params_.ss.spatial_layers[selected_sl].scaling_factor_den);
@ -1105,7 +1107,7 @@ void VideoQualityTest::RunWithAnalyzer(const Params& params) {
&send_transport, params_.analyzer.test_label,
disable_quality_check ? -1.1 : params_.analyzer.avg_psnr_threshold,
disable_quality_check ? -1.1 : params_.analyzer.avg_ssim_threshold,
params_.analyzer.test_durations_secs * params_.video.fps,
params_.analyzer.test_durations_secs * params_.common.fps,
graph_data_output_file, graph_title,
kVideoSendSsrcs[params_.ss.selected_stream]);
@ -1156,8 +1158,8 @@ void VideoQualityTest::RunWithRenderers(const Params& params) {
CheckParams();
std::unique_ptr<test::VideoRenderer> local_preview(
test::VideoRenderer::Create("Local Preview", params_.video.width,
params_.video.height));
test::VideoRenderer::Create("Local Preview", params_.common.width,
params_.common.height));
size_t stream_id = params_.ss.selected_stream;
std::string title = "Loopback Video";
if (params_.ss.streams.size() > 1) {
@ -1174,10 +1176,10 @@ void VideoQualityTest::RunWithRenderers(const Params& params) {
// TODO(ivica): Remove bitrate_config and use the default Call::Config(), to
// match the full stack tests.
Call::Config call_config;
call_config.bitrate_config = params_.call.call_bitrate_config;
call_config.bitrate_config = params_.common.call_bitrate_config;
::VoiceEngineState voe;
if (params_.audio.enabled) {
if (params_.audio) {
CreateVoiceEngine(&voe, decoder_factory_);
AudioState::Config audio_state_config;
audio_state_config.voice_engine = voe.voice_engine;
@ -1188,7 +1190,7 @@ void VideoQualityTest::RunWithRenderers(const Params& params) {
test::LayerFilteringTransport transport(
params.pipe, call.get(), kPayloadTypeVP8, kPayloadTypeVP9,
params.video.selected_tl, params_.ss.selected_sl);
params.common.selected_tl, params_.ss.selected_sl);
// TODO(ivica): Use two calls to be able to merge with RunWithAnalyzer or at
// least share as much code as possible. That way this test would also match
// the full stack tests better.
@ -1198,13 +1200,13 @@ void VideoQualityTest::RunWithRenderers(const Params& params) {
video_send_config_.pre_encode_callback = local_preview.get();
video_receive_configs_[stream_id].renderer = loopback_video.get();
if (params_.audio.enabled && params_.audio.sync_video)
if (params_.audio && params_.audio_video_sync)
video_receive_configs_[stream_id].sync_group = kSyncGroup;
video_send_config_.suspend_below_min_bitrate =
params_.video.suspend_below_min_bitrate;
params_.common.suspend_below_min_bitrate;
if (params.video.fec) {
if (params.common.fec) {
video_send_config_.rtp.fec.red_payload_type = kRedPayloadType;
video_send_config_.rtp.fec.ulpfec_payload_type = kUlpfecPayloadType;
video_receive_configs_[stream_id].rtp.fec.red_payload_type =
@ -1223,7 +1225,7 @@ void VideoQualityTest::RunWithRenderers(const Params& params) {
CreateCapturer(video_send_stream_->Input());
AudioReceiveStream* audio_receive_stream = nullptr;
if (params_.audio.enabled) {
if (params_.audio) {
audio_send_config_ = AudioSendStream::Config(&transport);
audio_send_config_.voe_channel_id = voe.send_channel_id;
audio_send_config_.rtp.ssrc = kAudioSendSsrc;
@ -1231,7 +1233,7 @@ void VideoQualityTest::RunWithRenderers(const Params& params) {
// Add extension to enable audio send side BWE, and allow audio bit rate
// adaptation.
audio_send_config_.rtp.extensions.clear();
if (params_.call.send_side_bwe) {
if (params_.common.send_side_bwe) {
audio_send_config_.rtp.extensions.push_back(webrtc::RtpExtension(
webrtc::RtpExtension::kTransportSequenceNumberUri,
test::kTransportSequenceNumberExtensionId));
@ -1246,10 +1248,10 @@ void VideoQualityTest::RunWithRenderers(const Params& params) {
audio_config.rtcp_send_transport = &transport;
audio_config.voe_channel_id = voe.receive_channel_id;
audio_config.rtp.remote_ssrc = audio_send_config_.rtp.ssrc;
audio_config.rtp.transport_cc = params_.call.send_side_bwe;
audio_config.rtp.transport_cc = params_.common.send_side_bwe;
audio_config.rtp.extensions = audio_send_config_.rtp.extensions;
audio_config.decoder_factory = decoder_factory_;
if (params_.audio.sync_video)
if (params_.audio_video_sync)
audio_config.sync_group = kSyncGroup;
audio_receive_stream =call->CreateAudioReceiveStream(audio_config);
@ -1263,7 +1265,7 @@ void VideoQualityTest::RunWithRenderers(const Params& params) {
video_send_stream_->Start();
capturer_->Start();
if (params_.audio.enabled) {
if (params_.audio) {
// Start receiving audio.
audio_receive_stream->Start();
EXPECT_EQ(0, voe.base->StartPlayout(voe.receive_channel_id));
@ -1276,7 +1278,7 @@ void VideoQualityTest::RunWithRenderers(const Params& params) {
test::PressEnterToContinue();
if (params_.audio.enabled) {
if (params_.audio) {
// Stop sending audio.
EXPECT_EQ(0, voe.base->StopSend(voe.send_channel_id));
audio_send_stream_->Stop();
@ -1295,13 +1297,13 @@ void VideoQualityTest::RunWithRenderers(const Params& params) {
call->DestroyVideoReceiveStream(video_receive_stream);
call->DestroyVideoSendStream(video_send_stream_);
if (params_.audio.enabled) {
call->DestroyAudioSendStream(audio_send_stream_);
call->DestroyAudioReceiveStream(audio_receive_stream);
if (params_.audio) {
call->DestroyAudioSendStream(audio_send_stream_);
call->DestroyAudioReceiveStream(audio_receive_stream);
}
transport.StopSending();
if (params_.audio.enabled)
if (params_.audio)
DestroyVoiceEngine(&voe);
}

20
webrtc/video/video_quality_test.h
View File

@ -28,11 +28,6 @@ class VideoQualityTest : public test::CallTest {
// which makes the implementation of VideoQualityTest a bit uglier.
struct Params {
struct {
bool send_side_bwe;
Call::Config::BitrateConfig call_bitrate_config;
} call;
struct {
bool enabled;
size_t width;
size_t height;
int32_t fps;
@ -44,19 +39,20 @@ class VideoQualityTest : public test::CallTest {
int num_temporal_layers;
int selected_tl;
int min_transmit_bps;
bool send_side_bwe;
bool fec;
Call::Config::BitrateConfig call_bitrate_config;
} common;
struct { // Video-specific settings.
std::string clip_name;
} video;
struct {
bool enabled;
bool sync_video;
} audio;
struct {
struct { // Screenshare-specific settings.
bool enabled;
int32_t slide_change_interval;
int32_t scroll_duration;
} screenshare;
struct {
struct { // Analyzer settings.
std::string test_label;
double avg_psnr_threshold; // (*)
double avg_ssim_threshold; // (*)
@ -74,6 +70,8 @@ class VideoQualityTest : public test::CallTest {
// If empty, bitrates are generated in VP9Impl automatically.
std::vector<SpatialLayer> spatial_layers;
} ss;
bool audio;
bool audio_video_sync;
};
// (*) Set to -1.1 if generating graph data for simulcast or SVC and the
// selected stream/layer doesn't have the same resolution as the largest