recording_materializer.h

// SPDX-FileCopyrightText: © 2026 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#pragma once
 
#include <cstdint>
#include <deque>
#include <functional>
#include <unordered_map>
 
#include "controllers/recording_coordinator.h"
#include "controllers/recording_mode.h"
#include "structure/arrangement/arranger_object_all.h"
#include "undo/undo_stack.h"
#include "utils/audio.h"
#include "utils/qt.h"
 
#include <QObject>
 
namespace zrythm::controllers
{

class RecordingMaterializer : public QObject
{
  Q_OBJECT
 
public:
  using RecordingMode = recording::RecordingMode;

  struct CreatedRegion
  {
    structure::arrangement::ArrangerObjectUuidReference region;
    size_t                                              actual_lane_index{};
  };
  using RegionCreationResult = std::optional<CreatedRegion>;

  using RecordingModeProvider = std::function<RecordingMode ()>;

  struct ArrangerObjectCreators
  {
    std::function<RegionCreationResult (
      structure::tracks::TrackUuid     track_id,
      units::sample_t                  start_position,
      const utils::audio::AudioBuffer &initial_frames,
      size_t                           lane_index)>
      audio_region;

    std::function<RegionCreationResult (
      structure::tracks::TrackUuid track_id,
      units::sample_t              start_position,
      size_t                       lane_index)>
      midi_region;

    std::function<void (
      structure::arrangement::MidiRegion &region,
      units::sample_t                     start_position,
      units::sample_t                     end_position,
      int                                 pitch,
      int                                 velocity,
      int                                 channel)>
      midi_note;

    std::function<void (
      structure::arrangement::MidiRegion                 &region,
      units::sample_t                                     position,
      structure::arrangement::MidiControlEvent::EventType type,
      int                                                 channel,
      int                                                 controller,
      int                                                 value)>
      midi_control_event;
  };
 
  explicit RecordingMaterializer (
    RecordingCoordinator  &recording_coordinator,
    undo::UndoStack       &undo_stack,
    ArrangerObjectCreators creators,
    RecordingModeProvider  recording_mode_provider,
    QObject *              parent = nullptr);
 
  ~RecordingMaterializer () override;
 
  Q_DISABLE_COPY_MOVE (RecordingMaterializer)
 
private:
  struct TrackRecordingState
  {
    struct PendingNote
    {
      units::sample_t start_position;
      uint8_t         velocity{};
      uint8_t         channel{};
    };

    std::optional<structure::arrangement::ArrangerObjectUuidReference>
      current_region;
    std::optional<units::sample_t> last_end_position;
    size_t current_lane_index = 0;
    std::unordered_map<uint16_t, std::deque<PendingNote>> unended_notes;
  };

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

  std::optional<structure::arrangement::ArrangerObjectUuidReference>
  get_or_create_region (
    TrackRecordingState             &state,
    structure::tracks::TrackUuid     track_id,
    units::sample_t                  start_position,
    const utils::audio::AudioBuffer &initial_frames);
 
  static dsp::FileAudioSource *
  get_clip_for_region (structure::arrangement::AudioRegion &region);

  void on_midi_data_ready (
    structure::tracks::TrackUuid            track_id,
    const std::vector<RecordingMidiPacket> &packets);

  bool ensure_midi_region (
    TrackRecordingState         &state,
    structure::tracks::TrackUuid track_id,
    units::sample_t              start_position);

  void handle_discontinuity (TrackRecordingState &state);

  void force_complete_pending_notes (TrackRecordingState &state);

  void ensure_recording_macro ();

  void finalize_recording_macro ();
 
  RecordingCoordinator     &recording_coordinator_;
  QPointer<undo::UndoStack> undo_stack_;
  ArrangerObjectCreators    creators_;
  RecordingModeProvider     recording_mode_provider_;

  std::unordered_map<structure::tracks::TrackUuid, TrackRecordingState>
    track_states_;

  utils::audio::AudioBuffer scratch_buf_{ 2, 0 };
 
  bool recording_macro_active_ = false;
};
 
}