working on todo.md features

src/acquisition.hpp

@@ -3,6 +3,7 @@
 
 #pragma once
 
+#include "capture.hpp"
 #include "config.hpp"
 #include "model.hpp"
 #include "trigger.hpp"
@@ -38,6 +39,19 @@ class Acquisition {
   void set_paused(bool paused) noexcept { paused_.store(paused, std::memory_order_relaxed); }
   bool paused() const noexcept { return paused_.load(std::memory_order_relaxed); }
 
+  /// Turns the packet capture on or off -- the whole GTK side of the feature. The
+  /// path is built here, once, *before* the flag is published, so the producer reads
+  /// a complete string whenever it reads a true flag. `slots` is the ring's size;
+  /// zero means the 1000-slot default. The producer does the open or the close at the
+  /// top of the next datagram, so a toggle costs no lock and no second thread.
+  void set_capture_want(bool want, std::uint32_t slots = 0);
+  bool capture_want() const noexcept {
+    return capture_want_.load(std::memory_order_acquire);
+  }
+  /// The capture, for the popover's row and the probe. Counters and errors are read
+  /// cross-thread through PacketCapture's own published fields.
+  const PacketCapture& capture() const noexcept { return capture_; }
+
  private:
   void run();
   void on_config(const udps_signal_t* signals, std::uint32_t count, std::uint8_t publish_mode);
@@ -48,6 +62,17 @@ class Acquisition {
                                 std::uint8_t publish_mode, void* user);
   static void data_trampoline(const udps_frame_t* frame, void* user);
   static void event_trampoline(udps_event_t event, const char* detail, void* user);
+  static void datagram_trampoline(const std::uint8_t* bytes, std::size_t len,
+                                  double recv_time, void* user);
+  /// Drops the producer state that is per *connection*: the counter mark, the time
+  /// anchors and the clock choice. A reconnect re-sends the CONFIG and the stream may
+  /// have restarted its numbering; carrying the old session's marks across makes the
+  /// first new frames read as late, as glitches or as an outage, which is recovery
+  /// failing exactly when it matters. Called on the producer thread, from on_event().
+  void reset_session_state() noexcept;
+  /// The producer side of the toggle: open on a rising edge, close on a falling one,
+  /// then store if enabled. Every file operation happens here, on this thread.
+  void on_datagram(const std::uint8_t* bytes, std::size_t len, double recv_time);
 
   /// Fills `stamps_` with this frame's base-tick timestamps, in stream seconds,
   /// and returns how many were written (`frame->num_samples` unless the frame is
@@ -73,6 +98,12 @@ class Acquisition {
   std::thread thread_;
   std::atomic<bool> running_{false};
   std::atomic<bool> paused_{false};
+  PacketCapture capture_;
+  std::atomic<bool> capture_want_{false};
+  std::uint32_t capture_slots_ = 1000;
+  /// Written once, by the GTK thread, before `capture_want_` is ever published true;
+  /// the producer reads it only after the flag, so no lock is needed.
+  std::string capture_path_;
   TriggerEngine engine_;
 
   std::uint64_t tick_ = 0;        ///< base ticks consumed since the epoch