Extract simulcast rate allocation outside of video encoder.

webrtc/modules/video_coding/utility/simulcast_rate_allocator.cc

+/*
+ *  Copyright (c) 2016 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.
+ */
+
+#include "webrtc/modules/video_coding/utility/simulcast_rate_allocator.h"
+
+#include <algorithm>
+
+namespace webrtc {
+
+webrtc::SimulcastRateAllocator::SimulcastRateAllocator(const VideoCodec& codec)
+    : codec_(codec) {}
+
+std::vector<uint32_t> webrtc::SimulcastRateAllocator::GetAllocation(
+    uint32_t bitrate_kbps) const {
+  // Always allocate enough bitrate for the minimum bitrate of the first layer.
+  // Suspending below min bitrate is controlled outside the codec implementation
+  // and is not overridden by this.
+  const uint32_t min_bitrate_bps = codec_.numberOfSimulcastStreams == 0
+                                       ? codec_.minBitrate
+                                       : codec_.simulcastStream[0].minBitrate;
+  uint32_t left_to_allocate = std::max(min_bitrate_bps, bitrate_kbps);
+  if (codec_.maxBitrate)
+    left_to_allocate = std::min(left_to_allocate, codec_.maxBitrate);
+
+  if (codec_.numberOfSimulcastStreams == 0) {
+    // No simulcast, just set the target as this has been capped already.
+    return std::vector<uint32_t>(1, left_to_allocate);
+  }
+
+  // Initialize bitrates with zeroes.
+  std::vector<uint32_t> allocated_bitrates_bps(codec_.numberOfSimulcastStreams,
+                                               0);
+
+  // First try to allocate up to the target bitrate for each substream.
+  uint32_t layer = 0;

[noahric, 2016/08/29 21:32:09]

size_t for an array index?

[sprang_webrtc, 2016/08/30 13:27:24]

Done.

+  for (; layer < codec_.numberOfSimulcastStreams; ++layer) {
+    const SimulcastStream& stream = codec_.simulcastStream[layer];
+    if (left_to_allocate < stream.minBitrate)
+      break;
+    uint32_t allocation = std::min(left_to_allocate, stream.targetBitrate);
+    allocated_bitrates_bps[layer] = allocation;
+    left_to_allocate -= allocation;
+  }
+
+  // Next, try to distribute remaining bitrate, up to max bitrate, across the
+  // enabled layers, starting with the highest.
+  for (; layer --> 0;) {

[noahric, 2016/08/29 21:32:09]

Can you rewrite this? As written, the code looks wrong, because it's non-obvious
that the first loop decrements layer from the last loop.

This would be a bit clearer:

// <existing comment>
// The active layer starts with layer (above) - 1, because the loop always steps
// past the last active layer.
for (size_t active_layer = layer - 1; active_layer >= 0; --active_layer) {
}

[sprang_webrtc, 2016/08/30 13:27:24]

Aww. I was was aware this was going to be shot down, I just like the "i --> 0"
syntax as it intuitively looks like "as i approaches 0". But yeah, how it
actually works isn't really that intuitive :)
Also, your suggestion won't work. size_t is unsigned and so active_layer will
always be >= 0. I'll test for equality to static_cast<size_t>(-1), which is
kinda ugly but correct. Post-decrementing in the test is the other alternative
as far as I can see.

[noahric, 2016/08/30 18:14:33]

Ah, yeah :( You can also just make active_layer an int, and optionally add a
comment for why it has to be signed. Up to you, though.

+    if (left_to_allocate == 0)
+      break;
+    const SimulcastStream& stream = codec_.simulcastStream[layer];
+    uint32_t allocation = std::min(
+        left_to_allocate, stream.maxBitrate - allocated_bitrates_bps[layer]);
+    left_to_allocate -= allocation;
+    allocated_bitrates_bps[layer] += allocation;
+  }
+  return allocated_bitrates_bps;
+}
+
+const VideoCodec& webrtc::SimulcastRateAllocator::GetCodec() const {
+  return codec_;
+}
+
+}  // namespace webrtc