track.h

// SPDX-FileCopyrightText: © 2018-2022, 2024-2026 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#pragma once
 
#include "dsp/modulator_macro_processor.h"
#include "dsp/timebase.h"
#include "structure/tracks/automation_tracklist.h"
#include "structure/tracks/channel.h"
#include "structure/tracks/piano_roll_track.h"
#include "structure/tracks/playback_cache_activity_tracker.h"
#include "structure/tracks/track_fwd.h"
#include "structure/tracks/track_lane_list.h"
#include "structure/tracks/track_processor.h"
#include "utils/iobject_registry.h"
#include "utils/playback_cache_scheduler.h"
#include "utils/typed_uuid_reference.h"
 
#include <QColor>
#include <QtQmlIntegration/qqmlintegration.h>
 
namespace zrythm::dsp
{
class MidiPlaybackCache;
class TempoMapWrapper;
}
 
namespace zrythm::structure::tracks
{
using SoloedTracksExistGetter = std::function<bool ()>;
 
using TrackRecordingCallback = std::function<void (
  const utils::UuidIdentifiableObject<Track>::Uuid &,
  units::sample_t,
  const dsp::ITransport &,
  const dsp::MidiEventBuffer *,
  std::optional<TrackProcessor::ConstStereoPortPair>,
  units::sample_u32_t)>;
 
struct BaseTrackDependencies
{
  const dsp::TempoMapWrapper &tempo_map_;
  utils::IObjectRegistry     &registry_;
  SoloedTracksExistGetter     soloed_tracks_exist_getter_;
  TrackRecordingCallback      track_recording_callback;
};

class Track : public utils::UuidIdentifiableObject<Track>
{
  Q_OBJECT
  Q_PROPERTY (Type type READ type CONSTANT)
  Q_PROPERTY (
    zrythm::structure::tracks::AutomationTracklist * automationTracklist READ
      automationTracklist CONSTANT)
  Q_PROPERTY (QString name READ name WRITE setName NOTIFY nameChanged)
  Q_PROPERTY (QColor color READ color WRITE setColor NOTIFY colorChanged)
  Q_PROPERTY (
    QString comment READ comment WRITE setComment NOTIFY commentChanged)
  Q_PROPERTY (QString icon READ icon WRITE setIcon NOTIFY iconChanged)
  Q_PROPERTY (bool visible READ visible WRITE setVisible NOTIFY visibleChanged)
  Q_PROPERTY (bool enabled READ enabled WRITE setEnabled NOTIFY enabledChanged)
  Q_PROPERTY (bool isDeletable READ is_deletable CONSTANT)
  Q_PROPERTY (double height READ height WRITE setHeight NOTIFY heightChanged)
  Q_PROPERTY (
    double fullVisibleHeight READ fullVisibleHeight NOTIFY
      fullVisibleHeightChanged)
  Q_PROPERTY (zrythm::structure::tracks::Channel * channel READ channel CONSTANT)
  Q_PROPERTY (zrythm::plugins::PluginGroup * modulators READ modulators CONSTANT)
  Q_PROPERTY (
    zrythm::structure::tracks::TrackLaneList * lanes READ lanes CONSTANT)
  Q_PROPERTY (
    zrythm::dsp::ProcessorParameter * recordingParam READ recordingParam CONSTANT)
  Q_PROPERTY (
    zrythm::dsp::ProcessorParameter * monitorParam READ monitorParam CONSTANT)
  Q_PROPERTY (
    zrythm::structure::tracks::PianoRollTrackMixin * pianoRollTrackMixin READ
      pianoRollTrackMixin CONSTANT)
  Q_PROPERTY (
    bool clipLauncherMode READ clipLauncherMode WRITE setClipLauncherMode NOTIFY
      clipLauncherModeChanged)
  Q_PROPERTY (
    zrythm::dsp::timebase::TimebaseProvider * timebaseProvider READ
      timebaseProvider CONSTANT)
  Q_PROPERTY (
    zrythm::structure::tracks::PlaybackCacheActivityTracker *
      playbackCacheActivityTracker READ playbackCacheActivityTracker CONSTANT)
  Q_PROPERTY (
    zrythm::dsp::MidiPort * trackProcessorMidiOut READ trackProcessorMidiOut
      CONSTANT)
  QML_ELEMENT
  QML_UNCREATABLE ("")
public:
  using PluginUuid = plugins::Plugin::Uuid;
  using PortType = dsp::PortType;
  using ArrangerObject = structure::arrangement::ArrangerObject;
  using ArrangerObjectPtrVariant =
    structure::arrangement::ArrangerObjectPtrVariant;
  using Color = utils::Color;
 
