Remove TemporalLayersFactory and associated classes
As the rate allocation has been moved into entirely into
SimulcastRateAllocator, and the listeners are thus no longer needed,
this class doesn't fill any other purpose than to determine if
ScreenshareLayers or TemporalLayers should be created for a given
simulcast stream. This can however be done just from looking at the
VideoCodec instance, so changing this into a static factory method.
Due to dependencies from upstream projects, keep the class name and
field in VideoCodec around for now.
Bug: webrtc:9012
Change-Id: I028fe6b2a19e0d16b35956cc2df01dcf5bfa7979
Reviewed-on: https://webrtc-review.googlesource.com/63264
Commit-Queue: Erik Språng <sprang@webrtc.org>
Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org>
Reviewed-by: Stefan Holmer <stefan@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#22529}diff --git a/media/engine/simulcast_encoder_adapter.cc b/media/engine/simulcast_encoder_adapter.cc
index ce6a5b1..e33666f 100644
--- a/media/engine/simulcast_encoder_adapter.cc
+++ b/media/engine/simulcast_encoder_adapter.cc
@@ -103,33 +103,6 @@
webrtc::SimulcastEncoderAdapter* const adapter_;
const size_t stream_idx_;
};
-
-// Utility class used to adapt the simulcast id as reported by the temporal
-// layers factory, since each sub-encoder will report stream 0.
-class TemporalLayersFactoryAdapter : public webrtc::TemporalLayersFactory {
- public:
- TemporalLayersFactoryAdapter(int adapted_simulcast_id,
- const TemporalLayersFactory& tl_factory)
- : adapted_simulcast_id_(adapted_simulcast_id), tl_factory_(tl_factory) {}
- ~TemporalLayersFactoryAdapter() override {}
- webrtc::TemporalLayers* Create(int simulcast_id,
- int temporal_layers,
- uint8_t initial_tl0_pic_idx) const override {
- return tl_factory_.Create(adapted_simulcast_id_, temporal_layers,
- initial_tl0_pic_idx);
- }
- std::unique_ptr<webrtc::TemporalLayersChecker> CreateChecker(
- int simulcast_id,
- int temporal_layers,
- uint8_t initial_tl0_pic_idx) const override {
- return tl_factory_.CreateChecker(adapted_simulcast_id_, temporal_layers,
- initial_tl0_pic_idx);
- }
-
- const int adapted_simulcast_id_;
- const TemporalLayersFactory& tl_factory_;
-};
-
} // namespace
namespace webrtc {
@@ -204,7 +177,7 @@
}
codec_ = *inst;
- SimulcastRateAllocator rate_allocator(codec_, nullptr);
+ SimulcastRateAllocator rate_allocator(codec_);
BitrateAllocation allocation = rate_allocator.GetAllocation(
codec_.startBitrate * 1000, codec_.maxFramerate);
std::vector<uint32_t> start_bitrates;
@@ -230,9 +203,6 @@
PopulateStreamCodec(codec_, i, start_bitrate_kbps,
highest_resolution_stream, &stream_codec);
}
- TemporalLayersFactoryAdapter tl_factory_adapter(i,
- *codec_.VP8()->tl_factory);
- stream_codec.VP8()->tl_factory = &tl_factory_adapter;
// TODO(ronghuawu): Remove once this is handled in LibvpxVp8Encoder.
if (stream_codec.qpMax < kDefaultMinQp) {
diff --git a/media/engine/simulcast_encoder_adapter_unittest.cc b/media/engine/simulcast_encoder_adapter_unittest.cc
index bd8f044..d2acd94 100644
--- a/media/engine/simulcast_encoder_adapter_unittest.cc
+++ b/media/engine/simulcast_encoder_adapter_unittest.cc
@@ -123,7 +123,7 @@
class MockVideoEncoder : public VideoEncoder {
public:
explicit MockVideoEncoder(MockVideoEncoderFactory* factory)
- : factory_(factory) {}
+ : factory_(factory), callback_(nullptr) {}
// TODO(nisse): Valid overrides commented out, because the gmock
// methods don't use any override declarations, and we want to avoid
@@ -313,9 +313,7 @@
void SetupCodec() {
TestVp8Simulcast::DefaultSettings(
&codec_, static_cast<const int*>(kTestTemporalLayerProfile));
- rate_allocator_.reset(new SimulcastRateAllocator(codec_, nullptr));
- tl_factory_.SetListener(rate_allocator_.get());
- codec_.VP8()->tl_factory = &tl_factory_;
+ rate_allocator_.reset(new SimulcastRateAllocator(codec_));
EXPECT_EQ(0, adapter_->InitEncode(&codec_, 1, 1200));
adapter_->RegisterEncodeCompleteCallback(this);
}
@@ -351,7 +349,6 @@
*ref_codec = codec_;
ref_codec->VP8()->numberOfTemporalLayers =
kTestTemporalLayerProfile[stream_index];
- ref_codec->VP8()->tl_factory = &tl_factory_;
ref_codec->width = codec_.simulcastStream[stream_index].width;
ref_codec->height = codec_.simulcastStream[stream_index].height;
ref_codec->maxBitrate = codec_.simulcastStream[stream_index].maxBitrate;
@@ -395,7 +392,6 @@
int last_encoded_image_width_;
int last_encoded_image_height_;
int last_encoded_image_simulcast_index_;
- TemporalLayersFactory tl_factory_;
std::unique_ptr<SimulcastRateAllocator> rate_allocator_;
};
@@ -466,9 +462,7 @@
// Set up common settings for three streams.
TestVp8Simulcast::DefaultSettings(
&codec_, static_cast<const int*>(kTestTemporalLayerProfile));
- rate_allocator_.reset(new SimulcastRateAllocator(codec_, nullptr));
- tl_factory_.SetListener(rate_allocator_.get());
- codec_.VP8()->tl_factory = &tl_factory_;
+ rate_allocator_.reset(new SimulcastRateAllocator(codec_));
adapter_->RegisterEncodeCompleteCallback(this);
// Input data.
@@ -666,7 +660,6 @@
TEST_F(TestSimulcastEncoderAdapterFake, SupportsNativeHandleForSingleStreams) {
TestVp8Simulcast::DefaultSettings(
&codec_, static_cast<const int*>(kTestTemporalLayerProfile));
- codec_.VP8()->tl_factory = &tl_factory_;
codec_.numberOfSimulcastStreams = 1;
EXPECT_EQ(0, adapter_->InitEncode(&codec_, 1, 1200));
adapter_->RegisterEncodeCompleteCallback(this);
@@ -680,11 +673,10 @@
TEST_F(TestSimulcastEncoderAdapterFake, SetRatesUnderMinBitrate) {
TestVp8Simulcast::DefaultSettings(
&codec_, static_cast<const int*>(kTestTemporalLayerProfile));
- codec_.VP8()->tl_factory = &tl_factory_;
codec_.minBitrate = 50;
codec_.numberOfSimulcastStreams = 1;
EXPECT_EQ(0, adapter_->InitEncode(&codec_, 1, 1200));
- rate_allocator_.reset(new SimulcastRateAllocator(codec_, nullptr));
+ rate_allocator_.reset(new SimulcastRateAllocator(codec_));
// Above min should be respected.
BitrateAllocation target_bitrate =
@@ -710,7 +702,6 @@
EXPECT_STREQ("SimulcastEncoderAdapter", adapter_->ImplementationName());
TestVp8Simulcast::DefaultSettings(
&codec_, static_cast<const int*>(kTestTemporalLayerProfile));
- codec_.VP8()->tl_factory = &tl_factory_;
std::vector<const char*> encoder_names;
encoder_names.push_back("codec1");
encoder_names.push_back("codec2");
@@ -733,7 +724,6 @@
SupportsNativeHandleForMultipleStreams) {
TestVp8Simulcast::DefaultSettings(
&codec_, static_cast<const int*>(kTestTemporalLayerProfile));
- codec_.VP8()->tl_factory = &tl_factory_;
codec_.numberOfSimulcastStreams = 3;
EXPECT_EQ(0, adapter_->InitEncode(&codec_, 1, 1200));
adapter_->RegisterEncodeCompleteCallback(this);
@@ -771,7 +761,6 @@
NativeHandleForwardingForMultipleStreams) {
TestVp8Simulcast::DefaultSettings(
&codec_, static_cast<const int*>(kTestTemporalLayerProfile));
- codec_.VP8()->tl_factory = &tl_factory_;
codec_.numberOfSimulcastStreams = 3;
// High start bitrate, so all streams are enabled.
codec_.startBitrate = 3000;
@@ -796,7 +785,6 @@
TEST_F(TestSimulcastEncoderAdapterFake, TestFailureReturnCodesFromEncodeCalls) {
TestVp8Simulcast::DefaultSettings(
&codec_, static_cast<const int*>(kTestTemporalLayerProfile));
- codec_.VP8()->tl_factory = &tl_factory_;
codec_.numberOfSimulcastStreams = 3;
EXPECT_EQ(0, adapter_->InitEncode(&codec_, 1, 1200));
adapter_->RegisterEncodeCompleteCallback(this);
@@ -818,7 +806,6 @@
TEST_F(TestSimulcastEncoderAdapterFake, TestInitFailureCleansUpEncoders) {
TestVp8Simulcast::DefaultSettings(
&codec_, static_cast<const int*>(kTestTemporalLayerProfile));
- codec_.VP8()->tl_factory = &tl_factory_;
codec_.numberOfSimulcastStreams = 3;
helper_->factory()->set_init_encode_return_value(
WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE);
diff --git a/media/engine/videoencodersoftwarefallbackwrapper_unittest.cc b/media/engine/videoencodersoftwarefallbackwrapper_unittest.cc
index f2a7ccf..df04d80 100644
--- a/media/engine/videoencodersoftwarefallbackwrapper_unittest.cc
+++ b/media/engine/videoencodersoftwarefallbackwrapper_unittest.cc
@@ -171,11 +171,7 @@
codec_.width = kWidth;
codec_.height = kHeight;
codec_.VP8()->numberOfTemporalLayers = 1;
- std::unique_ptr<TemporalLayersFactory> tl_factory(
- new TemporalLayersFactory());
- codec_.VP8()->tl_factory = tl_factory.get();
- rate_allocator_.reset(
- new SimulcastRateAllocator(codec_, std::move(tl_factory)));
+ rate_allocator_.reset(new SimulcastRateAllocator(codec_));
fake_encoder_->init_encode_return_code_ = WEBRTC_VIDEO_CODEC_ERROR;
EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
@@ -199,11 +195,7 @@
codec_.width = kWidth;
codec_.height = kHeight;
codec_.VP8()->numberOfTemporalLayers = 1;
- std::unique_ptr<TemporalLayersFactory> tl_factory(
- new TemporalLayersFactory());
- codec_.VP8()->tl_factory = tl_factory.get();
- rate_allocator_.reset(
- new SimulcastRateAllocator(codec_, std::move(tl_factory)));
+ rate_allocator_.reset(new SimulcastRateAllocator(codec_));
fallback_wrapper_.InitEncode(&codec_, 2, kMaxPayloadSize);
EXPECT_EQ(
WEBRTC_VIDEO_CODEC_OK,
@@ -352,8 +344,6 @@
void ConfigureVp8Codec() {
fallback_wrapper_.RegisterEncodeCompleteCallback(&callback_);
- std::unique_ptr<TemporalLayersFactory> tl_factory(
- new TemporalLayersFactory());
codec_.codecType = kVideoCodecVP8;
codec_.maxFramerate = kFramerate;
codec_.width = kWidth;
@@ -361,9 +351,7 @@
codec_.VP8()->numberOfTemporalLayers = 1;
codec_.VP8()->automaticResizeOn = true;
codec_.VP8()->frameDroppingOn = true;
- codec_.VP8()->tl_factory = tl_factory.get();
- rate_allocator_.reset(
- new SimulcastRateAllocator(codec_, std::move(tl_factory)));
+ rate_allocator_.reset(new SimulcastRateAllocator(codec_));
}
void InitEncode(int width, int height) {
diff --git a/media/engine/vp8_encoder_simulcast_proxy_unittest.cc b/media/engine/vp8_encoder_simulcast_proxy_unittest.cc
index 3e2761c..6b61b18 100644
--- a/media/engine/vp8_encoder_simulcast_proxy_unittest.cc
+++ b/media/engine/vp8_encoder_simulcast_proxy_unittest.cc
@@ -63,8 +63,6 @@
"SimulcastEncoderAdapter (Fake, Fake, Fake)";
VideoCodec codec_settings;
webrtc::test::CodecSettings(kVideoCodecVP8, &codec_settings);
- TemporalLayersFactory tl_factory;
- codec_settings.VP8()->tl_factory = &tl_factory;
codec_settings.simulcastStream[0] = {
test::kTestWidth, test::kTestHeight, 2, 2000, 1000, 1000, 56};
codec_settings.simulcastStream[1] = {
diff --git a/modules/video_coding/codecs/test/videoprocessor.cc b/modules/video_coding/codecs/test/videoprocessor.cc
index abec345..7c4df05 100644
--- a/modules/video_coding/codecs/test/videoprocessor.cc
+++ b/modules/video_coding/codecs/test/videoprocessor.cc
@@ -37,18 +37,6 @@
const int kMsToRtpTimestamp = kVideoPayloadTypeFrequency / 1000;
const int kMaxBufferedInputFrames = 10;
-std::unique_ptr<VideoBitrateAllocator> CreateBitrateAllocator(
- TestConfig* config) {
- std::unique_ptr<TemporalLayersFactory> tl_factory;
- if (config->codec_settings.codecType == VideoCodecType::kVideoCodecVP8) {
- tl_factory.reset(new TemporalLayersFactory());
- config->codec_settings.VP8()->tl_factory = tl_factory.get();
- }
- return std::unique_ptr<VideoBitrateAllocator>(
- VideoCodecInitializer::CreateBitrateAllocator(config->codec_settings,
- std::move(tl_factory)));
-}
-
size_t GetMaxNaluSizeBytes(const EncodedImage& encoded_frame,
const TestConfig& config) {
if (config.codec_settings.codecType != kVideoCodecH264)
@@ -179,7 +167,8 @@
stats_(stats),
encoder_(encoder),
decoders_(decoders),
- bitrate_allocator_(CreateBitrateAllocator(&config_)),
+ bitrate_allocator_(VideoCodecInitializer::CreateBitrateAllocator(
+ config_.codec_settings)),
framerate_fps_(0),
encode_callback_(this),
decode_callback_(this),
diff --git a/modules/video_coding/codecs/vp8/default_temporal_layers.cc b/modules/video_coding/codecs/vp8/default_temporal_layers.cc
index 02b3a37..bcead35 100644
--- a/modules/video_coding/codecs/vp8/default_temporal_layers.cc
+++ b/modules/video_coding/codecs/vp8/default_temporal_layers.cc
@@ -284,18 +284,6 @@
return {TemporalLayers::FrameConfig(
TemporalLayers::kNone, TemporalLayers::kNone, TemporalLayers::kNone)};
}
-
-// Temporary fix for forced SW fallback.
-// For VP8 SW codec, |TemporalLayers| is created and reported to
-// SimulcastRateAllocator::OnTemporalLayersCreated but not for VP8 HW.
-// Causes an issue when going from forced SW -> HW as |TemporalLayers| is not
-// deregistred when deleted by SW codec (tl factory might not exist, owned by
-// SimulcastRateAllocator).
-bool ExcludeOnTemporalLayersCreated(int num_temporal_layers) {
- return webrtc::field_trial::IsEnabled(
- "WebRTC-VP8-Forced-Fallback-Encoder-v2") &&
- num_temporal_layers == 1;
-}
} // namespace
DefaultTemporalLayers::DefaultTemporalLayers(int number_of_temporal_layers,
@@ -399,30 +387,6 @@
}
}
-TemporalLayers* TemporalLayersFactory::Create(
- int simulcast_id,
- int temporal_layers,
- uint8_t initial_tl0_pic_idx) const {
- TemporalLayers* tl =
- new DefaultTemporalLayers(temporal_layers, initial_tl0_pic_idx);
- if (listener_ && !ExcludeOnTemporalLayersCreated(temporal_layers))
- listener_->OnTemporalLayersCreated(simulcast_id, tl);
- return tl;
-}
-
-std::unique_ptr<TemporalLayersChecker> TemporalLayersFactory::CreateChecker(
- int /*simulcast_id*/,
- int temporal_layers,
- uint8_t initial_tl0_pic_idx) const {
- TemporalLayersChecker* tlc =
- new DefaultTemporalLayersChecker(temporal_layers, initial_tl0_pic_idx);
- return std::unique_ptr<TemporalLayersChecker>(tlc);
-}
-
-void TemporalLayersFactory::SetListener(TemporalLayersListener* listener) {
- listener_ = listener;
-}
-
// Returns list of temporal dependencies for each frame in the temporal pattern.
// Values are lists of indecies in the pattern.
std::vector<std::set<uint8_t>> GetTemporalDependencies(
diff --git a/modules/video_coding/codecs/vp8/default_temporal_layers_unittest.cc b/modules/video_coding/codecs/vp8/default_temporal_layers_unittest.cc
index 8314e2e..c11a7c9 100644
--- a/modules/video_coding/codecs/vp8/default_temporal_layers_unittest.cc
+++ b/modules/video_coding/codecs/vp8/default_temporal_layers_unittest.cc
@@ -63,7 +63,7 @@
codec.simulcastStream[0].maxBitrate = target_bitrate_kbps;
codec.simulcastStream[0].numberOfTemporalLayers = num_temporal_layers;
codec.simulcastStream[0].active = true;
- SimulcastRateAllocator allocator(codec, nullptr);
+ SimulcastRateAllocator allocator(codec);
return allocator.GetAllocation(target_bitrate_kbps, framerate_fps)
.GetTemporalLayerAllocation(0);
}
diff --git a/modules/video_coding/codecs/vp8/libvpx_vp8_encoder.cc b/modules/video_coding/codecs/vp8/libvpx_vp8_encoder.cc
index f1effc7..1f442a8 100644
--- a/modules/video_coding/codecs/vp8/libvpx_vp8_encoder.cc
+++ b/modules/video_coding/codecs/vp8/libvpx_vp8_encoder.cc
@@ -344,24 +344,12 @@
void LibvpxVp8Encoder::SetupTemporalLayers(int num_streams,
int num_temporal_layers,
const VideoCodec& codec) {
- RTC_DCHECK(codec.VP8().tl_factory != nullptr);
- const TemporalLayersFactory* tl_factory = codec.VP8().tl_factory;
RTC_DCHECK(temporal_layers_.empty());
- if (num_streams == 1) {
+ for (int i = 0; i < num_streams; ++i) {
temporal_layers_.emplace_back(
- tl_factory->Create(0, num_temporal_layers, tl0_pic_idx_[0]));
+ TemporalLayers::CreateTemporalLayers(codec, i, tl0_pic_idx_[i]));
temporal_layers_checkers_.emplace_back(
- tl_factory->CreateChecker(0, num_temporal_layers, tl0_pic_idx_[0]));
- } else {
- for (int i = 0; i < num_streams; ++i) {
- RTC_CHECK_GT(num_temporal_layers, 0);
- int layers = std::max(static_cast<uint8_t>(1),
- codec.simulcastStream[i].numberOfTemporalLayers);
- temporal_layers_.emplace_back(
- tl_factory->Create(i, layers, tl0_pic_idx_[i]));
- temporal_layers_checkers_.emplace_back(
- tl_factory->CreateChecker(i, layers, tl0_pic_idx_[i]));
- }
+ TemporalLayers::CreateTemporalLayersChecker(codec, i, tl0_pic_idx_[i]));
}
}
@@ -541,7 +529,7 @@
// Note the order we use is different from webm, we have lowest resolution
// at position 0 and they have highest resolution at position 0.
int stream_idx = encoders_.size() - 1;
- SimulcastRateAllocator init_allocator(codec_, nullptr);
+ SimulcastRateAllocator init_allocator(codec_);
BitrateAllocation allocation = init_allocator.GetAllocation(
inst->startBitrate * 1000, inst->maxFramerate);
std::vector<uint32_t> stream_bitrates;
diff --git a/modules/video_coding/codecs/vp8/screenshare_layers.cc b/modules/video_coding/codecs/vp8/screenshare_layers.cc
index 1e8427b..f3d8359 100644
--- a/modules/video_coding/codecs/vp8/screenshare_layers.cc
+++ b/modules/video_coding/codecs/vp8/screenshare_layers.cc
@@ -37,40 +37,6 @@
// been exceeded. This prevents needless keyframe requests.
const int ScreenshareLayers::kMaxFrameIntervalMs = 2750;
-webrtc::TemporalLayers* ScreenshareTemporalLayersFactory::Create(
- int simulcast_id,
- int num_temporal_layers,
- uint8_t initial_tl0_pic_idx) const {
- webrtc::TemporalLayers* tl;
- if (simulcast_id == 0) {
- tl = new webrtc::ScreenshareLayers(num_temporal_layers, rand(),
- webrtc::Clock::GetRealTimeClock());
- } else {
- TemporalLayersFactory rt_tl_factory;
- tl = rt_tl_factory.Create(simulcast_id, num_temporal_layers, rand());
- }
- if (listener_)
- listener_->OnTemporalLayersCreated(simulcast_id, tl);
- return tl;
-}
-
-std::unique_ptr<webrtc::TemporalLayersChecker>
-ScreenshareTemporalLayersFactory::CreateChecker(
- int simulcast_id,
- int temporal_layers,
- uint8_t initial_tl0_pic_idx) const {
- webrtc::TemporalLayersChecker* tlc;
- if (simulcast_id == 0) {
- tlc =
- new webrtc::TemporalLayersChecker(temporal_layers, initial_tl0_pic_idx);
- } else {
- TemporalLayersFactory rt_tl_factory;
- return rt_tl_factory.CreateChecker(simulcast_id, temporal_layers,
- initial_tl0_pic_idx);
- }
- return std::unique_ptr<webrtc::TemporalLayersChecker>(tlc);
-}
-
ScreenshareLayers::ScreenshareLayers(int num_temporal_layers,
uint8_t initial_tl0_pic_idx,
Clock* clock)
diff --git a/modules/video_coding/codecs/vp8/simulcast_rate_allocator.cc b/modules/video_coding/codecs/vp8/simulcast_rate_allocator.cc
index 483a36e..b819caa 100644
--- a/modules/video_coding/codecs/vp8/simulcast_rate_allocator.cc
+++ b/modules/video_coding/codecs/vp8/simulcast_rate_allocator.cc
@@ -20,20 +20,8 @@
namespace webrtc {
-SimulcastRateAllocator::SimulcastRateAllocator(
- const VideoCodec& codec,
- std::unique_ptr<TemporalLayersFactory> tl_factory)
- : codec_(codec), tl_factory_(std::move(tl_factory)) {
- if (tl_factory_.get())
- tl_factory_->SetListener(this);
-}
-
-void SimulcastRateAllocator::OnTemporalLayersCreated(int simulcast_id,
- TemporalLayers* layers) {
- RTC_DCHECK(temporal_layers_.find(simulcast_id) == temporal_layers_.end());
- RTC_DCHECK(layers);
- temporal_layers_[simulcast_id] = layers;
-}
+SimulcastRateAllocator::SimulcastRateAllocator(const VideoCodec& codec)
+ : codec_(codec) {}
BitrateAllocation SimulcastRateAllocator::GetAllocation(
uint32_t total_bitrate_bps,
@@ -241,12 +229,7 @@
}
uint32_t SimulcastRateAllocator::GetPreferredBitrateBps(uint32_t framerate) {
- // Create a temporary instance without temporal layers, as they may be
- // stateful, and updating the bitrate to max here can cause side effects.
- SimulcastRateAllocator temp_allocator(codec_, nullptr);
- BitrateAllocation allocation =
- temp_allocator.GetAllocation(codec_.maxBitrate * 1000, framerate);
- return allocation.get_sum_bps();
+ return GetAllocation(codec_.maxBitrate * 1000, framerate).get_sum_bps();
}
const VideoCodec& webrtc::SimulcastRateAllocator::GetCodec() const {
diff --git a/modules/video_coding/codecs/vp8/simulcast_rate_allocator.h b/modules/video_coding/codecs/vp8/simulcast_rate_allocator.h
index 958fdbc..23d158b 100644
--- a/modules/video_coding/codecs/vp8/simulcast_rate_allocator.h
+++ b/modules/video_coding/codecs/vp8/simulcast_rate_allocator.h
@@ -24,15 +24,9 @@
namespace webrtc {
-class SimulcastRateAllocator : public VideoBitrateAllocator,
- public TemporalLayersListener {
+class SimulcastRateAllocator : public VideoBitrateAllocator {
public:
- explicit SimulcastRateAllocator(
- const VideoCodec& codec,
- std::unique_ptr<TemporalLayersFactory> tl_factory);
-
- void OnTemporalLayersCreated(int simulcast_id,
- TemporalLayers* layers) override;
+ explicit SimulcastRateAllocator(const VideoCodec& codec);
BitrateAllocation GetAllocation(uint32_t total_bitrate_bps,
uint32_t framerate) override;
@@ -58,8 +52,6 @@
int NumTemporalStreams(size_t simulcast_id) const;
const VideoCodec codec_;
- std::map<uint32_t, TemporalLayers*> temporal_layers_;
- std::unique_ptr<TemporalLayersFactory> tl_factory_;
RTC_DISALLOW_COPY_AND_ASSIGN(SimulcastRateAllocator);
};
diff --git a/modules/video_coding/codecs/vp8/simulcast_test_utility.h b/modules/video_coding/codecs/vp8/simulcast_test_utility.h
index 231d36e..ba2bdcb 100644
--- a/modules/video_coding/codecs/vp8/simulcast_test_utility.h
+++ b/modules/video_coding/codecs/vp8/simulcast_test_utility.h
@@ -271,10 +271,7 @@
}
void SetUpRateAllocator() {
- TemporalLayersFactory* tl_factory = new TemporalLayersFactory();
- rate_allocator_.reset(new SimulcastRateAllocator(
- settings_, std::unique_ptr<TemporalLayersFactory>(tl_factory)));
- settings_.VP8()->tl_factory = tl_factory;
+ rate_allocator_.reset(new SimulcastRateAllocator(settings_));
}
void SetRates(uint32_t bitrate_kbps, uint32_t fps) {
diff --git a/modules/video_coding/codecs/vp8/temporal_layers.cc b/modules/video_coding/codecs/vp8/temporal_layers.cc
index 0a9b993..6339516 100644
--- a/modules/video_coding/codecs/vp8/temporal_layers.cc
+++ b/modules/video_coding/codecs/vp8/temporal_layers.cc
@@ -15,13 +15,65 @@
#include <vector>
#include "modules/include/module_common_types.h"
+#include "modules/video_coding/codecs/vp8/default_temporal_layers.h"
#include "modules/video_coding/codecs/vp8/include/vp8_common_types.h"
+#include "modules/video_coding/codecs/vp8/screenshare_layers.h"
#include "modules/video_coding/include/video_codec_interface.h"
#include "rtc_base/checks.h"
#include "rtc_base/logging.h"
+#include "rtc_base/ptr_util.h"
+#include "system_wrappers/include/clock.h"
#include "system_wrappers/include/field_trial.h"
namespace webrtc {
+namespace {
+uint8_t NumTemporalLayers(const VideoCodec& codec, int spatial_id) {
+ uint8_t num_temporal_layers =
+ std::max<uint8_t>(1, codec.VP8().numberOfTemporalLayers);
+ if (codec.numberOfSimulcastStreams > 0) {
+ RTC_DCHECK_LT(spatial_id, codec.numberOfSimulcastStreams);
+ num_temporal_layers =
+ std::max(num_temporal_layers,
+ codec.simulcastStream[spatial_id].numberOfTemporalLayers);
+ }
+ return num_temporal_layers;
+}
+
+bool IsConferenceModeScreenshare(const VideoCodec& codec) {
+ if (codec.mode != kScreensharing) {
+ return false;
+ }
+ return NumTemporalLayers(codec, 0) == 2;
+}
+} // namespace
+
+std::unique_ptr<TemporalLayers> TemporalLayers::CreateTemporalLayers(
+ const VideoCodec& codec,
+ size_t spatial_id,
+ uint8_t initial_tl0_pic_idx) {
+ if (IsConferenceModeScreenshare(codec) && spatial_id == 0) {
+ // Conference mode temporal layering for screen content in base stream.
+ return rtc::MakeUnique<ScreenshareLayers>(2, initial_tl0_pic_idx,
+ Clock::GetRealTimeClock());
+ }
+
+ return rtc::MakeUnique<DefaultTemporalLayers>(
+ NumTemporalLayers(codec, spatial_id), initial_tl0_pic_idx);
+}
+
+std::unique_ptr<TemporalLayersChecker>
+TemporalLayers::CreateTemporalLayersChecker(const VideoCodec& codec,
+ size_t spatial_id,
+ uint8_t initial_tl0_pic_idx) {
+ if (IsConferenceModeScreenshare(codec) && spatial_id == 0) {
+ // Conference mode temporal layering for screen content in base stream,
+ // use generic checker.
+ return rtc::MakeUnique<TemporalLayersChecker>(2, initial_tl0_pic_idx);
+ }
+
+ return rtc::MakeUnique<DefaultTemporalLayersChecker>(
+ NumTemporalLayers(codec, spatial_id), initial_tl0_pic_idx);
+}
TemporalLayersChecker::TemporalLayersChecker(int num_temporal_layers,
uint8_t /*initial_tl0_pic_idx*/)
diff --git a/modules/video_coding/codecs/vp8/temporal_layers.h b/modules/video_coding/codecs/vp8/temporal_layers.h
index e9af012..3d0912c 100644
--- a/modules/video_coding/codecs/vp8/temporal_layers.h
+++ b/modules/video_coding/codecs/vp8/temporal_layers.h
@@ -15,6 +15,7 @@
#include <vector>
#include <memory>
+#include "common_types.h" // NOLINT(build/include)
#include "typedefs.h" // NOLINT(build/include)
#define VP8_TS_MAX_PERIODICITY 16
@@ -35,6 +36,7 @@
unsigned int rc_max_quantizer;
};
+class TemporalLayersChecker;
class TemporalLayers {
public:
enum BufferFlags {
@@ -95,6 +97,15 @@
bool freeze_entropy);
};
+ static std::unique_ptr<TemporalLayers> CreateTemporalLayers(
+ const VideoCodec& codec,
+ size_t spatial_id,
+ uint8_t initial_tl0_pic_idx);
+ static std::unique_ptr<TemporalLayersChecker> CreateTemporalLayersChecker(
+ const VideoCodec& codec,
+ size_t spatial_id,
+ uint8_t initial_tl0_pic_idx);
+
// Factory for TemporalLayer strategy. Default behavior is a fixed pattern
// of temporal layers. See default_temporal_layers.cc
virtual ~TemporalLayers() {}
@@ -124,57 +135,14 @@
virtual uint8_t Tl0PicIdx() const = 0;
};
-class TemporalLayersListener;
-class TemporalLayersChecker;
-
+// TODO(webrtc:9012): Remove TemporalLayersFactory type and field once all
+// upstream usage is gone.
class TemporalLayersFactory {
public:
- TemporalLayersFactory() : listener_(nullptr) {}
- virtual ~TemporalLayersFactory() {}
- virtual TemporalLayers* Create(int simulcast_id,
- int temporal_layers,
- uint8_t initial_tl0_pic_idx) const;
-
- // Creates helper class which performs online checks of a correctness of
- // temporal layers dependencies returned by TemporalLayers class created in
- // the same factory.
- virtual std::unique_ptr<TemporalLayersChecker> CreateChecker(
- int simulcast_id,
- int temporal_layers,
- uint8_t initial_tl0_pic_idx) const;
-
- void SetListener(TemporalLayersListener* listener);
-
- protected:
- TemporalLayersListener* listener_;
+ TemporalLayersFactory() = default;
+ virtual ~TemporalLayersFactory() = default;
};
-class ScreenshareTemporalLayersFactory : public webrtc::TemporalLayersFactory {
- public:
- ScreenshareTemporalLayersFactory() {}
- virtual ~ScreenshareTemporalLayersFactory() {}
-
- webrtc::TemporalLayers* Create(int simulcast_id,
- int num_temporal_layers,
- uint8_t initial_tl0_pic_idx) const override;
-
- // Creates helper class which performs online checks of a correctness of
- // temporal layers dependencies returned by TemporalLayers class created in
- // the same factory.
- std::unique_ptr<webrtc::TemporalLayersChecker> CreateChecker(
- int simulcast_id,
- int temporal_layers,
- uint8_t initial_tl0_pic_idx) const override;
-};
-
-class TemporalLayersListener {
- public:
- TemporalLayersListener() {}
- virtual ~TemporalLayersListener() {}
-
- virtual void OnTemporalLayersCreated(int simulcast_id,
- TemporalLayers* layers) = 0;
-};
// Used only inside RTC_DCHECK(). It checks correctness of temporal layers
// dependencies and sync bits. The only method of this class is called after
diff --git a/modules/video_coding/codecs/vp8/test/vp8_impl_unittest.cc b/modules/video_coding/codecs/vp8/test/vp8_impl_unittest.cc
index c99498b..504cc3b 100644
--- a/modules/video_coding/codecs/vp8/test/vp8_impl_unittest.cc
+++ b/modules/video_coding/codecs/vp8/test/vp8_impl_unittest.cc
@@ -60,7 +60,6 @@
codec_settings.VP8()->frameDroppingOn = false;
codec_settings.VP8()->automaticResizeOn = false;
codec_settings.VP8()->complexity = kComplexityNormal;
- codec_settings.VP8()->tl_factory = &tl_factory_;
return codec_settings;
}
@@ -120,8 +119,6 @@
ASSERT_TRUE(vp8::GetQp(encoded_frame._buffer, encoded_frame._length, &qp));
EXPECT_EQ(encoded_frame.qp_, qp) << "Encoder QP != parsed bitstream QP.";
}
-
- TemporalLayersFactory tl_factory_;
};
TEST_F(TestVp8Impl, SetRateAllocation) {
diff --git a/modules/video_coding/include/video_codec_initializer.h b/modules/video_coding/include/video_codec_initializer.h
index 078d7ab..aded1f0 100644
--- a/modules/video_coding/include/video_codec_initializer.h
+++ b/modules/video_coding/include/video_codec_initializer.h
@@ -19,7 +19,6 @@
namespace webrtc {
-class TemporalLayersFactory;
class VideoBitrateAllocator;
class VideoCodec;
class VideoEncoderConfig;
@@ -44,8 +43,7 @@
// optional, if it is populated, ownership of that instance will be
// transferred to the VideoBitrateAllocator instance.
static std::unique_ptr<VideoBitrateAllocator> CreateBitrateAllocator(
- const VideoCodec& codec,
- std::unique_ptr<TemporalLayersFactory> tl_factory);
+ const VideoCodec& codec);
private:
static VideoCodec VideoEncoderConfigToVideoCodec(
diff --git a/modules/video_coding/utility/simulcast_rate_allocator_unittest.cc b/modules/video_coding/utility/simulcast_rate_allocator_unittest.cc
index 880ed79..f986d3b 100644
--- a/modules/video_coding/utility/simulcast_rate_allocator_unittest.cc
+++ b/modules/video_coding/utility/simulcast_rate_allocator_unittest.cc
@@ -81,23 +81,7 @@
}
void CreateAllocator() {
- std::unique_ptr<TemporalLayersFactory> tl_factory(GetTlFactory());
- codec_.VP8()->tl_factory = tl_factory.get();
- allocator_.reset(new SimulcastRateAllocator(codec_, std::move(tl_factory)));
-
- // Simulate InitEncode().
- tl_factories_.clear();
- if (codec_.numberOfSimulcastStreams == 0) {
- tl_factories_.push_back(
- std::unique_ptr<TemporalLayers>(codec_.VP8()->tl_factory->Create(
- 0, codec_.VP8()->numberOfTemporalLayers, 0)));
- } else {
- for (uint32_t i = 0; i < codec_.numberOfSimulcastStreams; ++i) {
- tl_factories_.push_back(
- std::unique_ptr<TemporalLayers>(codec_.VP8()->tl_factory->Create(
- i, codec_.simulcastStream[i].numberOfTemporalLayers, 0)));
- }
- }
+ allocator_.reset(new SimulcastRateAllocator(codec_));
}
void SetupCodecThreeSimulcastStreams(
@@ -128,10 +112,6 @@
}
}
- virtual std::unique_ptr<TemporalLayersFactory> GetTlFactory() {
- return std::unique_ptr<TemporalLayersFactory>(new TemporalLayersFactory());
- }
-
BitrateAllocation GetAllocation(uint32_t target_bitrate) {
return allocator_->GetAllocation(target_bitrate * 1000U, kDefaultFrameRate);
}
@@ -140,7 +120,6 @@
static const int kDefaultFrameRate = 30;
VideoCodec codec_;
std::unique_ptr<SimulcastRateAllocator> allocator_;
- std::vector<std::unique_ptr<TemporalLayers>> tl_factories_;
};
TEST_F(SimulcastRateAllocatorTest, NoSimulcastBelowMin) {
@@ -485,8 +464,7 @@
TEST_F(SimulcastRateAllocatorTest, GetPreferredBitrateBps) {
MockTemporalLayers mock_layers;
- allocator_.reset(new SimulcastRateAllocator(codec_, nullptr));
- allocator_->OnTemporalLayersCreated(0, &mock_layers);
+ allocator_.reset(new SimulcastRateAllocator(codec_));
EXPECT_CALL(mock_layers, OnRatesUpdated(_, _)).Times(0);
EXPECT_EQ(codec_.maxBitrate * 1000,
allocator_->GetPreferredBitrateBps(codec_.maxFramerate));
@@ -540,11 +518,6 @@
codec_.active = active;
}
}
-
- std::unique_ptr<TemporalLayersFactory> GetTlFactory() override {
- return std::unique_ptr<TemporalLayersFactory>(
- new ScreenshareTemporalLayersFactory());
- }
};
INSTANTIATE_TEST_CASE_P(ScreenshareTest,
diff --git a/modules/video_coding/video_codec_initializer.cc b/modules/video_coding/video_codec_initializer.cc
index f7e12c8..e473a16 100644
--- a/modules/video_coding/video_codec_initializer.cc
+++ b/modules/video_coding/video_codec_initializer.cc
@@ -48,47 +48,19 @@
*codec =
VideoEncoderConfigToVideoCodec(config, streams, settings.payload_name,
settings.payload_type, nack_enabled);
-
- std::unique_ptr<TemporalLayersFactory> tl_factory;
- switch (codec->codecType) {
- case kVideoCodecVP8: {
- if (!codec->VP8()->tl_factory) {
- if (codec->mode == kScreensharing &&
- (codec->numberOfSimulcastStreams > 1 ||
- (codec->numberOfSimulcastStreams == 1 &&
- codec->VP8()->numberOfTemporalLayers == 2))) {
- // Conference mode temporal layering for screen content.
- tl_factory.reset(new ScreenshareTemporalLayersFactory());
- } else {
- // Standard video temporal layers.
- tl_factory.reset(new TemporalLayersFactory());
- }
- codec->VP8()->tl_factory = tl_factory.get();
- }
- break;
- }
- default: {
- // TODO(sprang): Warn, once we have specific allocators for all supported
- // codec types.
- break;
- }
- }
- *bitrate_allocator = CreateBitrateAllocator(*codec, std::move(tl_factory));
+ *bitrate_allocator = CreateBitrateAllocator(*codec);
return true;
}
std::unique_ptr<VideoBitrateAllocator>
-VideoCodecInitializer::CreateBitrateAllocator(
- const VideoCodec& codec,
- std::unique_ptr<TemporalLayersFactory> tl_factory) {
+VideoCodecInitializer::CreateBitrateAllocator(const VideoCodec& codec) {
std::unique_ptr<VideoBitrateAllocator> rate_allocator;
switch (codec.codecType) {
case kVideoCodecVP8: {
// Set up default VP8 temporal layer factory, if not provided.
- rate_allocator.reset(
- new SimulcastRateAllocator(codec, std::move(tl_factory)));
+ rate_allocator.reset(new SimulcastRateAllocator(codec));
} break;
default:
rate_allocator.reset(new DefaultVideoBitrateAllocator(codec));
diff --git a/modules/video_coding/video_codec_initializer_unittest.cc b/modules/video_coding/video_codec_initializer_unittest.cc
index 46e2647..4e99fbb 100644
--- a/modules/video_coding/video_codec_initializer_unittest.cc
+++ b/modules/video_coding/video_codec_initializer_unittest.cc
@@ -37,23 +37,6 @@
static const uint32_t kHighScreenshareTl1Bps = 1200000;
} // namespace
-/*
- * static bool SetupCodec(
- const VideoEncoderConfig& config,
- const VideoSendStream::Config::EncoderSettings settings,
- const std::vector<VideoStream>& streams,
- bool nack_enabled,
- VideoCodec* codec,
- std::unique_ptr<VideoBitrateAllocator>* bitrate_allocator);
-
- // Create a bitrate allocator for the specified codec. |tl_factory| is
- // optional, if it is populated, ownership of that instance will be
- // transferred to the VideoBitrateAllocator instance.
- static std::unique_ptr<VideoBitrateAllocator> CreateBitrateAllocator(
- const VideoCodec& codec,
- std::unique_ptr<TemporalLayersFactory> tl_factory);
- */
-
// TODO(sprang): Extend coverage to handle the rest of the codec initializer.
class VideoCodecInitializerTest : public ::testing::Test {
public:
@@ -96,14 +79,12 @@
}
if (codec_out_.codecType == VideoCodecType::kVideoCodecMultiplex)
return true;
+
// Make sure temporal layers instances have been created.
if (codec_out_.codecType == VideoCodecType::kVideoCodecVP8) {
- if (!codec_out_.VP8()->tl_factory)
- return false;
-
for (int i = 0; i < codec_out_.numberOfSimulcastStreams; ++i) {
- temporal_layers_.emplace_back(codec_out_.VP8()->tl_factory->Create(
- i, *streams_[i].num_temporal_layers, 0));
+ temporal_layers_.emplace_back(
+ TemporalLayers::CreateTemporalLayers(codec_out_, i, 0));
}
}
return true;
diff --git a/modules/video_coding/video_coding_impl.cc b/modules/video_coding/video_coding_impl.cc
index c45f41e..1b098ed 100644
--- a/modules/video_coding/video_coding_impl.cc
+++ b/modules/video_coding/video_coding_impl.cc
@@ -114,11 +114,8 @@
// asynchronously keep the instance alive until destruction or until a
// new send codec is registered.
VideoCodec vp8_codec = *sendCodec;
- std::unique_ptr<TemporalLayersFactory> tl_factory(
- new TemporalLayersFactory());
- vp8_codec.VP8()->tl_factory = tl_factory.get();
- rate_allocator_ = VideoCodecInitializer::CreateBitrateAllocator(
- vp8_codec, std::move(tl_factory));
+ rate_allocator_ =
+ VideoCodecInitializer::CreateBitrateAllocator(vp8_codec);
return sender_.RegisterSendCodec(&vp8_codec, numberOfCores,
maxPayloadSize);
}
diff --git a/modules/video_coding/video_sender_unittest.cc b/modules/video_coding/video_sender_unittest.cc
index bce3f62..8e1330a 100644
--- a/modules/video_coding/video_sender_unittest.cc
+++ b/modules/video_coding/video_sender_unittest.cc
@@ -413,10 +413,7 @@
codec_.startBitrate = codec_bitrate_kbps_;
codec_.maxBitrate = codec_bitrate_kbps_;
- TemporalLayersFactory* tl_factory = new TemporalLayersFactory();
- rate_allocator_.reset(new SimulcastRateAllocator(
- codec_, std::unique_ptr<TemporalLayersFactory>(tl_factory)));
- codec_.VP8()->tl_factory = tl_factory;
+ rate_allocator_.reset(new SimulcastRateAllocator(codec_));
encoder_ = VP8Encoder::Create();
sender_->RegisterExternalEncoder(encoder_.get(), false);
diff --git a/video/video_send_stream_tests.cc b/video/video_send_stream_tests.cc
index e6f9244..b038f9c 100644
--- a/video/video_send_stream_tests.cc
+++ b/video/video_send_stream_tests.cc
@@ -2578,12 +2578,10 @@
}
// Set expected temporal layers as they should have been set when
- // reconfiguring the encoder and not match the set config. Also copy the
- // TemporalLayersFactory pointer that has been injected by VideoStreamEncoder.
+ // reconfiguring the encoder and not match the set config.
VideoCodecVP8 encoder_settings = encoder_settings_;
encoder_settings.numberOfTemporalLayers =
kVideoCodecConfigObserverNumberOfTemporalLayers;
- encoder_settings.tl_factory = config.VP8().tl_factory;
EXPECT_EQ(
0, memcmp(&config.VP8(), &encoder_settings, sizeof(encoder_settings_)));
}
diff --git a/video/video_stream_encoder_unittest.cc b/video/video_stream_encoder_unittest.cc
index 8e2eae3..8c12d8d 100644
--- a/video/video_stream_encoder_unittest.cc
+++ b/video/video_stream_encoder_unittest.cc
@@ -556,15 +556,13 @@
int res =
FakeEncoder::InitEncode(config, number_of_cores, max_payload_size);
rtc::CritScope lock(&local_crit_sect_);
- if (config->codecType == kVideoCodecVP8 && config->VP8().tl_factory) {
+ if (config->codecType == kVideoCodecVP8) {
// Simulate setting up temporal layers, in order to validate the life
// cycle of these objects.
int num_streams = std::max<int>(1, config->numberOfSimulcastStreams);
- int num_temporal_layers =
- std::max<int>(1, config->VP8().numberOfTemporalLayers);
for (int i = 0; i < num_streams; ++i) {
allocated_temporal_layers_.emplace_back(
- config->VP8().tl_factory->Create(i, num_temporal_layers, 42));
+ TemporalLayers::CreateTemporalLayers(*config, i, 42));
}
}
if (force_init_encode_failed_)