Home | History | Annotate | Download | only in call 
      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 {
     65     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 {
     71     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