Implemented and fixed many issues

2026-08-21 23:24:48 +02:00
parent 14d5351a81
commit e03c60db25
52 changed files with 7726 additions and 769 deletions
@@ -295,6 +295,83 @@ void UDPSourceSession::AllocateRingBuffers() {
    }
 }

+bool UDPSourceSession::GrowRingsForSeconds(float64 seconds, uint32 maxPts) {
+    if ((seconds <= 0.0) || (maxPts == 0u)) { return false; }
+
+    (void) metaMutex_.FastLock();
+    const uint32 nSigs = numSignals_;
+    metaMutex_.FastUnLock();
+
+    bool grew = false;
+    for (uint32 i = 0u; i < nSigs; i++) {
+        const uint32  count = rings_[i].Count();
+        const float64 span  = rings_[i].TimeSpan();
+        /* Need a decent sample of the stream before extrapolating a rate;
+         * a couple of packets' worth of span is enough at any rate. */
+        if ((count < 2u) || (span <= 0.0)) { continue; }
+
+        const float64 rate = static_cast<float64>(count) / span;
+        /* 20 % headroom absorbs rate jitter and the capture margin. */
+        float64 need = rate * seconds * 1.2;
+        if (need > static_cast<float64>(maxPts)) {
+            need = static_cast<float64>(maxPts);
+        }
+        const uint32 needPts = static_cast<uint32>(need);
+        if (needPts > rings_[i].Capacity()) {
+            if (rings_[i].Grow(needPts)) { grew = true; }
+        }
+    }
+    return grew;
+}
+
+uint32 UDPSourceSession::GetMaxRingCapacity() const {
+    (void) metaMutex_.FastLock();
+    const uint32 nSigs = numSignals_;
+    metaMutex_.FastUnLock();
+
+    uint32 maxCap = 0u;
+    for (uint32 i = 0u; i < nSigs; i++) {
+        const uint32 c = rings_[i].Capacity();
+        if (c > maxCap) { maxCap = c; }
+    }
+    return maxCap;
+}
+
+float64 UDPSourceSession::ProducerNewestTime() const {
+    /* Mirror exactly the ParseDataPayload branches that timestamp from the
+     * referenced time signal; every other branch stamps on arrival and so
+     * would report "now" in the hub's clock, not the producer's. The time
+     * signal itself is one of those — it is PACKET-timed. */
+    (void) metaMutex_.FastLock();
+    const uint32 nSigs = numSignals_;
+    bool producerTimed[UDPSS_MAX_SIGNALS];
+    for (uint32 i = 0u; i < nSigs; i++) {
+        const UDPSSignalDescriptor &d = sigDescs_[i];
+        uint64 ne = static_cast<uint64>(d.numRows) *
+                    static_cast<uint64>(d.numCols);
+        if (ne == 0u) { ne = 1u; }
+        const bool hasTimeSig = (d.timeSignalIdx != UDPS_NO_TIME_SIGNAL) &&
+                                (d.timeSignalIdx < nSigs);
+        const bool isFirstLast = (ne > 1u) &&
+            ((d.timeMode == UDPS_TIMEMODE_FIRST_SAMPLE) ||
+             (d.timeMode == UDPS_TIMEMODE_LAST_SAMPLE));
+        const bool isFullArray = (d.timeMode == UDPS_TIMEMODE_FULL_ARRAY);
+        producerTimed[i] = hasTimeSig && (isFullArray || isFirstLast);
+    }
+    metaMutex_.FastUnLock();
+
+    /* Signals of one source share a packet, so they advance together; the max
+     * is "how far this source has produced" without stalling on a signal that
+     * simply is not being sent. */
+    float64 newest = 0.0;
+    for (uint32 i = 0u; i < nSigs; i++) {
+        if (!producerTimed[i]) { continue; }
+        const float64 t = rings_[i].NewestTime();
+        if (t > newest) { newest = t; }
+    }
+    return newest;
+}
+
 /*---------------------------------------------------------------------------*/
 /* DATA parsing                                                               */
 /*---------------------------------------------------------------------------*/