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

This relands the
https://webrtc-review.googlesource.com/c/src/+/349920
where patchset#1 is identical to the original change,
patchset#2 undoes (postpones) the expectation downstream propagates the Environment too.

Bug: webrtc:42220378
Change-Id: I4a9a32bb0926a875d37f3ba19dd5309e97546553
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/350364
Reviewed-by: Erik Språng <sprang@webrtc.org>
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Reviewed-by: Philip Eliasson <philipel@webrtc.org>
Reviewed-by: Mirko Bonadei <mbonadei@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#42298}
This commit is contained in:
Danil Chapovalov 2024-05-13 16:33:07 +02:00 committed by WebRTC LUCI CQ
parent 1f90b92eda
commit 179f96de7e
19 changed files with 85 additions and 57 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 {
class MockVideoBitrateAllocatorFactory
: public webrtc::VideoBitrateAllocatorFactory {
class MockVideoBitrateAllocatorFactory : public VideoBitrateAllocatorFactory {
public:
~MockVideoBitrateAllocatorFactory() override { Die(); }
MOCK_METHOD(std::unique_ptr<VideoBitrateAllocator>,
CreateVideoBitrateAllocator,
(const VideoCodec&),
Create,
(const Environment&, const VideoCodec&),
(override));
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" ]
deps = [
":video_bitrate_allocator",
"../../rtc_base:checks",
"../environment",
"../video_codecs:video_codecs_api",
]
}

14
api/video/video_bitrate_allocator_factory.h
View File

@ -13,8 +13,10 @@
#include <memory>
#include "api/environment/environment.h"
#include "api/video/video_bitrate_allocator.h"
#include "api/video_codecs/video_codec.h"
#include "rtc_base/checks.h"
namespace webrtc {
@ -23,9 +25,19 @@ namespace webrtc {
class VideoBitrateAllocatorFactory {
public:
virtual ~VideoBitrateAllocatorFactory() = default;
// 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(
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

6
media/engine/webrtc_video_engine_unittest.cc
View File

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

1
modules/video_coding/BUILD.gn
View File

@ -1204,6 +1204,7 @@ if (rtc_include_tests) {
"../../api:scoped_refptr",
"../../api:simulcast_test_fixture_api",
"../../api:videocodec_test_fixture_api",
"../../api/environment",
"../../api/environment:environment_factory",
"../../api/task_queue",
"../../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);
EncodingSettings encoding_settings = VideoCodecTester::CreateEncodingSettings(
codec_type, /*scalability_mode=*/"L1T1", width, height,
env, codec_type, /*scalability_mode=*/"L1T1", width, height,
{DataRate::KilobitsPerSec(bitrate_kbps)},
Frequency::Hertz(framerate_fps));
@ -398,14 +398,14 @@ TEST_P(BitrateAdaptationTest, BitrateAdaptation) {
VideoSourceSettings source_settings = ToSourceSettings(video_info);
EncodingSettings encoding_settings = VideoCodecTester::CreateEncodingSettings(
codec_type, /*scalability_mode=*/"L1T1",
env, codec_type, /*scalability_mode=*/"L1T1",
/*width=*/640, /*height=*/360,
{DataRate::KilobitsPerSec(bitrate_kbps.first)},
/*framerate=*/Frequency::Hertz(30));
EncodingSettings encoding_settings2 =
VideoCodecTester::CreateEncodingSettings(
codec_type, /*scalability_mode=*/"L1T1",
env, codec_type, /*scalability_mode=*/"L1T1",
/*width=*/640, /*height=*/360,
{DataRate::KilobitsPerSec(bitrate_kbps.second)},
/*framerate=*/Frequency::Hertz(30));
@ -484,14 +484,14 @@ TEST_P(FramerateAdaptationTest, FramerateAdaptation) {
VideoSourceSettings source_settings = ToSourceSettings(video_info);
EncodingSettings encoding_settings = VideoCodecTester::CreateEncodingSettings(
codec_type, /*scalability_mode=*/"L1T1",
env, codec_type, /*scalability_mode=*/"L1T1",
/*width=*/640, /*height=*/360,
/*bitrate=*/{DataRate::KilobitsPerSec(512)},
Frequency::Hertz(framerate_fps.first));
EncodingSettings encoding_settings2 =
VideoCodecTester::CreateEncodingSettings(
codec_type, /*scalability_mode=*/"L1T1",
env, codec_type, /*scalability_mode=*/"L1T1",
/*width=*/640, /*height=*/360,
/*bitrate=*/{DataRate::KilobitsPerSec(512)},
Frequency::Hertz(framerate_fps.second));
@ -571,7 +571,7 @@ TEST(VideoCodecTest, DISABLED_EncodeDecode) {
.value_or(absl::GetFlag(FLAGS_input_framerate_fps)));
EncodingSettings encoding_settings = VideoCodecTester::CreateEncodingSettings(
CodecNameToCodecType(absl::GetFlag(FLAGS_encoder)),
env, CodecNameToCodecType(absl::GetFlag(FLAGS_encoder)),
absl::GetFlag(FLAGS_scalability_mode),
absl::GetFlag(FLAGS_width).value_or(absl::GetFlag(FLAGS_input_width)),
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::OpenH264DecoderTemplateAdapter,
webrtc::Dav1dDecoderTemplateAdapter>>()),
env_(CreateEnvironment()),
config_(config) {}
VideoCodecTestFixtureImpl::VideoCodecTestFixtureImpl(
@ -454,6 +455,7 @@ VideoCodecTestFixtureImpl::VideoCodecTestFixtureImpl(
std::unique_ptr<VideoEncoderFactory> encoder_factory)
: encoder_factory_(std::move(encoder_factory)),
decoder_factory_(std::move(decoder_factory)),
env_(CreateEnvironment()),
config_(config) {}
VideoCodecTestFixtureImpl::~VideoCodecTestFixtureImpl() = default;
@ -695,8 +697,6 @@ void VideoCodecTestFixtureImpl::VerifyVideoStatistic(
}
bool VideoCodecTestFixtureImpl::CreateEncoderAndDecoder() {
const Environment env = CreateEnvironment();
SdpVideoFormat encoder_format(CreateSdpVideoFormat(config_));
SdpVideoFormat decoder_format = encoder_format;
@ -711,7 +711,7 @@ bool VideoCodecTestFixtureImpl::CreateEncoderAndDecoder() {
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.";
if (encoder_ == nullptr) {
return false;
@ -721,7 +721,7 @@ bool VideoCodecTestFixtureImpl::CreateEncoderAndDecoder() {
config_.NumberOfSimulcastStreams(), config_.NumberOfSpatialLayers());
for (size_t i = 0; i < num_simulcast_or_spatial_layers; ++i) {
std::unique_ptr<VideoDecoder> decoder =
decoder_factory_->Create(env, decoder_format);
decoder_factory_->Create(env_, decoder_format);
EXPECT_TRUE(decoder) << "Decoder not successfully created.";
if (decoder == nullptr) {
return false;
@ -818,7 +818,7 @@ bool VideoCodecTestFixtureImpl::SetUpAndInitObjects(
task_queue->SendTask([this]() {
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_,
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 <vector>
#include "api/environment/environment.h"
#include "api/test/videocodec_test_fixture.h"
#include "api/video_codecs/video_decoder_factory.h"
#include "api/video_codecs/video_encoder_factory.h"
@ -92,6 +93,7 @@ class VideoCodecTestFixtureImpl : public VideoCodecTestFixture {
VideoProcessor::VideoDecoderList decoders_;
// Helper objects.
const Environment env_;
Config config_;
VideoCodecTestStatsImpl stats_;
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
VideoProcessor::VideoProcessor(webrtc::VideoEncoder* encoder,
VideoProcessor::VideoProcessor(const Environment& env,
webrtc::VideoEncoder* encoder,
VideoDecoderList* decoders,
FrameReader* input_frame_reader,
const VideoCodecTestFixture::Config& config,
@ -150,9 +151,9 @@ VideoProcessor::VideoProcessor(webrtc::VideoEncoder* encoder,
stats_(stats),
encoder_(encoder),
decoders_(decoders),
bitrate_allocator_(
CreateBuiltinVideoBitrateAllocatorFactory()
->CreateVideoBitrateAllocator(config_.codec_settings)),
bitrate_allocator_(CreateBuiltinVideoBitrateAllocatorFactory()->Create(
env,
config_.codec_settings)),
encode_callback_(this),
input_frame_reader_(input_frame_reader),
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 "absl/types/optional.h"
#include "api/environment/environment.h"
#include "api/sequence_checker.h"
#include "api/task_queue/task_queue_base.h"
#include "api/test/videocodec_test_fixture.h"
@ -61,7 +62,8 @@ class VideoProcessor {
using FrameWriterList = std::vector<std::unique_ptr<FrameWriter>>;
using FrameStatistics = VideoCodecTestStats::FrameStatistics;
VideoProcessor(webrtc::VideoEncoder* encoder,
VideoProcessor(const Environment& env,
VideoEncoder* encoder,
VideoDecoderList* decoders,
FrameReader* input_frame_reader,
const VideoCodecTestFixture::Config& config,

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

@ -12,6 +12,7 @@
#include <memory>
#include "api/environment/environment_factory.h"
#include "api/scoped_refptr.h"
#include "api/test/mock_video_decoder.h"
#include "api/test/mock_video_encoder.h"
@ -53,8 +54,9 @@ class VideoProcessorTest : public ::testing::Test {
ExpectInit();
q_.SendTask([this] {
video_processor_ = std::make_unique<VideoProcessor>(
&encoder_mock_, &decoders_, &frame_reader_mock_, config_, &stats_,
&encoded_frame_writers_, /*decoded_frame_writers=*/nullptr);
CreateEnvironment(), &encoder_mock_, &decoders_, &frame_reader_mock_,
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 "absl/types/optional.h"
#include "api/environment/environment.h"
#include "api/environment/environment_factory.h"
#include "api/scoped_refptr.h"
#include "api/test/mock_fec_controller_override.h"
#include "api/video/builtin_video_bitrate_allocator_factory.h"
@ -92,10 +94,10 @@ class VideoCodecInitializerTest : public ::testing::Test {
void InitializeCodec() {
frame_buffer_controller_.reset();
codec_out_ =
VideoCodecInitializer::SetupCodec(field_trials_, config_, streams_);
bitrate_allocator_ = CreateBuiltinVideoBitrateAllocatorFactory()
->CreateVideoBitrateAllocator(codec_out_);
codec_out_ = VideoCodecInitializer::SetupCodec(env_.field_trials(), config_,
streams_);
bitrate_allocator_ =
CreateBuiltinVideoBitrateAllocatorFactory()->Create(env_, codec_out_);
RTC_CHECK(bitrate_allocator_);
// Make sure temporal layers instances have been created.
@ -137,7 +139,7 @@ class VideoCodecInitializerTest : public ::testing::Test {
return stream;
}
const test::ExplicitKeyValueConfig field_trials_{""};
const Environment env_ = CreateEnvironment();
MockFecControllerOverride fec_controller_override_;
// Input settings.
@ -505,7 +507,7 @@ TEST_F(VideoCodecInitializerTest, Av1SingleSpatialLayerBitratesAreConsistent) {
streams[0].scalability_mode = ScalabilityMode::kL1T2;
VideoCodec codec =
VideoCodecInitializer::SetupCodec(field_trials_, config, streams);
VideoCodecInitializer::SetupCodec(env_.field_trials(), config, streams);
EXPECT_GE(codec.spatialLayers[0].targetBitrate,
codec.spatialLayers[0].minBitrate);
@ -520,7 +522,7 @@ TEST_F(VideoCodecInitializerTest, Av1TwoSpatialLayersBitratesAreConsistent) {
streams[0].scalability_mode = ScalabilityMode::kL2T2;
VideoCodec codec =
VideoCodecInitializer::SetupCodec(field_trials_, config, streams);
VideoCodecInitializer::SetupCodec(env_.field_trials(), config, streams);
EXPECT_GE(codec.spatialLayers[0].targetBitrate,
codec.spatialLayers[0].minBitrate);
@ -541,7 +543,7 @@ TEST_F(VideoCodecInitializerTest, Av1TwoSpatialLayersActiveByDefault) {
config.spatial_layers = {};
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[1].active);
@ -557,7 +559,7 @@ TEST_F(VideoCodecInitializerTest, Av1TwoSpatialLayersOneDeactivated) {
config.spatial_layers[1].active = false;
VideoCodec codec =
VideoCodecInitializer::SetupCodec(field_trials_, config, streams);
VideoCodecInitializer::SetupCodec(env_.field_trials(), config, streams);
EXPECT_TRUE(codec.spatialLayers[0].active);
EXPECT_FALSE(codec.spatialLayers[1].active);
@ -575,7 +577,7 @@ TEST_F(VideoCodecInitializerTest, Vp9SingleSpatialLayerBitratesAreConsistent) {
streams[0].scalability_mode = ScalabilityMode::kL1T2;
VideoCodec codec =
VideoCodecInitializer::SetupCodec(field_trials_, config, streams);
VideoCodecInitializer::SetupCodec(env_.field_trials(), config, streams);
EXPECT_EQ(1u, codec.VP9()->numberOfSpatialLayers);
// Target is consistent with min and max (min <= target <= max).
@ -603,7 +605,7 @@ TEST_F(VideoCodecInitializerTest, Vp9TwoSpatialLayersBitratesAreConsistent) {
streams[0].scalability_mode = ScalabilityMode::kL2T2;
VideoCodec codec =
VideoCodecInitializer::SetupCodec(field_trials_, config, streams);
VideoCodecInitializer::SetupCodec(env_.field_trials(), config, streams);
EXPECT_EQ(2u, codec.VP9()->numberOfSpatialLayers);
EXPECT_GE(codec.spatialLayers[0].targetBitrate,
@ -627,14 +629,15 @@ TEST_F(VideoCodecInitializerTest, UpdatesVp9SpecificFieldsWithScalabilityMode) {
streams[0].scalability_mode = ScalabilityMode::kL2T3_KEY;
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()->numberOfTemporalLayers, 3u);
EXPECT_EQ(codec.VP9()->interLayerPred, InterLayerPredMode::kOnKeyPic);
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()->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);
// Set bitrates.
std::unique_ptr<webrtc::VideoBitrateAllocator> bitrate_allocator_;
bitrate_allocator_ = webrtc::CreateBuiltinVideoBitrateAllocatorFactory()
->CreateVideoBitrateAllocator(video_codec_setting);
RTC_CHECK(bitrate_allocator_);
std::unique_ptr<VideoBitrateAllocator> bitrate_allocator =
CreateBuiltinVideoBitrateAllocatorFactory()->Create(
env, video_codec_setting);
RTC_CHECK(bitrate_allocator);
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();
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>
SplitBitrateAndUpdateScalabilityMode(std::string codec_type,
SplitBitrateAndUpdateScalabilityMode(const Environment& env,
std::string codec_type,
ScalabilityMode scalability_mode,
int width,
int height,
@ -1407,8 +1408,7 @@ SplitBitrateAndUpdateScalabilityMode(std::string codec_type,
}
std::unique_ptr<VideoBitrateAllocator> bitrate_allocator =
CreateBuiltinVideoBitrateAllocatorFactory()->CreateVideoBitrateAllocator(
vc);
CreateBuiltinVideoBitrateAllocatorFactory()->Create(env, vc);
VideoBitrateAllocation bitrate_allocation =
bitrate_allocator->Allocate(VideoBitrateAllocationParameters(
total_bitrate.bps(), framerate.hertz<double>()));
@ -1486,6 +1486,7 @@ void VideoCodecStats::Stream::LogMetrics(
}
EncodingSettings VideoCodecTester::CreateEncodingSettings(
const Environment& env,
std::string codec_type,
std::string scalability_name,
int width,
@ -1499,7 +1500,7 @@ EncodingSettings VideoCodecTester::CreateEncodingSettings(
auto [adjusted_bitrate, scalability_mode] =
SplitBitrateAndUpdateScalabilityMode(
codec_type, *ScalabilityModeFromString(scalability_name), width,
env, codec_type, *ScalabilityModeFromString(scalability_name), width,
height, bitrate, framerate, content_type);
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,
// then the codec-specific rate allocators used to distribute the total
// 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,
int width,
int height,

5
test/video_codec_tester_unittest.cc
View File

@ -620,7 +620,7 @@ TEST_P(VideoCodecTesterTestPacing, PaceEncode) {
}));
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 =
VideoCodecTester::CreateFrameSettings(encoding_settings, kNumFrames);
@ -687,7 +687,8 @@ class VideoCodecTesterTestEncodingSettings
TEST_P(VideoCodecTesterTestEncodingSettings, CreateEncodingSettings) {
EncodingSettingsTestParameters test_params = GetParam();
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);
const std::map<LayerId, LayerSettings>& layers_settings =
encoding_settings.layers_settings;

5
video/video_send_stream_tests.cc
View File

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

3
video/video_stream_encoder.cc
View File

@ -1267,8 +1267,7 @@ void VideoStreamEncoder::ReconfigureEncoder() {
}
}));
rate_allocator_ =
settings_.bitrate_allocator_factory->CreateVideoBitrateAllocator(codec);
rate_allocator_ = settings_.bitrate_allocator_factory->Create(env_, codec);
rate_allocator_->SetLegacyConferenceMode(
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_(
CreateBuiltinVideoBitrateAllocatorFactory()) {}
std::unique_ptr<VideoBitrateAllocator> CreateVideoBitrateAllocator(
std::unique_ptr<VideoBitrateAllocator> Create(
const Environment& env,
const VideoCodec& codec) override {
MutexLock lock(&mutex_);
codec_config_ = codec;
return bitrate_allocator_factory_->CreateVideoBitrateAllocator(codec);
return bitrate_allocator_factory_->Create(env, codec);
}
VideoCodec codec_config() const {