[feat] allocate DeskHub video bandwidth automatically

2026-10-20 11:06:46 +08:00 · 2026-10-13 15:39:50 +08:00
parent de16eb3b92
commit 4dfd8c3005
13 changed files with 270 additions and 43 deletions
@@ -0,0 +1,99 @@
+/*
+ * @Author: DI JUNKUN
+ * @Date: 2026-10-13
+ * Copyright (c) 2026 by DI JUNKUN, All Rights Reserved.
+ */
+
+#ifndef _PREVIEW_BANDWIDTH_H_
+#define _PREVIEW_BANDWIDTH_H_
+
+#include <algorithm>
+#include <cstddef>
+#include <cstdint>
+#include <vector>
+
+namespace crossdesk::gallery {
+struct PreviewBandwidthDemand {
+  int desired_bps = 0;
+  bool foreground = false;
+
+  bool operator==(const PreviewBandwidthDemand& other) const {
+    return desired_bps == other.desired_bps && foreground == other.foreground;
+  }
+
+  static int Estimate(int width, int height, int fps) {
+    // A demand ceiling, not a throughput measurement. Include room for video
+    // repair traffic; the sender's congestion control may allocate less.
+    const int64_t pixels = width > 0 && height > 0
+        ? int64_t(width) * height : 3840LL * 2160;
+    const int64_t estimate = pixels * std::clamp(fps, 1, 60) * 15 / 100;
+    return int(std::clamp<int64_t>((estimate + 49'999) / 50'000 * 50'000,
+                                   150'000, 20'000'000));
+  }
+};
+
+inline std::vector<int> AllocatePreviewBandwidth(
+    const std::vector<PreviewBandwidthDemand>& demands, int budget_bps) {
+  std::vector<int> result(demands.size(), 0);
+  int remaining = std::max(0, budget_bps);
+  int active = 0;
+  int64_t desired_total = 0;
+  for (const auto& demand : demands) {
+    active += demand.desired_bps > 0;
+    desired_total += std::max(0, demand.desired_bps);
+  }
+  if (!active || !remaining) return result;
+  if (desired_total <= remaining) {
+    for (std::size_t i = 0; i < demands.size(); ++i)
+      result[i] = std::max(0, demands[i].desired_bps);
+    return result;
+  }
+  // First preserve a small fair share for every visible device, then perform
+  // weighted max-min allocation. Satisfied devices return unused capacity.
+  const int baseline = std::min(100'000, remaining / active);
+  for (std::size_t i = 0; i < demands.size(); ++i) {
+    result[i] = std::min(std::max(0, demands[i].desired_bps), baseline);
+    remaining -= result[i];
+  }
+  while (remaining > 0) {
+    int weights = 0;
+    for (std::size_t i = 0; i < demands.size(); ++i)
+      if (result[i] < demands[i].desired_bps)
+        weights += demands[i].foreground ? 4 : 1;
+    if (!weights) break;
+    const int available = remaining;
+    for (std::size_t i = 0; i < demands.size() && remaining > 0; ++i) {
+      if (result[i] >= demands[i].desired_bps) continue;
+      const int share = int(int64_t(available) *
+                            (demands[i].foreground ? 4 : 1) / weights);
+      const int extra = std::min({remaining, demands[i].desired_bps - result[i],
+                                  std::max(1, share)});
+      result[i] += extra;
+      remaining -= extra;
+    }
+  }
+  return result;
+}
+
+// UI refreshes much more often than video demand changes. Keep the previous
+// result while membership, dimensions, cadence, priority and budget are stable.
+class PreviewBandwidthAllocator {
+ public:
+  const std::vector<int>& Allocate(
+      const std::vector<PreviewBandwidthDemand>& demands, int budget_bps) {
+    if (budget_bps_ != budget_bps || demands_ != demands) {
+      demands_ = demands;
+      budget_bps_ = budget_bps;
+      allocations_ = AllocatePreviewBandwidth(demands, budget_bps);
+    }
+    return allocations_;
+  }
+
+ private:
+  int budget_bps_ = -1;
+  std::vector<PreviewBandwidthDemand> demands_;
+  std::vector<int> allocations_;
+};
+}  // namespace crossdesk::gallery
+
+#endif