blob: f1b6567ba0292fcac06034ade875f0f618bf0e0b [file] [log] [blame]
/*
* Copyright (c) 2018 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.
*/
#include <string>
#include "api/test/video/function_video_encoder_factory.h"
#include "media/engine/internal_encoder_factory.h"
#include "modules/video_coding/codecs/h264/include/h264.h"
#include "modules/video_coding/codecs/vp8/include/vp8.h"
#include "modules/video_coding/codecs/vp9/include/vp9.h"
#include "test/call_test.h"
#include "test/field_trial.h"
#include "test/frame_generator_capturer.h"
namespace webrtc {
namespace {
constexpr int kWidth = 1280;
constexpr int kHeight = 720;
constexpr int kLowStartBps = 100000;
constexpr int kHighStartBps = 600000;
constexpr size_t kTimeoutMs = 10000; // Some tests are expected to time out.
void SetEncoderSpecific(VideoEncoderConfig* encoder_config,
VideoCodecType type,
bool automatic_resize,
size_t num_spatial_layers) {
if (type == kVideoCodecVP8) {
VideoCodecVP8 vp8 = VideoEncoder::GetDefaultVp8Settings();
vp8.automaticResizeOn = automatic_resize;
encoder_config->encoder_specific_settings = new rtc::RefCountedObject<
VideoEncoderConfig::Vp8EncoderSpecificSettings>(vp8);
} else if (type == kVideoCodecVP9) {
VideoCodecVP9 vp9 = VideoEncoder::GetDefaultVp9Settings();
vp9.automaticResizeOn = automatic_resize;
vp9.numberOfSpatialLayers = num_spatial_layers;
encoder_config->encoder_specific_settings = new rtc::RefCountedObject<
VideoEncoderConfig::Vp9EncoderSpecificSettings>(vp9);
}
}
} // namespace
class QualityScalingTest : public test::CallTest {
protected:
void RunTest(const std::string& payload_name,
const std::vector<bool>& streams_active,
int start_bps,
bool automatic_resize,
bool expect_adaptation);
const std::string kPrefix = "WebRTC-Video-QualityScaling/Enabled-";
const std::string kEnd = ",0,0,0.9995,0.9999,1/";
};
void QualityScalingTest::RunTest(const std::string& payload_name,
const std::vector<bool>& streams_active,
int start_bps,
bool automatic_resize,
bool expect_adaptation) {
class ScalingObserver
: public test::SendTest,
public test::FrameGeneratorCapturer::SinkWantsObserver {
public:
ScalingObserver(const std::string& payload_name,
const std::vector<bool>& streams_active,
int start_bps,
bool automatic_resize,
bool expect_adaptation)
: SendTest(expect_adaptation ? kDefaultTimeoutMs : kTimeoutMs),
encoder_factory_([](const SdpVideoFormat& format)
-> std::unique_ptr<VideoEncoder> {
if (format.name == "VP8")
return VP8Encoder::Create();
if (format.name == "VP9")
return VP9Encoder::Create();
if (format.name == "H264")
return H264Encoder::Create(cricket::VideoCodec("H264"));
RTC_NOTREACHED() << format.name;
return nullptr;
}),
payload_name_(payload_name),
streams_active_(streams_active),
start_bps_(start_bps),
automatic_resize_(automatic_resize),
expect_adaptation_(expect_adaptation) {}
private:
void OnFrameGeneratorCapturerCreated(
test::FrameGeneratorCapturer* frame_generator_capturer) override {
frame_generator_capturer->SetSinkWantsObserver(this);
// Set initial resolution.
frame_generator_capturer->ChangeResolution(kWidth, kHeight);
}
// Called when FrameGeneratorCapturer::AddOrUpdateSink is called.
void OnSinkWantsChanged(rtc::VideoSinkInterface<VideoFrame>* sink,
const rtc::VideoSinkWants& wants) override {
if (wants.max_pixel_count < kWidth * kHeight)
observation_complete_.Set();
}
void ModifySenderBitrateConfig(
BitrateConstraints* bitrate_config) override {
bitrate_config->start_bitrate_bps = start_bps_;
}
size_t GetNumVideoStreams() const override {
return (payload_name_ == "VP9") ? 1 : streams_active_.size();
}
void ModifyVideoConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
send_config->encoder_settings.encoder_factory = &encoder_factory_;
send_config->rtp.payload_name = payload_name_;
send_config->rtp.payload_type = kVideoSendPayloadType;
encoder_config->video_format.name = payload_name_;
const VideoCodecType codec_type = PayloadStringToCodecType(payload_name_);
encoder_config->codec_type = codec_type;
encoder_config->max_bitrate_bps =
std::max(start_bps_, encoder_config->max_bitrate_bps);
if (payload_name_ == "VP9") {
// Simulcast layers indicates which spatial layers are active.
encoder_config->simulcast_layers.resize(streams_active_.size());
}
double scale_factor = 1.0;
for (int i = streams_active_.size() - 1; i >= 0; --i) {
VideoStream& stream = encoder_config->simulcast_layers[i];
stream.active = streams_active_[i];
stream.scale_resolution_down_by = scale_factor;
scale_factor *= (payload_name_ == "VP9") ? 1.0 : 2.0;
}
SetEncoderSpecific(encoder_config, codec_type, automatic_resize_,
streams_active_.size());
}
void PerformTest() override {
EXPECT_EQ(expect_adaptation_, Wait())
<< "Timed out while waiting for a scale down.";
}
test::FunctionVideoEncoderFactory encoder_factory_;
const std::string payload_name_;
const std::vector<bool> streams_active_;
const int start_bps_;
const bool automatic_resize_;
const bool expect_adaptation_;
} test(payload_name, streams_active, start_bps, automatic_resize,
expect_adaptation);
RunBaseTest(&test);
}
TEST_F(QualityScalingTest, AdaptsDownForHighQp_Vp8) {
// qp_low:1, qp_high:1 -> kHighQp
test::ScopedFieldTrials field_trials(kPrefix + "1,1,0,0,0,0" + kEnd);
RunTest("VP8", {true}, kHighStartBps,
/*automatic_resize=*/true, /*expect_adaptation=*/true);
}
TEST_F(QualityScalingTest, NoAdaptDownForHighQpIfScalingOff_Vp8) {
// qp_low:1, qp_high:1 -> kHighQp
test::ScopedFieldTrials field_trials(kPrefix + "1,1,0,0,0,0" + kEnd);
RunTest("VP8", {true}, kHighStartBps,
/*automatic_resize=*/false, /*expect_adaptation=*/false);
}
TEST_F(QualityScalingTest, NoAdaptDownForNormalQp_Vp8) {
// qp_low:1, qp_high:127 -> kNormalQp
test::ScopedFieldTrials field_trials(kPrefix + "1,127,0,0,0,0" + kEnd);
RunTest("VP8", {true}, kHighStartBps,
/*automatic_resize=*/true, /*expect_adaptation=*/false);
}
TEST_F(QualityScalingTest, AdaptsDownForLowStartBitrate_Vp8) {
// qp_low:1, qp_high:127 -> kNormalQp
test::ScopedFieldTrials field_trials(kPrefix + "1,127,0,0,0,0" + kEnd);
RunTest("VP8", {true}, kLowStartBps,
/*automatic_resize=*/true, /*expect_adaptation=*/true);
}
TEST_F(QualityScalingTest, NoAdaptDownForLowStartBitrate_Simulcast) {
// qp_low:1, qp_high:127 -> kNormalQp
test::ScopedFieldTrials field_trials(kPrefix + "1,127,0,0,0,0" + kEnd);
RunTest("VP8", {true, true}, kLowStartBps,
/*automatic_resize=*/false, /*expect_adaptation=*/false);
}
TEST_F(QualityScalingTest, AdaptsDownForHighQp_HighestStreamActive_Vp8) {
// qp_low:1, qp_high:1 -> kHighQp
test::ScopedFieldTrials field_trials(kPrefix + "1,1,0,0,0,0" + kEnd);
RunTest("VP8", {false, false, true}, kHighStartBps,
/*automatic_resize=*/true, /*expect_adaptation=*/true);
}
TEST_F(QualityScalingTest,
AdaptsDownForLowStartBitrate_HighestStreamActive_Vp8) {
// qp_low:1, qp_high:127 -> kNormalQp
test::ScopedFieldTrials field_trials(kPrefix + "1,127,0,0,0,0" + kEnd);
RunTest("VP8", {false, false, true}, kLowStartBps,
/*automatic_resize=*/true, /*expect_adaptation=*/true);
}
TEST_F(QualityScalingTest, NoAdaptDownForHighQp_LowestStreamActive_Vp8) {
// qp_low:1, qp_high:1 -> kHighQp
test::ScopedFieldTrials field_trials(kPrefix + "1,1,0,0,0,0" + kEnd);
RunTest("VP8", {true, false, false}, kHighStartBps,
/*automatic_resize=*/true, /*expect_adaptation=*/false);
}
TEST_F(QualityScalingTest,
NoAdaptDownForLowStartBitrate_LowestStreamActive_Vp8) {
// qp_low:1, qp_high:127 -> kNormalQp
test::ScopedFieldTrials field_trials(kPrefix + "1,127,0,0,0,0" + kEnd);
RunTest("VP8", {true, false, false}, kLowStartBps,
/*automatic_resize=*/true, /*expect_adaptation=*/false);
}
TEST_F(QualityScalingTest, NoAdaptDownForLowStartBitrateIfScalingOff_Vp8) {
// qp_low:1, qp_high:127 -> kNormalQp
test::ScopedFieldTrials field_trials(kPrefix + "1,127,0,0,0,0" + kEnd);
RunTest("VP8", {true}, kLowStartBps,
/*automatic_resize=*/false, /*expect_adaptation=*/false);
}
TEST_F(QualityScalingTest, AdaptsDownForHighQp_Vp9) {
// qp_low:1, qp_high:1 -> kHighQp
test::ScopedFieldTrials field_trials(kPrefix + "0,0,1,1,0,0" + kEnd +
"WebRTC-VP9QualityScaler/Enabled/");
RunTest("VP9", {true}, kHighStartBps,
/*automatic_resize=*/true, /*expect_adaptation=*/true);
}
TEST_F(QualityScalingTest, NoAdaptDownForHighQpIfScalingOff_Vp9) {
// qp_low:1, qp_high:1 -> kHighQp
test::ScopedFieldTrials field_trials(kPrefix + "0,0,1,1,0,0" + kEnd +
"WebRTC-VP9QualityScaler/Disabled/");
RunTest("VP9", {true}, kHighStartBps,
/*automatic_resize=*/true, /*expect_adaptation=*/false);
}
TEST_F(QualityScalingTest, AdaptsDownForLowStartBitrate_Vp9) {
// qp_low:1, qp_high:255 -> kNormalQp
test::ScopedFieldTrials field_trials(kPrefix + "0,0,1,255,0,0" + kEnd +
"WebRTC-VP9QualityScaler/Enabled/");
RunTest("VP9", {true}, kLowStartBps,
/*automatic_resize=*/true, /*expect_adaptation=*/true);
}
TEST_F(QualityScalingTest, NoAdaptDownForHighQp_LowestStreamActive_Vp9) {
// qp_low:1, qp_high:1 -> kHighQp
test::ScopedFieldTrials field_trials(kPrefix + "0,0,1,1,0,0" + kEnd +
"WebRTC-VP9QualityScaler/Enabled/");
RunTest("VP9", {true, false, false}, kHighStartBps,
/*automatic_resize=*/true, /*expect_adaptation=*/false);
}
TEST_F(QualityScalingTest,
NoAdaptDownForLowStartBitrate_LowestStreamActive_Vp9) {
// qp_low:1, qp_high:255 -> kNormalQp
test::ScopedFieldTrials field_trials(kPrefix + "0,0,1,255,0,0" + kEnd +
"WebRTC-VP9QualityScaler/Enabled/");
RunTest("VP9", {true, false, false}, kLowStartBps,
/*automatic_resize=*/true, /*expect_adaptation=*/false);
}
TEST_F(QualityScalingTest, AdaptsDownForHighQp_MiddleStreamActive_Vp9) {
// qp_low:1, qp_high:1 -> kHighQp
test::ScopedFieldTrials field_trials(kPrefix + "0,0,1,1,0,0" + kEnd +
"WebRTC-VP9QualityScaler/Enabled/");
RunTest("VP9", {false, true, false}, kHighStartBps,
/*automatic_resize=*/true, /*expect_adaptation=*/true);
}
TEST_F(QualityScalingTest,
AdaptsDownForLowStartBitrate_MiddleStreamActive_Vp9) {
// qp_low:1, qp_high:255 -> kNormalQp
test::ScopedFieldTrials field_trials(kPrefix + "0,0,1,255,0,0" + kEnd +
"WebRTC-VP9QualityScaler/Enabled/");
RunTest("VP9", {false, true, false}, kLowStartBps,
/*automatic_resize=*/true, /*expect_adaptation=*/true);
}
#if defined(WEBRTC_USE_H264)
TEST_F(QualityScalingTest, AdaptsDownForHighQp_H264) {
// qp_low:1, qp_high:1 -> kHighQp
test::ScopedFieldTrials field_trials(kPrefix + "0,0,0,0,1,1" + kEnd);
RunTest("H264", {true}, kHighStartBps,
/*automatic_resize=*/true, /*expect_adaptation=*/true);
}
TEST_F(QualityScalingTest, AdaptsDownForLowStartBitrate_H264) {
// qp_low:1, qp_high:51 -> kNormalQp
test::ScopedFieldTrials field_trials(kPrefix + "0,0,0,0,1,51" + kEnd);
RunTest("H264", {true}, kLowStartBps,
/*automatic_resize=*/true, /*expect_adaptation=*/true);
}
#endif // defined(WEBRTC_USE_H264)
} // namespace webrtc