Clean up EncoderStreamFactory
* Simplified ctor. Get settings (max_qp, content_type, etc) from encoder_config passed to CreateEncoderStreams().
* Some tests assigned VideoEncoderConfig::video_stream_factory to EncoderStreamFactory they created. That's not really needed. VideoStreamEncoder creates the factory if video_stream_factory is not provided [1]. Removed video_stream_factory initialization in tests.
[1] https://source.chromium.org/chromium/chromium/src/+/main:third_party/webrtc/video/video_stream_encoder.cc;l=1002;drc=1d7d0e6e2c5002815853be251ce43fe88779ac85
Bug: b/347150850, webrtc:42233936
Change-Id: Ie0322abb6c48e1a9bd10e9ed3879e3ed484fea5d
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/355321
Reviewed-by: Erik Språng <sprang@webrtc.org>
Reviewed-by: Björn Terelius <terelius@webrtc.org>
Commit-Queue: Sergey Silkin <ssilkin@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#42608}
diff --git a/media/engine/fake_webrtc_call.cc b/media/engine/fake_webrtc_call.cc
index f5a1f69..894f69f 100644
--- a/media/engine/fake_webrtc_call.cc
+++ b/media/engine/fake_webrtc_call.cc
@@ -259,11 +259,8 @@
encoder_config_);
} else {
webrtc::VideoEncoder::EncoderInfo encoder_info;
- auto factory = rtc::make_ref_counted<cricket::EncoderStreamFactory>(
- encoder_config_.video_format.name, encoder_config_.max_qp,
- encoder_config_.content_type ==
- webrtc::VideoEncoderConfig::ContentType::kScreen,
- encoder_config_.legacy_conference_mode, encoder_info);
+ auto factory =
+ rtc::make_ref_counted<cricket::EncoderStreamFactory>(encoder_info);
video_streams_ = factory->CreateEncoderStreams(
env_.field_trials(), frame.width(), frame.height(), encoder_config_);
@@ -302,10 +299,8 @@
env_.field_trials(), width, height, config);
} else {
webrtc::VideoEncoder::EncoderInfo encoder_info;
- auto factory = rtc::make_ref_counted<cricket::EncoderStreamFactory>(
- config.video_format.name, config.max_qp,
- config.content_type == webrtc::VideoEncoderConfig::ContentType::kScreen,
- config.legacy_conference_mode, encoder_info);
+ auto factory =
+ rtc::make_ref_counted<cricket::EncoderStreamFactory>(encoder_info);
video_streams_ = factory->CreateEncoderStreams(env_.field_trials(), width,
height, config);
diff --git a/media/engine/webrtc_video_engine.cc b/media/engine/webrtc_video_engine.cc
index 75031fe..ac7d0f8 100644
--- a/media/engine/webrtc_video_engine.cc
+++ b/media/engine/webrtc_video_engine.cc
@@ -2240,21 +2240,10 @@
// Ensure frame dropping is always enabled.
encoder_config.frame_drop_enabled = true;
- int max_qp;
- switch (encoder_config.codec_type) {
- case webrtc::kVideoCodecH264:
- case webrtc::kVideoCodecH265:
- max_qp = kDefaultVideoMaxQpH26x;
- break;
- case webrtc::kVideoCodecVP8:
- case webrtc::kVideoCodecVP9:
- case webrtc::kVideoCodecAV1:
- case webrtc::kVideoCodecGeneric:
- max_qp = kDefaultVideoMaxQpVpx;
- break;
+ int max_qp = -1;
+ if (codec.GetParam(kCodecParamMaxQuantization, &max_qp) && max_qp > 0) {
+ encoder_config.max_qp = max_qp;
}
- codec.GetParam(kCodecParamMaxQuantization, &max_qp);
- encoder_config.max_qp = max_qp;
return encoder_config;
}
diff --git a/modules/video_coding/BUILD.gn b/modules/video_coding/BUILD.gn
index 606a49f..7b8ac7c 100644
--- a/modules/video_coding/BUILD.gn
+++ b/modules/video_coding/BUILD.gn
@@ -442,6 +442,7 @@
"../../rtc_base/system:file_wrapper",
"../../rtc_base/system:no_unique_address",
"../../rtc_base/task_utils:repeating_task",
+ "../../video/config:encoder_config",
"../rtp_rtcp:rtp_rtcp_format",
"svc:scalability_mode_util",
"//third_party/abseil-cpp/absl/numeric:bits",
diff --git a/modules/video_coding/utility/simulcast_utility.cc b/modules/video_coding/utility/simulcast_utility.cc
index 824f4b0..b637e7f 100644
--- a/modules/video_coding/utility/simulcast_utility.cc
+++ b/modules/video_coding/utility/simulcast_utility.cc
@@ -75,7 +75,18 @@
bool SimulcastUtility::IsConferenceModeScreenshare(const VideoCodec& codec) {
return codec.mode == VideoCodecMode::kScreensharing &&
- codec.legacy_conference_mode;
+ codec.legacy_conference_mode &&
+ (codec.codecType == kVideoCodecVP8 ||
+ codec.codecType == kVideoCodecH264);
+}
+
+bool SimulcastUtility::IsConferenceModeScreenshare(
+ const VideoEncoderConfig& encoder_config) {
+ return encoder_config.content_type ==
+ VideoEncoderConfig::ContentType::kScreen &&
+ encoder_config.legacy_conference_mode &&
+ (encoder_config.codec_type == webrtc::VideoCodecType::kVideoCodecVP8 ||
+ encoder_config.codec_type == webrtc::VideoCodecType::kVideoCodecH264);
}
int SimulcastUtility::NumberOfTemporalLayers(const VideoCodec& codec,
diff --git a/modules/video_coding/utility/simulcast_utility.h b/modules/video_coding/utility/simulcast_utility.h
index e25a594..4270f91 100644
--- a/modules/video_coding/utility/simulcast_utility.h
+++ b/modules/video_coding/utility/simulcast_utility.h
@@ -14,6 +14,7 @@
#include <stdint.h>
#include "api/video_codecs/video_codec.h"
+#include "video/config/video_encoder_config.h"
namespace webrtc {
@@ -26,6 +27,8 @@
static int NumberOfTemporalLayers(const VideoCodec& codec, int spatial_id);
// TODO(sprang): Remove this hack when ScreenshareLayers is gone.
static bool IsConferenceModeScreenshare(const VideoCodec& codec);
+ static bool IsConferenceModeScreenshare(
+ const VideoEncoderConfig& encoder_config);
};
} // namespace webrtc
diff --git a/rtc_tools/rtp_generator/rtp_generator.cc b/rtc_tools/rtp_generator/rtp_generator.cc
index 0c6d3e3..ade169a 100644
--- a/rtc_tools/rtp_generator/rtp_generator.cc
+++ b/rtc_tools/rtp_generator/rtp_generator.cc
@@ -237,11 +237,6 @@
encoder_config.simulcast_layers[i].max_framerate = send_config.video_fps;
}
- encoder_config.video_stream_factory =
- rtc::make_ref_counted<cricket::EncoderStreamFactory>(
- video_config.rtp.payload_name, /*max qp*/ 56, /*screencast*/ false,
- /*screenshare enabled*/ false, encoder_info);
-
// Setup the fake video stream for this.
std::unique_ptr<test::FrameGeneratorCapturer> frame_generator =
std::make_unique<test::FrameGeneratorCapturer>(
diff --git a/test/scenario/video_stream.cc b/test/scenario/video_stream.cc
index 188e89f..eb403f9 100644
--- a/test/scenario/video_stream.cc
+++ b/test/scenario/video_stream.cc
@@ -57,23 +57,7 @@
}
return {};
}
-std::string CodecTypeToCodecName(VideoCodecType codec_type) {
- switch (codec_type) {
- case VideoCodecType::kVideoCodecGeneric:
- return "";
- case VideoCodecType::kVideoCodecVP8:
- return cricket::kVp8CodecName;
- case VideoCodecType::kVideoCodecVP9:
- return cricket::kVp9CodecName;
- case VideoCodecType::kVideoCodecH264:
- return cricket::kH264CodecName;
- case VideoCodecType::kVideoCodecH265:
- return cricket::kH265CodecName;
- default:
- RTC_DCHECK_NOTREACHED();
- }
- return {};
-}
+
VideoEncoderConfig::ContentType ConvertContentType(
VideoStreamConfig::Encoder::ContentType content_type) {
switch (content_type) {
@@ -224,19 +208,6 @@
std::vector<VideoStream>(encoder_config.number_of_streams);
encoder_config.min_transmit_bitrate_bps = config.stream.pad_to_rate.bps();
- std::string cricket_codec = CodecTypeToCodecName(config.encoder.codec);
- if (!cricket_codec.empty()) {
- bool screenshare = config.encoder.content_type ==
- VideoStreamConfig::Encoder::ContentType::kScreen;
- encoder_config.video_stream_factory =
- rtc::make_ref_counted<cricket::EncoderStreamFactory>(
- cricket_codec, cricket::kDefaultVideoMaxQpVpx, screenshare,
- screenshare, encoder_info);
- } else {
- encoder_config.video_stream_factory =
- rtc::make_ref_counted<DefaultVideoStreamFactory>();
- }
-
// TODO(srte): Base this on encoder capabilities.
encoder_config.max_bitrate_bps =
config.encoder.max_data_rate.value_or(DataRate::KilobitsPerSec(10000))
diff --git a/video/config/encoder_stream_factory.cc b/video/config/encoder_stream_factory.cc
index 733e398..936e7f2 100644
--- a/video/config/encoder_stream_factory.cc
+++ b/video/config/encoder_stream_factory.cc
@@ -22,6 +22,7 @@
#include "media/base/media_constants.h"
#include "media/base/video_adapter.h"
#include "modules/video_coding/codecs/vp9/svc_config.h"
+#include "modules/video_coding/utility/simulcast_utility.h"
#include "rtc_base/experiments/min_video_bitrate_experiment.h"
#include "rtc_base/experiments/normalize_simulcast_size_experiment.h"
#include "rtc_base/logging.h"
@@ -60,10 +61,10 @@
return true;
}
-bool IsTemporalLayersSupported(const std::string& codec_name) {
- return absl::EqualsIgnoreCase(codec_name, kVp8CodecName) ||
- absl::EqualsIgnoreCase(codec_name, kVp9CodecName) ||
- absl::EqualsIgnoreCase(codec_name, kAv1CodecName);
+bool IsTemporalLayersSupported(webrtc::VideoCodecType codec_type) {
+ return codec_type == webrtc::VideoCodecType::kVideoCodecVP8 ||
+ codec_type == webrtc::VideoCodecType::kVideoCodecVP9 ||
+ codec_type == webrtc::VideoCodecType::kVideoCodecAV1;
}
size_t FindRequiredActiveLayers(
@@ -97,23 +98,25 @@
return max_bitrate;
}
+int GetDefaultMaxQp(webrtc::VideoCodecType codec_type) {
+ switch (codec_type) {
+ case webrtc::kVideoCodecH264:
+ case webrtc::kVideoCodecH265:
+ return kDefaultVideoMaxQpH26x;
+ case webrtc::kVideoCodecVP8:
+ case webrtc::kVideoCodecVP9:
+ case webrtc::kVideoCodecAV1:
+ case webrtc::kVideoCodecGeneric:
+ return kDefaultVideoMaxQpVpx;
+ }
+}
+
} // namespace
-// TODO(bugs.webrtc.org/8785): Consider removing max_qp as member of
-// EncoderStreamFactory and instead set this value individually for each stream
-// in the VideoEncoderConfig.simulcast_layers.
EncoderStreamFactory::EncoderStreamFactory(
- std::string codec_name,
- int max_qp,
- bool is_screenshare,
- bool conference_mode,
const webrtc::VideoEncoder::EncoderInfo& encoder_info,
absl::optional<webrtc::VideoSourceRestrictions> restrictions)
- : codec_name_(codec_name),
- max_qp_(max_qp),
- is_screenshare_(is_screenshare),
- conference_mode_(conference_mode),
- encoder_info_requested_resolution_alignment_(
+ : encoder_info_requested_resolution_alignment_(
encoder_info.requested_resolution_alignment),
restrictions_(restrictions) {}
@@ -146,9 +149,8 @@
}
}
- if (is_simulcast || ((absl::EqualsIgnoreCase(codec_name_, kVp8CodecName) ||
- absl::EqualsIgnoreCase(codec_name_, kH264CodecName)) &&
- is_screenshare_ && conference_mode_)) {
+ if (is_simulcast ||
+ webrtc::SimulcastUtility::IsConferenceModeScreenshare(encoder_config)) {
return CreateSimulcastOrConferenceModeScreenshareStreams(
trials, frame_width, frame_height, encoder_config,
experimental_min_bitrate);
@@ -164,7 +166,8 @@
int height,
const webrtc::VideoEncoderConfig& encoder_config,
const absl::optional<webrtc::DataRate>& experimental_min_bitrate) const {
- std::vector<webrtc::VideoStream> layers;
+ bool is_screencast = encoder_config.content_type ==
+ webrtc::VideoEncoderConfig::ContentType::kScreen;
// The max bitrate specified by the API.
// - `encoder_config.simulcast_layers[0].max_bitrate_bps` comes from the first
@@ -187,8 +190,7 @@
int max_bitrate_bps =
api_max_bitrate_bps.has_value()
? *api_max_bitrate_bps
- : GetMaxDefaultVideoBitrateKbps(width, height, is_screenshare_) *
- 1000;
+ : GetMaxDefaultVideoBitrateKbps(width, height, is_screencast) * 1000;
int min_bitrate_bps =
experimental_min_bitrate
@@ -234,7 +236,7 @@
kMinLayerSize);
}
- if (absl::EqualsIgnoreCase(codec_name_, kVp9CodecName)) {
+ if (encoder_config.codec_type == webrtc::VideoCodecType::kVideoCodecVP9) {
RTC_DCHECK(encoder_config.encoder_specific_settings);
// Use VP9 SVC layering from codec settings which might be initialized
// though field trial in ConfigureVideoEncoderSettings.
@@ -256,7 +258,7 @@
std::vector<webrtc::SpatialLayer> svc_layers =
webrtc::GetSvcConfig(width, height, max_framerate,
/*first_active_layer=*/0, num_spatial_layers,
- *layer.num_temporal_layers, is_screenshare_);
+ *layer.num_temporal_layers, is_screencast);
int sum_max_bitrates_kbps = 0;
for (const webrtc::SpatialLayer& spatial_layer : svc_layers) {
sum_max_bitrates_kbps += spatial_layer.maxBitrate;
@@ -282,10 +284,15 @@
encoder_config.simulcast_layers[0].target_bitrate_bps, max_bitrate_bps);
}
layer.max_bitrate_bps = max_bitrate_bps;
- layer.max_qp = max_qp_;
layer.bitrate_priority = encoder_config.bitrate_priority;
- if (IsTemporalLayersSupported(codec_name_)) {
+ if (encoder_config.max_qp > 0) {
+ layer.max_qp = encoder_config.max_qp;
+ } else {
+ layer.max_qp = GetDefaultMaxQp(encoder_config.codec_type);
+ }
+
+ if (IsTemporalLayersSupported(encoder_config.codec_type)) {
// Use configured number of temporal layers if set.
if (encoder_config.simulcast_layers[0].num_temporal_layers) {
layer.num_temporal_layers =
@@ -293,8 +300,7 @@
}
}
layer.scalability_mode = encoder_config.simulcast_layers[0].scalability_mode;
- layers.push_back(layer);
- return layers;
+ return {layer};
}
std::vector<webrtc::VideoStream>
@@ -304,17 +310,20 @@
int height,
const webrtc::VideoEncoderConfig& encoder_config,
const absl::optional<webrtc::DataRate>& experimental_min_bitrate) const {
+ bool is_screencast = encoder_config.content_type ==
+ webrtc::VideoEncoderConfig::ContentType::kScreen;
std::vector<webrtc::VideoStream> layers;
- const bool temporal_layers_supported = IsTemporalLayersSupported(codec_name_);
+ const bool temporal_layers_supported =
+ IsTemporalLayersSupported(encoder_config.codec_type);
// Use legacy simulcast screenshare if conference mode is explicitly enabled
// or use the regular simulcast configuration path which is generic.
- layers = GetSimulcastConfig(FindRequiredActiveLayers(encoder_config),
- encoder_config.number_of_streams, width, height,
- encoder_config.bitrate_priority, max_qp_,
- is_screenshare_ && conference_mode_,
- temporal_layers_supported, trials,
- encoder_config.codec_type);
+ layers = GetSimulcastConfig(
+ FindRequiredActiveLayers(encoder_config),
+ encoder_config.number_of_streams, width, height,
+ encoder_config.bitrate_priority, encoder_config.max_qp,
+ webrtc::SimulcastUtility::IsConferenceModeScreenshare(encoder_config),
+ temporal_layers_supported, trials, encoder_config.codec_type);
// Allow an experiment to override the minimum bitrate for the lowest
// spatial layer. The experiment's configuration has the lowest priority.
if (experimental_min_bitrate) {
@@ -355,7 +364,7 @@
encoder_config.simulcast_layers[i].requested_resolution;
// Update with configured num temporal layers if supported by codec.
if (encoder_config.simulcast_layers[i].num_temporal_layers &&
- IsTemporalLayersSupported(codec_name_)) {
+ temporal_layers_supported) {
layers[i].num_temporal_layers =
*encoder_config.simulcast_layers[i].num_temporal_layers;
}
@@ -419,12 +428,21 @@
std::min(layers[i].target_bitrate_bps, layers[i].max_bitrate_bps),
layers[i].min_bitrate_bps);
}
+
+ if (encoder_config.simulcast_layers[i].max_qp > 0) {
+ layers[i].max_qp = encoder_config.simulcast_layers[i].max_qp;
+ } else if (encoder_config.max_qp > 0) {
+ layers[i].max_qp = encoder_config.max_qp;
+ } else {
+ layers[i].max_qp = GetDefaultMaxQp(encoder_config.codec_type);
+ }
+
if (i == layers.size() - 1) {
is_highest_layer_max_bitrate_configured =
encoder_config.simulcast_layers[i].max_bitrate_bps > 0;
}
}
- if (!is_screenshare_ && !is_highest_layer_max_bitrate_configured &&
+ if (!is_screencast && !is_highest_layer_max_bitrate_configured &&
encoder_config.max_bitrate_bps > 0) {
// No application-configured maximum for the largest layer.
// If there is bitrate leftover, give it to the largest layer.
diff --git a/video/config/encoder_stream_factory.h b/video/config/encoder_stream_factory.h
index 92e4403..ef27fb8 100644
--- a/video/config/encoder_stream_factory.h
+++ b/video/config/encoder_stream_factory.h
@@ -24,11 +24,7 @@
class EncoderStreamFactory
: public webrtc::VideoEncoderConfig::VideoStreamFactoryInterface {
public:
- EncoderStreamFactory(std::string codec_name,
- int max_qp,
- bool is_screenshare,
- bool conference_mode,
- const webrtc::VideoEncoder::EncoderInfo& encoder_info,
+ EncoderStreamFactory(const webrtc::VideoEncoder::EncoderInfo& encoder_info,
absl::optional<webrtc::VideoSourceRestrictions>
restrictions = absl::nullopt);
@@ -58,12 +54,6 @@
int in_frame_height,
webrtc::Resolution requested_resolution) const;
- const std::string codec_name_;
- const int max_qp_;
- const bool is_screenshare_;
- // Allows a screenshare specific configuration, which enables temporal
- // layering and various settings.
- const bool conference_mode_;
const int encoder_info_requested_resolution_alignment_;
const absl::optional<webrtc::VideoSourceRestrictions> restrictions_;
};
diff --git a/video/config/encoder_stream_factory_unittest.cc b/video/config/encoder_stream_factory_unittest.cc
index 811b877..47ecf9f 100644
--- a/video/config/encoder_stream_factory_unittest.cc
+++ b/video/config/encoder_stream_factory_unittest.cc
@@ -20,8 +20,6 @@
using ::cricket::EncoderStreamFactory;
using test::ExplicitKeyValueConfig;
-constexpr int kMaxQp = 48;
-
std::vector<Resolution> GetStreamResolutions(
const std::vector<VideoStream>& streams) {
std::vector<Resolution> res;
@@ -45,10 +43,7 @@
TEST(EncoderStreamFactory, SinglecastRequestedResolution) {
ExplicitKeyValueConfig field_trials("");
VideoEncoder::EncoderInfo encoder_info;
- auto factory = rtc::make_ref_counted<EncoderStreamFactory>(
- "VP8", kMaxQp,
- /* is_screenshare= */ false,
- /* conference_mode= */ false, encoder_info);
+ auto factory = rtc::make_ref_counted<EncoderStreamFactory>(encoder_info);
VideoEncoderConfig encoder_config;
encoder_config.number_of_streams = 1;
encoder_config.simulcast_layers.push_back(
@@ -69,10 +64,8 @@
/* target_pixels_per_frame= */ absl::nullopt,
/* max_frame_rate= */ absl::nullopt);
VideoEncoder::EncoderInfo encoder_info;
- auto factory = rtc::make_ref_counted<EncoderStreamFactory>(
- "VP8", kMaxQp,
- /* is_screenshare= */ false,
- /* conference_mode= */ false, encoder_info, restrictions);
+ auto factory =
+ rtc::make_ref_counted<EncoderStreamFactory>(encoder_info, restrictions);
VideoEncoderConfig encoder_config;
encoder_config.number_of_streams = 1;
encoder_config.simulcast_layers.push_back(
diff --git a/video/config/video_encoder_config.cc b/video/config/video_encoder_config.cc
index 84442ae..5cecc45 100644
--- a/video/config/video_encoder_config.cc
+++ b/video/config/video_encoder_config.cc
@@ -59,7 +59,8 @@
bitrate_priority(1.0),
number_of_streams(0),
legacy_conference_mode(false),
- is_quality_scaling_allowed(false) {}
+ is_quality_scaling_allowed(false),
+ max_qp(-1) {}
VideoEncoderConfig::VideoEncoderConfig(VideoEncoderConfig&&) = default;
diff --git a/video/end_to_end_tests/resolution_bitrate_limits_tests.cc b/video/end_to_end_tests/resolution_bitrate_limits_tests.cc
index 2ee1589..7949376 100644
--- a/video/end_to_end_tests/resolution_bitrate_limits_tests.cc
+++ b/video/end_to_end_tests/resolution_bitrate_limits_tests.cc
@@ -147,17 +147,13 @@
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
- webrtc::VideoEncoder::EncoderInfo encoder_info;
send_config->encoder_settings.encoder_factory = &encoder_factory_;
send_config->rtp.payload_name = payload_name_;
send_config->rtp.payload_type =
test::VideoTestConstants::kVideoSendPayloadType;
const VideoCodecType codec_type = PayloadStringToCodecType(payload_name_);
encoder_config->codec_type = codec_type;
- encoder_config->video_stream_factory =
- rtc::make_ref_counted<cricket::EncoderStreamFactory>(
- payload_name_, /*max qp*/ 0, /*screencast*/ false,
- /*screenshare enabled*/ false, encoder_info);
+ encoder_config->video_stream_factory = nullptr;
encoder_config->max_bitrate_bps = -1;
if (configs_.size() == 1 && configs_[0].bitrate.max)
encoder_config->max_bitrate_bps = configs_[0].bitrate.max->bps();
diff --git a/video/quality_scaling_tests.cc b/video/quality_scaling_tests.cc
index 9040b65..cd67e68 100644
--- a/video/quality_scaling_tests.cc
+++ b/video/quality_scaling_tests.cc
@@ -125,7 +125,6 @@
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
- VideoEncoder::EncoderInfo encoder_info;
send_config->encoder_settings.encoder_factory = &encoder_factory_;
send_config->rtp.payload_name = payload_name_;
send_config->rtp.payload_type =
@@ -133,10 +132,6 @@
encoder_config->video_format.name = payload_name_;
const VideoCodecType codec_type = PayloadStringToCodecType(payload_name_);
encoder_config->codec_type = codec_type;
- encoder_config->video_stream_factory =
- rtc::make_ref_counted<cricket::EncoderStreamFactory>(
- payload_name_, /*max_qp=*/0, /*is_screenshare=*/false,
- /*conference_mode=*/false, encoder_info);
encoder_config->max_bitrate_bps =
std::max(start_bps_, encoder_config->max_bitrate_bps);
if (payload_name_ == "VP9") {
diff --git a/video/video_quality_test.cc b/video/video_quality_test.cc
index 3753ec1..0c63953 100644
--- a/video/video_quality_test.cc
+++ b/video/video_quality_test.cc
@@ -617,9 +617,7 @@
encoder_config.spatial_layers = params->ss[video_idx].spatial_layers;
encoder_config.simulcast_layers = std::vector<VideoStream>(num_streams);
encoder_config.video_stream_factory =
- rtc::make_ref_counted<cricket::EncoderStreamFactory>(
- params->video[video_idx].codec, cricket::kDefaultVideoMaxQpVpx,
- params->screenshare[video_idx].enabled, true, encoder_info);
+ rtc::make_ref_counted<cricket::EncoderStreamFactory>(encoder_info);
params->ss[video_idx].streams =
encoder_config.video_stream_factory->CreateEncoderStreams(
env().field_trials(), params->video[video_idx].width,
@@ -799,11 +797,6 @@
video_encoder_configs_[video_idx].simulcast_layers =
params_.ss[video_idx].streams;
}
- video_encoder_configs_[video_idx].video_stream_factory =
- rtc::make_ref_counted<cricket::EncoderStreamFactory>(
- params_.video[video_idx].codec,
- params_.ss[video_idx].streams[0].max_qp,
- params_.screenshare[video_idx].enabled, true, encoder_info);
video_encoder_configs_[video_idx].spatial_layers =
params_.ss[video_idx].spatial_layers;
@@ -823,6 +816,7 @@
// Fill out codec settings.
video_encoder_configs_[video_idx].content_type =
VideoEncoderConfig::ContentType::kScreen;
+ video_encoder_configs_[video_idx].legacy_conference_mode = true;
degradation_preference_ = DegradationPreference::MAINTAIN_RESOLUTION;
if (params_.video[video_idx].codec == "VP8") {
VideoCodecVP8 vp8_settings = VideoEncoder::GetDefaultVp8Settings();
diff --git a/video/video_send_stream_tests.cc b/video/video_send_stream_tests.cc
index 8237354..387695a 100644
--- a/video/video_send_stream_tests.cc
+++ b/video/video_send_stream_tests.cc
@@ -4077,10 +4077,6 @@
test::VideoTestConstants::kVideoSendPayloadType;
encoder_config->video_format.name = payload_name_;
encoder_config->codec_type = PayloadStringToCodecType(payload_name_);
- encoder_config->video_stream_factory =
- rtc::make_ref_counted<cricket::EncoderStreamFactory>(
- payload_name_, /*max_qp=*/56, /*is_screenshare=*/false,
- /*conference_mode=*/false, encoder_info);
encoder_config->max_bitrate_bps = kMaxBitrateBps;
if (absl::EqualsIgnoreCase(payload_name_, "VP9")) {
encoder_config->encoder_specific_settings = rtc::make_ref_counted<
diff --git a/video/video_stream_encoder.cc b/video/video_stream_encoder.cc
index 1e7672c..92f7308 100644
--- a/video/video_stream_encoder.cc
+++ b/video/video_stream_encoder.cc
@@ -996,11 +996,7 @@
encoder_config_);
} else {
auto factory = rtc::make_ref_counted<cricket::EncoderStreamFactory>(
- encoder_config_.video_format.name, encoder_config_.max_qp,
- encoder_config_.content_type ==
- webrtc::VideoEncoderConfig::ContentType::kScreen,
- encoder_config_.legacy_conference_mode, encoder_->GetEncoderInfo(),
- latest_restrictions_);
+ encoder_->GetEncoderInfo(), latest_restrictions_);
streams = factory->CreateEncoderStreams(
env_.field_trials(), last_frame_info_->width, last_frame_info_->height,
diff --git a/video/video_stream_encoder_unittest.cc b/video/video_stream_encoder_unittest.cc
index 6549bd5..aab791f 100644
--- a/video/video_stream_encoder_unittest.cc
+++ b/video/video_stream_encoder_unittest.cc
@@ -2226,16 +2226,12 @@
// Two streams, highest stream active.
VideoEncoderConfig config;
- webrtc::VideoEncoder::EncoderInfo encoder_info;
const int kNumStreams = 2;
test::FillEncoderConfiguration(kVideoCodecVP8, kNumStreams, &config);
config.max_bitrate_bps = 0;
config.simulcast_layers[0].active = false;
config.simulcast_layers[1].active = true;
- config.video_stream_factory =
- rtc::make_ref_counted<cricket::EncoderStreamFactory>(
- "VP8", /*max qp*/ 56, /*screencast*/ false,
- /*screenshare enabled*/ false, encoder_info);
+ config.video_stream_factory = nullptr;
video_stream_encoder_->ConfigureEncoder(config.Copy(), kMaxPayloadLength);
// The encoder bitrate limits for 270p should be used.
@@ -2291,16 +2287,12 @@
DefaultEncoderMaxAndMinBitratesUsedForTwoStreamsHighestActive) {
// Two streams, highest stream active.
VideoEncoderConfig config;
- webrtc::VideoEncoder::EncoderInfo encoder_info;
const int kNumStreams = 2;
test::FillEncoderConfiguration(kVideoCodecVP8, kNumStreams, &config);
config.max_bitrate_bps = 0;
config.simulcast_layers[0].active = false;
config.simulcast_layers[1].active = true;
- config.video_stream_factory =
- rtc::make_ref_counted<cricket::EncoderStreamFactory>(
- "VP8", /*max qp*/ 56, /*screencast*/ false,
- /*screenshare enabled*/ false, encoder_info);
+ config.video_stream_factory = nullptr;
video_stream_encoder_->ConfigureEncoder(config.Copy(), kMaxPayloadLength);
// Default bitrate limits for 270p should be used.
@@ -2365,16 +2357,12 @@
// Three streams, middle stream active.
VideoEncoderConfig config;
- webrtc::VideoEncoder::EncoderInfo encoder_info;
const int kNumStreams = 3;
test::FillEncoderConfiguration(kVideoCodecVP8, kNumStreams, &config);
config.simulcast_layers[0].active = false;
config.simulcast_layers[1].active = true;
config.simulcast_layers[2].active = false;
- config.video_stream_factory =
- rtc::make_ref_counted<cricket::EncoderStreamFactory>(
- "VP8", /*max qp*/ 56, /*screencast*/ false,
- /*screenshare enabled*/ false, encoder_info);
+ config.video_stream_factory = nullptr;
video_stream_encoder_->ConfigureEncoder(config.Copy(), kMaxPayloadLength);
// The encoder bitrate limits for 360p should be used.
@@ -2410,16 +2398,12 @@
// Three streams, lowest stream active.
VideoEncoderConfig config;
- webrtc::VideoEncoder::EncoderInfo encoder_info;
const int kNumStreams = 3;
test::FillEncoderConfiguration(kVideoCodecVP8, kNumStreams, &config);
config.simulcast_layers[0].active = true;
config.simulcast_layers[1].active = false;
config.simulcast_layers[2].active = false;
- config.video_stream_factory =
- rtc::make_ref_counted<cricket::EncoderStreamFactory>(
- "VP8", /*max qp*/ 56, /*screencast*/ false,
- /*screenshare enabled*/ false, encoder_info);
+ config.video_stream_factory = nullptr;
video_stream_encoder_->ConfigureEncoder(config.Copy(), kMaxPayloadLength);
// Resolution on lowest stream lower than 270p. The encoder limits not applied
@@ -2447,16 +2431,12 @@
// Two streams, highest stream active.
VideoEncoderConfig config;
- webrtc::VideoEncoder::EncoderInfo encoder_info;
const int kNumStreams = 2;
test::FillEncoderConfiguration(kVideoCodecVP8, kNumStreams, &config);
config.simulcast_layers[0].active = false;
config.simulcast_layers[1].active = true;
config.simulcast_layers[1].max_bitrate_bps = kMaxBitrateBps;
- config.video_stream_factory =
- rtc::make_ref_counted<cricket::EncoderStreamFactory>(
- "VP8", /*max qp*/ 56, /*screencast*/ false,
- /*screenshare enabled*/ false, encoder_info);
+ config.video_stream_factory = nullptr;
video_stream_encoder_->ConfigureEncoder(config.Copy(), kMaxPayloadLength);
// The encoder bitrate limits for 270p should be used.
@@ -2675,15 +2655,11 @@
// Fill config with the scaling factor by which to reduce encoding size.
const int num_streams = scale_factors_.size();
VideoEncoderConfig config;
- webrtc::VideoEncoder::EncoderInfo encoder_info;
test::FillEncoderConfiguration(kVideoCodecVP8, num_streams, &config);
for (int i = 0; i < num_streams; ++i) {
config.simulcast_layers[i].scale_resolution_down_by = scale_factors_[i];
}
- config.video_stream_factory =
- rtc::make_ref_counted<cricket::EncoderStreamFactory>(
- "VP8", /*max qp*/ 56, /*screencast*/ false,
- /*screenshare enabled*/ false, encoder_info);
+ config.video_stream_factory = nullptr;
video_stream_encoder_->ConfigureEncoder(std::move(config), kMaxPayloadLength);
video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources(
@@ -5842,13 +5818,9 @@
TEST_F(VideoStreamEncoderTest, InitialFrameDropAccountsForResolutionScaling) {
VideoEncoderConfig video_encoder_config;
- webrtc::VideoEncoder::EncoderInfo encoder_info;
test::FillEncoderConfiguration(PayloadStringToCodecType("VP8"), 1,
&video_encoder_config);
- video_encoder_config.video_stream_factory =
- rtc::make_ref_counted<cricket::EncoderStreamFactory>(
- "VP8", /*max qp*/ 56, /*screencast*/ false,
- /*screenshare enabled*/ false, encoder_info);
+ video_encoder_config.video_stream_factory = nullptr;
for (auto& layer : video_encoder_config.simulcast_layers) {
layer.num_temporal_layers = 1;
layer.max_framerate = kDefaultFramerate;
@@ -5894,13 +5866,9 @@
// Trigger QVGA "singlecast"
// Update the config.
VideoEncoderConfig video_encoder_config;
- webrtc::VideoEncoder::EncoderInfo encoder_info;
test::FillEncoderConfiguration(PayloadStringToCodecType("VP8"), 3,
&video_encoder_config);
- video_encoder_config.video_stream_factory =
- rtc::make_ref_counted<cricket::EncoderStreamFactory>(
- "VP8", /*max qp*/ 56, /*screencast*/ false,
- /*screenshare enabled*/ false, encoder_info);
+ video_encoder_config.video_stream_factory = nullptr;
for (auto& layer : video_encoder_config.simulcast_layers) {
layer.num_temporal_layers = 1;
layer.max_framerate = kDefaultFramerate;
@@ -8099,16 +8067,12 @@
const int number_layers =
sizeof(downscale_factors) / sizeof(downscale_factors[0]);
VideoEncoderConfig config;
- webrtc::VideoEncoder::EncoderInfo encoder_info;
test::FillEncoderConfiguration(kVideoCodecVP8, number_layers, &config);
for (int i = 0; i < number_layers; ++i) {
config.simulcast_layers[i].scale_resolution_down_by = downscale_factors[i];
config.simulcast_layers[i].active = true;
}
- config.video_stream_factory =
- rtc::make_ref_counted<cricket::EncoderStreamFactory>(
- "VP8", /*max qp*/ 56, /*screencast*/ false,
- /*screenshare enabled*/ false, encoder_info);
+ config.video_stream_factory = nullptr;
video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources(
kSimulcastTargetBitrate, kSimulcastTargetBitrate, kSimulcastTargetBitrate,
0, 0, 0);
@@ -8225,16 +8189,12 @@
kFrameWidth / kDownscaleFactors[2], kFrameHeight / kDownscaleFactors[2]);
VideoEncoderConfig config;
- webrtc::VideoEncoder::EncoderInfo encoder_info;
test::FillEncoderConfiguration(kVideoCodecVP8, kNumSimulcastLayers, &config);
for (size_t i = 0; i < kNumSimulcastLayers; ++i) {
config.simulcast_layers[i].scale_resolution_down_by = kDownscaleFactors[i];
config.simulcast_layers[i].active = true;
}
- config.video_stream_factory =
- rtc::make_ref_counted<cricket::EncoderStreamFactory>(
- "VP8", /*max qp*/ 56, /*screencast*/ false,
- /*screenshare enabled*/ false, encoder_info);
+ config.video_stream_factory = nullptr;
video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources(
kSimulcastTargetBitrate, kSimulcastTargetBitrate, kSimulcastTargetBitrate,
0, 0, 0);
@@ -8998,7 +8958,6 @@
kFrameWidth / kDownscaleFactors[2], kFrameHeight / kDownscaleFactors[2]);
VideoEncoderConfig config;
- webrtc::VideoEncoder::EncoderInfo encoder_info;
if (codec_type_ == VideoCodecType::kVideoCodecVP9) {
test::FillEncoderConfiguration(codec_type_, 1, &config);
config.max_bitrate_bps = kSimulcastTargetBitrate.bps();
@@ -9048,11 +9007,7 @@
}
};
- config.video_stream_factory =
- rtc::make_ref_counted<cricket::EncoderStreamFactory>(
- CodecTypeToPayloadString(codec_type_), /*max qp*/ 56,
- /*screencast*/ false,
- /*screenshare enabled*/ false, encoder_info);
+ config.video_stream_factory = nullptr;
video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources(
kSimulcastTargetBitrate, kSimulcastTargetBitrate, kSimulcastTargetBitrate,
0, 0, 0);
@@ -9169,15 +9124,10 @@
void ConfigureEncoder(const VideoStream& stream) {
VideoEncoderConfig config;
- webrtc::VideoEncoder::EncoderInfo encoder_info;
-
test::FillEncoderConfiguration(kVideoCodecVP8, /*num_streams=*/1, &config);
config.max_bitrate_bps = stream.max_bitrate_bps;
config.simulcast_layers[0] = stream;
- config.video_stream_factory =
- rtc::make_ref_counted<cricket::EncoderStreamFactory>(
- /*codec_name=*/"VP8", /*max_qp=*/0, /*is_screenshare=*/false,
- /*conference_mode=*/false, encoder_info);
+ config.video_stream_factory = nullptr;
video_stream_encoder_->ConfigureEncoder(std::move(config),
kMaxPayloadLength);
}
