mollyim/webrtc
1
0
Fork 0
mirror of https://github.com/mollyim/webrtc.git synced 2025-05-13 05:40:42 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

Propagate field trials for WebRTC-Video-MinVideoBitrate

Browse source 
Instead of relying on the global field trial string

Bug: webrtc:10335
Change-Id: I491be089ffc725fd28483edf10eae4ae5d17d651
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/346263
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Reviewed-by: Åsa Persson <asapersson@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#42021}
This commit is contained in:
Danil Chapovalov 2024-04-09 10:53:39 +02:00 committed by WebRTC LUCI CQ
parent 868ab5e9a8
commit 19f1297f7f
11 changed files with 128 additions and 134 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
modules/video_coding/BUILD.gn
View file

@ -1251,8 +1251,8 @@ if (rtc_include_tests) {
"../../rtc_base/synchronization:mutex", "../../rtc_base/synchronization:mutex",
"../../rtc_base/system:unused", "../../rtc_base/system:unused",
"../../system_wrappers", "../../system_wrappers",
"../../system_wrappers:field_trial",
"../../system_wrappers:metrics", "../../system_wrappers:metrics",
"../../test:explicit_key_value_config",
"../../test:fake_encoded_frame", "../../test:fake_encoded_frame",
"../../test:fake_video_codecs", "../../test:fake_video_codecs",
"../../test:field_trial", "../../test:field_trial",

17
modules/video_coding/include/video_codec_initializer.h
View file

@ -11,28 +11,21 @@
#ifndef MODULES_VIDEO_CODING_INCLUDE_VIDEO_CODEC_INITIALIZER_H_ #ifndef MODULES_VIDEO_CODING_INCLUDE_VIDEO_CODEC_INITIALIZER_H_
#define MODULES_VIDEO_CODING_INCLUDE_VIDEO_CODEC_INITIALIZER_H_ #define MODULES_VIDEO_CODING_INCLUDE_VIDEO_CODEC_INITIALIZER_H_
#include <memory>
#include <string>
#include <vector> #include <vector>
#include "api/field_trials_view.h"
#include "api/video_codecs/video_codec.h"
#include "video/config/video_encoder_config.h" #include "video/config/video_encoder_config.h"
namespace webrtc { namespace webrtc {
class VideoCodec;
class VideoCodecInitializer { class VideoCodecInitializer {
public: public:
// Takes a VideoEncoderConfig and the VideoStream configuration and // Takes a VideoEncoderConfig and the VideoStream configuration and
// translates them into the old school VideoCodec type. // translates them into the old school VideoCodec type.
static bool SetupCodec(const VideoEncoderConfig& config, static VideoCodec SetupCodec(const FieldTrialsView& field_trials,
const std::vector<VideoStream>& streams, const VideoEncoderConfig& config,
VideoCodec* codec); const std::vector<VideoStream>& streams);
private:
static VideoCodec VideoEncoderConfigToVideoCodec(
const VideoEncoderConfig& config,
const std::vector<VideoStream>& streams);
}; };
} // namespace webrtc } // namespace webrtc

14
modules/video_coding/video_codec_initializer.cc
View file

@ -16,6 +16,8 @@
#include <algorithm> #include <algorithm>
#include "absl/types/optional.h" #include "absl/types/optional.h"
#include "api/array_view.h"
#include "api/field_trials_view.h"
#include "api/scoped_refptr.h" #include "api/scoped_refptr.h"
#include "api/units/data_rate.h" #include "api/units/data_rate.h"
#include "api/video_codecs/video_encoder.h" #include "api/video_codecs/video_encoder.h"
@ -31,15 +33,9 @@
namespace webrtc { namespace webrtc {
bool VideoCodecInitializer::SetupCodec(const VideoEncoderConfig& config,
const std::vector<VideoStream>& streams,
VideoCodec* codec) {
*codec = VideoEncoderConfigToVideoCodec(config, streams);
return true;
}
// TODO(sprang): Split this up and separate the codec specific parts. // TODO(sprang): Split this up and separate the codec specific parts.
VideoCodec VideoCodecInitializer::VideoEncoderConfigToVideoCodec( VideoCodec VideoCodecInitializer::SetupCodec(
const FieldTrialsView& field_trials,
const VideoEncoderConfig& config, const VideoEncoderConfig& config,
const std::vector<VideoStream>& streams) { const std::vector<VideoStream>& streams) {
static const int kEncoderMinBitrateKbps = 30; static const int kEncoderMinBitrateKbps = 30;
@ -335,7 +331,7 @@ VideoCodec VideoCodecInitializer::VideoEncoderConfigToVideoCodec(
} }
const absl::optional<DataRate> experimental_min_bitrate = const absl::optional<DataRate> experimental_min_bitrate =
GetExperimentalMinVideoBitrate(video_codec.codecType); GetExperimentalMinVideoBitrate(field_trials, video_codec.codecType);
if (experimental_min_bitrate) { if (experimental_min_bitrate) {
const int experimental_min_bitrate_kbps = const int experimental_min_bitrate_kbps =
rtc::saturated_cast<int>(experimental_min_bitrate->kbps()); rtc::saturated_cast<int>(experimental_min_bitrate->kbps());

87
modules/video_coding/video_codec_initializer_unittest.cc
View file

@ -27,6 +27,7 @@
#include "api/video_codecs/vp8_temporal_layers_factory.h" #include "api/video_codecs/vp8_temporal_layers_factory.h"
#include "modules/video_coding/codecs/vp9/include/vp9_globals.h" #include "modules/video_coding/codecs/vp9/include/vp9_globals.h"
#include "rtc_base/checks.h" #include "rtc_base/checks.h"
#include "test/explicit_key_value_config.h"
#include "test/gmock.h" #include "test/gmock.h"
#include "test/gtest.h" #include "test/gtest.h"
@ -89,12 +90,10 @@ class VideoCodecInitializerTest : public ::testing::Test {
} }
} }
bool InitializeCodec() { void InitializeCodec() {
codec_out_ = VideoCodec();
frame_buffer_controller_.reset(); frame_buffer_controller_.reset();
if (!VideoCodecInitializer::SetupCodec(config_, streams_, &codec_out_)) { codec_out_ =
return false; VideoCodecInitializer::SetupCodec(field_trials_, config_, streams_);
}
bitrate_allocator_ = CreateBuiltinVideoBitrateAllocatorFactory() bitrate_allocator_ = CreateBuiltinVideoBitrateAllocatorFactory()
->CreateVideoBitrateAllocator(codec_out_); ->CreateVideoBitrateAllocator(codec_out_);
RTC_CHECK(bitrate_allocator_); RTC_CHECK(bitrate_allocator_);
@ -107,7 +106,6 @@ class VideoCodecInitializerTest : public ::testing::Test {
frame_buffer_controller_ = frame_buffer_controller_ =
factory.Create(codec_out_, settings, &fec_controller_override_); factory.Create(codec_out_, settings, &fec_controller_override_);
} }
return true;
} }
VideoStream DefaultStream( VideoStream DefaultStream(
@ -139,6 +137,7 @@ class VideoCodecInitializerTest : public ::testing::Test {
return stream; return stream;
} }
const test::ExplicitKeyValueConfig field_trials_{""};
MockFecControllerOverride fec_controller_override_; MockFecControllerOverride fec_controller_override_;
// Input settings. // Input settings.
@ -154,7 +153,7 @@ class VideoCodecInitializerTest : public ::testing::Test {
TEST_F(VideoCodecInitializerTest, SingleStreamVp8Screenshare) { TEST_F(VideoCodecInitializerTest, SingleStreamVp8Screenshare) {
SetUpFor(VideoCodecType::kVideoCodecVP8, 1, absl::nullopt, 1, true); SetUpFor(VideoCodecType::kVideoCodecVP8, 1, absl::nullopt, 1, true);
streams_.push_back(DefaultStream()); streams_.push_back(DefaultStream());
EXPECT_TRUE(InitializeCodec()); InitializeCodec();
VideoBitrateAllocation bitrate_allocation = VideoBitrateAllocation bitrate_allocation =
bitrate_allocator_->Allocate(VideoBitrateAllocationParameters( bitrate_allocator_->Allocate(VideoBitrateAllocationParameters(
@ -169,7 +168,7 @@ TEST_F(VideoCodecInitializerTest, SingleStreamVp8ScreenshareInactive) {
VideoStream inactive_stream = DefaultStream(); VideoStream inactive_stream = DefaultStream();
inactive_stream.active = false; inactive_stream.active = false;
streams_.push_back(inactive_stream); streams_.push_back(inactive_stream);
EXPECT_TRUE(InitializeCodec()); InitializeCodec();
VideoBitrateAllocation bitrate_allocation = VideoBitrateAllocation bitrate_allocation =
bitrate_allocator_->Allocate(VideoBitrateAllocationParameters( bitrate_allocator_->Allocate(VideoBitrateAllocationParameters(
@ -182,7 +181,7 @@ TEST_F(VideoCodecInitializerTest, SingleStreamVp8ScreenshareInactive) {
TEST_F(VideoCodecInitializerTest, TemporalLayeredVp8ScreenshareConference) { TEST_F(VideoCodecInitializerTest, TemporalLayeredVp8ScreenshareConference) {
SetUpFor(VideoCodecType::kVideoCodecVP8, 1, absl::nullopt, 2, true); SetUpFor(VideoCodecType::kVideoCodecVP8, 1, absl::nullopt, 2, true);
streams_.push_back(DefaultScreenshareStream()); streams_.push_back(DefaultScreenshareStream());
EXPECT_TRUE(InitializeCodec()); InitializeCodec();
bitrate_allocator_->SetLegacyConferenceMode(true); bitrate_allocator_->SetLegacyConferenceMode(true);
EXPECT_EQ(1u, codec_out_.numberOfSimulcastStreams); EXPECT_EQ(1u, codec_out_.numberOfSimulcastStreams);
@ -199,7 +198,7 @@ TEST_F(VideoCodecInitializerTest, TemporalLayeredVp8ScreenshareConference) {
TEST_F(VideoCodecInitializerTest, TemporalLayeredVp8Screenshare) { TEST_F(VideoCodecInitializerTest, TemporalLayeredVp8Screenshare) {
SetUpFor(VideoCodecType::kVideoCodecVP8, 1, absl::nullopt, 2, true); SetUpFor(VideoCodecType::kVideoCodecVP8, 1, absl::nullopt, 2, true);
streams_.push_back(DefaultScreenshareStream()); streams_.push_back(DefaultScreenshareStream());
EXPECT_TRUE(InitializeCodec()); InitializeCodec();
EXPECT_EQ(1u, codec_out_.numberOfSimulcastStreams); EXPECT_EQ(1u, codec_out_.numberOfSimulcastStreams);
EXPECT_EQ(2u, codec_out_.VP8()->numberOfTemporalLayers); EXPECT_EQ(2u, codec_out_.VP8()->numberOfTemporalLayers);
@ -217,7 +216,7 @@ TEST_F(VideoCodecInitializerTest, SimulcastVp8Screenshare) {
VideoStream video_stream = DefaultStream(); VideoStream video_stream = DefaultStream();
video_stream.max_framerate = kScreenshareDefaultFramerate; video_stream.max_framerate = kScreenshareDefaultFramerate;
streams_.push_back(video_stream); streams_.push_back(video_stream);
EXPECT_TRUE(InitializeCodec()); InitializeCodec();
EXPECT_EQ(2u, codec_out_.numberOfSimulcastStreams); EXPECT_EQ(2u, codec_out_.numberOfSimulcastStreams);
EXPECT_EQ(1u, codec_out_.VP8()->numberOfTemporalLayers); EXPECT_EQ(1u, codec_out_.VP8()->numberOfTemporalLayers);
@ -242,7 +241,7 @@ TEST_F(VideoCodecInitializerTest, SimulcastVp8ScreenshareInactive) {
inactive_video_stream.active = false; inactive_video_stream.active = false;
inactive_video_stream.max_framerate = kScreenshareDefaultFramerate; inactive_video_stream.max_framerate = kScreenshareDefaultFramerate;
streams_.push_back(inactive_video_stream); streams_.push_back(inactive_video_stream);
EXPECT_TRUE(InitializeCodec()); InitializeCodec();
EXPECT_EQ(2u, codec_out_.numberOfSimulcastStreams); EXPECT_EQ(2u, codec_out_.numberOfSimulcastStreams);
EXPECT_EQ(1u, codec_out_.VP8()->numberOfTemporalLayers); EXPECT_EQ(1u, codec_out_.VP8()->numberOfTemporalLayers);
@ -266,7 +265,7 @@ TEST_F(VideoCodecInitializerTest, HighFpsSimulcastVp8Screenshare) {
VideoStream video_stream = DefaultStream(); VideoStream video_stream = DefaultStream();
video_stream.num_temporal_layers = 3; video_stream.num_temporal_layers = 3;
streams_.push_back(video_stream); streams_.push_back(video_stream);
EXPECT_TRUE(InitializeCodec()); InitializeCodec();
EXPECT_EQ(2u, codec_out_.numberOfSimulcastStreams); EXPECT_EQ(2u, codec_out_.numberOfSimulcastStreams);
EXPECT_EQ(3u, codec_out_.VP8()->numberOfTemporalLayers); EXPECT_EQ(3u, codec_out_.VP8()->numberOfTemporalLayers);
@ -290,7 +289,7 @@ TEST_F(VideoCodecInitializerTest, Vp9SvcDefaultLayering) {
stream.num_temporal_layers = 3; stream.num_temporal_layers = 3;
streams_.push_back(stream); streams_.push_back(stream);
EXPECT_TRUE(InitializeCodec()); InitializeCodec();
EXPECT_EQ(codec_out_.VP9()->numberOfSpatialLayers, 3u); EXPECT_EQ(codec_out_.VP9()->numberOfSpatialLayers, 3u);
EXPECT_EQ(codec_out_.VP9()->numberOfTemporalLayers, 3u); EXPECT_EQ(codec_out_.VP9()->numberOfTemporalLayers, 3u);
} }
@ -305,7 +304,7 @@ TEST_F(VideoCodecInitializerTest, Vp9SvcAdjustedLayering) {
streams_.push_back(stream); streams_.push_back(stream);
EXPECT_TRUE(InitializeCodec()); InitializeCodec();
EXPECT_EQ(codec_out_.VP9()->numberOfSpatialLayers, 2u); EXPECT_EQ(codec_out_.VP9()->numberOfSpatialLayers, 2u);
} }
@ -316,7 +315,7 @@ TEST_F(VideoCodecInitializerTest,
stream.num_temporal_layers = 3; stream.num_temporal_layers = 3;
streams_.push_back(stream); streams_.push_back(stream);
EXPECT_TRUE(InitializeCodec()); InitializeCodec();
EXPECT_EQ(codec_out_.spatialLayers[0].maxBitrate, EXPECT_EQ(codec_out_.spatialLayers[0].maxBitrate,
kDefaultMaxBitrateBps / 1000); kDefaultMaxBitrateBps / 1000);
} }
@ -329,7 +328,7 @@ TEST_F(VideoCodecInitializerTest,
stream.scalability_mode = ScalabilityMode::kL1T1; stream.scalability_mode = ScalabilityMode::kL1T1;
streams_.push_back(stream); streams_.push_back(stream);
EXPECT_TRUE(InitializeCodec()); InitializeCodec();
EXPECT_EQ(1u, codec_out_.VP9()->numberOfSpatialLayers); EXPECT_EQ(1u, codec_out_.VP9()->numberOfSpatialLayers);
EXPECT_EQ(codec_out_.spatialLayers[0].minBitrate, EXPECT_EQ(codec_out_.spatialLayers[0].minBitrate,
kDefaultMinBitrateBps / 1000); kDefaultMinBitrateBps / 1000);
@ -344,7 +343,7 @@ TEST_F(VideoCodecInitializerTest,
stream.num_temporal_layers = 1; stream.num_temporal_layers = 1;
streams_.push_back(stream); streams_.push_back(stream);
EXPECT_TRUE(InitializeCodec()); InitializeCodec();
EXPECT_EQ(codec_out_.spatialLayers[0].targetBitrate, EXPECT_EQ(codec_out_.spatialLayers[0].targetBitrate,
kDefaultMaxBitrateBps / 1000); kDefaultMaxBitrateBps / 1000);
} }
@ -361,7 +360,7 @@ TEST_F(VideoCodecInitializerTest,
stream.num_temporal_layers = 3; stream.num_temporal_layers = 3;
streams_.push_back(stream); streams_.push_back(stream);
EXPECT_TRUE(InitializeCodec()); InitializeCodec();
EXPECT_LT(codec_out_.spatialLayers[0].maxBitrate, EXPECT_LT(codec_out_.spatialLayers[0].maxBitrate,
kDefaultMaxBitrateBps / 1000); kDefaultMaxBitrateBps / 1000);
} }
@ -379,7 +378,7 @@ TEST_F(VideoCodecInitializerTest,
stream.scalability_mode = ScalabilityMode::kL3T1; stream.scalability_mode = ScalabilityMode::kL3T1;
streams_.push_back(stream); streams_.push_back(stream);
EXPECT_TRUE(InitializeCodec()); InitializeCodec();
EXPECT_EQ(1u, codec_out_.VP9()->numberOfSpatialLayers); EXPECT_EQ(1u, codec_out_.VP9()->numberOfSpatialLayers);
EXPECT_LT(codec_out_.spatialLayers[0].minBitrate, EXPECT_LT(codec_out_.spatialLayers[0].minBitrate,
kDefaultMinBitrateBps / 1000); kDefaultMinBitrateBps / 1000);
@ -398,7 +397,7 @@ TEST_F(VideoCodecInitializerTest, Vp9DeactivateLayers) {
config_.simulcast_layers[0].active = true; config_.simulcast_layers[0].active = true;
config_.simulcast_layers[1].active = true; config_.simulcast_layers[1].active = true;
config_.simulcast_layers[2].active = true; config_.simulcast_layers[2].active = true;
EXPECT_TRUE(InitializeCodec()); InitializeCodec();
EXPECT_EQ(codec_out_.VP9()->numberOfSpatialLayers, 3); EXPECT_EQ(codec_out_.VP9()->numberOfSpatialLayers, 3);
EXPECT_TRUE(codec_out_.spatialLayers[0].active); EXPECT_TRUE(codec_out_.spatialLayers[0].active);
EXPECT_TRUE(codec_out_.spatialLayers[1].active); EXPECT_TRUE(codec_out_.spatialLayers[1].active);
@ -408,7 +407,7 @@ TEST_F(VideoCodecInitializerTest, Vp9DeactivateLayers) {
config_.simulcast_layers[0].active = true; config_.simulcast_layers[0].active = true;
config_.simulcast_layers[1].active = true; config_.simulcast_layers[1].active = true;
config_.simulcast_layers[2].active = false; config_.simulcast_layers[2].active = false;
EXPECT_TRUE(InitializeCodec()); InitializeCodec();
EXPECT_EQ(codec_out_.VP9()->numberOfSpatialLayers, 3); EXPECT_EQ(codec_out_.VP9()->numberOfSpatialLayers, 3);
EXPECT_TRUE(codec_out_.spatialLayers[0].active); EXPECT_TRUE(codec_out_.spatialLayers[0].active);
EXPECT_TRUE(codec_out_.spatialLayers[1].active); EXPECT_TRUE(codec_out_.spatialLayers[1].active);
@ -418,7 +417,7 @@ TEST_F(VideoCodecInitializerTest, Vp9DeactivateLayers) {
config_.simulcast_layers[0].active = true; config_.simulcast_layers[0].active = true;
config_.simulcast_layers[1].active = false; config_.simulcast_layers[1].active = false;
config_.simulcast_layers[2].active = true; config_.simulcast_layers[2].active = true;
EXPECT_TRUE(InitializeCodec()); InitializeCodec();
EXPECT_EQ(codec_out_.VP9()->numberOfSpatialLayers, 3); EXPECT_EQ(codec_out_.VP9()->numberOfSpatialLayers, 3);
EXPECT_TRUE(codec_out_.spatialLayers[0].active); EXPECT_TRUE(codec_out_.spatialLayers[0].active);
EXPECT_FALSE(codec_out_.spatialLayers[1].active); EXPECT_FALSE(codec_out_.spatialLayers[1].active);
@ -428,7 +427,7 @@ TEST_F(VideoCodecInitializerTest, Vp9DeactivateLayers) {
config_.simulcast_layers[0].active = false; config_.simulcast_layers[0].active = false;
config_.simulcast_layers[1].active = true; config_.simulcast_layers[1].active = true;
config_.simulcast_layers[2].active = true; config_.simulcast_layers[2].active = true;
EXPECT_TRUE(InitializeCodec()); InitializeCodec();
EXPECT_EQ(codec_out_.VP9()->numberOfSpatialLayers, 2); EXPECT_EQ(codec_out_.VP9()->numberOfSpatialLayers, 2);
EXPECT_TRUE(codec_out_.spatialLayers[0].active); EXPECT_TRUE(codec_out_.spatialLayers[0].active);
EXPECT_TRUE(codec_out_.spatialLayers[1].active); EXPECT_TRUE(codec_out_.spatialLayers[1].active);
@ -437,7 +436,7 @@ TEST_F(VideoCodecInitializerTest, Vp9DeactivateLayers) {
config_.simulcast_layers[0].active = false; config_.simulcast_layers[0].active = false;
config_.simulcast_layers[1].active = false; config_.simulcast_layers[1].active = false;
config_.simulcast_layers[2].active = true; config_.simulcast_layers[2].active = true;
EXPECT_TRUE(InitializeCodec()); InitializeCodec();
EXPECT_EQ(codec_out_.VP9()->numberOfSpatialLayers, 1); EXPECT_EQ(codec_out_.VP9()->numberOfSpatialLayers, 1);
EXPECT_TRUE(codec_out_.spatialLayers[0].active); EXPECT_TRUE(codec_out_.spatialLayers[0].active);
@ -445,7 +444,7 @@ TEST_F(VideoCodecInitializerTest, Vp9DeactivateLayers) {
config_.simulcast_layers[0].active = false; config_.simulcast_layers[0].active = false;
config_.simulcast_layers[1].active = true; config_.simulcast_layers[1].active = true;
config_.simulcast_layers[2].active = false; config_.simulcast_layers[2].active = false;
EXPECT_TRUE(InitializeCodec()); InitializeCodec();
EXPECT_EQ(codec_out_.VP9()->numberOfSpatialLayers, 2); EXPECT_EQ(codec_out_.VP9()->numberOfSpatialLayers, 2);
EXPECT_TRUE(codec_out_.spatialLayers[0].active); EXPECT_TRUE(codec_out_.spatialLayers[0].active);
EXPECT_FALSE(codec_out_.spatialLayers[1].active); EXPECT_FALSE(codec_out_.spatialLayers[1].active);
@ -454,7 +453,7 @@ TEST_F(VideoCodecInitializerTest, Vp9DeactivateLayers) {
config_.simulcast_layers[0].active = true; config_.simulcast_layers[0].active = true;
config_.simulcast_layers[1].active = false; config_.simulcast_layers[1].active = false;
config_.simulcast_layers[2].active = false; config_.simulcast_layers[2].active = false;
EXPECT_TRUE(InitializeCodec()); InitializeCodec();
EXPECT_EQ(codec_out_.VP9()->numberOfSpatialLayers, 3); EXPECT_EQ(codec_out_.VP9()->numberOfSpatialLayers, 3);
EXPECT_TRUE(codec_out_.spatialLayers[0].active); EXPECT_TRUE(codec_out_.spatialLayers[0].active);
EXPECT_FALSE(codec_out_.spatialLayers[1].active); EXPECT_FALSE(codec_out_.spatialLayers[1].active);
@ -469,7 +468,7 @@ TEST_F(VideoCodecInitializerTest, Vp9SvcResolutionAlignment) {
stream.num_temporal_layers = 3; stream.num_temporal_layers = 3;
streams_.push_back(stream); streams_.push_back(stream);
EXPECT_TRUE(InitializeCodec()); InitializeCodec();
EXPECT_EQ(codec_out_.width, 1280); EXPECT_EQ(codec_out_.width, 1280);
EXPECT_EQ(codec_out_.height, 720); EXPECT_EQ(codec_out_.height, 720);
EXPECT_EQ(codec_out_.numberOfSimulcastStreams, 1); EXPECT_EQ(codec_out_.numberOfSimulcastStreams, 1);
@ -485,7 +484,7 @@ TEST_F(VideoCodecInitializerTest, Vp9SimulcastResolutions) {
DefaultStream(640, 360, ScalabilityMode::kL1T3), DefaultStream(640, 360, ScalabilityMode::kL1T3),
DefaultStream(1280, 720, ScalabilityMode::kL1T3)}; DefaultStream(1280, 720, ScalabilityMode::kL1T3)};
EXPECT_TRUE(InitializeCodec()); InitializeCodec();
// This is expected to be the largest layer. // This is expected to be the largest layer.
EXPECT_EQ(codec_out_.width, 1280); EXPECT_EQ(codec_out_.width, 1280);
EXPECT_EQ(codec_out_.height, 720); EXPECT_EQ(codec_out_.height, 720);
@ -505,8 +504,8 @@ TEST_F(VideoCodecInitializerTest, Av1SingleSpatialLayerBitratesAreConsistent) {
std::vector<VideoStream> streams = {DefaultStream()}; std::vector<VideoStream> streams = {DefaultStream()};
streams[0].scalability_mode = ScalabilityMode::kL1T2; streams[0].scalability_mode = ScalabilityMode::kL1T2;
VideoCodec codec; VideoCodec codec =
EXPECT_TRUE(VideoCodecInitializer::SetupCodec(config, streams, &codec)); VideoCodecInitializer::SetupCodec(field_trials_, config, streams);
EXPECT_GE(codec.spatialLayers[0].targetBitrate, EXPECT_GE(codec.spatialLayers[0].targetBitrate,
codec.spatialLayers[0].minBitrate); codec.spatialLayers[0].minBitrate);
@ -520,8 +519,8 @@ TEST_F(VideoCodecInitializerTest, Av1TwoSpatialLayersBitratesAreConsistent) {
std::vector<VideoStream> streams = {DefaultStream()}; std::vector<VideoStream> streams = {DefaultStream()};
streams[0].scalability_mode = ScalabilityMode::kL2T2; streams[0].scalability_mode = ScalabilityMode::kL2T2;
VideoCodec codec; VideoCodec codec =
EXPECT_TRUE(VideoCodecInitializer::SetupCodec(config, streams, &codec)); VideoCodecInitializer::SetupCodec(field_trials_, config, streams);
EXPECT_GE(codec.spatialLayers[0].targetBitrate, EXPECT_GE(codec.spatialLayers[0].targetBitrate,
codec.spatialLayers[0].minBitrate); codec.spatialLayers[0].minBitrate);
@ -541,8 +540,8 @@ TEST_F(VideoCodecInitializerTest, Av1TwoSpatialLayersActiveByDefault) {
streams[0].scalability_mode = ScalabilityMode::kL2T2; streams[0].scalability_mode = ScalabilityMode::kL2T2;
config.spatial_layers = {}; config.spatial_layers = {};
VideoCodec codec; VideoCodec codec =
EXPECT_TRUE(VideoCodecInitializer::SetupCodec(config, streams, &codec)); VideoCodecInitializer::SetupCodec(field_trials_, config, streams);
EXPECT_TRUE(codec.spatialLayers[0].active); EXPECT_TRUE(codec.spatialLayers[0].active);
EXPECT_TRUE(codec.spatialLayers[1].active); EXPECT_TRUE(codec.spatialLayers[1].active);
@ -557,8 +556,8 @@ TEST_F(VideoCodecInitializerTest, Av1TwoSpatialLayersOneDeactivated) {
config.spatial_layers[0].active = true; config.spatial_layers[0].active = true;
config.spatial_layers[1].active = false; config.spatial_layers[1].active = false;
VideoCodec codec; VideoCodec codec =
EXPECT_TRUE(VideoCodecInitializer::SetupCodec(config, streams, &codec)); VideoCodecInitializer::SetupCodec(field_trials_, config, streams);
EXPECT_TRUE(codec.spatialLayers[0].active); EXPECT_TRUE(codec.spatialLayers[0].active);
EXPECT_FALSE(codec.spatialLayers[1].active); EXPECT_FALSE(codec.spatialLayers[1].active);
@ -575,8 +574,8 @@ TEST_F(VideoCodecInitializerTest, Vp9SingleSpatialLayerBitratesAreConsistent) {
std::vector<VideoStream> streams = {DefaultStream()}; std::vector<VideoStream> streams = {DefaultStream()};
streams[0].scalability_mode = ScalabilityMode::kL1T2; streams[0].scalability_mode = ScalabilityMode::kL1T2;
VideoCodec codec; VideoCodec codec =
EXPECT_TRUE(VideoCodecInitializer::SetupCodec(config, streams, &codec)); VideoCodecInitializer::SetupCodec(field_trials_, config, streams);
EXPECT_EQ(1u, codec.VP9()->numberOfSpatialLayers); EXPECT_EQ(1u, codec.VP9()->numberOfSpatialLayers);
// Target is consistent with min and max (min <= target <= max). // Target is consistent with min and max (min <= target <= max).
@ -603,8 +602,8 @@ TEST_F(VideoCodecInitializerTest, Vp9TwoSpatialLayersBitratesAreConsistent) {
std::vector<VideoStream> streams = {DefaultStream()}; std::vector<VideoStream> streams = {DefaultStream()};
streams[0].scalability_mode = ScalabilityMode::kL2T2; streams[0].scalability_mode = ScalabilityMode::kL2T2;
VideoCodec codec; VideoCodec codec =
EXPECT_TRUE(VideoCodecInitializer::SetupCodec(config, streams, &codec)); VideoCodecInitializer::SetupCodec(field_trials_, config, streams);
EXPECT_EQ(2u, codec.VP9()->numberOfSpatialLayers); EXPECT_EQ(2u, codec.VP9()->numberOfSpatialLayers);
EXPECT_GE(codec.spatialLayers[0].targetBitrate, EXPECT_GE(codec.spatialLayers[0].targetBitrate,
@ -627,15 +626,15 @@ TEST_F(VideoCodecInitializerTest, UpdatesVp9SpecificFieldsWithScalabilityMode) {
std::vector<VideoStream> streams = {DefaultStream()}; std::vector<VideoStream> streams = {DefaultStream()};
streams[0].scalability_mode = ScalabilityMode::kL2T3_KEY; streams[0].scalability_mode = ScalabilityMode::kL2T3_KEY;
VideoCodec codec; VideoCodec codec =
EXPECT_TRUE(VideoCodecInitializer::SetupCodec(config, streams, &codec)); VideoCodecInitializer::SetupCodec(field_trials_, config, streams);
EXPECT_EQ(codec.VP9()->numberOfSpatialLayers, 2u); EXPECT_EQ(codec.VP9()->numberOfSpatialLayers, 2u);
EXPECT_EQ(codec.VP9()->numberOfTemporalLayers, 3u); EXPECT_EQ(codec.VP9()->numberOfTemporalLayers, 3u);
EXPECT_EQ(codec.VP9()->interLayerPred, InterLayerPredMode::kOnKeyPic); EXPECT_EQ(codec.VP9()->interLayerPred, InterLayerPredMode::kOnKeyPic);
streams[0].scalability_mode = ScalabilityMode::kS3T1; streams[0].scalability_mode = ScalabilityMode::kS3T1;
EXPECT_TRUE(VideoCodecInitializer::SetupCodec(config, streams, &codec)); codec = VideoCodecInitializer::SetupCodec(field_trials_, config, streams);
EXPECT_EQ(codec.VP9()->numberOfSpatialLayers, 3u); EXPECT_EQ(codec.VP9()->numberOfSpatialLayers, 3u);
EXPECT_EQ(codec.VP9()->numberOfTemporalLayers, 1u); EXPECT_EQ(codec.VP9()->numberOfTemporalLayers, 1u);

2
rtc_base/experiments/BUILD.gn
View file

@ -222,11 +222,11 @@ rtc_library("min_video_bitrate_experiment") {
] ]
deps = [ deps = [
":field_trial_parser", ":field_trial_parser",
"../../api:field_trials_view",
"../../api/units:data_rate", "../../api/units:data_rate",
"../../api/video:video_frame", "../../api/video:video_frame",
"../../rtc_base:checks", "../../rtc_base:checks",
"../../rtc_base:logging", "../../rtc_base:logging",
"../../system_wrappers:field_trial",
] ]
absl_deps = [ "//third_party/abseil-cpp/absl/types:optional" ] absl_deps = [ "//third_party/abseil-cpp/absl/types:optional" ]
} }

21
rtc_base/experiments/min_video_bitrate_experiment.cc
View file

@ -12,10 +12,10 @@
#include <string> #include <string>
#include "api/field_trials_view.h"
#include "rtc_base/checks.h" #include "rtc_base/checks.h"
#include "rtc_base/experiments/field_trial_parser.h" #include "rtc_base/experiments/field_trial_parser.h"
#include "rtc_base/logging.h" #include "rtc_base/logging.h"
#include "system_wrappers/include/field_trial.h"
namespace webrtc { namespace webrtc {
@ -26,17 +26,18 @@ const char kForcedFallbackFieldTrial[] =
"WebRTC-VP8-Forced-Fallback-Encoder-v2"; "WebRTC-VP8-Forced-Fallback-Encoder-v2";
const char kMinVideoBitrateExperiment[] = "WebRTC-Video-MinVideoBitrate"; const char kMinVideoBitrateExperiment[] = "WebRTC-Video-MinVideoBitrate";
absl::optional<int> GetFallbackMinBpsFromFieldTrial(VideoCodecType type) { absl::optional<int> GetFallbackMinBpsFromFieldTrial(
const FieldTrialsView& field_trials,
VideoCodecType type) {
if (type != kVideoCodecVP8) { if (type != kVideoCodecVP8) {
return absl::nullopt; return absl::nullopt;
} }
if (!webrtc::field_trial::IsEnabled(kForcedFallbackFieldTrial)) { if (!field_trials.IsEnabled(kForcedFallbackFieldTrial)) {
return absl::nullopt; return absl::nullopt;
} }
const std::string group = const std::string group = field_trials.Lookup(kForcedFallbackFieldTrial);
webrtc::field_trial::FindFullName(kForcedFallbackFieldTrial);
if (group.empty()) { if (group.empty()) {
return absl::nullopt; return absl::nullopt;
} }
@ -57,14 +58,16 @@ absl::optional<int> GetFallbackMinBpsFromFieldTrial(VideoCodecType type) {
} }
} // namespace } // namespace
absl::optional<DataRate> GetExperimentalMinVideoBitrate(VideoCodecType type) { absl::optional<DataRate> GetExperimentalMinVideoBitrate(
const FieldTrialsView& field_trials,
VideoCodecType type) {
const absl::optional<int> fallback_min_bitrate_bps = const absl::optional<int> fallback_min_bitrate_bps =
GetFallbackMinBpsFromFieldTrial(type); GetFallbackMinBpsFromFieldTrial(field_trials, type);
if (fallback_min_bitrate_bps) { if (fallback_min_bitrate_bps) {
return DataRate::BitsPerSec(*fallback_min_bitrate_bps); return DataRate::BitsPerSec(*fallback_min_bitrate_bps);
} }
if (webrtc::field_trial::IsEnabled(kMinVideoBitrateExperiment)) { if (field_trials.IsEnabled(kMinVideoBitrateExperiment)) {
webrtc::FieldTrialFlag enabled("Enabled"); webrtc::FieldTrialFlag enabled("Enabled");
// Backwards-compatibility with an old experiment - a generic minimum which, // Backwards-compatibility with an old experiment - a generic minimum which,
@ -80,7 +83,7 @@ absl::optional<DataRate> GetExperimentalMinVideoBitrate(VideoCodecType type) {
webrtc::ParseFieldTrial( webrtc::ParseFieldTrial(
{&enabled, &min_video_bitrate, &min_bitrate_vp8, &min_bitrate_vp9, {&enabled, &min_video_bitrate, &min_bitrate_vp8, &min_bitrate_vp9,
&min_bitrate_av1, &min_bitrate_h264}, &min_bitrate_av1, &min_bitrate_h264},
webrtc::field_trial::FindFullName(kMinVideoBitrateExperiment)); field_trials.Lookup(kMinVideoBitrateExperiment));
if (min_video_bitrate) { if (min_video_bitrate) {
if (min_bitrate_vp8 || min_bitrate_vp9 || min_bitrate_av1 || if (min_bitrate_vp8 || min_bitrate_vp9 || min_bitrate_av1 ||

5
rtc_base/experiments/min_video_bitrate_experiment.h
View file

@ -12,6 +12,7 @@
#define RTC_BASE_EXPERIMENTS_MIN_VIDEO_BITRATE_EXPERIMENT_H_ #define RTC_BASE_EXPERIMENTS_MIN_VIDEO_BITRATE_EXPERIMENT_H_
#include "absl/types/optional.h" #include "absl/types/optional.h"
#include "api/field_trials_view.h"
#include "api/units/data_rate.h" #include "api/units/data_rate.h"
#include "api/video/video_codec_type.h" #include "api/video/video_codec_type.h"
@ -21,7 +22,9 @@ extern const int kDefaultMinVideoBitrateBps;
// Return the experiment-driven minimum video bitrate. // Return the experiment-driven minimum video bitrate.
// If no experiment is effective, returns nullopt. // If no experiment is effective, returns nullopt.
absl::optional<DataRate> GetExperimentalMinVideoBitrate(VideoCodecType type); absl::optional<DataRate> GetExperimentalMinVideoBitrate(
const FieldTrialsView& field_trials,
VideoCodecType type);
} // namespace webrtc } // namespace webrtc

104
rtc_base/experiments/min_video_bitrate_experiment_unittest.cc
View file

@ -13,127 +13,129 @@
#include "absl/types/optional.h" #include "absl/types/optional.h"
#include "api/units/data_rate.h" #include "api/units/data_rate.h"
#include "api/video/video_codec_type.h" #include "api/video/video_codec_type.h"
#include "test/field_trial.h" #include "test/explicit_key_value_config.h"
#include "test/gtest.h" #include "test/gtest.h"
namespace webrtc { namespace webrtc {
namespace { namespace {
using test::ExplicitKeyValueConfig;
TEST(GetExperimentalMinVideoBitrateTest, TEST(GetExperimentalMinVideoBitrateTest,
NulloptForAllCodecsIfFieldTrialUndefined) { NulloptForAllCodecsIfFieldTrialUndefined) {
test::ScopedFieldTrials field_trials(""); ExplicitKeyValueConfig field_trials("");
EXPECT_EQ(GetExperimentalMinVideoBitrate(VideoCodecType::kVideoCodecGeneric), EXPECT_EQ(GetExperimentalMinVideoBitrate(field_trials, kVideoCodecGeneric),
absl::nullopt); absl::nullopt);
EXPECT_EQ(GetExperimentalMinVideoBitrate(VideoCodecType::kVideoCodecVP8), EXPECT_EQ(GetExperimentalMinVideoBitrate(field_trials, kVideoCodecVP8),
absl::nullopt); absl::nullopt);
EXPECT_EQ(GetExperimentalMinVideoBitrate(VideoCodecType::kVideoCodecVP9), EXPECT_EQ(GetExperimentalMinVideoBitrate(field_trials, kVideoCodecVP9),
absl::nullopt); absl::nullopt);
EXPECT_EQ(GetExperimentalMinVideoBitrate(VideoCodecType::kVideoCodecH264), EXPECT_EQ(GetExperimentalMinVideoBitrate(field_trials, kVideoCodecH264),
absl::nullopt); absl::nullopt);
} }
TEST(GetExperimentalMinVideoBitrateTest, TEST(GetExperimentalMinVideoBitrateTest,
NulloptForAllCodecsIfFieldTrialDisabled) { NulloptForAllCodecsIfFieldTrialDisabled) {
test::ScopedFieldTrials field_trials( ExplicitKeyValueConfig field_trials(
"WebRTC-Video-MinVideoBitrate/Disabled,br:123kbps/"); "WebRTC-Video-MinVideoBitrate/Disabled,br:123kbps/");
EXPECT_EQ(GetExperimentalMinVideoBitrate(VideoCodecType::kVideoCodecGeneric), EXPECT_EQ(GetExperimentalMinVideoBitrate(field_trials, kVideoCodecGeneric),
absl::nullopt); absl::nullopt);
EXPECT_EQ(GetExperimentalMinVideoBitrate(VideoCodecType::kVideoCodecVP8), EXPECT_EQ(GetExperimentalMinVideoBitrate(field_trials, kVideoCodecVP8),
absl::nullopt); absl::nullopt);
EXPECT_EQ(GetExperimentalMinVideoBitrate(VideoCodecType::kVideoCodecVP9), EXPECT_EQ(GetExperimentalMinVideoBitrate(field_trials, kVideoCodecVP9),
absl::nullopt); absl::nullopt);
EXPECT_EQ(GetExperimentalMinVideoBitrate(VideoCodecType::kVideoCodecH264), EXPECT_EQ(GetExperimentalMinVideoBitrate(field_trials, kVideoCodecH264),
absl::nullopt); absl::nullopt);
} }
TEST(GetExperimentalMinVideoBitrateTest, BrForAllCodecsIfDefined) { TEST(GetExperimentalMinVideoBitrateTest, BrForAllCodecsIfDefined) {
test::ScopedFieldTrials field_trials( ExplicitKeyValueConfig field_trials(
"WebRTC-Video-MinVideoBitrate/Enabled,br:123kbps/"); "WebRTC-Video-MinVideoBitrate/Enabled,br:123kbps/");
EXPECT_EQ(GetExperimentalMinVideoBitrate(VideoCodecType::kVideoCodecGeneric), EXPECT_EQ(GetExperimentalMinVideoBitrate(field_trials, kVideoCodecGeneric),
absl::make_optional(DataRate::KilobitsPerSec(123))); DataRate::KilobitsPerSec(123));
EXPECT_EQ(GetExperimentalMinVideoBitrate(VideoCodecType::kVideoCodecVP8), EXPECT_EQ(GetExperimentalMinVideoBitrate(field_trials, kVideoCodecVP8),
absl::make_optional(DataRate::KilobitsPerSec(123))); DataRate::KilobitsPerSec(123));
EXPECT_EQ(GetExperimentalMinVideoBitrate(VideoCodecType::kVideoCodecVP9), EXPECT_EQ(GetExperimentalMinVideoBitrate(field_trials, kVideoCodecVP9),
absl::make_optional(DataRate::KilobitsPerSec(123))); DataRate::KilobitsPerSec(123));
EXPECT_EQ(GetExperimentalMinVideoBitrate(VideoCodecType::kVideoCodecH264), EXPECT_EQ(GetExperimentalMinVideoBitrate(field_trials, kVideoCodecH264),
absl::make_optional(DataRate::KilobitsPerSec(123))); DataRate::KilobitsPerSec(123));
} }
TEST(GetExperimentalMinVideoBitrateTest, BrTrumpsSpecificCodecConfigs) { TEST(GetExperimentalMinVideoBitrateTest, BrTrumpsSpecificCodecConfigs) {
test::ScopedFieldTrials field_trials( ExplicitKeyValueConfig field_trials(
"WebRTC-Video-MinVideoBitrate/" "WebRTC-Video-MinVideoBitrate/"
"Enabled,br:123kbps,vp8_br:100kbps,vp9_br:200kbps,h264_br:300kbps/"); "Enabled,br:123kbps,vp8_br:100kbps,vp9_br:200kbps,h264_br:300kbps/");
EXPECT_EQ(GetExperimentalMinVideoBitrate(VideoCodecType::kVideoCodecGeneric), EXPECT_EQ(GetExperimentalMinVideoBitrate(field_trials, kVideoCodecGeneric),
absl::make_optional(DataRate::KilobitsPerSec(123))); DataRate::KilobitsPerSec(123));
EXPECT_EQ(GetExperimentalMinVideoBitrate(VideoCodecType::kVideoCodecVP8), EXPECT_EQ(GetExperimentalMinVideoBitrate(field_trials, kVideoCodecVP8),
absl::make_optional(DataRate::KilobitsPerSec(123))); DataRate::KilobitsPerSec(123));
EXPECT_EQ(GetExperimentalMinVideoBitrate(VideoCodecType::kVideoCodecVP9), EXPECT_EQ(GetExperimentalMinVideoBitrate(field_trials, kVideoCodecVP9),
absl::make_optional(DataRate::KilobitsPerSec(123))); DataRate::KilobitsPerSec(123));
EXPECT_EQ(GetExperimentalMinVideoBitrate(VideoCodecType::kVideoCodecH264), EXPECT_EQ(GetExperimentalMinVideoBitrate(field_trials, kVideoCodecH264),
absl::make_optional(DataRate::KilobitsPerSec(123))); DataRate::KilobitsPerSec(123));
} }
TEST(GetExperimentalMinVideoBitrateTest, TEST(GetExperimentalMinVideoBitrateTest,
SpecificCodecConfigsIgnoredIfExpDisabled) { SpecificCodecConfigsIgnoredIfExpDisabled) {
test::ScopedFieldTrials field_trials( ExplicitKeyValueConfig field_trials(
"WebRTC-Video-MinVideoBitrate/" "WebRTC-Video-MinVideoBitrate/"
"Disabled,vp8_br:100kbps,vp9_br:200kbps,h264_br:300kbps/"); "Disabled,vp8_br:100kbps,vp9_br:200kbps,h264_br:300kbps/");
EXPECT_EQ(GetExperimentalMinVideoBitrate(VideoCodecType::kVideoCodecGeneric), EXPECT_EQ(GetExperimentalMinVideoBitrate(field_trials, kVideoCodecGeneric),
absl::nullopt); absl::nullopt);
EXPECT_EQ(GetExperimentalMinVideoBitrate(VideoCodecType::kVideoCodecVP8), EXPECT_EQ(GetExperimentalMinVideoBitrate(field_trials, kVideoCodecVP8),
absl::nullopt); absl::nullopt);
EXPECT_EQ(GetExperimentalMinVideoBitrate(VideoCodecType::kVideoCodecVP9), EXPECT_EQ(GetExperimentalMinVideoBitrate(field_trials, kVideoCodecVP9),
absl::nullopt); absl::nullopt);
EXPECT_EQ(GetExperimentalMinVideoBitrate(VideoCodecType::kVideoCodecH264), EXPECT_EQ(GetExperimentalMinVideoBitrate(field_trials, kVideoCodecH264),
absl::nullopt); absl::nullopt);
} }
TEST(GetExperimentalMinVideoBitrateTest, SpecificCodecConfigsUsedIfExpEnabled) { TEST(GetExperimentalMinVideoBitrateTest, SpecificCodecConfigsUsedIfExpEnabled) {
test::ScopedFieldTrials field_trials( ExplicitKeyValueConfig field_trials(
"WebRTC-Video-MinVideoBitrate/" "WebRTC-Video-MinVideoBitrate/"
"Enabled,vp8_br:100kbps,vp9_br:200kbps,h264_br:300kbps/"); "Enabled,vp8_br:100kbps,vp9_br:200kbps,h264_br:300kbps/");
EXPECT_EQ(GetExperimentalMinVideoBitrate(VideoCodecType::kVideoCodecGeneric), EXPECT_EQ(GetExperimentalMinVideoBitrate(field_trials, kVideoCodecGeneric),
absl::nullopt); absl::nullopt);
EXPECT_EQ(GetExperimentalMinVideoBitrate(VideoCodecType::kVideoCodecVP8), EXPECT_EQ(GetExperimentalMinVideoBitrate(field_trials, kVideoCodecVP8),
absl::make_optional(DataRate::KilobitsPerSec(100))); DataRate::KilobitsPerSec(100));
EXPECT_EQ(GetExperimentalMinVideoBitrate(VideoCodecType::kVideoCodecVP9), EXPECT_EQ(GetExperimentalMinVideoBitrate(field_trials, kVideoCodecVP9),
absl::make_optional(DataRate::KilobitsPerSec(200))); DataRate::KilobitsPerSec(200));
EXPECT_EQ(GetExperimentalMinVideoBitrate(VideoCodecType::kVideoCodecH264), EXPECT_EQ(GetExperimentalMinVideoBitrate(field_trials, kVideoCodecH264),
absl::make_optional(DataRate::KilobitsPerSec(300))); DataRate::KilobitsPerSec(300));
} }
TEST(GetExperimentalMinVideoBitrateTest, TEST(GetExperimentalMinVideoBitrateTest,
Vp8BitrateValueTakenFromFallbackIfAvailable) { Vp8BitrateValueTakenFromFallbackIfAvailable) {
test::ScopedFieldTrials field_trials( ExplicitKeyValueConfig field_trials(
"WebRTC-Video-MinVideoBitrate/" "WebRTC-Video-MinVideoBitrate/"
"Enabled,vp8_br:100kbps,vp9_br:200kbps,h264_br:300kbps/" "Enabled,vp8_br:100kbps,vp9_br:200kbps,h264_br:300kbps/"
"WebRTC-VP8-Forced-Fallback-Encoder-v2/" "WebRTC-VP8-Forced-Fallback-Encoder-v2/"
"Enabled-444444,555555,666666/"); "Enabled-444444,555555,666666/");
EXPECT_EQ(GetExperimentalMinVideoBitrate(VideoCodecType::kVideoCodecVP8), EXPECT_EQ(GetExperimentalMinVideoBitrate(field_trials, kVideoCodecVP8),
absl::make_optional(DataRate::BitsPerSec(666666))); DataRate::BitsPerSec(666666));
} }
TEST(GetExperimentalMinVideoBitrateTest, TEST(GetExperimentalMinVideoBitrateTest,
NonVp8BitrateValuesTakenFromMinVideoBitrate) { NonVp8BitrateValuesTakenFromMinVideoBitrate) {
test::ScopedFieldTrials field_trials( ExplicitKeyValueConfig field_trials(
"WebRTC-Video-MinVideoBitrate/" "WebRTC-Video-MinVideoBitrate/"
"Enabled,vp8_br:100kbps,vp9_br:200kbps,h264_br:300kbps/" "Enabled,vp8_br:100kbps,vp9_br:200kbps,h264_br:300kbps/"
"WebRTC-VP8-Forced-Fallback-Encoder-v2/" "WebRTC-VP8-Forced-Fallback-Encoder-v2/"
"Enabled-444444,555555,666666/"); "Enabled-444444,555555,666666/");
EXPECT_EQ(GetExperimentalMinVideoBitrate(VideoCodecType::kVideoCodecGeneric), EXPECT_EQ(GetExperimentalMinVideoBitrate(field_trials, kVideoCodecGeneric),
absl::nullopt); absl::nullopt);
EXPECT_EQ(GetExperimentalMinVideoBitrate(VideoCodecType::kVideoCodecVP9), EXPECT_EQ(GetExperimentalMinVideoBitrate(field_trials, kVideoCodecVP9),
absl::make_optional(DataRate::KilobitsPerSec(200))); DataRate::KilobitsPerSec(200));
EXPECT_EQ(GetExperimentalMinVideoBitrate(VideoCodecType::kVideoCodecH264), EXPECT_EQ(GetExperimentalMinVideoBitrate(field_trials, kVideoCodecH264),
absl::make_optional(DataRate::KilobitsPerSec(300))); DataRate::KilobitsPerSec(300));
} }
} // namespace } // namespace

2
video/config/encoder_stream_factory.cc
View file

@ -136,7 +136,7 @@ std::vector<webrtc::VideoStream> EncoderStreamFactory::CreateEncoderStreams(
encoder_config.number_of_streams); encoder_config.number_of_streams);
const absl::optional<webrtc::DataRate> experimental_min_bitrate = const absl::optional<webrtc::DataRate> experimental_min_bitrate =
GetExperimentalMinVideoBitrate(encoder_config.codec_type); GetExperimentalMinVideoBitrate(trials_, encoder_config.codec_type);
bool is_simulcast = (encoder_config.number_of_streams > 1); bool is_simulcast = (encoder_config.number_of_streams > 1);
// If scalability mode was specified, don't treat {active,inactive,inactive} // If scalability mode was specified, don't treat {active,inactive,inactive}

2
video/video_send_stream_impl.cc
View file

@ -801,7 +801,7 @@ void VideoSendStreamImpl::OnEncoderConfigurationChanged(
PayloadStringToCodecType(config_.rtp.payload_name); PayloadStringToCodecType(config_.rtp.payload_name);
const absl::optional<DataRate> experimental_min_bitrate = const absl::optional<DataRate> experimental_min_bitrate =
GetExperimentalMinVideoBitrate(codec_type); GetExperimentalMinVideoBitrate(env_.field_trials(), codec_type);
encoder_min_bitrate_bps_ = encoder_min_bitrate_bps_ =
experimental_min_bitrate experimental_min_bitrate
? experimental_min_bitrate->bps() ? experimental_min_bitrate->bps()

6
video/video_stream_encoder.cc
View file

@ -1177,10 +1177,8 @@ void VideoStreamEncoder::ReconfigureEncoder() {
encoder_->GetEncoderInfo(), encoder_config_, default_limits_allowed_), encoder_->GetEncoderInfo(), encoder_config_, default_limits_allowed_),
encoder_config_.simulcast_layers, &streams); encoder_config_.simulcast_layers, &streams);
VideoCodec codec; VideoCodec codec = VideoCodecInitializer::SetupCodec(
if (!VideoCodecInitializer::SetupCodec(encoder_config_, streams, &codec)) { env_.field_trials(), encoder_config_, streams);
RTC_LOG(LS_ERROR) << "Failed to create encoder configuration.";
}
if (encoder_config_.codec_type == kVideoCodecVP9 || if (encoder_config_.codec_type == kVideoCodecVP9 ||
encoder_config_.codec_type == kVideoCodecAV1) { encoder_config_.codec_type == kVideoCodecAV1) {