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  *  Usage: this class will register multiple RtcpBitrateObserver's one at each
11  *  RTCP module. It will aggregate the results and run one bandwidth estimation
12  *  and push the result to the encoders via BitrateObserver(s).
13  */
14 
15 #ifndef WEBRTC_CALL_BITRATE_ALLOCATOR_H_
16 #define WEBRTC_CALL_BITRATE_ALLOCATOR_H_
17 
18 #include <list>
19 #include <map>
20 #include <utility>
21 
22 #include "webrtc/base/scoped_ptr.h"
23 #include "webrtc/base/thread_annotations.h"
24 #include "webrtc/system_wrappers/include/critical_section_wrapper.h"
25 
26 namespace webrtc {
27 
28 class BitrateObserver;
29 
30 class BitrateAllocator {
31  public:
32   BitrateAllocator();
33 
34   // Allocate target_bitrate across the registered BitrateObservers.
35   // Returns actual bitrate allocated (might be higher than target_bitrate if
36   // for instance EnforceMinBitrate() is enabled.
37   uint32_t OnNetworkChanged(uint32_t target_bitrate,
38                             uint8_t fraction_loss,
39                             int64_t rtt);
40 
41   // Set the start and max send bitrate used by the bandwidth management.
42   //
43   // |observer| updates bitrates if already in use.
44   // |min_bitrate_bps| = 0 equals no min bitrate.
45   // |max_bitrate_bps| = 0 equals no max bitrate.
46   // Returns bitrate allocated for the bitrate observer.
47   int AddBitrateObserver(BitrateObserver* observer,
48                          uint32_t min_bitrate_bps,
49                          uint32_t max_bitrate_bps);
50 
51   void RemoveBitrateObserver(BitrateObserver* observer);
52 
53   void GetMinMaxBitrateSumBps(int* min_bitrate_sum_bps,
54                               int* max_bitrate_sum_bps) const;
55 
56   // This method controls the behavior when the available bitrate is lower than
57   // the minimum bitrate, or the sum of minimum bitrates.
58   // When true, the bitrate will never be set lower than the minimum bitrate(s).
59   // When false, the bitrate observers will be allocated rates up to their
60   // respective minimum bitrate, satisfying one observer after the other.
61   void EnforceMinBitrate(bool enforce_min_bitrate);
62 
63  private:
64   struct BitrateConfiguration {
BitrateConfigurationBitrateConfiguration65     BitrateConfiguration(uint32_t min_bitrate, uint32_t max_bitrate)
66         : min_bitrate(min_bitrate), max_bitrate(max_bitrate) {}
67     uint32_t min_bitrate;
68     uint32_t max_bitrate;
69   };
70   struct ObserverConfiguration {
ObserverConfigurationObserverConfiguration71     ObserverConfiguration(BitrateObserver* observer, uint32_t bitrate)
72         : observer(observer), min_bitrate(bitrate) {}
73     BitrateObserver* const observer;
74     uint32_t min_bitrate;
75   };
76   typedef std::pair<BitrateObserver*, BitrateConfiguration>
77       BitrateObserverConfiguration;
78   typedef std::list<BitrateObserverConfiguration> BitrateObserverConfList;
79   typedef std::multimap<uint32_t, ObserverConfiguration> ObserverSortingMap;
80   typedef std::map<BitrateObserver*, int> ObserverBitrateMap;
81 
82   BitrateObserverConfList::iterator FindObserverConfigurationPair(
83       const BitrateObserver* observer) EXCLUSIVE_LOCKS_REQUIRED(crit_sect_);
84   ObserverBitrateMap AllocateBitrates() EXCLUSIVE_LOCKS_REQUIRED(crit_sect_);
85   ObserverBitrateMap NormalRateAllocation(uint32_t bitrate,
86                                           uint32_t sum_min_bitrates)
87       EXCLUSIVE_LOCKS_REQUIRED(crit_sect_);
88 
89   ObserverBitrateMap LowRateAllocation(uint32_t bitrate)
90       EXCLUSIVE_LOCKS_REQUIRED(crit_sect_);
91 
92   rtc::scoped_ptr<CriticalSectionWrapper> crit_sect_;
93   // Stored in a list to keep track of the insertion order.
94   BitrateObserverConfList bitrate_observers_ GUARDED_BY(crit_sect_);
95   bool bitrate_observers_modified_ GUARDED_BY(crit_sect_);
96   bool enforce_min_bitrate_ GUARDED_BY(crit_sect_);
97   uint32_t last_bitrate_bps_ GUARDED_BY(crit_sect_);
98   uint8_t last_fraction_loss_ GUARDED_BY(crit_sect_);
99   int64_t last_rtt_ GUARDED_BY(crit_sect_);
100 };
101 }  // namespace webrtc
102 #endif  // WEBRTC_CALL_BITRATE_ALLOCATOR_H_
103