From 47be1493b670b85a640ad1da02be66ee1a4446d3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Erik=20Spr=C3=A5ng?= Date: Tue, 2 Aug 2022 14:35:58 +0200 Subject: [PATCH] Remove unused field trial WebRTC-VP8ScreenshareTemporalLayers. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Bug: webrtc:9477 Change-Id: I5419653fea369ad253c4815f2b961db7e92b332b Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/269203 Auto-Submit: Erik Språng Reviewed-by: Danil Chapovalov Commit-Queue: Erik Språng Cr-Commit-Position: refs/heads/main@{#37668} --- media/engine/simulcast.cc | 84 ++++++++++++++------------------------- 1 file changed, 29 insertions(+), 55 deletions(-) diff --git a/media/engine/simulcast.cc b/media/engine/simulcast.cc index 93607e8c18..fb10c0f3e0 100644 --- a/media/engine/simulcast.cc +++ b/media/engine/simulcast.cc @@ -33,23 +33,11 @@ namespace cricket { namespace { -constexpr webrtc::DataRate Interpolate(const webrtc::DataRate& a, - const webrtc::DataRate& b, - float rate) { - return a * (1.0 - rate) + b * rate; -} - constexpr char kUseLegacySimulcastLayerLimitFieldTrial[] = "WebRTC-LegacySimulcastLayerLimit"; constexpr double kDefaultMaxRoundupRate = 0.1; -// TODO(webrtc:12415): Flip this to a kill switch when this feature launches. -bool EnableLowresBitrateInterpolation(const webrtc::FieldTrialsView& trials) { - return absl::StartsWith( - trials.Lookup("WebRTC-LowresSimulcastBitrateInterpolation"), "Enabled"); -} - // Limits for legacy conference screensharing mode. Currently used for the // lower of the two simulcast streams. constexpr webrtc::DataRate kScreenshareDefaultTl0Bitrate = @@ -64,7 +52,9 @@ constexpr webrtc::DataRate kScreenshareHighStreamMinBitrate = constexpr webrtc::DataRate kScreenshareHighStreamMaxBitrate = webrtc::DataRate::KilobitsPerSec(1250); -} // namespace +constexpr int kDefaultNumTemporalLayers = 3; +constexpr int kScreenshareMaxSimulcastLayers = 2; +constexpr int kScreenshareTemporalLayers = 2; struct SimulcastFormat { int width; @@ -112,6 +102,18 @@ constexpr const SimulcastFormat kSimulcastFormats[] = { webrtc::DataRate::KilobitsPerSec(0), webrtc::DataRate::KilobitsPerSec(30)}}; +constexpr webrtc::DataRate Interpolate(const webrtc::DataRate& a, + const webrtc::DataRate& b, + float rate) { + return a * (1.0 - rate) + b * rate; +} + +// TODO(webrtc:12415): Flip this to a kill switch when this feature launches. +bool EnableLowresBitrateInterpolation(const webrtc::FieldTrialsView& trials) { + return absl::StartsWith( + trials.Lookup("WebRTC-LowresSimulcastBitrateInterpolation"), "Enabled"); +} + std::vector GetSimulcastFormats( bool enable_lowres_bitrate_interpolation) { std::vector formats; @@ -128,28 +130,14 @@ std::vector GetSimulcastFormats( return formats; } -const int kMaxScreenshareSimulcastLayers = 2; - // Multiway: Number of temporal layers for each simulcast stream. -int DefaultNumberOfTemporalLayers(int simulcast_id, - bool screenshare, - const webrtc::FieldTrialsView& trials) { - RTC_CHECK_GE(simulcast_id, 0); - RTC_CHECK_LT(simulcast_id, webrtc::kMaxSimulcastStreams); - - const int kDefaultNumTemporalLayers = 3; - const int kDefaultNumScreenshareTemporalLayers = 2; - int default_num_temporal_layers = screenshare - ? kDefaultNumScreenshareTemporalLayers - : kDefaultNumTemporalLayers; - +int DefaultNumberOfTemporalLayers(const webrtc::FieldTrialsView& trials) { const std::string group_name = - screenshare ? trials.Lookup("WebRTC-VP8ScreenshareTemporalLayers") - : trials.Lookup("WebRTC-VP8ConferenceTemporalLayers"); + trials.Lookup("WebRTC-VP8ConferenceTemporalLayers"); if (group_name.empty()) - return default_num_temporal_layers; + return kDefaultNumTemporalLayers; - int num_temporal_layers = default_num_temporal_layers; + int num_temporal_layers = kDefaultNumTemporalLayers; if (sscanf(group_name.c_str(), "%d", &num_temporal_layers) == 1 && num_temporal_layers > 0 && num_temporal_layers <= webrtc::kMaxTemporalStreams) { @@ -160,7 +148,7 @@ int DefaultNumberOfTemporalLayers(int simulcast_id, "incorrect value: " << group_name; - return default_num_temporal_layers; + return kDefaultNumTemporalLayers; } int FindSimulcastFormatIndex(int width, @@ -178,6 +166,8 @@ int FindSimulcastFormatIndex(int width, return -1; } +} // namespace + // Round size to nearest simulcast-friendly size. // Simulcast stream width and height must both be dividable by // |2 ^ (simulcast_layers - 1)|. @@ -376,9 +366,7 @@ std::vector GetNormalSimulcastLayers( // TODO(pbos): Fill actual temporal-layer bitrate thresholds. layers[s].max_qp = max_qp; layers[s].num_temporal_layers = - temporal_layers_supported - ? DefaultNumberOfTemporalLayers(s, false, trials) - : 1; + temporal_layers_supported ? DefaultNumberOfTemporalLayers(trials) : 1; layers[s].max_bitrate_bps = FindSimulcastMaxBitrate(width, height, enable_lowres_bitrate_interpolation) @@ -387,7 +375,7 @@ std::vector GetNormalSimulcastLayers( FindSimulcastTargetBitrate(width, height, enable_lowres_bitrate_interpolation) .bps(); - int num_temporal_layers = DefaultNumberOfTemporalLayers(s, false, trials); + int num_temporal_layers = DefaultNumberOfTemporalLayers(trials); if (s == 0) { // If alternative temporal rate allocation is selected, adjust the // bitrate of the lowest simulcast stream so that absolute bitrate for @@ -451,9 +439,8 @@ std::vector GetScreenshareLayers( bool temporal_layers_supported, bool base_heavy_tl3_rate_alloc, const webrtc::FieldTrialsView& trials) { - auto max_screenshare_layers = kMaxScreenshareSimulcastLayers; size_t num_simulcast_layers = - std::min(max_layers, max_screenshare_layers); + std::min(max_layers, kScreenshareMaxSimulcastLayers); std::vector layers(num_simulcast_layers); // For legacy screenshare in conference mode, tl0 and tl1 bitrates are @@ -471,10 +458,8 @@ std::vector GetScreenshareLayers( // With simulcast enabled, add another spatial layer. This one will have a // more normal layout, with the regular 3 temporal layer pattern and no fps // restrictions. The base simulcast layer will still use legacy setup. - if (num_simulcast_layers == kMaxScreenshareSimulcastLayers) { + if (num_simulcast_layers == kScreenshareMaxSimulcastLayers) { // Add optional upper simulcast layer. - const int num_temporal_layers = - DefaultNumberOfTemporalLayers(1, true, trials); int max_bitrate_bps; bool using_boosted_bitrate = false; if (!temporal_layers_supported) { @@ -483,20 +468,11 @@ std::vector GetScreenshareLayers( max_bitrate_bps = static_cast( kScreenshareHighStreamMaxBitrate.bps() * webrtc::SimulcastRateAllocator::GetTemporalRateAllocation( - num_temporal_layers, 0, base_heavy_tl3_rate_alloc)); - } else if (DefaultNumberOfTemporalLayers(1, true, trials) != 3 || - base_heavy_tl3_rate_alloc) { + kScreenshareTemporalLayers, 0, base_heavy_tl3_rate_alloc)); + } else { // Experimental temporal layer mode used, use increased max bitrate. max_bitrate_bps = kScreenshareHighStreamMaxBitrate.bps(); using_boosted_bitrate = true; - } else { - // Keep current bitrates with default 3tl/8 frame settings. - // Lowest temporal layers of a 3 layer setup will have 40% of the total - // bitrate allocation for that simulcast layer. Make sure the gap between - // the target of the lower simulcast layer and first temporal layer of the - // higher one is at most 2x the bitrate, so that upswitching is not - // hampered by stalled bitrate estimates. - max_bitrate_bps = 2 * ((layers[0].target_bitrate_bps * 10) / 4); } layers[1].width = width; @@ -504,9 +480,7 @@ std::vector GetScreenshareLayers( layers[1].max_qp = max_qp; layers[1].max_framerate = kDefaultVideoMaxFramerate; layers[1].num_temporal_layers = - temporal_layers_supported - ? DefaultNumberOfTemporalLayers(1, true, trials) - : 1; + temporal_layers_supported ? kScreenshareTemporalLayers : 1; layers[1].min_bitrate_bps = using_boosted_bitrate ? kScreenshareHighStreamMinBitrate.bps() : layers[0].target_bitrate_bps * 2;