  enum class Type : uint8_t
  {
    Instrument,

    Audio,

    Master,

    Chord,

    Marker,

    Modulator,

    AudioBus,

    AudioGroup,

    Midi,

    MidiBus,

    MidiGroup,

    Folder,
  };
  Q_ENUM (Type)
 
  static constexpr int MIN_HEIGHT = 26;
  static constexpr int DEF_HEIGHT = 52;
 
  static bool
  type_can_have_clip_type (Type type, ArrangerObject::Type clip_type)
  {
    switch (clip_type)
      {
      case ArrangerObject::Type::AudioClip:
        return type == Type::Audio;
      case ArrangerObject::Type::MidiClip:
        return type == Type::Midi || type == Type::Instrument;
      case ArrangerObject::Type::ChordClip:
        return type == Type::Chord;
      case ArrangerObject::Type::AutomationClip:
        return true;
      default:
        throw std::runtime_error ("Invalid clip type");
      }
  }
 
  static constexpr bool type_is_foldable (Type type)
  {
    return type == Type::Folder || type == Type::AudioGroup
           || type == Type::MidiGroup;
  }
 
  static constexpr bool type_is_copyable (Type type)
  {
    return type != Type::Master && type != Type::Chord
           && type != Type::Modulator && type != Type::Marker;
  }

  static constexpr bool type_is_deletable (Type type)
  {
    return type_is_copyable (type);
  }
 
  static Type type_get_from_plugin_descriptor (
    const zrythm::plugins::PluginDescriptor &descr);
 
  static consteval bool type_has_mono_compat_switch (const Type tt)
  {
    return tt == Type::AudioGroup || tt == Type::Master;
  }


  static constexpr bool
  type_is_compatible_for_moving (const Type type1, const Type type2)
  {
    return type1 == type2 || (type1 == Type::Midi && type2 == Type::Instrument)
           || (type1 == Type::Instrument && type2 == Type::Midi);
  }

  [[gnu::const]]
  static constexpr bool type_has_piano_roll (const Type type)
  {
    return type == Type::Midi || type == Type::Instrument;
  }

  static constexpr bool type_has_inputs (const Type type)
  {
    return type == Type::Midi || type == Type::Instrument || type == Type::Audio;
  }

  static constexpr bool type_can_be_group_target (const Type type)
  {
    return type == Type::AudioGroup || type == Type::MidiGroup
           || type == Type::Instrument || type == Type::Master;
  }
 
  static constexpr bool type_can_have_automation (const Type type)
  {
    return type == Type::Instrument || type == Type::Audio
           || type == Type::Master || type == Type::Chord
           || type == Type::Modulator || type == Type::AudioBus
           || type == Type::AudioGroup || type == Type::Midi
           || type == Type::MidiBus || type == Type::MidiGroup;
  }
 
  static constexpr bool type_can_have_lanes (const Type type)
  {
    return type == Type::Instrument || type == Type::Audio || type == Type::Midi;
  }
 
  template <typename T> static consteval Type get_type_for_class ()
  {
    if constexpr (std::is_same_v<T, MidiTrack>)
      return Type::Midi;
    else if constexpr (std::is_same_v<T, AudioTrack>)
      return Type::Audio;
    else if constexpr (std::is_same_v<T, ChordTrack>)
      return Type::Chord;
    else if constexpr (std::is_same_v<T, InstrumentTrack>)
      return Type::Instrument;
    else if constexpr (std::is_same_v<T, AudioBusTrack>)
      return Type::AudioBus;
    else if constexpr (std::is_same_v<T, MidiBusTrack>)
      return Type::MidiBus;
    else if constexpr (std::is_same_v<T, MasterTrack>)
      return Type::Master;
    else if constexpr (std::is_same_v<T, ModulatorTrack>)
      return Type::Modulator;
    else if constexpr (std::is_same_v<T, MarkerTrack>)
      return Type::Marker;
    else if constexpr (std::is_same_v<T, FolderTrack>)
      return Type::Folder;
    else if constexpr (std::is_same_v<T, AudioGroupTrack>)
      return Type::AudioGroup;
    else if constexpr (std::is_same_v<T, MidiGroupTrack>)
      return Type::MidiGroup;
    else
      {
        static_assert (utils::dependent_false_v<T>, "Unknown track type");
      }
  }
 
public:
  ~Track () override;
  Q_DISABLE_COPY_MOVE (Track)
 
protected:
  enum class TrackFeatures : std::uint8_t
  {
    Modulators = 1 << 0,
    Automation = 1 << 1,
    Lanes = 1 << 2,
    Recording = 1 << 3,
    PianoRoll = 1 << 4,
  };

