BWE allocation strategy

webrtc/rtc_base/bitrateallocationstrategy.h

+/*
+ *  Copyright 2017 The WebRTC Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#ifndef WEBRTC_RTC_BASE_BITRATEALLOCATIONSTRATEGY_H_
+#define WEBRTC_RTC_BASE_BITRATEALLOCATIONSTRATEGY_H_
+
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+#include "webrtc/rtc_base/checks.h"
+#include "webrtc/rtc_base/refcount.h"
+#include "webrtc/rtc_base/refcountedobject.h"
+
+namespace rtc {
+
+// Plugable strategy allows configuration of bitrate allocation per media track.
+class BitrateAllocationStrategy : public RefCountedObject<RefCountInterface> {

[nisse-webrtc, 2017/09/06 09:04:02]

Just spotted this, you should not inherit RefCountedObject, if you do, that
blocks cl https://codereview.webrtc.org/3007973002/ which tries to mark it as a
final class.

Also, not sure this really needs to be refcounted at all. Shouldn't it be owned
by the application, to manage ownership in any way it sees fit?

[alexnarest, 2017/09/08 17:09:23]

I think it is more convenient to app to create the strategy and pass it to API
rather than maintain it explicitly by setting strategy to null before releasing
it.  App does not have a lot to do with the strategy on its own.

But it is too small to discuss, I removed ref pointer and added setting to null
on disconnect.

+ public:
+  struct TrackConfig {
+    TrackConfig(uint32_t min_bitrate_bps,
+                uint32_t max_bitrate_bps,
+                bool enforce_min_bitrate,
+                std::string track_id)
+        : min_bitrate_bps(min_bitrate_bps),
+          max_bitrate_bps(max_bitrate_bps),
+          enforce_min_bitrate(enforce_min_bitrate),
+          track_id(track_id) {}
+    TrackConfig(const TrackConfig& track_config) = default;
+    TrackConfig() {}
+
+    uint32_t min_bitrate_bps;
+    uint32_t max_bitrate_bps;
+    bool enforce_min_bitrate;
+    std::string track_id;
+  };
+
+  typedef std::vector<std::unique_ptr<TrackConfig>> TrackConfigs;
+
+  std::vector<uint32_t> SetAllBitratesToMinimum(
+      const TrackConfigs& track_configs);
+  std::vector<uint32_t> DistributeBitratesEvenly(
+      const TrackConfigs& track_configs,
+      uint32_t available_bitrate);
+
+  virtual std::vector<uint32_t> AllocateBitrates(
+      uint32_t available_bitrate,
+      const TrackConfigs& track_configs) = 0;
+};
+
+// Simple allocation strategy giving priority to audio at low bitrates.
+class AudioPriorityBitrateAllocationStrategy
+    : public BitrateAllocationStrategy {
+ public:
+  AudioPriorityBitrateAllocationStrategy(std::string audio_track_id,
+                                         uint32_t sufficient_audio_bitrate);
+  std::vector<uint32_t> AllocateBitrates(
+      uint32_t available_bitrate,
+      const TrackConfigs& track_configs) override;
+
+ private:
+  std::string audio_track_id_;
+  uint32_t sufficient_audio_bitrate_;
+};
+}  // namespace rtc
+
+#endif  // WEBRTC_RTC_BASE_BITRATEALLOCATIONSTRATEGY_H_