From 86aabb288d61d56955e7fa4890f46f3388f28263 Mon Sep 17 00:00:00 2001 From: mflodman Date: Fri, 11 Mar 2016 15:44:32 +0100 Subject: [PATCH] Move BitrateAllocator reference from ViEEncoder to VideoSendStream. This CL will be followed up with a CL adding AudioSendStream to BitrateAllocator, so this is a small CL to have the video connection to BitrateAllocator "at the same level" as for audio. BUG=webrtc:5079 R=stefan@webrtc.org Review URL: https://codereview.webrtc.org/1785283002 . Cr-Commit-Position: refs/heads/master@{#11955} --- webrtc/call/bitrate_allocator.cc | 14 +++--- webrtc/call/bitrate_allocator.h | 40 +++++++++------ webrtc/call/bitrate_allocator_unittest.cc | 49 ++++++++----------- webrtc/call/call.cc | 2 +- .../video/encoder_state_feedback_unittest.cc | 1 - webrtc/video/video_send_stream.cc | 25 ++++++++-- webrtc/video/video_send_stream.h | 12 ++++- webrtc/video/vie_encoder.cc | 48 ++---------------- webrtc/video/vie_encoder.h | 17 +------ 9 files changed, 91 insertions(+), 117 deletions(-) diff --git a/webrtc/call/bitrate_allocator.cc b/webrtc/call/bitrate_allocator.cc index 07f830610c..097378f02a 100644 --- a/webrtc/call/bitrate_allocator.cc +++ b/webrtc/call/bitrate_allocator.cc @@ -41,7 +41,7 @@ uint32_t BitrateAllocator::OnNetworkChanged(uint32_t bitrate, uint32_t allocated_bitrate_bps = 0; ObserverBitrateMap allocation = AllocateBitrates(); for (const auto& kv : allocation) { - kv.first->OnNetworkChanged(kv.second, last_fraction_loss_, last_rtt_); + kv.first->OnBitrateUpdated(kv.second, last_fraction_loss_, last_rtt_); allocated_bitrate_bps += kv.second; } return allocated_bitrate_bps; @@ -60,9 +60,9 @@ BitrateAllocator::ObserverBitrateMap BitrateAllocator::AllocateBitrates() { return NormalRateAllocation(last_bitrate_bps_, sum_min_bitrates); } -int BitrateAllocator::AddBitrateObserver(BitrateObserver* observer, - uint32_t min_bitrate_bps, - uint32_t max_bitrate_bps) { +int BitrateAllocator::AddObserver(BitrateAllocatorObserver* observer, + uint32_t min_bitrate_bps, + uint32_t max_bitrate_bps) { rtc::CritScope lock(&crit_sect_); BitrateObserverConfList::iterator it = @@ -87,14 +87,14 @@ int BitrateAllocator::AddBitrateObserver(BitrateObserver* observer, ObserverBitrateMap allocation = AllocateBitrates(); int new_observer_bitrate_bps = 0; for (auto& kv : allocation) { - kv.first->OnNetworkChanged(kv.second, last_fraction_loss_, last_rtt_); + kv.first->OnBitrateUpdated(kv.second, last_fraction_loss_, last_rtt_); if (kv.first == observer) new_observer_bitrate_bps = kv.second; } return new_observer_bitrate_bps; } -void BitrateAllocator::RemoveBitrateObserver(BitrateObserver* observer) { +void BitrateAllocator::RemoveObserver(BitrateAllocatorObserver* observer) { rtc::CritScope lock(&crit_sect_); BitrateObserverConfList::iterator it = FindObserverConfigurationPair(observer); @@ -118,7 +118,7 @@ void BitrateAllocator::GetMinMaxBitrateSumBps(int* min_bitrate_sum_bps, BitrateAllocator::BitrateObserverConfList::iterator BitrateAllocator::FindObserverConfigurationPair( - const BitrateObserver* observer) { + const BitrateAllocatorObserver* observer) { for (auto it = bitrate_observers_.begin(); it != bitrate_observers_.end(); ++it) { if (it->first == observer) diff --git a/webrtc/call/bitrate_allocator.h b/webrtc/call/bitrate_allocator.h index 5028e124bd..25ca735585 100644 --- a/webrtc/call/bitrate_allocator.h +++ b/webrtc/call/bitrate_allocator.h @@ -6,10 +6,6 @@ * tree. An additional intellectual property rights grant can be found * in the file PATENTS. All contributing project authors may * be found in the AUTHORS file in the root of the source tree. - * - * Usage: this class will register multiple RtcpBitrateObserver's one at each - * RTCP module. It will aggregate the results and run one bandwidth estimation - * and push the result to the encoders via BitrateObserver(s). */ #ifndef WEBRTC_CALL_BITRATE_ALLOCATOR_H_ @@ -25,13 +21,26 @@ namespace webrtc { -class BitrateObserver; +// Used by all send streams with adaptive bitrate, to get the currently +// allocated bitrate for the send stream. The current network properties are +// given at the same time, to let the send stream decide about possible loss +// protection. +class BitrateAllocatorObserver { + public: + virtual void OnBitrateUpdated(uint32_t bitrate_bps, + uint8_t fraction_loss, + int64_t rtt) = 0; + virtual ~BitrateAllocatorObserver() {} +}; +// Usage: this class will register multiple RtcpBitrateObserver's one at each +// RTCP module. It will aggregate the results and run one bandwidth estimation +// and push the result to the encoders via BitrateAllocatorObserver(s). class BitrateAllocator { public: BitrateAllocator(); - // Allocate target_bitrate across the registered BitrateObservers. + // Allocate target_bitrate across the registered BitrateAllocatorObservers. // Returns actual bitrate allocated (might be higher than target_bitrate if // for instance EnforceMinBitrate() is enabled. uint32_t OnNetworkChanged(uint32_t target_bitrate, @@ -44,11 +53,11 @@ class BitrateAllocator { // |min_bitrate_bps| = 0 equals no min bitrate. // |max_bitrate_bps| = 0 equals no max bitrate. // Returns bitrate allocated for the bitrate observer. - int AddBitrateObserver(BitrateObserver* observer, - uint32_t min_bitrate_bps, - uint32_t max_bitrate_bps); + int AddObserver(BitrateAllocatorObserver* observer, + uint32_t min_bitrate_bps, + uint32_t max_bitrate_bps); - void RemoveBitrateObserver(BitrateObserver* observer); + void RemoveObserver(BitrateAllocatorObserver* observer); void GetMinMaxBitrateSumBps(int* min_bitrate_sum_bps, int* max_bitrate_sum_bps) const; @@ -68,19 +77,20 @@ class BitrateAllocator { uint32_t max_bitrate; }; struct ObserverConfiguration { - ObserverConfiguration(BitrateObserver* observer, uint32_t bitrate) + ObserverConfiguration(BitrateAllocatorObserver* observer, uint32_t bitrate) : observer(observer), min_bitrate(bitrate) {} - BitrateObserver* const observer; + BitrateAllocatorObserver* const observer; uint32_t min_bitrate; }; - typedef std::pair + typedef std::pair BitrateObserverConfiguration; typedef std::list BitrateObserverConfList; typedef std::multimap ObserverSortingMap; - typedef std::map ObserverBitrateMap; + typedef std::map ObserverBitrateMap; BitrateObserverConfList::iterator FindObserverConfigurationPair( - const BitrateObserver* observer) EXCLUSIVE_LOCKS_REQUIRED(crit_sect_); + const BitrateAllocatorObserver* observer) + EXCLUSIVE_LOCKS_REQUIRED(crit_sect_); ObserverBitrateMap AllocateBitrates() EXCLUSIVE_LOCKS_REQUIRED(crit_sect_); ObserverBitrateMap NormalRateAllocation(uint32_t bitrate, uint32_t sum_min_bitrates) diff --git a/webrtc/call/bitrate_allocator_unittest.cc b/webrtc/call/bitrate_allocator_unittest.cc index 86f75a4380..fc4f1702bb 100644 --- a/webrtc/call/bitrate_allocator_unittest.cc +++ b/webrtc/call/bitrate_allocator_unittest.cc @@ -17,12 +17,12 @@ namespace webrtc { -class TestBitrateObserver : public BitrateObserver { +class TestBitrateObserver : public BitrateAllocatorObserver { public: TestBitrateObserver() : last_bitrate_(0), last_fraction_loss_(0), last_rtt_(0) {} - virtual void OnNetworkChanged(uint32_t bitrate, + virtual void OnBitrateUpdated(uint32_t bitrate, uint8_t fraction_loss, int64_t rtt) { last_bitrate_ = bitrate; @@ -47,7 +47,7 @@ class BitrateAllocatorTest : public ::testing::Test { TEST_F(BitrateAllocatorTest, UpdatingBitrateObserver) { TestBitrateObserver bitrate_observer; int start_bitrate = - allocator_->AddBitrateObserver(&bitrate_observer, 100000, 1500000); + allocator_->AddObserver(&bitrate_observer, 100000, 1500000); EXPECT_EQ(300000, start_bitrate); allocator_->OnNetworkChanged(200000, 0, 0); EXPECT_EQ(200000u, bitrate_observer.last_bitrate_); @@ -56,12 +56,10 @@ TEST_F(BitrateAllocatorTest, UpdatingBitrateObserver) { // bitrate for FEC/retransmissions (see todo in BitrateAllocator). allocator_->OnNetworkChanged(4000000, 0, 0); EXPECT_EQ(3000000u, bitrate_observer.last_bitrate_); - start_bitrate = - allocator_->AddBitrateObserver(&bitrate_observer, 100000, 4000000); + start_bitrate = allocator_->AddObserver(&bitrate_observer, 100000, 4000000); EXPECT_EQ(4000000, start_bitrate); - start_bitrate = - allocator_->AddBitrateObserver(&bitrate_observer, 100000, 1500000); + start_bitrate = allocator_->AddObserver(&bitrate_observer, 100000, 1500000); EXPECT_EQ(3000000, start_bitrate); EXPECT_EQ(3000000u, bitrate_observer.last_bitrate_); allocator_->OnNetworkChanged(1500000, 0, 0); @@ -72,10 +70,9 @@ TEST_F(BitrateAllocatorTest, TwoBitrateObserversOneRtcpObserver) { TestBitrateObserver bitrate_observer_1; TestBitrateObserver bitrate_observer_2; int start_bitrate = - allocator_->AddBitrateObserver(&bitrate_observer_1, 100000, 300000); + allocator_->AddObserver(&bitrate_observer_1, 100000, 300000); EXPECT_EQ(300000, start_bitrate); - start_bitrate = - allocator_->AddBitrateObserver(&bitrate_observer_2, 200000, 300000); + start_bitrate = allocator_->AddObserver(&bitrate_observer_2, 200000, 300000); EXPECT_EQ(200000, start_bitrate); // Test too low start bitrate, hence lower than sum of min. Min bitrates will @@ -116,7 +113,7 @@ class BitrateAllocatorTestNoEnforceMin : public ::testing::Test { TEST_F(BitrateAllocatorTestNoEnforceMin, OneBitrateObserver) { TestBitrateObserver bitrate_observer_1; int start_bitrate = - allocator_->AddBitrateObserver(&bitrate_observer_1, 100000, 400000); + allocator_->AddObserver(&bitrate_observer_1, 100000, 400000); EXPECT_EQ(300000, start_bitrate); // High REMB. @@ -127,7 +124,7 @@ TEST_F(BitrateAllocatorTestNoEnforceMin, OneBitrateObserver) { allocator_->OnNetworkChanged(10000, 0, 0); EXPECT_EQ(10000u, bitrate_observer_1.last_bitrate_); - allocator_->RemoveBitrateObserver(&bitrate_observer_1); + allocator_->RemoveObserver(&bitrate_observer_1); } TEST_F(BitrateAllocatorTestNoEnforceMin, ThreeBitrateObservers) { @@ -136,16 +133,14 @@ TEST_F(BitrateAllocatorTestNoEnforceMin, ThreeBitrateObservers) { TestBitrateObserver bitrate_observer_3; // Set up the observers with min bitrates at 100000, 200000, and 300000. int start_bitrate = - allocator_->AddBitrateObserver(&bitrate_observer_1, 100000, 400000); + allocator_->AddObserver(&bitrate_observer_1, 100000, 400000); EXPECT_EQ(300000, start_bitrate); - start_bitrate = - allocator_->AddBitrateObserver(&bitrate_observer_2, 200000, 400000); + start_bitrate = allocator_->AddObserver(&bitrate_observer_2, 200000, 400000); EXPECT_EQ(200000, start_bitrate); EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_); - start_bitrate = - allocator_->AddBitrateObserver(&bitrate_observer_3, 300000, 400000); + start_bitrate = allocator_->AddObserver(&bitrate_observer_3, 300000, 400000); EXPECT_EQ(0, start_bitrate); EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_); EXPECT_EQ(200000u, bitrate_observer_2.last_bitrate_); @@ -175,9 +170,9 @@ TEST_F(BitrateAllocatorTestNoEnforceMin, ThreeBitrateObservers) { EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_); EXPECT_EQ(0u, bitrate_observer_3.last_bitrate_); - allocator_->RemoveBitrateObserver(&bitrate_observer_1); - allocator_->RemoveBitrateObserver(&bitrate_observer_2); - allocator_->RemoveBitrateObserver(&bitrate_observer_3); + allocator_->RemoveObserver(&bitrate_observer_1); + allocator_->RemoveObserver(&bitrate_observer_2); + allocator_->RemoveObserver(&bitrate_observer_3); } TEST_F(BitrateAllocatorTest, ThreeBitrateObserversLowRembEnforceMin) { @@ -185,16 +180,14 @@ TEST_F(BitrateAllocatorTest, ThreeBitrateObserversLowRembEnforceMin) { TestBitrateObserver bitrate_observer_2; TestBitrateObserver bitrate_observer_3; int start_bitrate = - allocator_->AddBitrateObserver(&bitrate_observer_1, 100000, 400000); + allocator_->AddObserver(&bitrate_observer_1, 100000, 400000); EXPECT_EQ(300000, start_bitrate); - start_bitrate = - allocator_->AddBitrateObserver(&bitrate_observer_2, 200000, 400000); + start_bitrate = allocator_->AddObserver(&bitrate_observer_2, 200000, 400000); EXPECT_EQ(200000, start_bitrate); EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_); - start_bitrate = - allocator_->AddBitrateObserver(&bitrate_observer_3, 300000, 400000); + start_bitrate = allocator_->AddObserver(&bitrate_observer_3, 300000, 400000); EXPECT_EQ(300000, start_bitrate); EXPECT_EQ(100000, static_cast(bitrate_observer_1.last_bitrate_)); EXPECT_EQ(200000, static_cast(bitrate_observer_2.last_bitrate_)); @@ -205,8 +198,8 @@ TEST_F(BitrateAllocatorTest, ThreeBitrateObserversLowRembEnforceMin) { EXPECT_EQ(200000u, bitrate_observer_2.last_bitrate_); // Min cap. EXPECT_EQ(300000u, bitrate_observer_3.last_bitrate_); // Min cap. - allocator_->RemoveBitrateObserver(&bitrate_observer_1); - allocator_->RemoveBitrateObserver(&bitrate_observer_2); - allocator_->RemoveBitrateObserver(&bitrate_observer_3); + allocator_->RemoveObserver(&bitrate_observer_1); + allocator_->RemoveObserver(&bitrate_observer_2); + allocator_->RemoveObserver(&bitrate_observer_3); } } // namespace webrtc diff --git a/webrtc/call/call.cc b/webrtc/call/call.cc index 41ac328eab..2dfb13a2e6 100644 --- a/webrtc/call/call.cc +++ b/webrtc/call/call.cc @@ -394,7 +394,7 @@ webrtc::VideoSendStream* Call::CreateVideoSendStream( // the call has already started. VideoSendStream* send_stream = new VideoSendStream( num_cpu_cores_, module_process_thread_.get(), call_stats_.get(), - congestion_controller_.get(), &remb_, bitrate_allocator_.get(), config, + congestion_controller_.get(), bitrate_allocator_.get(), &remb_, config, encoder_config, suspended_video_send_ssrcs_); if (!network_enabled_) diff --git a/webrtc/video/encoder_state_feedback_unittest.cc b/webrtc/video/encoder_state_feedback_unittest.cc index be81bdade2..3341cf0667 100644 --- a/webrtc/video/encoder_state_feedback_unittest.cc +++ b/webrtc/video/encoder_state_feedback_unittest.cc @@ -35,7 +35,6 @@ class MockVieEncoder : public ViEEncoder { nullptr, nullptr, pacer, - nullptr, nullptr) {} ~MockVieEncoder() {} diff --git a/webrtc/video/video_send_stream.cc b/webrtc/video/video_send_stream.cc index c98e5187db..658cd495ba 100644 --- a/webrtc/video/video_send_stream.cc +++ b/webrtc/video/video_send_stream.cc @@ -156,8 +156,8 @@ VideoSendStream::VideoSendStream( ProcessThread* module_process_thread, CallStats* call_stats, CongestionController* congestion_controller, - VieRemb* remb, BitrateAllocator* bitrate_allocator, + VieRemb* remb, const VideoSendStream::Config& config, const VideoEncoderConfig& encoder_config, const std::map& suspended_ssrcs) @@ -170,6 +170,7 @@ VideoSendStream::VideoSendStream( module_process_thread_(module_process_thread), call_stats_(call_stats), congestion_controller_(congestion_controller), + bitrate_allocator_(bitrate_allocator), remb_(remb), encoder_thread_(EncoderThreadFunction, this, "EncoderThread"), encoder_wakeup_event_(false, false), @@ -202,8 +203,7 @@ VideoSendStream::VideoSendStream( config.pre_encode_callback, &overuse_detector_, congestion_controller_->pacer(), - &payload_router_, - bitrate_allocator), + &payload_router_), vcm_(vie_encoder_.vcm()), rtp_rtcp_modules_(vie_channel_.rtp_rtcp()), input_(&encoder_wakeup_event_, @@ -298,8 +298,10 @@ VideoSendStream::VideoSendStream( if (config_.post_encode_callback) vie_encoder_.RegisterPostEncodeImageCallback(&encoded_frame_proxy_); - if (config_.suspend_below_min_bitrate) - vie_encoder_.SuspendBelowMinBitrate(); + if (config_.suspend_below_min_bitrate) { + vcm_->SuspendBelowMinBitrate(); + bitrate_allocator_->EnforceMinBitrate(false); + } vie_channel_.RegisterRtcpPacketTypeCounterObserver(&stats_proxy_); vie_channel_.RegisterSendBitrateObserver(&stats_proxy_); @@ -313,6 +315,8 @@ VideoSendStream::VideoSendStream( VideoSendStream::~VideoSendStream() { LOG(LS_INFO) << "~VideoSendStream: " << config_.ToString(); + + bitrate_allocator_->RemoveObserver(this); Stop(); // Stop the encoder thread permanently. @@ -516,6 +520,10 @@ void VideoSendStream::ReconfigureVideoEncoder( RTC_DCHECK_GT(streams[0].max_framerate, 0); video_codec.maxFramerate = streams[0].max_framerate; + video_codec.startBitrate = + bitrate_allocator_->AddObserver(this, + video_codec.minBitrate * 1000, + video_codec.maxBitrate * 1000) / 1000; vie_encoder_.SetEncoder(video_codec, config.min_transmit_bitrate_bps); } @@ -614,5 +622,12 @@ void VideoSendStream::SignalNetworkState(NetworkState state) { int VideoSendStream::GetPaddingNeededBps() const { return vie_encoder_.GetPaddingNeededBps(); } + +void VideoSendStream::OnBitrateUpdated(uint32_t bitrate_bps, + uint8_t fraction_loss, + int64_t rtt) { + vie_encoder_.OnBitrateUpdated(bitrate_bps, fraction_loss, rtt); +} + } // namespace internal } // namespace webrtc diff --git a/webrtc/video/video_send_stream.h b/webrtc/video/video_send_stream.h index 88d8abc4fb..8b3d064f3e 100644 --- a/webrtc/video/video_send_stream.h +++ b/webrtc/video/video_send_stream.h @@ -14,6 +14,7 @@ #include #include +#include "webrtc/call/bitrate_allocator.h" #include "webrtc/call.h" #include "webrtc/common_video/libyuv/include/webrtc_libyuv.h" #include "webrtc/video/encoded_frame_callback_adapter.h" @@ -40,14 +41,15 @@ class VieRemb; namespace internal { class VideoSendStream : public webrtc::VideoSendStream, - public webrtc::CpuOveruseObserver { + public webrtc::CpuOveruseObserver, + public webrtc::BitrateAllocatorObserver { public: VideoSendStream(int num_cpu_cores, ProcessThread* module_process_thread, CallStats* call_stats, CongestionController* congestion_controller, - VieRemb* remb, BitrateAllocator* bitrate_allocator, + VieRemb* remb, const VideoSendStream::Config& config, const VideoEncoderConfig& encoder_config, const std::map& suspended_ssrcs); @@ -74,6 +76,11 @@ class VideoSendStream : public webrtc::VideoSendStream, int GetPaddingNeededBps() const; + // Implements BitrateAllocatorObserver. + void OnBitrateUpdated(uint32_t bitrate_bps, + uint8_t fraction_loss, + int64_t rtt) override; + private: static bool EncoderThreadFunction(void* obj); void EncoderProcess(); @@ -88,6 +95,7 @@ class VideoSendStream : public webrtc::VideoSendStream, ProcessThread* const module_process_thread_; CallStats* const call_stats_; CongestionController* const congestion_controller_; + BitrateAllocator* const bitrate_allocator_; VieRemb* const remb_; rtc::PlatformThread encoder_thread_; diff --git a/webrtc/video/vie_encoder.cc b/webrtc/video/vie_encoder.cc index bd0729c1f2..e6f6776ad6 100644 --- a/webrtc/video/vie_encoder.cc +++ b/webrtc/video/vie_encoder.cc @@ -17,11 +17,9 @@ #include "webrtc/base/checks.h" #include "webrtc/base/logging.h" #include "webrtc/base/trace_event.h" -#include "webrtc/call/bitrate_allocator.h" #include "webrtc/common_video/include/video_image.h" #include "webrtc/common_video/libyuv/include/webrtc_libyuv.h" #include "webrtc/frame_callback.h" -#include "webrtc/modules/bitrate_controller/include/bitrate_controller.h" #include "webrtc/modules/pacing/paced_sender.h" #include "webrtc/modules/utility/include/process_thread.h" #include "webrtc/modules/video_coding/include/video_codec_interface.h" @@ -80,22 +78,6 @@ class QMVideoSettingsCallback : public VCMQMSettingsCallback { VideoProcessing* vp_; }; -class ViEBitrateObserver : public BitrateObserver { - public: - explicit ViEBitrateObserver(ViEEncoder* owner) - : owner_(owner) { - } - virtual ~ViEBitrateObserver() {} - // Implements BitrateObserver. - virtual void OnNetworkChanged(uint32_t bitrate_bps, - uint8_t fraction_lost, - int64_t rtt) { - owner_->OnNetworkChanged(bitrate_bps, fraction_lost, rtt); - } - private: - ViEEncoder* owner_; -}; - ViEEncoder::ViEEncoder(uint32_t number_of_cores, const std::vector& ssrcs, ProcessThread* module_process_thread, @@ -103,8 +85,7 @@ ViEEncoder::ViEEncoder(uint32_t number_of_cores, I420FrameCallback* pre_encode_callback, OveruseFrameDetector* overuse_detector, PacedSender* pacer, - PayloadRouter* payload_router, - BitrateAllocator* bitrate_allocator) + PayloadRouter* payload_router) : number_of_cores_(number_of_cores), ssrcs_(ssrcs), vp_(VideoProcessing::Create()), @@ -117,7 +98,6 @@ ViEEncoder::ViEEncoder(uint32_t number_of_cores, overuse_detector_(overuse_detector), pacer_(pacer), send_payload_router_(payload_router), - bitrate_allocator_(bitrate_allocator), time_of_last_frame_activity_ms_(0), encoder_config_(), min_transmit_bitrate_bps_(0), @@ -132,7 +112,6 @@ ViEEncoder::ViEEncoder(uint32_t number_of_cores, has_received_rpsi_(false), picture_id_rpsi_(0), video_suspended_(false) { - bitrate_observer_.reset(new ViEBitrateObserver(this)); module_process_thread_->RegisterModule(vcm_.get()); } @@ -157,8 +136,6 @@ VideoCodingModule* ViEEncoder::vcm() const { ViEEncoder::~ViEEncoder() { module_process_thread_->DeRegisterModule(vcm_.get()); - if (bitrate_allocator_) - bitrate_allocator_->RemoveBitrateObserver(bitrate_observer_.get()); } void ViEEncoder::SetNetworkTransmissionState(bool is_transmitting) { @@ -202,7 +179,7 @@ void ViEEncoder::SetEncoder(const webrtc::VideoCodec& video_codec, vp_->SetTargetResolution(video_codec.width, video_codec.height, video_codec.maxFramerate)); - // Cache codec before calling AddBitrateObserver (which calls OnNetworkChanged + // Cache codec before calling AddBitrateObserver (which calls OnBitrateUpdated // that makes use of the number of simulcast streams configured). { rtc::CritScope lock(&data_cs_); @@ -211,18 +188,9 @@ void ViEEncoder::SetEncoder(const webrtc::VideoCodec& video_codec, min_transmit_bitrate_bps_ = min_transmit_bitrate_bps; } - // Add a bitrate observer to the allocator and update the start, max and - // min bitrates of the bitrate controller as needed. - int allocated_bitrate_bps = bitrate_allocator_->AddBitrateObserver( - bitrate_observer_.get(), video_codec.minBitrate * 1000, - video_codec.maxBitrate * 1000); - - webrtc::VideoCodec modified_video_codec = video_codec; - modified_video_codec.startBitrate = allocated_bitrate_bps / 1000; - size_t max_data_payload_length = send_payload_router_->MaxPayloadLength(); bool success = vcm_->RegisterSendCodec( - &modified_video_codec, number_of_cores_, + &video_codec, number_of_cores_, static_cast(max_data_payload_length)) == VCM_OK; if (!success) { LOG(LS_ERROR) << "Failed to configure encoder."; @@ -511,11 +479,10 @@ void ViEEncoder::OnReceivedIntraFrameRequest(uint32_t ssrc) { RTC_NOTREACHED() << "Should not receive keyframe requests on unknown SSRCs."; } -// Called from ViEBitrateObserver. -void ViEEncoder::OnNetworkChanged(uint32_t bitrate_bps, +void ViEEncoder::OnBitrateUpdated(uint32_t bitrate_bps, uint8_t fraction_lost, int64_t round_trip_time_ms) { - LOG(LS_VERBOSE) << "OnNetworkChanged, bitrate" << bitrate_bps + LOG(LS_VERBOSE) << "OnBitrateUpdated, bitrate" << bitrate_bps << " packet loss " << static_cast(fraction_lost) << " rtt " << round_trip_time_ms; RTC_DCHECK(send_payload_router_ != NULL); @@ -546,11 +513,6 @@ void ViEEncoder::OnNetworkChanged(uint32_t bitrate_bps, stats_proxy_->OnSuspendChange(video_is_suspended); } -void ViEEncoder::SuspendBelowMinBitrate() { - vcm_->SuspendBelowMinBitrate(); - bitrate_allocator_->EnforceMinBitrate(false); -} - void ViEEncoder::RegisterPostEncodeImageCallback( EncodedImageCallback* post_encode_callback) { vcm_->RegisterPostEncodeImageCallback(post_encode_callback); diff --git a/webrtc/video/vie_encoder.h b/webrtc/video/vie_encoder.h index 3703ccd94c..ce1e508eba 100644 --- a/webrtc/video/vie_encoder.h +++ b/webrtc/video/vie_encoder.h @@ -17,7 +17,6 @@ #include "webrtc/base/criticalsection.h" #include "webrtc/base/scoped_ref_ptr.h" #include "webrtc/base/thread_annotations.h" -#include "webrtc/call/bitrate_allocator.h" #include "webrtc/common_types.h" #include "webrtc/frame_callback.h" #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h" @@ -27,8 +26,6 @@ namespace webrtc { -class BitrateAllocator; -class BitrateObserver; class Config; class EncodedImageCallback; class OveruseFrameDetector; @@ -55,8 +52,7 @@ class ViEEncoder : public VideoEncoderRateObserver, I420FrameCallback* pre_encode_callback, OveruseFrameDetector* overuse_detector, PacedSender* pacer, - PayloadRouter* payload_router, - BitrateAllocator* bitrate_allocator); + PayloadRouter* payload_router); ~ViEEncoder(); bool Init(); @@ -109,20 +105,13 @@ class ViEEncoder : public VideoEncoderRateObserver, virtual void OnReceivedSLI(uint32_t ssrc, uint8_t picture_id); virtual void OnReceivedRPSI(uint32_t ssrc, uint64_t picture_id); - // Lets the sender suspend video when the rate drops below - // |threshold_bps|, and turns back on when the rate goes back up above - // |threshold_bps| + |window_bps|. - void SuspendBelowMinBitrate(); - // New-style callbacks, used by VideoSendStream. void RegisterPostEncodeImageCallback( EncodedImageCallback* post_encode_callback); int GetPaddingNeededBps() const; - protected: - // Called by BitrateObserver. - void OnNetworkChanged(uint32_t bitrate_bps, + void OnBitrateUpdated(uint32_t bitrate_bps, uint8_t fraction_lost, int64_t round_trip_time_ms); @@ -139,14 +128,12 @@ class ViEEncoder : public VideoEncoderRateObserver, const std::unique_ptr vcm_; rtc::CriticalSection data_cs_; - std::unique_ptr bitrate_observer_; SendStatisticsProxy* const stats_proxy_; I420FrameCallback* const pre_encode_callback_; OveruseFrameDetector* const overuse_detector_; PacedSender* const pacer_; PayloadRouter* const send_payload_router_; - BitrateAllocator* const bitrate_allocator_; // The time we last received an input frame or encoded frame. This is used to // track when video is stopped long enough that we also want to stop sending