diff --git a/api/video_codecs/BUILD.gn b/api/video_codecs/BUILD.gn index bcf11cb7a1..444a8fcaeb 100644 --- a/api/video_codecs/BUILD.gn +++ b/api/video_codecs/BUILD.gn @@ -322,7 +322,6 @@ rtc_library("rtc_software_fallback_wrappers") { "../../rtc_base:logging", "../../rtc_base/experiments:field_trial_parser", "../../rtc_base/system:rtc_export", - "../../system_wrappers:field_trial", "../../system_wrappers:metrics", "../video:encoded_image", "../video:video_bitrate_allocation", diff --git a/api/video_codecs/test/video_encoder_software_fallback_wrapper_unittest.cc b/api/video_codecs/test/video_encoder_software_fallback_wrapper_unittest.cc index 6a21ecf29a..9438b0d594 100644 --- a/api/video_codecs/test/video_encoder_software_fallback_wrapper_unittest.cc +++ b/api/video_codecs/test/video_encoder_software_fallback_wrapper_unittest.cc @@ -18,6 +18,8 @@ #include #include "absl/types/optional.h" +#include "api/environment/environment.h" +#include "api/environment/environment_factory.h" #include "api/fec_controller_override.h" #include "api/scoped_refptr.h" #include "api/test/mock_video_encoder.h" @@ -34,18 +36,20 @@ #include "modules/video_coding/include/video_error_codes.h" #include "modules/video_coding/utility/simulcast_rate_allocator.h" #include "rtc_base/fake_clock.h" +#include "test/explicit_key_value_config.h" #include "test/fake_encoder.h" #include "test/fake_texture_frame.h" -#include "test/field_trial.h" #include "test/gmock.h" #include "test/gtest.h" namespace webrtc { +namespace { + +using test::ExplicitKeyValueConfig; using ::testing::_; using ::testing::Return; using ::testing::ValuesIn; -namespace { const int kWidth = 320; const int kHeight = 240; const int kNumCores = 2; @@ -87,12 +91,12 @@ class FakeEncodedImageCallback : public EncodedImageCallback { class VideoEncoderSoftwareFallbackWrapperTestBase : public ::testing::Test { protected: VideoEncoderSoftwareFallbackWrapperTestBase( - const std::string& field_trials, + const Environment& env, std::unique_ptr sw_encoder) - : override_field_trials_(field_trials), - fake_encoder_(new CountingFakeEncoder()), + : fake_encoder_(new CountingFakeEncoder()), wrapper_initialized_(false), fallback_wrapper_(CreateVideoEncoderSoftwareFallbackWrapper( + env, std::move(sw_encoder), std::unique_ptr(fake_encoder_), false)) {} @@ -168,7 +172,6 @@ class VideoEncoderSoftwareFallbackWrapperTestBase : public ::testing::Test { fallback_wrapper_->GetEncoderInfo().implementation_name); } - test::ScopedFieldTrials override_field_trials_; FakeEncodedImageCallback callback_; // `fake_encoder_` is owned and released by `fallback_wrapper_`. CountingFakeEncoder* fake_encoder_; @@ -188,7 +191,7 @@ class VideoEncoderSoftwareFallbackWrapperTest explicit VideoEncoderSoftwareFallbackWrapperTest( CountingFakeEncoder* fake_sw_encoder) : VideoEncoderSoftwareFallbackWrapperTestBase( - "", + CreateEnvironment(), std::unique_ptr(fake_sw_encoder)), fake_sw_encoder_(fake_sw_encoder) { fake_sw_encoder_->implementation_name_ = "fake_sw_encoder"; @@ -485,9 +488,9 @@ const char kFieldTrial[] = "WebRTC-VP8-Forced-Fallback-Encoder-v2"; class ForcedFallbackTest : public VideoEncoderSoftwareFallbackWrapperTestBase { public: - explicit ForcedFallbackTest(const std::string& field_trials) - : VideoEncoderSoftwareFallbackWrapperTestBase(field_trials, - VP8Encoder::Create()) {} + explicit ForcedFallbackTest(const Environment& env) + : VideoEncoderSoftwareFallbackWrapperTestBase(env, + CreateVp8Encoder(env)) {} ~ForcedFallbackTest() override {} @@ -550,15 +553,19 @@ class ForcedFallbackTest : public VideoEncoderSoftwareFallbackWrapperTestBase { class ForcedFallbackTestEnabled : public ForcedFallbackTest { public: ForcedFallbackTestEnabled() - : ForcedFallbackTest(std::string(kFieldTrial) + "/Enabled-" + - std::to_string(kMinPixelsPerFrame) + "," + - std::to_string(kWidth * kHeight) + ",30000/") {} + : ForcedFallbackTest( + CreateEnvironment(std::make_unique( + std::string(kFieldTrial) + "/Enabled-" + + std::to_string(kMinPixelsPerFrame) + "," + + std::to_string(kWidth * kHeight) + ",30000/"))) {} }; class ForcedFallbackTestDisabled : public ForcedFallbackTest { public: ForcedFallbackTestDisabled() - : ForcedFallbackTest(std::string(kFieldTrial) + "/Disabled/") {} + : ForcedFallbackTest( + CreateEnvironment(std::make_unique( + std::string(kFieldTrial) + "/Disabled/"))) {} }; TEST_F(ForcedFallbackTestDisabled, NoFallbackWithoutFieldTrial) { @@ -704,8 +711,9 @@ TEST(SoftwareFallbackEncoderTest, BothRateControllersNotTrusted) { std::unique_ptr wrapper = CreateVideoEncoderSoftwareFallbackWrapper( - std::unique_ptr(sw_encoder), - std::unique_ptr(hw_encoder)); + CreateEnvironment(), std::unique_ptr(sw_encoder), + std::unique_ptr(hw_encoder), + /*prefer_temporal_support=*/false); EXPECT_FALSE(wrapper->GetEncoderInfo().has_trusted_rate_controller); } @@ -719,8 +727,9 @@ TEST(SoftwareFallbackEncoderTest, SwRateControllerTrusted) { std::unique_ptr wrapper = CreateVideoEncoderSoftwareFallbackWrapper( - std::unique_ptr(sw_encoder), - std::unique_ptr(hw_encoder)); + CreateEnvironment(), std::unique_ptr(sw_encoder), + std::unique_ptr(hw_encoder), + /*prefer_temporal_support=*/false); EXPECT_FALSE(wrapper->GetEncoderInfo().has_trusted_rate_controller); } @@ -734,8 +743,9 @@ TEST(SoftwareFallbackEncoderTest, HwRateControllerTrusted) { std::unique_ptr wrapper = CreateVideoEncoderSoftwareFallbackWrapper( - std::unique_ptr(sw_encoder), - std::unique_ptr(hw_encoder)); + CreateEnvironment(), std::unique_ptr(sw_encoder), + std::unique_ptr(hw_encoder), + /*prefer_temporal_support=*/false); EXPECT_TRUE(wrapper->GetEncoderInfo().has_trusted_rate_controller); VideoCodec codec_ = {}; @@ -764,8 +774,9 @@ TEST(SoftwareFallbackEncoderTest, BothRateControllersTrusted) { std::unique_ptr wrapper = CreateVideoEncoderSoftwareFallbackWrapper( - std::unique_ptr(sw_encoder), - std::unique_ptr(hw_encoder)); + CreateEnvironment(), std::unique_ptr(sw_encoder), + std::unique_ptr(hw_encoder), + /*prefer_temporal_support=*/false); EXPECT_TRUE(wrapper->GetEncoderInfo().has_trusted_rate_controller); } @@ -779,8 +790,9 @@ TEST(SoftwareFallbackEncoderTest, ReportsHardwareAccelerated) { std::unique_ptr wrapper = CreateVideoEncoderSoftwareFallbackWrapper( - std::unique_ptr(sw_encoder), - std::unique_ptr(hw_encoder)); + CreateEnvironment(), std::unique_ptr(sw_encoder), + std::unique_ptr(hw_encoder), + /*prefer_temporal_support=*/false); EXPECT_TRUE(wrapper->GetEncoderInfo().is_hardware_accelerated); VideoCodec codec_ = {}; @@ -808,8 +820,9 @@ TEST(SoftwareFallbackEncoderTest, ConfigureHardwareOnSecondAttempt) { std::unique_ptr wrapper = CreateVideoEncoderSoftwareFallbackWrapper( - std::unique_ptr(sw_encoder), - std::unique_ptr(hw_encoder)); + CreateEnvironment(), std::unique_ptr(sw_encoder), + std::unique_ptr(hw_encoder), + /*prefer_temporal_support=*/false); EXPECT_TRUE(wrapper->GetEncoderInfo().is_hardware_accelerated); // Initialize the encoder. When HW attempt fails we fallback to SW. @@ -850,7 +863,8 @@ class PreferTemporalLayersFallbackTest : public ::testing::Test { .WillRepeatedly(Return(WEBRTC_VIDEO_CODEC_OK)); wrapper_ = CreateVideoEncoderSoftwareFallbackWrapper( - std::unique_ptr(sw_), std::unique_ptr(hw_), + CreateEnvironment(), std::unique_ptr(sw_), + std::unique_ptr(hw_), /*prefer_temporal_support=*/true); codec_settings.codecType = kVideoCodecVP8; @@ -1123,15 +1137,15 @@ INSTANTIATE_TEST_SUITE_P( TEST_P(ResolutionBasedFallbackTest, VerifyForcedEncoderFallback) { const ResolutionBasedFallbackTestParams& params = GetParam(); - test::ScopedFieldTrials field_trials(params.field_trials); - auto primary = new test::FakeEncoder(Clock::GetRealTimeClock()); - auto fallback = new test::FakeEncoder(Clock::GetRealTimeClock()); - auto encoder = CreateVideoEncoderSoftwareFallbackWrapper( - std::unique_ptr(fallback), - std::unique_ptr(primary), - /*prefer_temporal_support=*/false); + const Environment env = CreateEnvironment( + std::make_unique(params.field_trials)); + auto primary = std::make_unique(env); primary->SetImplementationName("primary"); + auto fallback = std::make_unique(env); fallback->SetImplementationName("fallback"); + auto encoder = CreateVideoEncoderSoftwareFallbackWrapper( + env, std::move(fallback), std::move(primary), + /*prefer_temporal_support=*/false); VideoCodec codec; codec.codecType = params.codec_type; codec.width = params.width; diff --git a/api/video_codecs/video_encoder_software_fallback_wrapper.cc b/api/video_codecs/video_encoder_software_fallback_wrapper.cc index e50b5086e8..00d7053ded 100644 --- a/api/video_codecs/video_encoder_software_fallback_wrapper.cc +++ b/api/video_codecs/video_encoder_software_fallback_wrapper.cc @@ -19,7 +19,9 @@ #include "absl/strings/match.h" #include "absl/types/optional.h" +#include "api/environment/environment.h" #include "api/fec_controller_override.h" +#include "api/field_trials_view.h" #include "api/transport/field_trial_based_config.h" #include "api/video/i420_buffer.h" #include "api/video/video_bitrate_allocation.h" @@ -33,7 +35,6 @@ #include "rtc_base/checks.h" #include "rtc_base/experiments/field_trial_parser.h" #include "rtc_base/logging.h" -#include "system_wrappers/include/field_trial.h" namespace webrtc { @@ -81,13 +82,13 @@ const char kVp8ForceFallbackEncoderFieldTrial[] = "WebRTC-VP8-Forced-Fallback-Encoder-v2"; absl::optional ParseFallbackParamsFromFieldTrials( + const FieldTrialsView& field_trials, const VideoEncoder& main_encoder) { // Ignore WebRTC-VP8-Forced-Fallback-Encoder-v2 if // WebRTC-Video-EncoderFallbackSettings is present. FieldTrialOptional resolution_threshold_px("resolution_threshold_px"); - ParseFieldTrial( - {&resolution_threshold_px}, - FieldTrialBasedConfig().Lookup("WebRTC-Video-EncoderFallbackSettings")); + ParseFieldTrial({&resolution_threshold_px}, + field_trials.Lookup("WebRTC-Video-EncoderFallbackSettings")); if (resolution_threshold_px) { ForcedFallbackParams params; params.enable_resolution_based_switch = true; @@ -96,7 +97,7 @@ absl::optional ParseFallbackParamsFromFieldTrials( } const std::string field_trial = - webrtc::field_trial::FindFullName(kVp8ForceFallbackEncoderFieldTrial); + field_trials.Lookup(kVp8ForceFallbackEncoderFieldTrial); if (!absl::StartsWith(field_trial, "Enabled")) { return absl::nullopt; } @@ -125,10 +126,11 @@ absl::optional ParseFallbackParamsFromFieldTrials( } absl::optional GetForcedFallbackParams( + const FieldTrialsView& field_trials, bool prefer_temporal_support, const VideoEncoder& main_encoder) { absl::optional params = - ParseFallbackParamsFromFieldTrials(main_encoder); + ParseFallbackParamsFromFieldTrials(field_trials, main_encoder); if (prefer_temporal_support) { if (!params.has_value()) { params.emplace(); @@ -141,6 +143,7 @@ absl::optional GetForcedFallbackParams( class VideoEncoderSoftwareFallbackWrapper final : public VideoEncoder { public: VideoEncoderSoftwareFallbackWrapper( + const FieldTrialsView& field_trials, std::unique_ptr sw_encoder, std::unique_ptr hw_encoder, bool prefer_temporal_support); @@ -227,6 +230,7 @@ class VideoEncoderSoftwareFallbackWrapper final : public VideoEncoder { }; VideoEncoderSoftwareFallbackWrapper::VideoEncoderSoftwareFallbackWrapper( + const FieldTrialsView& field_trials, std::unique_ptr sw_encoder, std::unique_ptr hw_encoder, bool prefer_temporal_support) @@ -234,8 +238,9 @@ VideoEncoderSoftwareFallbackWrapper::VideoEncoderSoftwareFallbackWrapper( encoder_(std::move(hw_encoder)), fallback_encoder_(std::move(sw_encoder)), callback_(nullptr), - fallback_params_( - GetForcedFallbackParams(prefer_temporal_support, *encoder_)) { + fallback_params_(GetForcedFallbackParams(field_trials, + prefer_temporal_support, + *encoder_)) { RTC_DCHECK(fallback_encoder_); } @@ -537,12 +542,22 @@ bool VideoEncoderSoftwareFallbackWrapper::TryInitForcedFallbackEncoder() { } // namespace std::unique_ptr CreateVideoEncoderSoftwareFallbackWrapper( + const Environment& env, std::unique_ptr sw_fallback_encoder, std::unique_ptr hw_encoder, bool prefer_temporal_support) { return std::make_unique( - std::move(sw_fallback_encoder), std::move(hw_encoder), + env.field_trials(), std::move(sw_fallback_encoder), std::move(hw_encoder), prefer_temporal_support); } +std::unique_ptr CreateVideoEncoderSoftwareFallbackWrapper( + std::unique_ptr sw_fallback_encoder, + std::unique_ptr hw_encoder, + bool prefer_temporal_support) { + return std::make_unique( + FieldTrialBasedConfig(), std::move(sw_fallback_encoder), + std::move(hw_encoder), prefer_temporal_support); +} + } // namespace webrtc diff --git a/api/video_codecs/video_encoder_software_fallback_wrapper.h b/api/video_codecs/video_encoder_software_fallback_wrapper.h index 6e6902eb3f..45118e2a15 100644 --- a/api/video_codecs/video_encoder_software_fallback_wrapper.h +++ b/api/video_codecs/video_encoder_software_fallback_wrapper.h @@ -14,6 +14,7 @@ #include #include +#include "api/environment/environment.h" #include "api/video_codecs/video_encoder.h" #include "rtc_base/system/rtc_export.h" @@ -25,22 +26,19 @@ namespace webrtc { // |bool prefer_temporal_support| indicates that if the software fallback // encoder supports temporal layers but the hardware encoder does not, a // fallback should be forced even if the encoder otherwise works. -RTC_EXPORT std::unique_ptr +// TODO: bugs.webrtc.org/15860 - Delete after 2024-04-22. +[[deprecated]] RTC_EXPORT std::unique_ptr CreateVideoEncoderSoftwareFallbackWrapper( std::unique_ptr sw_fallback_encoder, std::unique_ptr hw_encoder, bool prefer_temporal_support); -// Default fallback for call-sites not yet updated with -// `prefer_temporal_support`. -// TODO(sprang): Remove when usage is gone. -RTC_EXPORT inline std::unique_ptr +RTC_EXPORT std::unique_ptr CreateVideoEncoderSoftwareFallbackWrapper( + const Environment& env, std::unique_ptr sw_fallback_encoder, - std::unique_ptr hw_encoder) { - return CreateVideoEncoderSoftwareFallbackWrapper( - std::move(sw_fallback_encoder), std::move(hw_encoder), false); -} + std::unique_ptr hw_encoder, + bool prefer_temporal_support); } // namespace webrtc diff --git a/media/engine/simulcast_encoder_adapter.cc b/media/engine/simulcast_encoder_adapter.cc index f95ccb052a..5ca2a03fc4 100644 --- a/media/engine/simulcast_encoder_adapter.cc +++ b/media/engine/simulcast_encoder_adapter.cc @@ -756,7 +756,7 @@ SimulcastEncoderAdapter::FetchOrCreateEncoderContext( encoder = std::move(primary_encoder); } else { encoder = CreateVideoEncoderSoftwareFallbackWrapper( - std::move(fallback_encoder), std::move(primary_encoder), + env_, std::move(fallback_encoder), std::move(primary_encoder), prefer_temporal_support); } } else if (fallback_encoder != nullptr) { diff --git a/sdk/android/src/jni/video_encoder_fallback.cc b/sdk/android/src/jni/video_encoder_fallback.cc index dcca70abae..fa1fbc9270 100644 --- a/sdk/android/src/jni/video_encoder_fallback.cc +++ b/sdk/android/src/jni/video_encoder_fallback.cc @@ -29,11 +29,12 @@ jlong JNI_VideoEncoderFallback_Create( std::unique_ptr primary_encoder = JavaToNativeVideoEncoder(jni, j_primary_encoder, j_webrtc_env_ref); - return NativeToJavaPointer(CreateVideoEncoderSoftwareFallbackWrapper( - std::move(fallback_encoder), - std::move(primary_encoder), - /*prefer_temporal_support=*/false) - .release()); + return NativeToJavaPointer( + CreateVideoEncoderSoftwareFallbackWrapper( + *reinterpret_cast(j_webrtc_env_ref), + std::move(fallback_encoder), std::move(primary_encoder), + /*prefer_temporal_support=*/false) + .release()); } } // namespace jni