feat(core,apple,session): report decode latency from the Apple + Windows/Linux clients too

Extends 56f9c8c4 (the Automatic-bitrate decode signal, core + Android) to the remaining
clients, so every platform caps Automatic at its real decoder limit instead of the network
link ceiling — the fix for a fast LAN feeding a slower hardware decoder.

- core/abi: punktfunk_connection_report_decode_us + _wants_decode_latency expose the
  NativeClient methods to the C-ABI embedders (regenerated punktfunk_core.h, additive only).
- apple: PunktfunkConnection wrappers + Stage2Pipeline reports received→decoded from the
  VideoToolbox decode-completion callback — every decoded frame, before the newest-wins ring
  can drop the backlog. Stage-1 (AVSampleBufferDisplayLayer, no per-frame decode callback)
  stays network-only; stage-2 is the metered path.
- windows/linux: the shared punktfunk-session client (pf-client-core) links core directly, so
  it calls the NativeClient methods — report received→decoded from the pump, gated on
  wants_decode_latency. Exact for the synchronous D3D11VA/software decode; received→submit
  (still the decoder-input backpressure signal) for the async Vulkan-Video path.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

crates/pf-client-core/src/session.rs

@@ -352,6 +352,9 @@ fn pump(
     // corrected), `decode` = received→decoded (client-local). p50 per 1 s window.
     let mut hostnet_us: Vec<u64> = Vec::with_capacity(256);
     let mut decode_us: Vec<u64> = Vec::with_capacity(256);
+    // Adaptive bitrate: report the decode stage back to the core controller only when it's armed
+    // (Automatic, non-PyroWave). Constant for the session — resolve once, gate the per-frame call.
+    let wants_decode = connector.wants_decode_latency();
     // Host/network split (Phase 2): frames awaiting their per-AU 0xCF host timing,
     // correlated by pts_ns. Bounded — an old host never sends any, so entries just age out.
     let mut pending_split: std::collections::VecDeque<(u64, u64)> =
@@ -574,6 +577,15 @@ fn pump(
                                 decode_us.push(decoded_ns.saturating_sub(received_ns) / 1000);
                             }
                         }
+                        // Adaptive bitrate: feed the decoder-backlog signal every frame (the network
+                        // signals can't see the client's decoder). Uses the CPU-side decoded stamp:
+                        // exact for the synchronous D3D11VA/software path; received→submit for the
+                        // async Vulkan-Video path — still the decoder-input backpressure the rate
+                        // controller needs, without the per-frame fence wait the HUD stat avoids.
+                        if wants_decode {
+                            let us = decoded_ns.saturating_sub(received_ns) / 1000;
+                            connector.report_decode_us(us.min(u32::MAX as u64) as u32);
+                        }
                     }
                     // The decoder produced nothing — under zero-reorder LOW_DELAY (one-in/one-out) that
                     // means it's wedged on missing references with no reassembler drop to trigger

crates/punktfunk-core/src/abi.rs

@@ -2686,6 +2686,63 @@ pub unsafe extern "C" fn punktfunk_connection_frames_dropped(
     })
 }
 
+/// Report one decoded frame's decode-stage latency, in microseconds: the wall-clock elapsed from
+/// the access unit leaving [`punktfunk_connection_next_au`] to its decoded output becoming
+/// available (VideoToolbox/D3D11VA/… produced the frame). This feeds the "Automatic" bitrate
+/// controller's decode signal — the only one that sees the client's own decoder, so the rate is
+/// capped at the real decode limit instead of climbing to the network link ceiling and choking a
+/// slower hardware decoder (a fast LAN feeding a mobile-class decoder). Measure from the AU pull,
+/// NOT from the decoder-submit call, so decoder-input backpressure (the backlog) is included;
+/// exclude the presenter's vsync wait so a paced/capped frame rate doesn't read as decode latency.
+/// Cheap — the client may call it every frame; the controller ignores it unless armed (query
+/// [`punktfunk_connection_wants_decode_latency`] once to skip the measurement entirely when it's not).
+///
+/// # Safety
+/// `c` is a valid connection handle.
+#[cfg(feature = "quic")]
+#[no_mangle]
+pub unsafe extern "C" fn punktfunk_connection_report_decode_us(
+    c: *const PunktfunkConnection,
+    us: u32,
+) -> PunktfunkStatus {
+    guard(|| {
+        let c = match unsafe { c.as_ref() } {
+            Some(c) => c,
+            None => return PunktfunkStatus::NullPointer,
+        };
+        c.inner.report_decode_us(us);
+        PunktfunkStatus::Ok
+    })
+}
+
+/// Whether [`punktfunk_connection_report_decode_us`] is worth calling this session: writes 1 to
+/// `out` only when the adaptive-bitrate controller is armed (Automatic bitrate, non-PyroWave), so a
+/// client can skip the per-frame decode-latency measurement entirely for explicit-bitrate and
+/// PyroWave sessions (where the signal is ignored). Constant for the session — query once. Writes 0
+/// on a NULL connection.
+///
+/// # Safety
+/// `c` is a valid connection handle; `out` is writable (NULL is skipped).
+#[cfg(feature = "quic")]
+#[no_mangle]
+pub unsafe extern "C" fn punktfunk_connection_wants_decode_latency(
+    c: *const PunktfunkConnection,
+    out: *mut bool,
+) -> PunktfunkStatus {
+    guard(|| {
+        let c = match unsafe { c.as_ref() } {
+            Some(c) => c,
+            None => return PunktfunkStatus::NullPointer,
+        };
+        unsafe {
+            if !out.is_null() {
+                *out = c.inner.wants_decode_latency();
+            }
+        }
+        PunktfunkStatus::Ok
+    })
+}
+
 /// A speed-test measurement, filled by [`punktfunk_connection_probe_result`]. `done` is 0 until
 /// the host's end-of-burst report lands, then 1 (the numbers are final). `throughput_kbps` is the
 /// delivered wire throughput to drive a bitrate choice from; `loss_pct` is the link loss and