recording_session.h

// SPDX-FileCopyrightText: © 2026 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#pragma once
 
#include <atomic>
#include <concepts>
#include <memory>
#include <vector>
 
#include "controllers/recording_audio_packet.h"
#include "controllers/recording_midi_packet.h"
#include "utils/units.h"
 
#include <QtClassHelperMacros>
 
namespace zrythm::controllers
{
 
template <typename T>
concept RecordingPacket =
  requires (T &slot, const T &source, units::sample_u32_t block_length) {
    { T::copy_from (slot, source) };
    { T::resize (slot, block_length) };
  };

template <RecordingPacket Packet> class RecordingSession
{
public:
  enum class State : uint8_t
  {
    Armed,
    Capturing,
    Finalizing,
  };
 
  explicit RecordingSession (units::sample_u32_t max_block_length);
  ~RecordingSession ();
 
  Q_DISABLE_COPY_MOVE (RecordingSession)
 
  static constexpr size_t kFifoCapacity = 1024;
 
  using PacketType = Packet;

  void prepare_for_processing (units::sample_u32_t block_length);

  void write (
    units::sample_t        timeline_position,
    bool                   transport_recording,
    std::span<const float> l_data,
    std::span<const float> r_data) noexcept [[clang::nonblocking]]
    requires std::same_as<Packet, RecordingAudioPacket>;

  void write (
    units::sample_t                 timeline_position,
    bool                            transport_recording,
    std::span<const dsp::MidiEvent> midi_events,
    units::sample_u32_t             nframes) noexcept [[clang::nonblocking]]
    requires std::same_as<Packet, RecordingMidiPacket>;

  [[nodiscard]] std::vector<Packet> drain_pending () [[clang::blocking]];
 
  [[nodiscard]] auto state () const
  {
    return state_.load (std::memory_order_acquire);
  }

  void finalize () noexcept [[clang::nonblocking]];

  void reset ();
 
  [[nodiscard]] uint64_t dropped_packets () const
  {
    return dropped_packets_.load (std::memory_order_relaxed);
  }
 
private:
  struct Impl;
  std::unique_ptr<Impl> impl_;
 
  std::atomic<State>    state_{ State::Armed };
  std::atomic<uint64_t> dropped_packets_{ 0 };
};
 
using AudioRecordingSession = RecordingSession<RecordingAudioPacket>;
using MidiRecordingSession = RecordingSession<RecordingMidiPacket>;
 
}