generic-library/webrtc
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Change the low-bitrate handling in BitrateControllerImpl

Browse Source 
Changing to using strategy classes rather than having two different
derived classes of BitrateControllerImpl. This enables run-time switching
of the strategy, which is now possible through a new API. The reason is
that it must fit the current design of ViE.

BUG=2436
R=stefan@webrtc.org

Review URL: https://webrtc-codereview.appspot.com/2789004

git-svn-id: http://webrtc.googlecode.com/svn/trunk@5028 4adac7df-926f-26a2-2b94-8c16560cd09d
This commit is contained in:
henrik.lundin@webrtc.org 2013-10-24 09:24:06 +00:00
parent 37bb4974e7
commit b56d0e383e
3 changed files with 87 additions and 41 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

79
webrtc/modules/bitrate_controller/bitrate_controller_impl.cc
View File

@ -76,26 +76,56 @@ class RtcpBandwidthObserverImpl : public RtcpBandwidthObserver {
BitrateControllerImpl* owner_;
};
class BitrateControllerEnforceMinRate : public BitrateControllerImpl {
private:
class LowRateStrategy {
public:
LowRateStrategy(
SendSideBandwidthEstimation* bandwidth_estimation,
BitrateControllerImpl::BitrateObserverConfList* bitrate_observers)
: bandwidth_estimation_(bandwidth_estimation),
bitrate_observers_(bitrate_observers) {}
virtual ~LowRateStrategy() {}
virtual void LowRateAllocation(uint32_t bitrate,
uint8_t fraction_loss,
uint32_t rtt,
uint32_t sum_min_bitrates) = 0;
protected:
SendSideBandwidthEstimation* bandwidth_estimation_;
BitrateControllerImpl::BitrateObserverConfList* bitrate_observers_;
};
class EnforceMinRateStrategy : public LowRateStrategy {
public:
EnforceMinRateStrategy(
SendSideBandwidthEstimation* bandwidth_estimation,
BitrateControllerImpl::BitrateObserverConfList* bitrate_observers)
: LowRateStrategy(bandwidth_estimation, bitrate_observers) {}
void LowRateAllocation(uint32_t bitrate,
uint8_t fraction_loss,
uint32_t rtt,
uint32_t sum_min_bitrates) {
// Min bitrate to all observers.
BitrateObserverConfList::iterator it;
for (it = bitrate_observers_.begin(); it != bitrate_observers_.end();
BitrateControllerImpl::BitrateObserverConfList::iterator it;
for (it = bitrate_observers_->begin(); it != bitrate_observers_->end();
++it) {
it->first->OnNetworkChanged(it->second->min_bitrate_, fraction_loss,
rtt);
}
// Set sum of min to current send bitrate.
bandwidth_estimation_.SetSendBitrate(sum_min_bitrates);
bandwidth_estimation_->SetSendBitrate(sum_min_bitrates);
}
};
class BitrateControllerNoEnforceMinRate : public BitrateControllerImpl {
private:
class NoEnforceMinRateStrategy : public LowRateStrategy {
public:
NoEnforceMinRateStrategy(
SendSideBandwidthEstimation* bandwidth_estimation,
BitrateControllerImpl::BitrateObserverConfList* bitrate_observers)
: LowRateStrategy(bandwidth_estimation, bitrate_observers) {}
void LowRateAllocation(uint32_t bitrate,
uint8_t fraction_loss,
uint32_t rtt,
@ -103,29 +133,32 @@ class BitrateControllerNoEnforceMinRate : public BitrateControllerImpl {
// Allocate up to |min_bitrate_| to one observer at a time, until
// |bitrate| is depleted.
uint32_t remainder = bitrate;
BitrateObserverConfList::iterator it;
for (it = bitrate_observers_.begin(); it != bitrate_observers_.end();
BitrateControllerImpl::BitrateObserverConfList::iterator it;
for (it = bitrate_observers_->begin(); it != bitrate_observers_->end();
++it) {
uint32_t allocation = std::min(remainder, it->second->min_bitrate_);
it->first->OnNetworkChanged(allocation, fraction_loss, rtt);
remainder -= allocation;
}
// Set |bitrate| to current send bitrate.
bandwidth_estimation_.SetSendBitrate(bitrate);
bandwidth_estimation_->SetSendBitrate(bitrate);
}
};
BitrateController* BitrateController::CreateBitrateController(
bool enforce_min_bitrate) {
if (enforce_min_bitrate) {
return new BitrateControllerEnforceMinRate();
} else {
return new BitrateControllerNoEnforceMinRate();
}
return new BitrateControllerImpl(enforce_min_bitrate);
}
BitrateControllerImpl::BitrateControllerImpl()
BitrateControllerImpl::BitrateControllerImpl(bool enforce_min_bitrate)
: critsect_(CriticalSectionWrapper::CreateCriticalSection()) {
if (enforce_min_bitrate) {
low_rate_strategy_.reset(new EnforceMinRateStrategy(
&bandwidth_estimation_, &bitrate_observers_));
} else {
low_rate_strategy_.reset(new NoEnforceMinRateStrategy(
&bandwidth_estimation_, &bitrate_observers_));
}
}
BitrateControllerImpl::~BitrateControllerImpl() {
@ -205,6 +238,17 @@ void BitrateControllerImpl::RemoveBitrateObserver(BitrateObserver* observer) {
}
}
void BitrateControllerImpl::EnforceMinBitrate(bool enforce_min_bitrate) {
CriticalSectionScoped cs(critsect_);
if (enforce_min_bitrate) {
low_rate_strategy_.reset(new EnforceMinRateStrategy(
&bandwidth_estimation_, &bitrate_observers_));
} else {
low_rate_strategy_.reset(new NoEnforceMinRateStrategy(
&bandwidth_estimation_, &bitrate_observers_));
}
}
void BitrateControllerImpl::OnReceivedEstimatedBitrate(const uint32_t bitrate) {
uint32_t new_bitrate = 0;
uint8_t fraction_lost = 0;
@ -247,7 +291,8 @@ void BitrateControllerImpl::OnNetworkChanged(const uint32_t bitrate,
sum_min_bitrates += it->second->min_bitrate_;
}
if (bitrate <= sum_min_bitrates) {
return LowRateAllocation(bitrate, fraction_loss, rtt, sum_min_bitrates);
return low_rate_strategy_->LowRateAllocation(bitrate, fraction_loss, rtt,
sum_min_bitrates);
}
uint32_t bitrate_per_observer = (bitrate - sum_min_bitrates) /
number_of_observers;

46
webrtc/modules/bitrate_controller/bitrate_controller_impl.h
View File

@ -23,30 +23,17 @@
#include "webrtc/modules/bitrate_controller/send_side_bandwidth_estimation.h"
#include "webrtc/system_wrappers/interface/critical_section_wrapper.h"
#include "webrtc/system_wrappers/interface/scoped_ptr.h"
namespace webrtc {
class RtcpBandwidthObserverImpl;
class LowRateStrategy;
class BitrateControllerImpl : public BitrateController {
public:
friend class RtcpBandwidthObserverImpl;
explicit BitrateControllerImpl();
virtual ~BitrateControllerImpl();
virtual bool AvailableBandwidth(uint32_t* bandwidth) const OVERRIDE;
virtual RtcpBandwidthObserver* CreateRtcpBandwidthObserver() OVERRIDE;
virtual void SetBitrateObserver(BitrateObserver* observer,
const uint32_t start_bitrate,
const uint32_t min_bitrate,
const uint32_t max_bitrate) OVERRIDE;
virtual void RemoveBitrateObserver(BitrateObserver* observer) OVERRIDE;
protected:
struct BitrateConfiguration {
BitrateConfiguration(uint32_t start_bitrate,
uint32_t min_bitrate,
@ -72,6 +59,23 @@ class BitrateControllerImpl : public BitrateController {
BitrateObserverConfiguration;
typedef std::list<BitrateObserverConfiguration> BitrateObserverConfList;
explicit BitrateControllerImpl(bool enforce_min_bitrate);
virtual ~BitrateControllerImpl();
virtual bool AvailableBandwidth(uint32_t* bandwidth) const OVERRIDE;
virtual RtcpBandwidthObserver* CreateRtcpBandwidthObserver() OVERRIDE;
virtual void SetBitrateObserver(BitrateObserver* observer,
const uint32_t start_bitrate,
const uint32_t min_bitrate,
const uint32_t max_bitrate) OVERRIDE;
virtual void RemoveBitrateObserver(BitrateObserver* observer) OVERRIDE;
virtual void EnforceMinBitrate(bool enforce_min_bitrate) OVERRIDE;
private:
// Called by BitrateObserver's direct from the RTCP module.
void OnReceivedEstimatedBitrate(const uint32_t bitrate);
@ -80,10 +84,6 @@ class BitrateControllerImpl : public BitrateController {
const int number_of_packets,
const uint32_t now_ms);
SendSideBandwidthEstimation bandwidth_estimation_;
BitrateObserverConfList bitrate_observers_;
private:
typedef std::multimap<uint32_t, ObserverConfiguration*> ObserverSortingMap;
BitrateObserverConfList::iterator
@ -91,13 +91,11 @@ class BitrateControllerImpl : public BitrateController {
void OnNetworkChanged(const uint32_t bitrate,
const uint8_t fraction_loss, // 0 - 255.
const uint32_t rtt);
// Derived classes must implement this strategy method.
virtual void LowRateAllocation(uint32_t bitrate,
uint8_t fraction_loss,
uint32_t rtt,
uint32_t sum_min_bitrates) = 0;
CriticalSectionWrapper* critsect_;
SendSideBandwidthEstimation bandwidth_estimation_;
BitrateObserverConfList bitrate_observers_;
scoped_ptr<LowRateStrategy> low_rate_strategy_;
};
} // namespace webrtc
#endif // WEBRTC_MODULES_BITRATE_CONTROLLER_BITRATE_CONTROLLER_IMPL_H_

3
webrtc/modules/bitrate_controller/include/bitrate_controller.h
View File

@ -70,6 +70,9 @@ class BitrateController {
const uint32_t max_bitrate) = 0;
virtual void RemoveBitrateObserver(BitrateObserver* observer) = 0;
// Changes the mode that was set in the constructor.
virtual void EnforceMinBitrate(bool enforce_min_bitrate) = 0;
};
} // namespace webrtc
#endif // WEBRTC_MODULES_BITRATE_CONTROLLER_INCLUDE_BITRATE_CONTROLLER_H_