Line data Source code
1 : /*
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.
9 : */
10 :
11 : #ifndef WEBRTC_CALL_BITRATE_ALLOCATOR_H_
12 : #define WEBRTC_CALL_BITRATE_ALLOCATOR_H_
13 :
14 : #include <stdint.h>
15 :
16 : #include <map>
17 : #include <utility>
18 : #include <vector>
19 :
20 : #include "webrtc/base/sequenced_task_checker.h"
21 :
22 : namespace webrtc {
23 :
24 : class Clock;
25 :
26 : // Used by all send streams with adaptive bitrate, to get the currently
27 : // allocated bitrate for the send stream. The current network properties are
28 : // given at the same time, to let the send stream decide about possible loss
29 : // protection.
30 0 : class BitrateAllocatorObserver {
31 : public:
32 : // Returns the amount of protection used by the BitrateAllocatorObserver
33 : // implementation, as bitrate in bps.
34 : virtual uint32_t OnBitrateUpdated(uint32_t bitrate_bps,
35 : uint8_t fraction_loss,
36 : int64_t rtt,
37 : int64_t probing_interval_ms) = 0;
38 :
39 : protected:
40 0 : virtual ~BitrateAllocatorObserver() {}
41 : };
42 :
43 : // Usage: this class will register multiple RtcpBitrateObserver's one at each
44 : // RTCP module. It will aggregate the results and run one bandwidth estimation
45 : // and push the result to the encoders via BitrateAllocatorObserver(s).
46 : class BitrateAllocator {
47 : public:
48 : // Used to get notified when send stream limits such as the minimum send
49 : // bitrate and max padding bitrate is changed.
50 0 : class LimitObserver {
51 : public:
52 : virtual void OnAllocationLimitsChanged(
53 : uint32_t min_send_bitrate_bps,
54 : uint32_t max_padding_bitrate_bps) = 0;
55 :
56 : protected:
57 0 : virtual ~LimitObserver() {}
58 : };
59 :
60 : explicit BitrateAllocator(LimitObserver* limit_observer);
61 : ~BitrateAllocator();
62 :
63 : // Allocate target_bitrate across the registered BitrateAllocatorObservers.
64 : void OnNetworkChanged(uint32_t target_bitrate_bps,
65 : uint8_t fraction_loss,
66 : int64_t rtt,
67 : int64_t probing_interval_ms);
68 :
69 : // Set the start and max send bitrate used by the bandwidth management.
70 : //
71 : // |observer| updates bitrates if already in use.
72 : // |min_bitrate_bps| = 0 equals no min bitrate.
73 : // |max_bitrate_bps| = 0 equals no max bitrate.
74 : // |enforce_min_bitrate| = 'true' will allocate at least |min_bitrate_bps| for
75 : // this observer, even if the BWE is too low, 'false' will allocate 0 to
76 : // the observer if BWE doesn't allow |min_bitrate_bps|.
77 : // Note that |observer|->OnBitrateUpdated() will be called within the scope of
78 : // this method with the current rtt, fraction_loss and available bitrate and
79 : // that the bitrate in OnBitrateUpdated will be zero if the |observer| is
80 : // currently not allowed to send data.
81 : void AddObserver(BitrateAllocatorObserver* observer,
82 : uint32_t min_bitrate_bps,
83 : uint32_t max_bitrate_bps,
84 : uint32_t pad_up_bitrate_bps,
85 : bool enforce_min_bitrate);
86 :
87 : // Removes a previously added observer, but will not trigger a new bitrate
88 : // allocation.
89 : void RemoveObserver(BitrateAllocatorObserver* observer);
90 :
91 : // Returns initial bitrate allocated for |observer|. If |observer| is not in
92 : // the list of added observers, a best guess is returned.
93 : int GetStartBitrate(BitrateAllocatorObserver* observer);
94 :
95 : private:
96 : // Note: All bitrates for member variables and methods are in bps.
97 : struct ObserverConfig {
98 0 : ObserverConfig(BitrateAllocatorObserver* observer,
99 : uint32_t min_bitrate_bps,
100 : uint32_t max_bitrate_bps,
101 : uint32_t pad_up_bitrate_bps,
102 : bool enforce_min_bitrate)
103 0 : : observer(observer),
104 : min_bitrate_bps(min_bitrate_bps),
105 : max_bitrate_bps(max_bitrate_bps),
106 : pad_up_bitrate_bps(pad_up_bitrate_bps),
107 : enforce_min_bitrate(enforce_min_bitrate),
108 : allocated_bitrate_bps(-1),
109 0 : media_ratio(1.0) {}
110 :
111 : BitrateAllocatorObserver* observer;
112 : uint32_t min_bitrate_bps;
113 : uint32_t max_bitrate_bps;
114 : uint32_t pad_up_bitrate_bps;
115 : bool enforce_min_bitrate;
116 : int64_t allocated_bitrate_bps;
117 : double media_ratio; // Part of the total bitrate used for media [0.0, 1.0].
118 : };
119 :
120 : // Calculates the minimum requested send bitrate and max padding bitrate and
121 : // calls LimitObserver::OnAllocationLimitsChanged.
122 : void UpdateAllocationLimits();
123 :
124 : typedef std::vector<ObserverConfig> ObserverConfigs;
125 : ObserverConfigs::iterator FindObserverConfig(
126 : const BitrateAllocatorObserver* observer);
127 :
128 : typedef std::multimap<uint32_t, const ObserverConfig*> ObserverSortingMap;
129 : typedef std::map<BitrateAllocatorObserver*, int> ObserverAllocation;
130 :
131 : ObserverAllocation AllocateBitrates(uint32_t bitrate);
132 :
133 : ObserverAllocation ZeroRateAllocation();
134 : ObserverAllocation LowRateAllocation(uint32_t bitrate);
135 : ObserverAllocation NormalRateAllocation(uint32_t bitrate,
136 : uint32_t sum_min_bitrates);
137 : ObserverAllocation MaxRateAllocation(uint32_t bitrate,
138 : uint32_t sum_max_bitrates);
139 :
140 : uint32_t LastAllocatedBitrate(const ObserverConfig& observer_config);
141 : // The minimum bitrate required by this observer, including enable-hysteresis
142 : // if the observer is in a paused state.
143 : uint32_t MinBitrateWithHysteresis(const ObserverConfig& observer_config);
144 : // Splits |bitrate| evenly to observers already in |allocation|.
145 : // |include_zero_allocations| decides if zero allocations should be part of
146 : // the distribution or not. The allowed max bitrate is |max_multiplier| x
147 : // observer max bitrate.
148 : void DistributeBitrateEvenly(uint32_t bitrate,
149 : bool include_zero_allocations,
150 : int max_multiplier,
151 : ObserverAllocation* allocation);
152 : bool EnoughBitrateForAllObservers(uint32_t bitrate,
153 : uint32_t sum_min_bitrates);
154 :
155 : rtc::SequencedTaskChecker sequenced_checker_;
156 : LimitObserver* const limit_observer_ GUARDED_BY(&sequenced_checker_);
157 : // Stored in a list to keep track of the insertion order.
158 : ObserverConfigs bitrate_observer_configs_ GUARDED_BY(&sequenced_checker_);
159 : uint32_t last_bitrate_bps_ GUARDED_BY(&sequenced_checker_);
160 : uint32_t last_non_zero_bitrate_bps_ GUARDED_BY(&sequenced_checker_);
161 : uint8_t last_fraction_loss_ GUARDED_BY(&sequenced_checker_);
162 : int64_t last_rtt_ GUARDED_BY(&sequenced_checker_);
163 : int64_t last_probing_interval_ms_ GUARDED_BY(&sequenced_checker_);
164 : // Number of mute events based on too low BWE, not network up/down.
165 : int num_pause_events_ GUARDED_BY(&sequenced_checker_);
166 : Clock* const clock_ GUARDED_BY(&sequenced_checker_);
167 : int64_t last_bwe_log_time_ GUARDED_BY(&sequenced_checker_);
168 : };
169 : } // namespace webrtc
170 : #endif // WEBRTC_CALL_BITRATE_ALLOCATOR_H_
|
