chore: improve live

Author: lukepolo

src/lib/common.sh

@@ -414,22 +414,6 @@ _cudaupload_dmabuf_ok() {
   [ "$GS_CUDAUPLOAD_DMABUF" = 1 ]
 }
 
-# True when GPU HUD compositing is usable for the live/demo composite: requested
-# (GS_GPU_COMPOSITOR=1), the active encoder is CUDA NVENC (so the
-# cudacompositor -> cudaconvertscale -> nvenc chain stays GPU-resident), and this
-# gst has cudacompositor. Moves the 1080p60 HUD alpha-blend off the 2 capture CPU
-# cores onto the GPU. Default OFF (opt-in); a miss => the software `compositor`.
-# Cached. Usage: _gpu_compositor_ok <codec>.
-_gpu_compositor_ok() {
-  case "${GS_GPU_COMPOSITOR:-0}" in 1|on|true|yes) ;; *) return 1 ;; esac
-  _active_encoder_is_cuda "${1:-h264}" || return 1
-  if [ -z "${GS_CUDACOMP_OK:-}" ]; then
-    if gst-inspect-1.0 cudacompositor >/dev/null 2>&1; then GS_CUDACOMP_OK=1; else GS_CUDACOMP_OK=0; fi
-    export GS_CUDACOMP_OK
-  fi
-  [ "$GS_CUDACOMP_OK" = 1 ]
-}
-
 # Emit the scale + colorspace-convert fragment that feeds the encoder.
 # When the active encoder is a CUDA NVENC element and cudaconvertscale is
 # present, the scale (e.g. 1440p->1080p) and RGBx->NV12 convert run on the

src/lib/stream.sh

