recording_manager.h

// SPDX-FileCopyrightText: © 2019, 2023-2025 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#pragma once
 
#include <semaphore>
 
#include "engine/session/recording_event.h"
#include "structure/arrangement/automation_point.h"
#include "structure/tracks/track_all.h"
#include "utils/mpmc_queue.h"
#include "utils/object_pool.h"
#include "utils/types.h"
 
namespace zrythm::structure::tracks
{
class TrackProcessor;
}
 
#define RECORDING_MANAGER (gZrythm->recording_manager_)
 
namespace zrythm::engine::session
{
QT_WARNING_PUSH
QT_WARNING_DISABLE_DEPRECATED
class RecordingManager : public QObject
{
public:
  using AutomationTrack = structure::tracks::AutomationTrack;
  using AutomationRegion = structure::arrangement::AutomationRegion;
  using AutomationPoint = structure::arrangement::AutomationPoint;
 
public:
  RecordingManager (QObject * parent = nullptr);
  Q_DISABLE_COPY_MOVE (RecordingManager)
  ~RecordingManager () override;

  void handle_recording (
    structure::tracks::TrackPtrVariant track_var,
    const EngineProcessTimeInfo       &time_nfo,
    const dsp::MidiEventVector *       midi_events,
    std::optional<structure::tracks::TrackProcessor::ConstStereoPortPair>
      stereo_ports);
 
  Q_SLOT void process_events ();

  void start_unended_note (
    structure::arrangement::MidiRegion &mr,
    double                              start_pos,
    std::optional<double>               end_pos,
    int                                 pitch,
    int                                 vel);

  structure::arrangement::MidiNote *
  pop_unended_note (structure::arrangement::MidiRegion &mr, int pitch);

  void get_aps_since_last_recorded (
    const structure::arrangement::AutomationRegion &ar,
    signed_frame_t                                  pos,
    std::vector<AutomationPoint *>                 &aps) const;
 
private:
  void handle_start_recording (const RecordingEvent &ev, bool is_automation);

  bool handle_resume_event (const RecordingEvent &ev);

  void handle_pause_event (const RecordingEvent &ev);

  AutomationPoint * create_automation_point (
    AutomationTrack * at,
    AutomationRegion &region,
    float             val,
    float             normalized_val,
    signed_frame_t    pos_frames);
 
  void handle_stop_recording (bool is_automation);

  void delete_automation_points (
    AutomationTrack * at,
    AutomationRegion &region,
    signed_frame_t    pos_frames);

  void handle_audio_event (const RecordingEvent &ev);

  void handle_midi_event (const RecordingEvent &ev);

  void handle_automation_event (const RecordingEvent &ev);
 
  static utils::Utf8String
  gen_name_for_recording_clip (const utils::Utf8String &track_name, int lane)
  {
    return utils::Utf8String::from_utf8_encoded_string (
      fmt::format (
        "{} - lane {} - recording", track_name,
        /* add 1 to get human friendly index */
        lane + 1));
  }
 
  std::optional<structure::arrangement::ArrangerObjectPtrVariant>
  get_recording_region_for_track (
    const structure::tracks::Track::Uuid &track_id) const;
 
public:
  int num_active_recordings_ = 0;

  MPMCQueue<RecordingEvent *> event_queue_;

  ObjectPool<RecordingEvent> event_obj_pool_;

  std::vector<structure::arrangement::ArrangerObjectPtrVariant>
    objects_before_start_;

  std::vector<structure::arrangement::ArrangerObject::Uuid> recorded_ids_;

  std::unordered_map<
    structure::arrangement::ArrangerObjectUuid,
    std::vector<QPointer<structure::arrangement::MidiNote>>>
    unended_notes_per_region_;

  std::unordered_map<
    structure::tracks::Track::Uuid,
    std::vector<QPointer<AutomationTrack>>>
    ats_in_record_mode_;

  std::unordered_map<
    structure::arrangement::ArrangerObjectUuid,
    QPointer<AutomationPoint>>
    last_recorded_aps_per_region_;

  std::unordered_map<
    structure::tracks::Track::Uuid,
    structure::arrangement::ArrangerObject::Uuid>
    recording_region_per_track_;

  std::unordered_set<structure::tracks::Track::Uuid>
    tracks_recording_stop_was_sent_to_;
 
  std::unordered_set<structure::tracks::Track::Uuid>
    tracks_recording_start_was_sent_to_;

  std::unordered_set<structure::tracks::Track::Uuid> tracks_recording_was_paused_;

  std::vector<structure::arrangement::AutomationPoint *> pending_aps_;
 
  bool                  currently_processing_ = false;
  std::binary_semaphore processing_sem_{ 1 };
 
  bool freeing_ = false;
 
private:
  std::unique_ptr<juce::TimeSliceThread> time_slice_thread_;
};
QT_WARNING_POP
 
} // namespace zrythm::engine::session