blob: 3bafcd756be38194c1d79a41e4a253e2d6a54ed1 [file] [log] [blame]
stefan@webrtc.org792f1a12015-03-04 12:24:26 +00001/*
2 * Copyright (c) 2015 The WebRTC project authors. All Rights Reserved.
3 *
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
stefan@webrtc.org792f1a12015-03-04 12:24:26 +00009 */
10
mflodman0e7e2592015-11-12 21:02:42 -080011#ifndef WEBRTC_CALL_BITRATE_ALLOCATOR_H_
12#define WEBRTC_CALL_BITRATE_ALLOCATOR_H_
stefan@webrtc.org792f1a12015-03-04 12:24:26 +000013
kwibergb25345e2016-03-12 06:10:44 -080014#include <stdint.h>
15
stefan@webrtc.org792f1a12015-03-04 12:24:26 +000016#include <list>
17#include <map>
18#include <utility>
19
tommi63cb4342016-01-20 02:32:54 -080020#include "webrtc/base/criticalsection.h"
stefan@webrtc.org792f1a12015-03-04 12:24:26 +000021#include "webrtc/base/thread_annotations.h"
stefan@webrtc.org792f1a12015-03-04 12:24:26 +000022
23namespace webrtc {
24
mflodman86aabb22016-03-11 15:44:32 +010025// Used by all send streams with adaptive bitrate, to get the currently
26// allocated bitrate for the send stream. The current network properties are
27// given at the same time, to let the send stream decide about possible loss
28// protection.
29class BitrateAllocatorObserver {
30 public:
31 virtual void OnBitrateUpdated(uint32_t bitrate_bps,
32 uint8_t fraction_loss,
33 int64_t rtt) = 0;
34 virtual ~BitrateAllocatorObserver() {}
35};
stefan@webrtc.org792f1a12015-03-04 12:24:26 +000036
mflodman86aabb22016-03-11 15:44:32 +010037// Usage: this class will register multiple RtcpBitrateObserver's one at each
38// RTCP module. It will aggregate the results and run one bandwidth estimation
39// and push the result to the encoders via BitrateAllocatorObserver(s).
stefan@webrtc.org792f1a12015-03-04 12:24:26 +000040class BitrateAllocator {
41 public:
42 BitrateAllocator();
stefan@webrtc.org792f1a12015-03-04 12:24:26 +000043
mflodman86aabb22016-03-11 15:44:32 +010044 // Allocate target_bitrate across the registered BitrateAllocatorObservers.
sprang2f48d942015-11-05 04:25:49 -080045 // Returns actual bitrate allocated (might be higher than target_bitrate if
46 // for instance EnforceMinBitrate() is enabled.
47 uint32_t OnNetworkChanged(uint32_t target_bitrate,
48 uint8_t fraction_loss,
49 int64_t rtt);
stefan@webrtc.org792f1a12015-03-04 12:24:26 +000050
51 // Set the start and max send bitrate used by the bandwidth management.
52 //
Peter Boström8e4e8b02015-09-15 15:08:03 +020053 // |observer| updates bitrates if already in use.
54 // |min_bitrate_bps| = 0 equals no min bitrate.
55 // |max_bitrate_bps| = 0 equals no max bitrate.
mflodman2ebe5b12016-05-13 01:43:51 -070056 // |enforce_min_bitrate| = 'true' will allocate at least |min_bitrate_bps| for
57 // this observer, even if the BWE is too low, 'false' will allocate 0 to
58 // the observer if BWE doesn't allow |min_bitrate_bps|.
perkjfea93092016-05-14 00:58:48 -070059 // Returns initial bitrate allocated for |observer|.
60 // Note that |observer|->OnBitrateUpdated() will be called within the scope of
61 // this method with the current rtt, fraction_loss and available bitrate and
62 // that the bitrate in OnBitrateUpdated will be zero if the |observer| is
63 // currently not allowed to send data.
mflodman86aabb22016-03-11 15:44:32 +010064 int AddObserver(BitrateAllocatorObserver* observer,
65 uint32_t min_bitrate_bps,
mflodman2ebe5b12016-05-13 01:43:51 -070066 uint32_t max_bitrate_bps,
67 bool enforce_min_bitrate);
stefan@webrtc.org792f1a12015-03-04 12:24:26 +000068
mflodman86aabb22016-03-11 15:44:32 +010069 void RemoveObserver(BitrateAllocatorObserver* observer);
stefan@webrtc.org792f1a12015-03-04 12:24:26 +000070
mflodman2ebe5b12016-05-13 01:43:51 -070071 private:
72 struct ObserverConfig {
73 ObserverConfig(BitrateAllocatorObserver* observer,
74 uint32_t min_bitrate_bps,
75 uint32_t max_bitrate_bps,
76 bool enforce_min_bitrate)
77 : observer(observer),
78 min_bitrate_bps(min_bitrate_bps),
79 max_bitrate_bps(max_bitrate_bps),
80 enforce_min_bitrate(enforce_min_bitrate) {}
81 BitrateAllocatorObserver* const observer;
82 uint32_t min_bitrate_bps;
83 uint32_t max_bitrate_bps;
84 bool enforce_min_bitrate;
85 };
86
stefan@webrtc.org792f1a12015-03-04 12:24:26 +000087 // This method controls the behavior when the available bitrate is lower than
88 // the minimum bitrate, or the sum of minimum bitrates.
89 // When true, the bitrate will never be set lower than the minimum bitrate(s).
90 // When false, the bitrate observers will be allocated rates up to their
91 // respective minimum bitrate, satisfying one observer after the other.
mflodman2ebe5b12016-05-13 01:43:51 -070092 void EnforceMinBitrate(bool enforce_min_bitrate)
93 EXCLUSIVE_LOCKS_REQUIRED(crit_sect_);
stefan@webrtc.org792f1a12015-03-04 12:24:26 +000094
mflodman2ebe5b12016-05-13 01:43:51 -070095 typedef std::list<ObserverConfig> ObserverConfigList;
96 ObserverConfigList::iterator FindObserverConfig(
mflodman86aabb22016-03-11 15:44:32 +010097 const BitrateAllocatorObserver* observer)
98 EXCLUSIVE_LOCKS_REQUIRED(crit_sect_);
mflodman2ebe5b12016-05-13 01:43:51 -070099
100 typedef std::multimap<uint32_t, const ObserverConfig*> ObserverSortingMap;
101 typedef std::map<BitrateAllocatorObserver*, int> ObserverAllocation;
102
perkjfea93092016-05-14 00:58:48 -0700103 ObserverAllocation AllocateBitrates(uint32_t bitrate)
104 EXCLUSIVE_LOCKS_REQUIRED(crit_sect_);
mflodman2ebe5b12016-05-13 01:43:51 -0700105 ObserverAllocation NormalRateAllocation(uint32_t bitrate,
Stefan Holmere5904162015-03-26 11:11:06 +0100106 uint32_t sum_min_bitrates)
107 EXCLUSIVE_LOCKS_REQUIRED(crit_sect_);
108
mflodman2ebe5b12016-05-13 01:43:51 -0700109 ObserverAllocation ZeroRateAllocation() EXCLUSIVE_LOCKS_REQUIRED(crit_sect_);
110 ObserverAllocation LowRateAllocation(uint32_t bitrate)
Stefan Holmere5904162015-03-26 11:11:06 +0100111 EXCLUSIVE_LOCKS_REQUIRED(crit_sect_);
stefan@webrtc.org792f1a12015-03-04 12:24:26 +0000112
pbos5ad935c2016-01-25 03:52:44 -0800113 rtc::CriticalSection crit_sect_;
Stefan Holmere5904162015-03-26 11:11:06 +0100114 // Stored in a list to keep track of the insertion order.
mflodman2ebe5b12016-05-13 01:43:51 -0700115 ObserverConfigList bitrate_observer_configs_;
stefan@webrtc.org792f1a12015-03-04 12:24:26 +0000116 bool enforce_min_bitrate_ GUARDED_BY(crit_sect_);
Stefan Holmere5904162015-03-26 11:11:06 +0100117 uint32_t last_bitrate_bps_ GUARDED_BY(crit_sect_);
perkjfea93092016-05-14 00:58:48 -0700118 uint32_t last_non_zero_bitrate_bps_ GUARDED_BY(crit_sect_);
Stefan Holmere5904162015-03-26 11:11:06 +0100119 uint8_t last_fraction_loss_ GUARDED_BY(crit_sect_);
120 int64_t last_rtt_ GUARDED_BY(crit_sect_);
stefan@webrtc.org792f1a12015-03-04 12:24:26 +0000121};
122} // namespace webrtc
mflodman0e7e2592015-11-12 21:02:42 -0800123#endif // WEBRTC_CALL_BITRATE_ALLOCATOR_H_