@@ -118,28 +118,17 @@ start_capture() {
   if [ -n "$hud_xid" ]; then
     log "  composite: cs2 present-hook + HUD overlay (xid=$hud_xid, hud=${hud_fps}fps)"
     # sink_0 = cs2 (base), sink_1 = HUD on top. The HUD ximagesrc MUST carry alpha
-    # (BGRA) or it paints opaque over cs2.
-    local cs2_src hud_src outchain
-    if _gpu_compositor_ok "$codec"; then
-      # GPU HUD blend: upload both legs to CUDA and let cudacompositor alpha-blend
-      # on the GPU, then cudaconvertscale -> nvenc, all GPU-resident. Keeps the
-      # 1080p60 blend off the 2 capture CPU cores (the software compositor's cost).
-      # Opt-in (GS_GPU_COMPOSITOR=1); dies-on-spawn falls back to ximagesrc below.
-      log "  composite: GPU HUD blend (cudacompositor) — alpha-blend off the capture CPU"
-      cs2_src="appsrc name=vksrc ! queue ! videorate ! video/x-raw,framerate=$fps/1 ! cudaupload ! comp.sink_0"
-      hud_src="ximagesrc xid=$hud_xid use-damage=0 show-pointer=false ! video/x-raw,framerate=$hud_fps/1 ! videoconvert ! video/x-raw,format=BGRA ! cudaupload ! queue leaky=downstream max-size-buffers=2 ! comp.sink_1"
-      outchain="cudacompositor name=comp background=black ! cudaconvertscale ! video/x-raw(memory:CUDAMemory),format=NV12,width=$out_w,height=$out_h,framerate=$fps/1 ! $enc ! $parse"
-    else
-      # Software compositor (default): CPU alpha-blend on the capture cores.
-      cs2_src="appsrc name=vksrc ! queue ! videorate ! video/x-raw,framerate=$fps/1 ! comp.sink_0"
-      # leaky=downstream: a slow/blocked HUD grab drops its own frames instead of
-      # back-pressuring the compositor (which would stall the cs2 leg too).
-      hud_src="ximagesrc xid=$hud_xid use-damage=0 show-pointer=false ! video/x-raw,framerate=$hud_fps/1 ! videoconvert ! video/x-raw,format=BGRA ! queue leaky=downstream max-size-buffers=2 ! comp.sink_1"
-      # queue after the compositor = a thread boundary so the software blend and the
-      # upload/encode run on separate cores (else they serialize on one). Bounded by
-      # buffer count — raw frames are big, so the default byte cap would throttle.
-      outchain="compositor name=comp background=black ! queue max-size-buffers=8 max-size-bytes=0 max-size-time=0 ! $convert ! $enc ! $parse"
-    fi
+    # (BGRA) or it paints opaque over cs2 — verify this on-node first. The software
+    # compositor stays: LIVE-DIAG measured the capture at ~1.1 of its 2 cores, so the
+    # blend is NOT CPU-bound and GPU compositing would buy nothing here.
+    local cs2_src="appsrc name=vksrc ! queue ! videorate ! video/x-raw,framerate=$fps/1 ! comp.sink_0"
+    # leaky=downstream: a slow/blocked HUD grab drops its own frames instead of
+    # back-pressuring the compositor (which would stall the cs2 leg too).
+    local hud_src="ximagesrc xid=$hud_xid use-damage=0 show-pointer=false ! video/x-raw,framerate=$hud_fps/1 ! videoconvert ! video/x-raw,format=BGRA ! queue leaky=downstream max-size-buffers=2 ! comp.sink_1"
+    # queue after the compositor = a thread boundary so the software blend and the
+    # upload/encode run on separate cores (else they serialize on one). Bounded by
+    # buffer count — raw frames are big, so the default byte cap would throttle.
+    local outchain="compositor name=comp background=black ! queue max-size-buffers=8 max-size-bytes=0 max-size-time=0 ! $convert ! $enc ! $parse"
     local pipeline
     if [ "$audio" = 1 ]; then
       pipeline="$outchain ! queue ! mux. \
@@ -153,6 +142,12 @@ $cs2_src \
 $hud_src"
     fi
     export VKCAP_FPS="$fps"
+    # With LIVE-DIAG on, also have the consumer log presents/s — present-locked,
+    # so presents/s == cs2's REAL render fps feeding the stream. This is the signal
+    # LIVE-DIAG lacked: presents/s consistently ≥ fps ⇒ the stream is true CFR and
+    # any "not 60" feel is the camera switching or viewer-side; presents/s dipping
+    # below fps ⇒ cs2 isn't holding the rate under live load (videorate then dups).
+    [ "${GS_LIVE_DIAG:-1}" = "1" ] && export VKCAP_DEBUG="${VKCAP_DEBUG:-1}"
     # Zero-copy is clip-only: the software `compositor` here blends in system
     # memory and can't consume a device-local dmabuf. Force it off so a global
     # VKCAP_ZEROCOPY=1 can't push this path into the ximagesrc fallback.

src/spectator/constants.mjs

@@ -48,6 +48,13 @@ export const DIRECTOR_STICKY_PRIORITY_FLOOR = 140;
 // whiplashes between simultaneous events.
 export const DIRECTOR_MIN_DWELL_MS = 3_000;
 
+// Death of the current target still cuts fast, but NOT instantly: snapping at
+// 0ms cuts into cs2's death-cam/PVS transition (a black frame on the new POV, made
+// worse by GSI's ~10Hz alive-state lagging cs2's render tick) and reads as frantic.
+// A short grace lets the kill register + the new view settle, then cut. Also linger
+// a beat on the kill, which is natural broadcast feel. Tune/zero via env if needed.
+export const DIRECTOR_DEATH_GRACE_MS = 350;
+
 // Max time on one target before the camera is forced off — keeps the
 // view moving when nothing else is more interesting.
 export const DIRECTOR_DWELL_MAX_MS = {

src/spectator/director/index.mjs

@@ -2,6 +2,7 @@ import process from "node:process";
 
 import {
   DIRECTOR_MIN_DWELL_MS,
+  DIRECTOR_DEATH_GRACE_MS,
   DIRECTOR_TICK_MS,
   KEY_AUTODIRECTOR_OFF,
 } from "../constants.mjs";
@@ -59,14 +60,17 @@ export async function directorTick() {
       : null;
     if (cur && cur.steamId === pick.target.steamId && cur.alive) return;
 
-    // Death of the current target is the only thing that bypasses the
-    // minimum dwell. Event bonuses (AWP kill, damage dealer, upset)
-    // already bumped priority — they wait their turn here.
+    // Death of the current target cuts fast but NOT instantly — a short grace
+    // (vs the full dwell) lets cs2's death-cam/PVS transition settle so we don't
+    // cut into a black frame, and avoids whiplash on multi-kill exchanges. Event
+    // bonuses (AWP kill, damage dealer, upset) already bumped priority — they wait
+    // the full dwell.
     const sinceLast = nowMs - directorState.lastSwitchMs;
-    if (!pick.forcedByDeath && sinceLast < DIRECTOR_MIN_DWELL_MS) {
+    const dwellFloor = pick.forcedByDeath ? DIRECTOR_DEATH_GRACE_MS : DIRECTOR_MIN_DWELL_MS;
+    if (sinceLast < dwellFloor) {
       logSkip(
         "skip: min-dwell",
-        `${sinceLast}ms < ${DIRECTOR_MIN_DWELL_MS}ms (want=${pick.target.name ?? pick.target.steamId} slot=${pick.target.slot})`,
+        `${sinceLast}ms < ${dwellFloor}ms (want=${pick.target.name ?? pick.target.steamId} slot=${pick.target.slot}${pick.forcedByDeath ? " death-grace" : ""})`,
       );
       return;
     }