recording_coordinator.h

// SPDX-FileCopyrightText: © 2026 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#pragma once
 
#include <atomic>
#include <chrono>
#include <memory>
#include <unordered_map>
#include <vector>
 
#include "controllers/audio_recording_session.h"
#include "structure/tracks/track_fwd.h"
 
#include <QObject>
 
namespace zrythm::controllers
{

class RecordingCoordinator : public QObject
{
  Q_OBJECT
 
public:
  static constexpr auto kDrainInterval = std::chrono::milliseconds (100);
 
  explicit RecordingCoordinator (QObject * parent = nullptr);
  ~RecordingCoordinator () override;
 
  Q_DISABLE_COPY_MOVE (RecordingCoordinator)
 
  
  void arm_track (
    structure::tracks::TrackUuid track_id,
    units::sample_u32_t          max_block_length) [[clang::blocking]];

  void disarm_track (structure::tracks::TrackUuid track_id) [[clang::blocking]];

  [[nodiscard]] bool has_session (structure::tracks::TrackUuid track_id) const;

  void process_pending ();

  Q_SLOT void finalizeAllSessions ();

  [[nodiscard]] AudioRecordingSession *
  session_for_track (structure::tracks::TrackUuid track_id) const noexcept
    [[clang::nonblocking]];

  void prepare_for_processing (units::sample_u32_t block_length);
 
Q_SIGNALS:

  void audioDataReady (
    structure::tracks::TrackUuid      track_id,
    std::vector<RecordingAudioPacket> packets);

  void recordingSessionEnded ();
 
private:
  using Snapshot =
    std::unordered_map<structure::tracks::TrackUuid, AudioRecordingSession *>;
 
  using DrainResult = std::vector<
    std::pair<structure::tracks::TrackUuid, std::vector<RecordingAudioPacket>>>;
 
  void publish_snapshot ();
 
  bool drain_pending_deletion (DrainResult &ready);
 
  // TODO: Replace this raw atomic pointer with a proper multi-reader
  // realtime-safe container.  The current approach works but is ugly:
  // publish_snapshot() heap-allocates a new Snapshot, atomically swaps the
  // pointer, and defers the old Snapshot's deletion to
  // pending_snapshot_deletion_.  Those deferred snapshots are freed in
  // process_pending(), which runs at least kDrainInterval (100 ms) after
  // the last publish — long after any RT thread has finished reading the
  // old snapshot.  The initial snapshot (created in the constructor) and
  // any remaining pending snapshots are freed in the destructor.
  std::atomic<Snapshot *> rt_snapshot_{ nullptr };
 
  // Two-phase deferred deletion for retired snapshots:
  //   1. publish_snapshot() pushes the old snapshot into
  //      pending_snapshot_deletion_.
  //   2. process_pending() swaps pending_snapshot_deletion_ into
  //      old_snapshots_ (destroying what was previously there) and emits
  //      signals.  Each retired snapshot therefore survives at least two
  //      drain intervals (~200 ms), guaranteeing every RT reader has moved
  //      on to a newer snapshot before the old one is freed.
  std::vector<std::unique_ptr<Snapshot>> pending_snapshot_deletion_;
  std::vector<std::unique_ptr<Snapshot>> old_snapshots_;
 
  struct Impl;
  std::unique_ptr<Impl> impl_;
};
 
}