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 <variant>
#include <vector>
 
#include "controllers/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)
 
  enum class SessionType : std::uint8_t
  {
    Audio,
    Midi,
  };
 
  using SessionHandle =
    std::variant<std::monostate, AudioRecordingSession *, MidiRecordingSession *>;

  void arm_track (
    structure::tracks::TrackUuid track_id,
    units::sample_u32_t          max_block_length,
    SessionType                  type) [[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]] SessionHandle
  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 midiDataReady (
    structure::tracks::TrackUuid     track_id,
    std::vector<RecordingMidiPacket> packets);

  void recordingSessionEnded ();
 
private:
  struct RtSnapshot
  {
    std::unordered_map<structure::tracks::TrackUuid, AudioRecordingSession *>
      audio;
    std::unordered_map<structure::tracks::TrackUuid, MidiRecordingSession *> midi;
  };
 
  using AudioDrainResult = std::vector<
    std::pair<structure::tracks::TrackUuid, std::vector<RecordingAudioPacket>>>;
 
  using MidiDrainResult = std::vector<
    std::pair<structure::tracks::TrackUuid, std::vector<RecordingMidiPacket>>>;
 
  void publish_snapshot ();
 
  bool drain_pending_deletion (
    AudioDrainResult &audio_ready,
    MidiDrainResult  &midi_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 RtSnapshot, atomically swaps the
  // pointer, and defers the old RtSnapshot'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<RtSnapshot *> 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<RtSnapshot>> pending_snapshot_deletion_;
  std::vector<std::unique_ptr<RtSnapshot>> old_snapshots_;
 
  struct Impl;
  std::unique_ptr<Impl> impl_;
};
 
}