audio_recording_session.h

// SPDX-FileCopyrightText: © 2026 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#pragma once
 
#include <atomic>
#include <memory>
#include <span>
#include <vector>
 
#include "utils/units.h"
 
#include <QtClassHelperMacros>
 
namespace zrythm::controllers
{

struct RecordingAudioPacket
{
  units::sample_t     timeline_position;
  bool                transport_recording{};
  units::sample_u32_t nframes;
  std::vector<float>  l_frames;
  std::vector<float>  r_frames;
};

class AudioRecordingSession
{
public:
  enum class State : uint8_t
  {
    Armed,
    Capturing,
    Finalizing,
  };
 
  explicit AudioRecordingSession (units::sample_u32_t max_block_length);
  ~AudioRecordingSession ();
 
  Q_DISABLE_COPY_MOVE (AudioRecordingSession)
 
  static constexpr size_t kFifoCapacity = 1024;

  void prepare_for_processing (units::sample_u32_t block_length);

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

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

  void finalize () noexcept;

  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 };
};
 
}