  Track (
    Type                    type,
    std::optional<PortType> in_signal_type,
    std::optional<PortType> out_signal_type,
    TrackFeatures           enabled_features,
    BaseTrackDependencies   dependencies);
 
public:
  bool has_piano_roll () const { return type_has_piano_roll (type_); }
 
  bool is_folder () const { return type_ == Type::Folder; }
  bool is_audio_group () const { return type_ == Type::AudioGroup; }
  bool is_midi_group () const { return type_ == Type::MidiGroup; }
  bool is_audio_bus () const { return type_ == Type::AudioBus; }
  bool is_midi_bus () const { return type_ == Type::MidiBus; }
  bool is_modulator () const { return type_ == Type::Modulator; }
  bool is_chord () const { return type_ == Type::Chord; }
  bool is_marker () const { return type_ == Type::Marker; }
  bool is_audio () const { return type_ == Type::Audio; }
  bool is_instrument () const { return type_ == Type::Instrument; }
  bool is_midi () const { return type_ == Type::Midi; }
  bool is_master () const { return type_ == Type::Master; }
 
  // ========================================================================
  // QML Interface
  // ========================================================================
 
  Type type () const { return type_; }
 
  AutomationTracklist * automationTracklist () const
  {
    return automation_tracklist_.get ();
  }
 
  QString name () const { return name_.to_qstring (); }
  void    setName (const QString &name)
  {
    const auto name_str = utils::Utf8String::from_qstring (name);
    if (name_ == name_str)
      return;
 
    name_ = name_str;
    Q_EMIT nameChanged (name);
  }
  Q_SIGNAL void nameChanged (const QString &name);
 
  QColor color () const { return color_.to_qcolor (); }
  void   setColor (const QColor &color)
  {
    if (color_.to_qcolor () == color)
      return;
 
    color_ = color;
    Q_EMIT colorChanged (color);
  }
  Q_SIGNAL void colorChanged (const QColor &color);
 
  QString comment () const { return comment_.to_qstring (); }
  void    setComment (const QString &comment)
  {
    const auto comment_str = utils::Utf8String::from_qstring (comment);
    if (comment_ == comment_str)
      return;
 
    comment_ = comment_str;
    Q_EMIT commentChanged (comment);
  }
  Q_SIGNAL void commentChanged (const QString &comment);
 
  bool visible () const { return visible_; }
  void setVisible (bool visible)
  {
    if (visible_ == visible)
      return;
 
    visible_ = visible;
    Q_EMIT visibleChanged (visible);
  }
  Q_SIGNAL void visibleChanged (bool visible);
 
  bool enabled () const { return enabled_; }
  void setEnabled (bool enabled)
  {
    if (enabled_ == enabled)
      return;
    enabled_ = enabled;
    Q_EMIT enabledChanged (enabled);
  }
  Q_SIGNAL void enabledChanged (bool enabled);
 
  double height () const { return main_height_; }
  void   setHeight (double height)
  {
    if (utils::values_equal_for_qproperty_type (height, main_height_))
      return;
 
    height = std::max (static_cast<double> (Track::MIN_HEIGHT), height);
    main_height_ = height;
    Q_EMIT heightChanged (height);
  }
  Q_SIGNAL void heightChanged (double height);
 
  double fullVisibleHeight () const { return get_full_visible_height (); }
  Q_SIGNAL void fullVisibleHeightChanged ();
 
  QString icon () const { return icon_name_.to_qstring (); }
  void    setIcon (const QString &icon)
  {
    const auto icon_str = utils::Utf8String::from_qstring (icon);
    if (icon_name_ == icon_str)
      {
        return;
      }
    icon_name_ = icon_str;
    Q_EMIT iconChanged (icon);
  }
  Q_SIGNAL void iconChanged (const QString &icon);
 
  Channel * channel () const { return channel_.get (); }
 
  plugins::PluginGroup * modulators () const { return modulators_.get (); }
 
  TrackLaneList * lanes () const { return lanes_.get (); }
 
  dsp::ProcessorParameter * recordingParam () const;
  dsp::ProcessorParameter * monitorParam () const;
 
