zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Move BitrateAllocator from BitrateController logic to Call.

Browse Source 
This is a step on the way to have variable bitrate for audio and is
intended to be as much of a no-op as possible.

BUG=webrtc:5079

Review URL: https://codereview.webrtc.org/1441673002

Cr-Commit-Position: refs/heads/master@{#10630}
This commit is contained in:
mflodman
2015-11-12 21:02:42 -08:00
committed by Commit bot
parent 69191ed845
commit 0e7e259ebd
18 changed files with 89 additions and 61 deletions
Download Patch File Download Diff File Expand all files Collapse all files

102
webrtc/modules/bitrate_controller/include/bitrate_allocator.h
View File

@ -1,102 +0,0 @@
/*
* 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_MODULES_BITRATE_CONTROLLER_INCLUDE_BITRATE_ALLOCATOR_H_
#define WEBRTC_MODULES_BITRATE_CONTROLLER_INCLUDE_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_MODULES_BITRATE_CONTROLLER_INCLUDE_BITRATE_ALLOCATOR_H_