stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 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. |
stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 9 | */ |
| 10 | |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 11 | #ifndef CALL_BITRATE_ALLOCATOR_H_ |
| 12 | #define CALL_BITRATE_ALLOCATOR_H_ |
stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 13 | |
kwiberg | b25345e | 2016-03-12 06:10:44 -0800 | [diff] [blame] | 14 | #include <stdint.h> |
| 15 | |
stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 16 | #include <map> |
Alex Narest | 78609d5 | 2017-10-20 10:37:47 +0200 | [diff] [blame] | 17 | #include <memory> |
Alex Narest | b3944f0 | 2017-10-13 14:56:18 +0200 | [diff] [blame] | 18 | #include <string> |
stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 19 | #include <utility> |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 20 | #include <vector> |
stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 21 | |
Sebastian Jansson | 6736df1 | 2018-11-21 19:18:39 +0100 | [diff] [blame] | 22 | #include "api/call/bitrate_allocation.h" |
Sebastian Jansson | 93b1ea2 | 2019-09-18 18:31:52 +0200 | [diff] [blame] | 23 | #include "api/transport/network_types.h" |
Sebastian Jansson | b55015e | 2019-04-09 13:44:04 +0200 | [diff] [blame] | 24 | #include "rtc_base/synchronization/sequence_checker.h" |
stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 25 | |
| 26 | namespace webrtc { |
| 27 | |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 28 | class Clock; |
| 29 | |
mflodman | 86aabb2 | 2016-03-11 15:44:32 +0100 | [diff] [blame] | 30 | // Used by all send streams with adaptive bitrate, to get the currently |
| 31 | // allocated bitrate for the send stream. The current network properties are |
| 32 | // given at the same time, to let the send stream decide about possible loss |
| 33 | // protection. |
| 34 | class BitrateAllocatorObserver { |
| 35 | public: |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 36 | // Returns the amount of protection used by the BitrateAllocatorObserver |
| 37 | // implementation, as bitrate in bps. |
Sebastian Jansson | c0e4d45 | 2018-10-25 15:08:32 +0200 | [diff] [blame] | 38 | virtual uint32_t OnBitrateUpdated(BitrateAllocationUpdate update) = 0; |
minyue | 78b4d56 | 2016-11-30 04:47:39 -0800 | [diff] [blame] | 39 | |
perkj | 71ee44c | 2016-06-15 00:47:53 -0700 | [diff] [blame] | 40 | protected: |
mflodman | 86aabb2 | 2016-03-11 15:44:32 +0100 | [diff] [blame] | 41 | virtual ~BitrateAllocatorObserver() {} |
| 42 | }; |
stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 43 | |
Sebastian Jansson | 24ad720 | 2018-04-19 08:25:12 +0200 | [diff] [blame] | 44 | // Struct describing parameters for how a media stream should get bitrate |
Sebastian Jansson | 4d461ba | 2019-09-17 20:53:26 +0200 | [diff] [blame] | 45 | // allocated to it. |
| 46 | |
Sebastian Jansson | 24ad720 | 2018-04-19 08:25:12 +0200 | [diff] [blame] | 47 | struct MediaStreamAllocationConfig { |
Sebastian Jansson | 4d461ba | 2019-09-17 20:53:26 +0200 | [diff] [blame] | 48 | // Minimum bitrate supported by track. 0 equals no min bitrate. |
Sebastian Jansson | 24ad720 | 2018-04-19 08:25:12 +0200 | [diff] [blame] | 49 | uint32_t min_bitrate_bps; |
Sebastian Jansson | 4d461ba | 2019-09-17 20:53:26 +0200 | [diff] [blame] | 50 | // Maximum bitrate supported by track. 0 equals no max bitrate. |
Sebastian Jansson | 24ad720 | 2018-04-19 08:25:12 +0200 | [diff] [blame] | 51 | uint32_t max_bitrate_bps; |
| 52 | uint32_t pad_up_bitrate_bps; |
Sebastian Jansson | 464a557 | 2019-02-12 13:32:32 +0100 | [diff] [blame] | 53 | int64_t priority_bitrate_bps; |
Sebastian Jansson | 4d461ba | 2019-09-17 20:53:26 +0200 | [diff] [blame] | 54 | // True means track may not be paused by allocating 0 bitrate will allocate at |
| 55 | // least |min_bitrate_bps| for this observer, even if the BWE is too low, |
| 56 | // false will allocate 0 to the observer if BWE doesn't allow |
| 57 | // |min_bitrate_bps|. |
Sebastian Jansson | 24ad720 | 2018-04-19 08:25:12 +0200 | [diff] [blame] | 58 | bool enforce_min_bitrate; |
Sebastian Jansson | 4d461ba | 2019-09-17 20:53:26 +0200 | [diff] [blame] | 59 | // The amount of bitrate allocated to this observer relative to all other |
| 60 | // observers. If an observer has twice the bitrate_priority of other |
| 61 | // observers, it should be allocated twice the bitrate above its min. |
Sebastian Jansson | 24ad720 | 2018-04-19 08:25:12 +0200 | [diff] [blame] | 62 | double bitrate_priority; |
Sebastian Jansson | 24ad720 | 2018-04-19 08:25:12 +0200 | [diff] [blame] | 63 | }; |
| 64 | |
Sebastian Jansson | 8326780 | 2018-04-19 08:27:19 +0200 | [diff] [blame] | 65 | // Interface used for mocking |
| 66 | class BitrateAllocatorInterface { |
| 67 | public: |
| 68 | virtual void AddObserver(BitrateAllocatorObserver* observer, |
| 69 | MediaStreamAllocationConfig config) = 0; |
| 70 | virtual void RemoveObserver(BitrateAllocatorObserver* observer) = 0; |
Sebastian Jansson | 44a262a | 2018-10-24 16:07:20 +0200 | [diff] [blame] | 71 | virtual int GetStartBitrate(BitrateAllocatorObserver* observer) const = 0; |
Sebastian Jansson | 8326780 | 2018-04-19 08:27:19 +0200 | [diff] [blame] | 72 | |
| 73 | protected: |
| 74 | virtual ~BitrateAllocatorInterface() = default; |
| 75 | }; |
| 76 | |
mflodman | 86aabb2 | 2016-03-11 15:44:32 +0100 | [diff] [blame] | 77 | // Usage: this class will register multiple RtcpBitrateObserver's one at each |
| 78 | // RTCP module. It will aggregate the results and run one bandwidth estimation |
| 79 | // and push the result to the encoders via BitrateAllocatorObserver(s). |
Sebastian Jansson | 8326780 | 2018-04-19 08:27:19 +0200 | [diff] [blame] | 80 | class BitrateAllocator : public BitrateAllocatorInterface { |
stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 81 | public: |
perkj | 71ee44c | 2016-06-15 00:47:53 -0700 | [diff] [blame] | 82 | // Used to get notified when send stream limits such as the minimum send |
| 83 | // bitrate and max padding bitrate is changed. |
| 84 | class LimitObserver { |
| 85 | public: |
Sebastian Jansson | 93b1ea2 | 2019-09-18 18:31:52 +0200 | [diff] [blame] | 86 | virtual void OnAllocationLimitsChanged(BitrateAllocationLimits limits) = 0; |
perkj | 71ee44c | 2016-06-15 00:47:53 -0700 | [diff] [blame] | 87 | |
| 88 | protected: |
Sebastian Jansson | 8326780 | 2018-04-19 08:27:19 +0200 | [diff] [blame] | 89 | virtual ~LimitObserver() = default; |
perkj | 71ee44c | 2016-06-15 00:47:53 -0700 | [diff] [blame] | 90 | }; |
| 91 | |
Sebastian Jansson | 40de3cc | 2019-09-19 14:54:43 +0200 | [diff] [blame^] | 92 | explicit BitrateAllocator(LimitObserver* limit_observer); |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 93 | ~BitrateAllocator() override; |
stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 94 | |
Sebastian Jansson | 2701bc9 | 2018-12-11 15:02:47 +0100 | [diff] [blame] | 95 | void UpdateStartRate(uint32_t start_rate_bps); |
| 96 | |
mflodman | 86aabb2 | 2016-03-11 15:44:32 +0100 | [diff] [blame] | 97 | // Allocate target_bitrate across the registered BitrateAllocatorObservers. |
Sebastian Jansson | 40de3cc | 2019-09-19 14:54:43 +0200 | [diff] [blame^] | 98 | void OnNetworkEstimateChanged(TargetTransferRate msg); |
stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 99 | |
Sebastian Jansson | 29b204e | 2018-03-21 12:45:27 +0100 | [diff] [blame] | 100 | // Set the configuration used by the bandwidth management. |
Peter Boström | 8e4e8b0 | 2015-09-15 15:08:03 +0200 | [diff] [blame] | 101 | // |observer| updates bitrates if already in use. |
Sebastian Jansson | 24ad720 | 2018-04-19 08:25:12 +0200 | [diff] [blame] | 102 | // |config| is the configuration to use for allocation. |
Sebastian Jansson | 4d461ba | 2019-09-17 20:53:26 +0200 | [diff] [blame] | 103 | // Note that |observer|->OnBitrateUpdated() will be called |
| 104 | // within the scope of this method with the current rtt, fraction_loss and |
| 105 | // available bitrate and that the bitrate in OnBitrateUpdated will be zero if |
| 106 | // the |observer| is currently not allowed to send data. |
perkj | 57c21f9 | 2016-06-17 07:27:16 -0700 | [diff] [blame] | 107 | void AddObserver(BitrateAllocatorObserver* observer, |
Sebastian Jansson | 8326780 | 2018-04-19 08:27:19 +0200 | [diff] [blame] | 108 | MediaStreamAllocationConfig config) override; |
stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 109 | |
mflodman | 101f250 | 2016-06-09 17:21:19 +0200 | [diff] [blame] | 110 | // Removes a previously added observer, but will not trigger a new bitrate |
| 111 | // allocation. |
Sebastian Jansson | 8326780 | 2018-04-19 08:27:19 +0200 | [diff] [blame] | 112 | void RemoveObserver(BitrateAllocatorObserver* observer) override; |
stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 113 | |
perkj | 57c21f9 | 2016-06-17 07:27:16 -0700 | [diff] [blame] | 114 | // Returns initial bitrate allocated for |observer|. If |observer| is not in |
| 115 | // the list of added observers, a best guess is returned. |
Sebastian Jansson | 44a262a | 2018-10-24 16:07:20 +0200 | [diff] [blame] | 116 | int GetStartBitrate(BitrateAllocatorObserver* observer) const override; |
perkj | 57c21f9 | 2016-06-17 07:27:16 -0700 | [diff] [blame] | 117 | |
mflodman | 2ebe5b1 | 2016-05-13 01:43:51 -0700 | [diff] [blame] | 118 | private: |
Sebastian Jansson | 4d461ba | 2019-09-17 20:53:26 +0200 | [diff] [blame] | 119 | struct AllocatableTrack { |
| 120 | AllocatableTrack(BitrateAllocatorObserver* observer, |
| 121 | MediaStreamAllocationConfig allocation_config) |
Jonas Olsson | 0182a03 | 2019-07-09 12:31:20 +0200 | [diff] [blame] | 122 | : observer(observer), |
Sebastian Jansson | 4d461ba | 2019-09-17 20:53:26 +0200 | [diff] [blame] | 123 | config(allocation_config), |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 124 | allocated_bitrate_bps(-1), |
Sebastian Jansson | 4d461ba | 2019-09-17 20:53:26 +0200 | [diff] [blame] | 125 | media_ratio(1.0) {} |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 126 | BitrateAllocatorObserver* observer; |
Sebastian Jansson | 4d461ba | 2019-09-17 20:53:26 +0200 | [diff] [blame] | 127 | MediaStreamAllocationConfig config; |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 128 | int64_t allocated_bitrate_bps; |
| 129 | double media_ratio; // Part of the total bitrate used for media [0.0, 1.0]. |
Jonas Olsson | 0182a03 | 2019-07-09 12:31:20 +0200 | [diff] [blame] | 130 | |
srte | 1eb051c | 2017-11-29 11:23:59 +0100 | [diff] [blame] | 131 | uint32_t LastAllocatedBitrate() const; |
| 132 | // The minimum bitrate required by this observer, including |
| 133 | // enable-hysteresis if the observer is in a paused state. |
| 134 | uint32_t MinBitrateWithHysteresis() const; |
mflodman | 2ebe5b1 | 2016-05-13 01:43:51 -0700 | [diff] [blame] | 135 | }; |
| 136 | |
perkj | 71ee44c | 2016-06-15 00:47:53 -0700 | [diff] [blame] | 137 | // Calculates the minimum requested send bitrate and max padding bitrate and |
| 138 | // calls LimitObserver::OnAllocationLimitsChanged. |
Niels Möller | d4043f6 | 2018-04-26 16:06:22 +0200 | [diff] [blame] | 139 | void UpdateAllocationLimits() RTC_RUN_ON(&sequenced_checker_); |
perkj | 71ee44c | 2016-06-15 00:47:53 -0700 | [diff] [blame] | 140 | |
Sebastian Jansson | 4d461ba | 2019-09-17 20:53:26 +0200 | [diff] [blame] | 141 | typedef std::multimap<uint32_t, const AllocatableTrack*> ObserverSortingMap; |
mflodman | 2ebe5b1 | 2016-05-13 01:43:51 -0700 | [diff] [blame] | 142 | typedef std::map<BitrateAllocatorObserver*, int> ObserverAllocation; |
| 143 | |
Sebastian Jansson | 44a262a | 2018-10-24 16:07:20 +0200 | [diff] [blame] | 144 | ObserverAllocation AllocateBitrates(uint32_t bitrate) const |
Niels Möller | d4043f6 | 2018-04-26 16:06:22 +0200 | [diff] [blame] | 145 | RTC_RUN_ON(&sequenced_checker_); |
Stefan Holmer | e590416 | 2015-03-26 11:11:06 +0100 | [diff] [blame] | 146 | |
Seth Hampson | fe73d6a | 2017-11-14 10:49:06 -0800 | [diff] [blame] | 147 | // Allocates zero bitrate to all observers. |
Sebastian Jansson | 44a262a | 2018-10-24 16:07:20 +0200 | [diff] [blame] | 148 | ObserverAllocation ZeroRateAllocation() const RTC_RUN_ON(&sequenced_checker_); |
Seth Hampson | fe73d6a | 2017-11-14 10:49:06 -0800 | [diff] [blame] | 149 | // Allocates bitrate to observers when there isn't enough to allocate the |
| 150 | // minimum to all observers. |
Sebastian Jansson | 44a262a | 2018-10-24 16:07:20 +0200 | [diff] [blame] | 151 | ObserverAllocation LowRateAllocation(uint32_t bitrate) const |
Niels Möller | d4043f6 | 2018-04-26 16:06:22 +0200 | [diff] [blame] | 152 | RTC_RUN_ON(&sequenced_checker_); |
Seth Hampson | fe73d6a | 2017-11-14 10:49:06 -0800 | [diff] [blame] | 153 | // Allocates bitrate to all observers when the available bandwidth is enough |
| 154 | // to allocate the minimum to all observers but not enough to allocate the |
| 155 | // max bitrate of each observer. |
mflodman | 101f250 | 2016-06-09 17:21:19 +0200 | [diff] [blame] | 156 | ObserverAllocation NormalRateAllocation(uint32_t bitrate, |
Sebastian Jansson | 44a262a | 2018-10-24 16:07:20 +0200 | [diff] [blame] | 157 | uint32_t sum_min_bitrates) const |
Niels Möller | d4043f6 | 2018-04-26 16:06:22 +0200 | [diff] [blame] | 158 | RTC_RUN_ON(&sequenced_checker_); |
Seth Hampson | fe73d6a | 2017-11-14 10:49:06 -0800 | [diff] [blame] | 159 | // Allocates bitrate to observers when there is enough available bandwidth |
| 160 | // for all observers to be allocated their max bitrate. |
mflodman | 101f250 | 2016-06-09 17:21:19 +0200 | [diff] [blame] | 161 | ObserverAllocation MaxRateAllocation(uint32_t bitrate, |
Sebastian Jansson | 44a262a | 2018-10-24 16:07:20 +0200 | [diff] [blame] | 162 | uint32_t sum_max_bitrates) const |
Niels Möller | d4043f6 | 2018-04-26 16:06:22 +0200 | [diff] [blame] | 163 | RTC_RUN_ON(&sequenced_checker_); |
mflodman | 101f250 | 2016-06-09 17:21:19 +0200 | [diff] [blame] | 164 | |
mflodman | 101f250 | 2016-06-09 17:21:19 +0200 | [diff] [blame] | 165 | // Splits |bitrate| evenly to observers already in |allocation|. |
| 166 | // |include_zero_allocations| decides if zero allocations should be part of |
| 167 | // the distribution or not. The allowed max bitrate is |max_multiplier| x |
| 168 | // observer max bitrate. |
| 169 | void DistributeBitrateEvenly(uint32_t bitrate, |
| 170 | bool include_zero_allocations, |
| 171 | int max_multiplier, |
Sebastian Jansson | 44a262a | 2018-10-24 16:07:20 +0200 | [diff] [blame] | 172 | ObserverAllocation* allocation) const |
Niels Möller | d4043f6 | 2018-04-26 16:06:22 +0200 | [diff] [blame] | 173 | RTC_RUN_ON(&sequenced_checker_); |
Sebastian Jansson | 44a262a | 2018-10-24 16:07:20 +0200 | [diff] [blame] | 174 | bool EnoughBitrateForAllObservers(uint32_t bitrate, |
| 175 | uint32_t sum_min_bitrates) const |
Niels Möller | d4043f6 | 2018-04-26 16:06:22 +0200 | [diff] [blame] | 176 | RTC_RUN_ON(&sequenced_checker_); |
mflodman | 101f250 | 2016-06-09 17:21:19 +0200 | [diff] [blame] | 177 | |
Seth Hampson | fe73d6a | 2017-11-14 10:49:06 -0800 | [diff] [blame] | 178 | // From the available |bitrate|, each observer will be allocated a |
| 179 | // proportional amount based upon its bitrate priority. If that amount is |
| 180 | // more than the observer's capacity, it will be allocated its capacity, and |
| 181 | // the excess bitrate is still allocated proportionally to other observers. |
| 182 | // Allocating the proportional amount means an observer with twice the |
| 183 | // bitrate_priority of another will be allocated twice the bitrate. |
| 184 | void DistributeBitrateRelatively( |
| 185 | uint32_t bitrate, |
| 186 | const ObserverAllocation& observers_capacities, |
Sebastian Jansson | 44a262a | 2018-10-24 16:07:20 +0200 | [diff] [blame] | 187 | ObserverAllocation* allocation) const RTC_RUN_ON(&sequenced_checker_); |
Seth Hampson | fe73d6a | 2017-11-14 10:49:06 -0800 | [diff] [blame] | 188 | |
Ying Wang | a646d30 | 2018-03-02 17:04:11 +0100 | [diff] [blame] | 189 | // Allow packets to be transmitted in up to 2 times max video bitrate if the |
| 190 | // bandwidth estimate allows it. |
| 191 | // TODO(bugs.webrtc.org/8541): May be worth to refactor to keep this logic in |
Jonas Olsson | 0182a03 | 2019-07-09 12:31:20 +0200 | [diff] [blame] | 192 | // video send stream. |
Niels Möller | 74e5f80 | 2018-04-25 14:03:46 +0200 | [diff] [blame] | 193 | static uint8_t GetTransmissionMaxBitrateMultiplier(); |
Ying Wang | a646d30 | 2018-03-02 17:04:11 +0100 | [diff] [blame] | 194 | |
Sebastian Jansson | b55015e | 2019-04-09 13:44:04 +0200 | [diff] [blame] | 195 | SequenceChecker sequenced_checker_; |
danilchap | a37de39 | 2017-09-09 04:17:22 -0700 | [diff] [blame] | 196 | LimitObserver* const limit_observer_ RTC_GUARDED_BY(&sequenced_checker_); |
Stefan Holmer | e590416 | 2015-03-26 11:11:06 +0100 | [diff] [blame] | 197 | // Stored in a list to keep track of the insertion order. |
Sebastian Jansson | 4d461ba | 2019-09-17 20:53:26 +0200 | [diff] [blame] | 198 | std::vector<AllocatableTrack> allocatable_tracks_ |
| 199 | RTC_GUARDED_BY(&sequenced_checker_); |
Sebastian Jansson | 89c94b9 | 2018-11-20 17:16:36 +0100 | [diff] [blame] | 200 | uint32_t last_target_bps_ RTC_GUARDED_BY(&sequenced_checker_); |
Florent Castelli | 4e615d5 | 2019-08-22 16:09:06 +0200 | [diff] [blame] | 201 | uint32_t last_stable_target_bps_ RTC_GUARDED_BY(&sequenced_checker_); |
| 202 | uint32_t last_bandwidth_bps_ RTC_GUARDED_BY(&sequenced_checker_); |
danilchap | a37de39 | 2017-09-09 04:17:22 -0700 | [diff] [blame] | 203 | uint32_t last_non_zero_bitrate_bps_ RTC_GUARDED_BY(&sequenced_checker_); |
| 204 | uint8_t last_fraction_loss_ RTC_GUARDED_BY(&sequenced_checker_); |
| 205 | int64_t last_rtt_ RTC_GUARDED_BY(&sequenced_checker_); |
| 206 | int64_t last_bwe_period_ms_ RTC_GUARDED_BY(&sequenced_checker_); |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 207 | // Number of mute events based on too low BWE, not network up/down. |
danilchap | a37de39 | 2017-09-09 04:17:22 -0700 | [diff] [blame] | 208 | int num_pause_events_ RTC_GUARDED_BY(&sequenced_checker_); |
danilchap | a37de39 | 2017-09-09 04:17:22 -0700 | [diff] [blame] | 209 | int64_t last_bwe_log_time_ RTC_GUARDED_BY(&sequenced_checker_); |
Sebastian Jansson | 93b1ea2 | 2019-09-18 18:31:52 +0200 | [diff] [blame] | 210 | BitrateAllocationLimits current_limits_ RTC_GUARDED_BY(&sequenced_checker_); |
Niels Möller | 74e5f80 | 2018-04-25 14:03:46 +0200 | [diff] [blame] | 211 | const uint8_t transmission_max_bitrate_multiplier_; |
stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 212 | }; |
Seth Hampson | fe73d6a | 2017-11-14 10:49:06 -0800 | [diff] [blame] | 213 | |
stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 214 | } // namespace webrtc |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 215 | #endif // CALL_BITRATE_ALLOCATOR_H_ |