  PianoRollTrackMixin * pianoRollTrackMixin () const
  {
    return piano_roll_track_mixin_.get ();
  }
 
  bool          clipLauncherMode () const { return clip_launcher_mode_; }
  void          setClipLauncherMode (bool mode);
  Q_SIGNAL void clipLauncherModeChanged (bool mode);
 
  dsp::TimebaseProvider * timebaseProvider ()
  {
    return timebase_provider_.get ();
  }
 
  // cache activity tracking
  [[nodiscard]] PlaybackCacheActivityTracker *
  playbackCacheActivityTracker () const
  {
    return playback_cache_activity_tracker_.get ();
  }
 
  dsp::MidiPort * trackProcessorMidiOut () const;

  Q_INVOKABLE void
  regeneratePlaybackCaches (utils::ExpandableTickRange affectedRange);
 
  // ========================================================================
 
  // bool has_lanes () const { return type_has_lanes (type_); }
 
  bool is_deletable () const { return type_is_deletable (type_); }
  bool is_copyable () const { return type_is_copyable (type_); }
  bool has_automation () const { return automationTracklist () != nullptr; }

  double get_full_visible_height () const;
 
  bool multiply_heights (double multiplier, bool visible_only, bool check_only);
 
  bool can_be_group_target () const { return type_can_be_group_target (type_); }

  void set_default_name ();
 
  template <arrangement::ClipObject ClipT>
  auto generate_name_for_clip (
    const ClipT      &clip,
    AutomationTrack * automation_track = nullptr)
  {
    auto ret = get_name ();
    if constexpr (std::is_same_v<ClipT, arrangement::AutomationClip>)
      {
        assert (automation_track != nullptr);
        ret = utils::Utf8String::from_utf8_encoded_string (
          fmt::format (
            "{} - {}", get_name (), automation_track->parameter ()->label ()));
      }
    return ret;
  }

  void collect_timeline_objects (
    std::vector<ArrangerObjectPtrVariant> &objects) const;
 
  bool contains_uninstantiated_plugin () const;

  utils::Utf8String get_name () const { return name_; };
 
  auto input_signal_type () const { return in_signal_type_; }
  auto output_signal_type () const { return out_signal_type_; }

  uint8_t get_midi_ch (const arrangement::MidiClip &midi_clip) const;

  void
  collect_plugins (std::vector<plugins::PluginUuidReference> &plugins) const;
 
// TODO
#if 0
  static bool is_plugin_descriptor_valid_for_slot_type (
    const plugins::PluginDescriptor &descr,
    zrythm::plugins::PluginSlotType  slot_type,
    Track::Type                      track_type);
#endif
 
  utils::Utf8String get_full_designation_for_port (const dsp::Port &port) const;

  void generate_basic_automation_tracks ();
 
  auto &get_registry () const { return base_dependencies_.registry_; }
  auto &get_registry () { return base_dependencies_.registry_; }
 
  TrackProcessor * get_track_processor () const { return processor_.get (); }
 
  auto get_icon_name () const { return icon_name_; }
 
protected:
  friend void
  init_from (Track &obj, const Track &other, utils::ObjectCloneType clone_type);
 
  void generate_automation_tracks_for_processor (
    std::vector<utils::QObjectUniquePtr<AutomationTrack>> &ats,
    const dsp::ProcessorBase                              &processor)
  {
    structure::tracks::generate_automation_tracks_for_processor (
      ats, processor, base_dependencies_.tempo_map_,
      base_dependencies_.registry_, timebaseProvider ());
  }


  [[nodiscard]] utils::QObjectUniquePtr<TrackProcessor> make_track_processor (
    std::optional<TrackProcessor::FillEventsCallback> fill_events_cb =
      std::nullopt,
    std::optional<TrackProcessor::TransformMidiInputsFunc>
      transform_midi_inputs_func = std::nullopt,
    std::optional<TrackProcessor::AppendMidiInputsToOutputsFunc>
      append_midi_inputs_to_outputs_func = std::nullopt);

