admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Provide Environment to construct VideoBitrateAllocator

Browse Source 
To allow various VideoBitrateAllocators to use propagated rather than global field trials

Bug: webrtc:42220378
Change-Id: I52816628169a54b18a4405d84fee69b101f92f72
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/349920
Reviewed-by: Erik Språng <sprang@webrtc.org>
Reviewed-by: Philip Eliasson <philipel@webrtc.org>
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Reviewed-by: Mirko Bonadei <mbonadei@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#42288}
This commit is contained in:
Danil Chapovalov 2024-05-10 15:00:00 +02:00 committed by WebRTC LUCI CQ
parent eaa4f3ae3c
commit 4bf4e1753c
20 changed files with 89 additions and 58 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
api/test/mock_video_bitrate_allocator_factory.h
View File

@ -18,13 +18,12 @@
namespace webrtc { namespace webrtc {
class MockVideoBitrateAllocatorFactory class MockVideoBitrateAllocatorFactory : public VideoBitrateAllocatorFactory {
: public webrtc::VideoBitrateAllocatorFactory {
public: public:
~MockVideoBitrateAllocatorFactory() override { Die(); } ~MockVideoBitrateAllocatorFactory() override { Die(); }
MOCK_METHOD(std::unique_ptr<VideoBitrateAllocator>, MOCK_METHOD(std::unique_ptr<VideoBitrateAllocator>,
CreateVideoBitrateAllocator, Create,
(const VideoCodec&), (const Environment&, const VideoCodec&),
(override)); (override));
MOCK_METHOD(void, Die, ()); MOCK_METHOD(void, Die, ());
}; };

2
api/video/BUILD.gn
View File

@ -264,6 +264,8 @@ rtc_source_set("video_bitrate_allocator_factory") {
sources = [ "video_bitrate_allocator_factory.h" ] sources = [ "video_bitrate_allocator_factory.h" ]
deps = [ deps = [
":video_bitrate_allocator", ":video_bitrate_allocator",
"../../rtc_base:checks",
"../environment",
"../video_codecs:video_codecs_api", "../video_codecs:video_codecs_api",
] ]
} }

5
api/video/builtin_video_bitrate_allocator_factory.cc
View File

@ -29,7 +29,10 @@ class BuiltinVideoBitrateAllocatorFactory
BuiltinVideoBitrateAllocatorFactory() = default; BuiltinVideoBitrateAllocatorFactory() = default;
~BuiltinVideoBitrateAllocatorFactory() override = default; ~BuiltinVideoBitrateAllocatorFactory() override = default;
std::unique_ptr<VideoBitrateAllocator> CreateVideoBitrateAllocator( // TODO: bugs.webrtc.org/42220378 - propagate Environment into RateAllocators
// so that they wouldn't use global field trials string to query field trials.
std::unique_ptr<VideoBitrateAllocator> Create(
const Environment& /*env*/,
const VideoCodec& codec) override { const VideoCodec& codec) override {
// TODO(https://crbug.com/webrtc/14884): Update SvcRateAllocator to // TODO(https://crbug.com/webrtc/14884): Update SvcRateAllocator to
// support simulcast and use it for VP9/AV1 simulcast as well. // support simulcast and use it for VP9/AV1 simulcast as well.

14
api/video/video_bitrate_allocator_factory.h
View File

@ -13,8 +13,10 @@
#include <memory> #include <memory>
#include "api/environment/environment.h"
#include "api/video/video_bitrate_allocator.h" #include "api/video/video_bitrate_allocator.h"
#include "api/video_codecs/video_codec.h" #include "api/video_codecs/video_codec.h"
#include "rtc_base/checks.h"
namespace webrtc { namespace webrtc {
@ -23,9 +25,19 @@ namespace webrtc {
class VideoBitrateAllocatorFactory { class VideoBitrateAllocatorFactory {
public: public:
virtual ~VideoBitrateAllocatorFactory() = default; virtual ~VideoBitrateAllocatorFactory() = default;
// Creates a VideoBitrateAllocator for a specific video codec. // Creates a VideoBitrateAllocator for a specific video codec.
virtual std::unique_ptr<VideoBitrateAllocator> Create(
const Environment& env,
const VideoCodec& codec) {
return CreateVideoBitrateAllocator(codec);
}
virtual std::unique_ptr<VideoBitrateAllocator> CreateVideoBitrateAllocator( virtual std::unique_ptr<VideoBitrateAllocator> CreateVideoBitrateAllocator(
const VideoCodec& codec) = 0; const VideoCodec& codec) {
// Newer code shouldn't call this function,
// Older code should implement it in derived classes.
RTC_CHECK_NOTREACHED();
}
}; };
} // namespace webrtc } // namespace webrtc

6
media/engine/webrtc_video_engine_unittest.cc
View File

@ -1363,9 +1363,9 @@ TEST(WebRtcVideoEngineNewVideoCodecFactoryTest, Vp8) {
std::unique_ptr<webrtc::MockVideoBitrateAllocatorFactory> std::unique_ptr<webrtc::MockVideoBitrateAllocatorFactory>
rate_allocator_factory = rate_allocator_factory =
std::make_unique<webrtc::MockVideoBitrateAllocatorFactory>(); std::make_unique<webrtc::MockVideoBitrateAllocatorFactory>();
EXPECT_CALL(*rate_allocator_factory, EXPECT_CALL(
CreateVideoBitrateAllocator(Field(&webrtc::VideoCodec::codecType, *rate_allocator_factory,
webrtc::kVideoCodecVP8))) Create(_, Field(&webrtc::VideoCodec::codecType, webrtc::kVideoCodecVP8)))
.WillOnce( .WillOnce(
[] { return std::make_unique<webrtc::MockVideoBitrateAllocator>(); }); [] { return std::make_unique<webrtc::MockVideoBitrateAllocator>(); });
webrtc::FieldTrialBasedConfig trials; webrtc::FieldTrialBasedConfig trials;

1
modules/video_coding/BUILD.gn
View File

@ -1204,6 +1204,7 @@ if (rtc_include_tests) {
"../../api:scoped_refptr", "../../api:scoped_refptr",
"../../api:simulcast_test_fixture_api", "../../api:simulcast_test_fixture_api",
"../../api:videocodec_test_fixture_api", "../../api:videocodec_test_fixture_api",
"../../api/environment",
"../../api/environment:environment_factory", "../../api/environment:environment_factory",
"../../api/task_queue", "../../api/task_queue",
"../../api/task_queue:default_task_queue_factory", "../../api/task_queue:default_task_queue_factory",

12
modules/video_coding/codecs/test/video_codec_test.cc
View File

@ -319,7 +319,7 @@ TEST_P(SpatialQualityTest, SpatialQuality) {
VideoSourceSettings source_settings = ToSourceSettings(video_info); VideoSourceSettings source_settings = ToSourceSettings(video_info);
EncodingSettings encoding_settings = VideoCodecTester::CreateEncodingSettings( EncodingSettings encoding_settings = VideoCodecTester::CreateEncodingSettings(
codec_type, /*scalability_mode=*/"L1T1", width, height, env, codec_type, /*scalability_mode=*/"L1T1", width, height,
{DataRate::KilobitsPerSec(bitrate_kbps)}, {DataRate::KilobitsPerSec(bitrate_kbps)},
Frequency::Hertz(framerate_fps)); Frequency::Hertz(framerate_fps));
@ -398,14 +398,14 @@ TEST_P(BitrateAdaptationTest, BitrateAdaptation) {
VideoSourceSettings source_settings = ToSourceSettings(video_info); VideoSourceSettings source_settings = ToSourceSettings(video_info);
EncodingSettings encoding_settings = VideoCodecTester::CreateEncodingSettings( EncodingSettings encoding_settings = VideoCodecTester::CreateEncodingSettings(
codec_type, /*scalability_mode=*/"L1T1", env, codec_type, /*scalability_mode=*/"L1T1",
/*width=*/640, /*height=*/360, /*width=*/640, /*height=*/360,
{DataRate::KilobitsPerSec(bitrate_kbps.first)}, {DataRate::KilobitsPerSec(bitrate_kbps.first)},
/*framerate=*/Frequency::Hertz(30)); /*framerate=*/Frequency::Hertz(30));
EncodingSettings encoding_settings2 = EncodingSettings encoding_settings2 =
VideoCodecTester::CreateEncodingSettings( VideoCodecTester::CreateEncodingSettings(
codec_type, /*scalability_mode=*/"L1T1", env, codec_type, /*scalability_mode=*/"L1T1",
/*width=*/640, /*height=*/360, /*width=*/640, /*height=*/360,
{DataRate::KilobitsPerSec(bitrate_kbps.second)}, {DataRate::KilobitsPerSec(bitrate_kbps.second)},
/*framerate=*/Frequency::Hertz(30)); /*framerate=*/Frequency::Hertz(30));
@ -484,14 +484,14 @@ TEST_P(FramerateAdaptationTest, FramerateAdaptation) {
VideoSourceSettings source_settings = ToSourceSettings(video_info); VideoSourceSettings source_settings = ToSourceSettings(video_info);
EncodingSettings encoding_settings = VideoCodecTester::CreateEncodingSettings( EncodingSettings encoding_settings = VideoCodecTester::CreateEncodingSettings(
codec_type, /*scalability_mode=*/"L1T1", env, codec_type, /*scalability_mode=*/"L1T1",
/*width=*/640, /*height=*/360, /*width=*/640, /*height=*/360,
/*bitrate=*/{DataRate::KilobitsPerSec(512)}, /*bitrate=*/{DataRate::KilobitsPerSec(512)},
Frequency::Hertz(framerate_fps.first)); Frequency::Hertz(framerate_fps.first));
EncodingSettings encoding_settings2 = EncodingSettings encoding_settings2 =
VideoCodecTester::CreateEncodingSettings( VideoCodecTester::CreateEncodingSettings(
codec_type, /*scalability_mode=*/"L1T1", env, codec_type, /*scalability_mode=*/"L1T1",
/*width=*/640, /*height=*/360, /*width=*/640, /*height=*/360,
/*bitrate=*/{DataRate::KilobitsPerSec(512)}, /*bitrate=*/{DataRate::KilobitsPerSec(512)},
Frequency::Hertz(framerate_fps.second)); Frequency::Hertz(framerate_fps.second));
@ -571,7 +571,7 @@ TEST(VideoCodecTest, DISABLED_EncodeDecode) {
.value_or(absl::GetFlag(FLAGS_input_framerate_fps))); .value_or(absl::GetFlag(FLAGS_input_framerate_fps)));
EncodingSettings encoding_settings = VideoCodecTester::CreateEncodingSettings( EncodingSettings encoding_settings = VideoCodecTester::CreateEncodingSettings(
CodecNameToCodecType(absl::GetFlag(FLAGS_encoder)), env, CodecNameToCodecType(absl::GetFlag(FLAGS_encoder)),
absl::GetFlag(FLAGS_scalability_mode), absl::GetFlag(FLAGS_scalability_mode),
absl::GetFlag(FLAGS_width).value_or(absl::GetFlag(FLAGS_input_width)), absl::GetFlag(FLAGS_width).value_or(absl::GetFlag(FLAGS_input_width)),
absl::GetFlag(FLAGS_height).value_or(absl::GetFlag(FLAGS_input_height)), absl::GetFlag(FLAGS_height).value_or(absl::GetFlag(FLAGS_input_height)),

10
modules/video_coding/codecs/test/videocodec_test_fixture_impl.cc
View File

@ -446,6 +446,7 @@ VideoCodecTestFixtureImpl::VideoCodecTestFixtureImpl(Config config)
webrtc::LibvpxVp9DecoderTemplateAdapter, webrtc::LibvpxVp9DecoderTemplateAdapter,
webrtc::OpenH264DecoderTemplateAdapter, webrtc::OpenH264DecoderTemplateAdapter,
webrtc::Dav1dDecoderTemplateAdapter>>()), webrtc::Dav1dDecoderTemplateAdapter>>()),
env_(CreateEnvironment()),
config_(config) {} config_(config) {}
VideoCodecTestFixtureImpl::VideoCodecTestFixtureImpl( VideoCodecTestFixtureImpl::VideoCodecTestFixtureImpl(
@ -454,6 +455,7 @@ VideoCodecTestFixtureImpl::VideoCodecTestFixtureImpl(
std::unique_ptr<VideoEncoderFactory> encoder_factory) std::unique_ptr<VideoEncoderFactory> encoder_factory)
: encoder_factory_(std::move(encoder_factory)), : encoder_factory_(std::move(encoder_factory)),
decoder_factory_(std::move(decoder_factory)), decoder_factory_(std::move(decoder_factory)),
env_(CreateEnvironment()),
config_(config) {} config_(config) {}
VideoCodecTestFixtureImpl::~VideoCodecTestFixtureImpl() = default; VideoCodecTestFixtureImpl::~VideoCodecTestFixtureImpl() = default;
@ -695,8 +697,6 @@ void VideoCodecTestFixtureImpl::VerifyVideoStatistic(
} }
bool VideoCodecTestFixtureImpl::CreateEncoderAndDecoder() { bool VideoCodecTestFixtureImpl::CreateEncoderAndDecoder() {
const Environment env = CreateEnvironment();
SdpVideoFormat encoder_format(CreateSdpVideoFormat(config_)); SdpVideoFormat encoder_format(CreateSdpVideoFormat(config_));
SdpVideoFormat decoder_format = encoder_format; SdpVideoFormat decoder_format = encoder_format;
@ -711,7 +711,7 @@ bool VideoCodecTestFixtureImpl::CreateEncoderAndDecoder() {
decoder_format = *config_.decoder_format; decoder_format = *config_.decoder_format;
} }
encoder_ = encoder_factory_->Create(env, encoder_format); encoder_ = encoder_factory_->Create(env_, encoder_format);
EXPECT_TRUE(encoder_) << "Encoder not successfully created."; EXPECT_TRUE(encoder_) << "Encoder not successfully created.";
if (encoder_ == nullptr) { if (encoder_ == nullptr) {
return false; return false;
@ -721,7 +721,7 @@ bool VideoCodecTestFixtureImpl::CreateEncoderAndDecoder() {
config_.NumberOfSimulcastStreams(), config_.NumberOfSpatialLayers()); config_.NumberOfSimulcastStreams(), config_.NumberOfSpatialLayers());
for (size_t i = 0; i < num_simulcast_or_spatial_layers; ++i) { for (size_t i = 0; i < num_simulcast_or_spatial_layers; ++i) {
std::unique_ptr<VideoDecoder> decoder = std::unique_ptr<VideoDecoder> decoder =
decoder_factory_->Create(env, decoder_format); decoder_factory_->Create(env_, decoder_format);
EXPECT_TRUE(decoder) << "Decoder not successfully created."; EXPECT_TRUE(decoder) << "Decoder not successfully created.";
if (decoder == nullptr) { if (decoder == nullptr) {
return false; return false;
@ -818,7 +818,7 @@ bool VideoCodecTestFixtureImpl::SetUpAndInitObjects(
task_queue->SendTask([this]() { task_queue->SendTask([this]() {
processor_ = std::make_unique<VideoProcessor>( processor_ = std::make_unique<VideoProcessor>(
encoder_.get(), &decoders_, source_frame_reader_.get(), config_, env_, encoder_.get(), &decoders_, source_frame_reader_.get(), config_,
&stats_, &encoded_frame_writers_, &stats_, &encoded_frame_writers_,
decoded_frame_writers_.empty() ? nullptr : &decoded_frame_writers_); decoded_frame_writers_.empty() ? nullptr : &decoded_frame_writers_);
}); });

2
modules/video_coding/codecs/test/videocodec_test_fixture_impl.h
View File

@ -15,6 +15,7 @@
#include <string> #include <string>
#include <vector> #include <vector>
#include "api/environment/environment.h"
#include "api/test/videocodec_test_fixture.h" #include "api/test/videocodec_test_fixture.h"
#include "api/video_codecs/video_decoder_factory.h" #include "api/video_codecs/video_decoder_factory.h"
#include "api/video_codecs/video_encoder_factory.h" #include "api/video_codecs/video_encoder_factory.h"
@ -92,6 +93,7 @@ class VideoCodecTestFixtureImpl : public VideoCodecTestFixture {
VideoProcessor::VideoDecoderList decoders_; VideoProcessor::VideoDecoderList decoders_;
// Helper objects. // Helper objects.
const Environment env_;
Config config_; Config config_;
VideoCodecTestStatsImpl stats_; VideoCodecTestStatsImpl stats_;
std::unique_ptr<FrameReader> source_frame_reader_; std::unique_ptr<FrameReader> source_frame_reader_;

9
modules/video_coding/codecs/test/videoprocessor.cc
View File

@ -135,7 +135,8 @@ void CalculateFrameQuality(const I420BufferInterface& ref_buffer,
} // namespace } // namespace
VideoProcessor::VideoProcessor(webrtc::VideoEncoder* encoder, VideoProcessor::VideoProcessor(const Environment& env,
webrtc::VideoEncoder* encoder,
VideoDecoderList* decoders, VideoDecoderList* decoders,
FrameReader* input_frame_reader, FrameReader* input_frame_reader,
const VideoCodecTestFixture::Config& config, const VideoCodecTestFixture::Config& config,
@ -150,9 +151,9 @@ VideoProcessor::VideoProcessor(webrtc::VideoEncoder* encoder,
stats_(stats), stats_(stats),
encoder_(encoder), encoder_(encoder),
decoders_(decoders), decoders_(decoders),
bitrate_allocator_( bitrate_allocator_(CreateBuiltinVideoBitrateAllocatorFactory()->Create(
CreateBuiltinVideoBitrateAllocatorFactory() env,
->CreateVideoBitrateAllocator(config_.codec_settings)), config_.codec_settings)),
encode_callback_(this), encode_callback_(this),
input_frame_reader_(input_frame_reader), input_frame_reader_(input_frame_reader),
merged_encoded_frames_(num_simulcast_or_spatial_layers_), merged_encoded_frames_(num_simulcast_or_spatial_layers_),

4
modules/video_coding/codecs/test/videoprocessor.h
View File

@ -20,6 +20,7 @@
#include <vector> #include <vector>
#include "absl/types/optional.h" #include "absl/types/optional.h"
#include "api/environment/environment.h"
#include "api/sequence_checker.h" #include "api/sequence_checker.h"
#include "api/task_queue/task_queue_base.h" #include "api/task_queue/task_queue_base.h"
#include "api/test/videocodec_test_fixture.h" #include "api/test/videocodec_test_fixture.h"
@ -61,7 +62,8 @@ class VideoProcessor {
using FrameWriterList = std::vector<std::unique_ptr<FrameWriter>>; using FrameWriterList = std::vector<std::unique_ptr<FrameWriter>>;
using FrameStatistics = VideoCodecTestStats::FrameStatistics; using FrameStatistics = VideoCodecTestStats::FrameStatistics;
VideoProcessor(webrtc::VideoEncoder* encoder, VideoProcessor(const Environment& env,
VideoEncoder* encoder,
VideoDecoderList* decoders, VideoDecoderList* decoders,
FrameReader* input_frame_reader, FrameReader* input_frame_reader,
const VideoCodecTestFixture::Config& config, const VideoCodecTestFixture::Config& config,

6
modules/video_coding/codecs/test/videoprocessor_unittest.cc
View File

@ -12,6 +12,7 @@
#include <memory> #include <memory>
#include "api/environment/environment_factory.h"
#include "api/scoped_refptr.h" #include "api/scoped_refptr.h"
#include "api/test/mock_video_decoder.h" #include "api/test/mock_video_decoder.h"
#include "api/test/mock_video_encoder.h" #include "api/test/mock_video_encoder.h"
@ -53,8 +54,9 @@ class VideoProcessorTest : public ::testing::Test {
ExpectInit(); ExpectInit();
q_.SendTask([this] { q_.SendTask([this] {
video_processor_ = std::make_unique<VideoProcessor>( video_processor_ = std::make_unique<VideoProcessor>(
&encoder_mock_, &decoders_, &frame_reader_mock_, config_, &stats_, CreateEnvironment(), &encoder_mock_, &decoders_, &frame_reader_mock_,
&encoded_frame_writers_, /*decoded_frame_writers=*/nullptr); config_, &stats_, &encoded_frame_writers_,
/*decoded_frame_writers=*/nullptr);
}); });
} }

29
modules/video_coding/video_codec_initializer_unittest.cc
View File

@ -16,6 +16,8 @@
#include <memory> #include <memory>
#include "absl/types/optional.h" #include "absl/types/optional.h"
#include "api/environment/environment.h"
#include "api/environment/environment_factory.h"
#include "api/scoped_refptr.h" #include "api/scoped_refptr.h"
#include "api/test/mock_fec_controller_override.h" #include "api/test/mock_fec_controller_override.h"
#include "api/video/builtin_video_bitrate_allocator_factory.h" #include "api/video/builtin_video_bitrate_allocator_factory.h"
@ -92,10 +94,10 @@ class VideoCodecInitializerTest : public ::testing::Test {
void InitializeCodec() { void InitializeCodec() {
frame_buffer_controller_.reset(); frame_buffer_controller_.reset();
codec_out_ = codec_out_ = VideoCodecInitializer::SetupCodec(env_.field_trials(), config_,
VideoCodecInitializer::SetupCodec(field_trials_, config_, streams_); streams_);
bitrate_allocator_ = CreateBuiltinVideoBitrateAllocatorFactory() bitrate_allocator_ =
->CreateVideoBitrateAllocator(codec_out_); CreateBuiltinVideoBitrateAllocatorFactory()->Create(env_, codec_out_);
RTC_CHECK(bitrate_allocator_); RTC_CHECK(bitrate_allocator_);
// Make sure temporal layers instances have been created. // Make sure temporal layers instances have been created.
@ -137,7 +139,7 @@ class VideoCodecInitializerTest : public ::testing::Test {
return stream; return stream;
} }
const test::ExplicitKeyValueConfig field_trials_{""}; const Environment env_ = CreateEnvironment();
MockFecControllerOverride fec_controller_override_; MockFecControllerOverride fec_controller_override_;
// Input settings. // Input settings.
@ -505,7 +507,7 @@ TEST_F(VideoCodecInitializerTest, Av1SingleSpatialLayerBitratesAreConsistent) {
streams[0].scalability_mode = ScalabilityMode::kL1T2; streams[0].scalability_mode = ScalabilityMode::kL1T2;
VideoCodec codec = VideoCodec codec =
VideoCodecInitializer::SetupCodec(field_trials_, config, streams); VideoCodecInitializer::SetupCodec(env_.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,7 +522,7 @@ TEST_F(VideoCodecInitializerTest, Av1TwoSpatialLayersBitratesAreConsistent) {
streams[0].scalability_mode = ScalabilityMode::kL2T2; streams[0].scalability_mode = ScalabilityMode::kL2T2;
VideoCodec codec = VideoCodec codec =
VideoCodecInitializer::SetupCodec(field_trials_, config, streams); VideoCodecInitializer::SetupCodec(env_.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,7 +543,7 @@ TEST_F(VideoCodecInitializerTest, Av1TwoSpatialLayersActiveByDefault) {
config.spatial_layers = {}; config.spatial_layers = {};
VideoCodec codec = VideoCodec codec =
VideoCodecInitializer::SetupCodec(field_trials_, config, streams); VideoCodecInitializer::SetupCodec(env_.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,7 +559,7 @@ TEST_F(VideoCodecInitializerTest, Av1TwoSpatialLayersOneDeactivated) {
config.spatial_layers[1].active = false; config.spatial_layers[1].active = false;
VideoCodec codec = VideoCodec codec =
VideoCodecInitializer::SetupCodec(field_trials_, config, streams); VideoCodecInitializer::SetupCodec(env_.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,7 +577,7 @@ TEST_F(VideoCodecInitializerTest, Vp9SingleSpatialLayerBitratesAreConsistent) {
streams[0].scalability_mode = ScalabilityMode::kL1T2; streams[0].scalability_mode = ScalabilityMode::kL1T2;
VideoCodec codec = VideoCodec codec =
VideoCodecInitializer::SetupCodec(field_trials_, config, streams); VideoCodecInitializer::SetupCodec(env_.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,7 +605,7 @@ TEST_F(VideoCodecInitializerTest, Vp9TwoSpatialLayersBitratesAreConsistent) {
streams[0].scalability_mode = ScalabilityMode::kL2T2; streams[0].scalability_mode = ScalabilityMode::kL2T2;
VideoCodec codec = VideoCodec codec =
VideoCodecInitializer::SetupCodec(field_trials_, config, streams); VideoCodecInitializer::SetupCodec(env_.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,14 +629,15 @@ TEST_F(VideoCodecInitializerTest, UpdatesVp9SpecificFieldsWithScalabilityMode) {
streams[0].scalability_mode = ScalabilityMode::kL2T3_KEY; streams[0].scalability_mode = ScalabilityMode::kL2T3_KEY;
VideoCodec codec = VideoCodec codec =
VideoCodecInitializer::SetupCodec(field_trials_, config, streams); VideoCodecInitializer::SetupCodec(env_.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;
codec = VideoCodecInitializer::SetupCodec(field_trials_, config, streams); codec =
VideoCodecInitializer::SetupCodec(env_.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);

10
rtc_tools/video_encoder/video_encoder.cc
View File

@ -333,13 +333,13 @@ class TestVideoEncoderFactoryWrapper final {
RTC_CHECK_EQ(ret, WEBRTC_VIDEO_CODEC_OK); RTC_CHECK_EQ(ret, WEBRTC_VIDEO_CODEC_OK);
// Set bitrates. // Set bitrates.
std::unique_ptr<webrtc::VideoBitrateAllocator> bitrate_allocator_; std::unique_ptr<VideoBitrateAllocator> bitrate_allocator =
bitrate_allocator_ = webrtc::CreateBuiltinVideoBitrateAllocatorFactory() CreateBuiltinVideoBitrateAllocatorFactory()->Create(
->CreateVideoBitrateAllocator(video_codec_setting); env, video_codec_setting);
RTC_CHECK(bitrate_allocator_); RTC_CHECK(bitrate_allocator);
webrtc::VideoBitrateAllocation allocation = webrtc::VideoBitrateAllocation allocation =
bitrate_allocator_->GetAllocation(bitrate_kbps * 1000, frame_rate_fps); bitrate_allocator->GetAllocation(bitrate_kbps * 1000, frame_rate_fps);
RTC_LOG(LS_INFO) << allocation.ToString(); RTC_LOG(LS_INFO) << allocation.ToString();
video_encoder->SetRates(webrtc::VideoEncoder::RateControlParameters( video_encoder->SetRates(webrtc::VideoEncoder::RateControlParameters(

9
test/video_codec_tester.cc
View File

@ -1300,7 +1300,8 @@ void SetDefaultCodecSpecificSettings(VideoCodec* vc, int num_temporal_layers) {
} }
std::tuple<std::vector<DataRate>, ScalabilityMode> std::tuple<std::vector<DataRate>, ScalabilityMode>
SplitBitrateAndUpdateScalabilityMode(std::string codec_type, SplitBitrateAndUpdateScalabilityMode(const Environment& env,
std::string codec_type,
ScalabilityMode scalability_mode, ScalabilityMode scalability_mode,
int width, int width,
int height, int height,
@ -1407,8 +1408,7 @@ SplitBitrateAndUpdateScalabilityMode(std::string codec_type,
} }
std::unique_ptr<VideoBitrateAllocator> bitrate_allocator = std::unique_ptr<VideoBitrateAllocator> bitrate_allocator =
CreateBuiltinVideoBitrateAllocatorFactory()->CreateVideoBitrateAllocator( CreateBuiltinVideoBitrateAllocatorFactory()->Create(env, vc);
vc);
VideoBitrateAllocation bitrate_allocation = VideoBitrateAllocation bitrate_allocation =
bitrate_allocator->Allocate(VideoBitrateAllocationParameters( bitrate_allocator->Allocate(VideoBitrateAllocationParameters(
total_bitrate.bps(), framerate.hertz<double>())); total_bitrate.bps(), framerate.hertz<double>()));
@ -1486,6 +1486,7 @@ void VideoCodecStats::Stream::LogMetrics(
} }
EncodingSettings VideoCodecTester::CreateEncodingSettings( EncodingSettings VideoCodecTester::CreateEncodingSettings(
const Environment& env,
std::string codec_type, std::string codec_type,
std::string scalability_name, std::string scalability_name,
int width, int width,
@ -1499,7 +1500,7 @@ EncodingSettings VideoCodecTester::CreateEncodingSettings(
auto [adjusted_bitrate, scalability_mode] = auto [adjusted_bitrate, scalability_mode] =
SplitBitrateAndUpdateScalabilityMode( SplitBitrateAndUpdateScalabilityMode(
codec_type, *ScalabilityModeFromString(scalability_name), width, env, codec_type, *ScalabilityModeFromString(scalability_name), width,
height, bitrate, framerate, content_type); height, bitrate, framerate, content_type);
int num_spatial_layers = ScalabilityModeToNumSpatialLayers(scalability_mode); int num_spatial_layers = ScalabilityModeToNumSpatialLayers(scalability_mode);

3
test/video_codec_tester.h
View File

@ -194,7 +194,8 @@ class VideoCodecTester {
// and per-temporal layer. If layer bitrates are not explicitly specified, // and per-temporal layer. If layer bitrates are not explicitly specified,
// then the codec-specific rate allocators used to distribute the total // then the codec-specific rate allocators used to distribute the total
// bitrate across spatial or/and temporal layers. // bitrate across spatial or/and temporal layers.
static EncodingSettings CreateEncodingSettings(std::string codec_type, static EncodingSettings CreateEncodingSettings(const Environment& env,
std::string codec_type,
std::string scalability_name, std::string scalability_name,
int width, int width,
int height, int height,

5
test/video_codec_tester_unittest.cc
View File

@ -620,7 +620,7 @@ TEST_P(VideoCodecTesterTestPacing, PaceEncode) {
})); }));
EncodingSettings encoding_settings = VideoCodecTester::CreateEncodingSettings( EncodingSettings encoding_settings = VideoCodecTester::CreateEncodingSettings(
"VP8", "L1T1", kSourceWidth, kSourceHeight, {kBitrate}, kFramerate); env, "VP8", "L1T1", kSourceWidth, kSourceHeight, {kBitrate}, kFramerate);
std::map<uint32_t, EncodingSettings> frame_settings = std::map<uint32_t, EncodingSettings> frame_settings =
VideoCodecTester::CreateFrameSettings(encoding_settings, kNumFrames); VideoCodecTester::CreateFrameSettings(encoding_settings, kNumFrames);
@ -687,7 +687,8 @@ class VideoCodecTesterTestEncodingSettings
TEST_P(VideoCodecTesterTestEncodingSettings, CreateEncodingSettings) { TEST_P(VideoCodecTesterTestEncodingSettings, CreateEncodingSettings) {
EncodingSettingsTestParameters test_params = GetParam(); EncodingSettingsTestParameters test_params = GetParam();
EncodingSettings encoding_settings = VideoCodecTester::CreateEncodingSettings( EncodingSettings encoding_settings = VideoCodecTester::CreateEncodingSettings(
test_params.codec_type, test_params.scalability_mode, /*width=*/1280, CreateEnvironment(), test_params.codec_type, test_params.scalability_mode,
/*width=*/1280,
/*height=*/720, test_params.bitrate, kFramerate); /*height=*/720, test_params.bitrate, kFramerate);
const std::map<LayerId, LayerSettings>& layers_settings = const std::map<LayerId, LayerSettings>& layers_settings =
encoding_settings.layers_settings; encoding_settings.layers_settings;

5
video/video_send_stream_tests.cc
View File

@ -2697,7 +2697,8 @@ TEST_F(VideoSendStreamTest, ReconfigureBitratesSetsEncoderBitratesCorrectly) {
CreateBuiltinVideoBitrateAllocatorFactory()) {} CreateBuiltinVideoBitrateAllocatorFactory()) {}
private: private:
std::unique_ptr<VideoBitrateAllocator> CreateVideoBitrateAllocator( std::unique_ptr<VideoBitrateAllocator> Create(
const Environment& env,
const VideoCodec& codec) override { const VideoCodec& codec) override {
EXPECT_GE(codec.startBitrate, codec.minBitrate); EXPECT_GE(codec.startBitrate, codec.minBitrate);
EXPECT_LE(codec.startBitrate, codec.maxBitrate); EXPECT_LE(codec.startBitrate, codec.maxBitrate);
@ -2722,7 +2723,7 @@ TEST_F(VideoSendStreamTest, ReconfigureBitratesSetsEncoderBitratesCorrectly) {
++num_rate_allocator_creations_; ++num_rate_allocator_creations_;
create_rate_allocator_event_.Set(); create_rate_allocator_event_.Set();
return bitrate_allocator_factory_->CreateVideoBitrateAllocator(codec); return bitrate_allocator_factory_->Create(env, codec);
} }
int32_t InitEncode(const VideoCodec* codecSettings, int32_t InitEncode(const VideoCodec* codecSettings,

3
video/video_stream_encoder.cc
View File

@ -1267,8 +1267,7 @@ void VideoStreamEncoder::ReconfigureEncoder() {
} }
})); }));
rate_allocator_ = rate_allocator_ = settings_.bitrate_allocator_factory->Create(env_, codec);
settings_.bitrate_allocator_factory->CreateVideoBitrateAllocator(codec);
rate_allocator_->SetLegacyConferenceMode( rate_allocator_->SetLegacyConferenceMode(
encoder_config_.legacy_conference_mode); encoder_config_.legacy_conference_mode);

5
video/video_stream_encoder_unittest.cc
View File

@ -1601,11 +1601,12 @@ class VideoStreamEncoderTest : public ::testing::Test {
: bitrate_allocator_factory_( : bitrate_allocator_factory_(
CreateBuiltinVideoBitrateAllocatorFactory()) {} CreateBuiltinVideoBitrateAllocatorFactory()) {}
std::unique_ptr<VideoBitrateAllocator> CreateVideoBitrateAllocator( std::unique_ptr<VideoBitrateAllocator> Create(
const Environment& env,
const VideoCodec& codec) override { const VideoCodec& codec) override {
MutexLock lock(&mutex_); MutexLock lock(&mutex_);
codec_config_ = codec; codec_config_ = codec;
return bitrate_allocator_factory_->CreateVideoBitrateAllocator(codec); return bitrate_allocator_factory_->Create(env, codec);
} }
VideoCodec codec_config() const { VideoCodec codec_config() const {