diff options
Diffstat (limited to 'webrtc/call/bitrate_allocator.h')
-rw-r--r-- | webrtc/call/bitrate_allocator.h | 102 |
1 files changed, 102 insertions, 0 deletions
diff --git a/webrtc/call/bitrate_allocator.h b/webrtc/call/bitrate_allocator.h new file mode 100644 index 0000000000..4a3fd59d49 --- /dev/null +++ b/webrtc/call/bitrate_allocator.h @@ -0,0 +1,102 @@ +/* + * Copyright (c) 2015 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * 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_ +#define WEBRTC_CALL_BITRATE_ALLOCATOR_H_ + +#include <list> +#include <map> +#include <utility> + +#include "webrtc/base/scoped_ptr.h" +#include "webrtc/base/thread_annotations.h" +#include "webrtc/system_wrappers/include/critical_section_wrapper.h" + +namespace webrtc { + +class BitrateObserver; + +class BitrateAllocator { + public: + BitrateAllocator(); + + // Allocate target_bitrate across the registered BitrateObservers. + // Returns actual bitrate allocated (might be higher than target_bitrate if + // for instance EnforceMinBitrate() is enabled. + uint32_t OnNetworkChanged(uint32_t target_bitrate, + uint8_t fraction_loss, + int64_t rtt); + + // Set the start and max send bitrate used by the bandwidth management. + // + // |observer| updates bitrates if already in use. + // |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); + + void RemoveBitrateObserver(BitrateObserver* observer); + + void GetMinMaxBitrateSumBps(int* min_bitrate_sum_bps, + int* max_bitrate_sum_bps) const; + + // This method controls the behavior when the available bitrate is lower than + // the minimum bitrate, or the sum of minimum bitrates. + // When true, the bitrate will never be set lower than the minimum bitrate(s). + // When false, the bitrate observers will be allocated rates up to their + // respective minimum bitrate, satisfying one observer after the other. + void EnforceMinBitrate(bool enforce_min_bitrate); + + private: + struct BitrateConfiguration { + BitrateConfiguration(uint32_t min_bitrate, uint32_t max_bitrate) + : min_bitrate(min_bitrate), max_bitrate(max_bitrate) {} + uint32_t min_bitrate; + uint32_t max_bitrate; + }; + struct ObserverConfiguration { + ObserverConfiguration(BitrateObserver* observer, uint32_t bitrate) + : observer(observer), min_bitrate(bitrate) {} + BitrateObserver* const observer; + uint32_t min_bitrate; + }; + typedef std::pair<BitrateObserver*, BitrateConfiguration> + BitrateObserverConfiguration; + typedef std::list<BitrateObserverConfiguration> BitrateObserverConfList; + typedef std::multimap<uint32_t, ObserverConfiguration> ObserverSortingMap; + typedef std::map<BitrateObserver*, int> ObserverBitrateMap; + + BitrateObserverConfList::iterator FindObserverConfigurationPair( + const BitrateObserver* observer) EXCLUSIVE_LOCKS_REQUIRED(crit_sect_); + ObserverBitrateMap AllocateBitrates() EXCLUSIVE_LOCKS_REQUIRED(crit_sect_); + ObserverBitrateMap NormalRateAllocation(uint32_t bitrate, + uint32_t sum_min_bitrates) + EXCLUSIVE_LOCKS_REQUIRED(crit_sect_); + + ObserverBitrateMap LowRateAllocation(uint32_t bitrate) + EXCLUSIVE_LOCKS_REQUIRED(crit_sect_); + + rtc::scoped_ptr<CriticalSectionWrapper> crit_sect_; + // Stored in a list to keep track of the insertion order. + BitrateObserverConfList bitrate_observers_ GUARDED_BY(crit_sect_); + bool bitrate_observers_modified_ GUARDED_BY(crit_sect_); + bool enforce_min_bitrate_ GUARDED_BY(crit_sect_); + uint32_t last_bitrate_bps_ GUARDED_BY(crit_sect_); + uint8_t last_fraction_loss_ GUARDED_BY(crit_sect_); + int64_t last_rtt_ GUARDED_BY(crit_sect_); +}; +} // namespace webrtc +#endif // WEBRTC_CALL_BITRATE_ALLOCATOR_H_ |