  virtual void collect_additional_timeline_objects (
    std::vector<ArrangerObjectPtrVariant> &objects) const
  {
  }
 
private:
  static constexpr auto kNameKey = "name"sv;
  static constexpr auto kIconNameKey = "iconName"sv;
  static constexpr auto kVisibleKey = "visible"sv;
  static constexpr auto kMainHeightKey = "mainHeight"sv;
  static constexpr auto kEnabledKey = "enabled"sv;
  static constexpr auto kColorKey = "color"sv;
  static constexpr auto kInputSignalTypeKey = "inSignalType"sv;
  static constexpr auto kOutputSignalTypeKey = "outSignalType"sv;
  static constexpr auto kCommentKey = "comment"sv;
  static constexpr auto kFrozenClipIdKey = "frozenClipId"sv;
  static constexpr auto kProcessorKey = "processor"sv;
  static constexpr auto kAutomationTracklistKey = "automationTracklist"sv;
  static constexpr auto kChannelKey = "channel"sv;
  static constexpr auto kModulatorsKey = "modulators"sv;
  static constexpr auto kModulatorMacroProcessorsKey =
    "modulatorMacroProcessors"sv;
  static constexpr auto kPianoRollKey = "pianoRoll"sv;
  static constexpr auto kClipLauncherModeKey = "clipLauncherMode"sv;
  static constexpr auto kTimebaseKey = "timebase"sv;
  friend void           to_json (nlohmann::json &j, const Track &track);
  friend void           from_json (const nlohmann::json &j, Track &track);
 
  [[nodiscard]] utils::QObjectUniquePtr<AutomationTracklist>
                                                 make_automation_tracklist ();
  [[nodiscard]] utils::QObjectUniquePtr<Channel> make_channel ();
  [[nodiscard]] utils::QObjectUniquePtr<plugins::PluginGroup>
                                                       make_modulators ();
  [[nodiscard]] utils::QObjectUniquePtr<TrackLaneList> make_lanes ();
  [[nodiscard]] utils::QObjectUniquePtr<PianoRollTrackMixin>
  make_piano_roll_track_mixin ();

  void init_cache_scheduler ();

  void init_playback_cache_activity_tracker (TrackProcessor &proc);
 
protected:
  BaseTrackDependencies base_dependencies_;

  Type type_{};
 
  TrackFeatures features_{};

  utils::Utf8String name_;

  utils::Utf8String icon_name_;

  bool visible_ = true;

  double main_height_{ DEF_HEIGHT };

  bool enabled_ = true;

  Color color_;

  std::optional<PortType> in_signal_type_;

  std::optional<PortType> out_signal_type_;

  utils::Utf8String comment_;

  std::optional<dsp::FileAudioSourceUuidReference> frozen_clip_id_;

  utils::QObjectUniquePtr<AutomationTracklist> automation_tracklist_;

  utils::QObjectUniquePtr<TrackProcessor> processor_;

  utils::QObjectUniquePtr<Channel> channel_;

  utils::QObjectUniquePtr<plugins::PluginGroup> modulators_;

  std::vector<utils::QObjectUniquePtr<dsp::ModulatorMacroProcessor>>
    modulator_macro_processors_;
 
  utils::QObjectUniquePtr<TrackLaneList> lanes_;
 
  utils::QObjectUniquePtr<PianoRollTrackMixin> piano_roll_track_mixin_;

  utils::QObjectUniquePtr<utils::PlaybackCacheScheduler>
    playable_content_cache_request_debouncer_;
 
  bool clip_launcher_mode_{};
  utils::QObjectUniquePtr<PlaybackCacheActivityTracker>
    playback_cache_activity_tracker_;
 
  utils::QObjectUniquePtr<dsp::TimebaseProvider> timebase_provider_;
 
  BOOST_DESCRIBE_CLASS (
    Track,
    (utils::UuidIdentifiableObject<Track>),
    (),
    (type_,
     name_,
     visible_,
     main_height_,
     enabled_,
     color_,
     in_signal_type_,
     out_signal_type_,
     comment_,
     automation_tracklist_,
     processor_,
     channel_,
     modulators_,
     modulator_macro_processors_,
     lanes_,
     piano_roll_track_mixin_,
     clip_launcher_mode_),
    ())
};
 
using TrackUuidReference = utils::TypedUuidReference<Track>;
 
struct FinalTrackDependencies : public BaseTrackDependencies
{
  FinalTrackDependencies (
    const dsp::TempoMapWrapper &tempo_map,
    utils::IObjectRegistry     &registry,
    SoloedTracksExistGetter     soloed_tracks_exist_getter,
    TrackRecordingCallback      recording_callback)
      : BaseTrackDependencies (
          tempo_map,
          registry,
          std::move (soloed_tracks_exist_getter),
          std::move (recording_callback))
  {
  }
 
  BaseTrackDependencies to_base_dependencies ()
  {
    return static_cast<BaseTrackDependencies> (*this); // NOLINT
  }
};
 
} // namespace zrythm::structure::tracks