channel.h

// SPDX-FileCopyrightText: © 2018-2022, 2024-2025 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#pragma once
 
#include "zrythm-config.h"
 
#include "dsp/channel.h"
#include "gui/dsp/channel_send.h"
#include "gui/dsp/ext_port.h"
#include "gui/dsp/fader.h"
#include "gui/dsp/plugin.h"
#include "gui/dsp/plugin_span.h"
#include "gui/dsp/track.h"
#include "utils/icloneable.h"
 
class AutomationTrack;
class ChannelTrack;
class GroupTargetTrack;
class ExtPort;
 
class Track;
 
namespace zrythm::gui
{
 
static constexpr float MAX_FADER_AMP = 1.42f;
 
struct PluginImportData;

class Channel final : public QObject, public ICloneable<Channel>, public IPortOwner
{
  Q_OBJECT
  QML_ELEMENT
  Q_PROPERTY (Fader * fader READ getFader CONSTANT)
  Q_PROPERTY (Fader * preFader READ getPreFader CONSTANT)
  Q_PROPERTY (AudioPort * leftAudioOut READ getLeftAudioOut CONSTANT)
  Q_PROPERTY (AudioPort * rightAudioOut READ getRightAudioOut CONSTANT)
  Q_PROPERTY (MidiPort * midiOut READ getMidiOut CONSTANT)
 
public:
  static constexpr auto STRIP_SIZE = zrythm::dsp::STRIP_SIZE;
  using PortType = zrythm::dsp::PortType;
  using PortIdentifier = dsp::PortIdentifier;
  using TrackUuid = utils::UuidIdentifiableObject<Track>::Uuid;
  using Plugin = gui::old_dsp::plugins::Plugin;
  using PluginDescriptor = zrythm::plugins::PluginDescriptor;
  using PluginSlot = zrythm::plugins::PluginSlot;
  using PluginSlotType = zrythm::plugins::PluginSlotType;
  using PluginPtrVariant = gui::old_dsp::plugins::PluginPtrVariant;
  using PluginUuid = Plugin::Uuid;
 
  // FIXME: leftover from C port, fix/refactor how import works in channel.cpp
  friend struct PluginImportData;
 
public:
  explicit Channel (
    TrackRegistry            &track_registry,
    PluginRegistry           &plugin_registry,
    PortRegistry             &port_registry,
    OptionalRef<ChannelTrack> track);

  explicit Channel (
    TrackRegistry  &track_registry,
    PluginRegistry &plugin_registry,
    PortRegistry   &port_registry)
      : Channel (track_registry, plugin_registry, port_registry, {})
  {
  }
 
private:
  auto &get_track_registry () { return track_registry_; }
  auto &get_track_registry () const { return track_registry_; }
  auto &get_plugin_registry () { return plugin_registry_; }
  auto &get_plugin_registry () const { return plugin_registry_; }
  auto &get_port_registry () { return port_registry_; }
  auto &get_port_registry () const { return port_registry_; }
 
public:
  // ============================================================================
  // QML Interface
  // ============================================================================
 
  Fader *     getFader () const { return fader_; }
  Fader *     getPreFader () const { return prefader_; }
  AudioPort * getLeftAudioOut () const
  {
    return stereo_out_left_id_.has_value ()
             ? std::addressof (get_stereo_out_ports ().first)
             : nullptr;
  }
  AudioPort * getRightAudioOut () const
  {
    return stereo_out_left_id_.has_value ()
             ? std::addressof (get_stereo_out_ports ().second)
             : nullptr;
  }
  MidiPort * getMidiOut () const
  {
    return midi_out_id_.has_value () ? std::addressof (get_midi_out_port ()) : nullptr;
  }
 
  // ============================================================================

  void init ();
 
  bool is_in_active_project () const override;
 
  void set_port_metadata_from_owner (dsp::PortIdentifier &id, PortRange &range)
    const override;
 
  utils::Utf8String
  get_full_designation_for_port (const dsp::PortIdentifier &id) const override;
 
  bool should_bounce_to_master (utils::audio::BounceStep step) const override;
 
  MidiPort &get_midi_out_port () const
  {
    return *std::get<MidiPort *> (midi_out_id_->get_object ());
  }
  std::pair<AudioPort &, AudioPort &> get_stereo_out_ports () const
  {
    auto * l = std::get<AudioPort *> (stereo_out_left_id_->get_object ());
    auto * r = std::get<AudioPort *> (stereo_out_right_id_->get_object ());
    return { *l, *r };
  }

  void reset_fader (bool fire_events);

  void handle_plugin_import (
    const Plugin *            pl,
    std::optional<PluginSpan> plugins,
    const PluginDescriptor *  descr,
    PluginSlot                slot,
    bool                      copy,
    bool                      ask_if_overwrite);

  void prepare_process (nframes_t nframes);

  void process ();

  PluginPtrVariant add_plugin (
    PluginUuidReference plugin_id,
    PluginSlot          slot,
    bool                confirm,
    bool                moving_plugin,
    bool                gen_automatables,
    bool                recalc_graph,
    bool                pub_events);
 
  ChannelTrack &get_track () const { return *track_; }
 
  GroupTargetTrack * get_output_track () const;

  void reconnect_ext_input_ports (AudioEngine &engine);

  AutomationTrack *
  get_automation_track (PortIdentifier::Flags port_flags) const;

  PluginUuid remove_plugin_from_channel (
    PluginSlot slot,
    bool       moving_plugin,
    bool       deleting_plugin);

  void get_plugins (std::vector<Plugin *> &pls);

  void paste_plugins_to_slot (PluginSpan plugins, PluginSlot slot);

  bool get_mono_compat_enabled ();

  void set_mono_compat_enabled (bool enabled, bool fire_events);

  bool get_swap_phase ();

  void set_swap_phase (bool enabled, bool fire_events);
 
  std::optional<PluginPtrVariant> get_plugin_at_slot (PluginSlot slot) const;
 
  auto get_plugin_slot (const PluginUuid &plugin_id) const -> PluginSlot;
 
  std::optional<PluginPtrVariant> get_plugin_from_id (PluginUuid id) const;
 
  std::optional<PluginPtrVariant> get_instrument () const
  {
    return instrument_ ? std::make_optional (instrument_->get_object ()) : std::nullopt;
  }

  void select_all (PluginSlotType type, bool select);

  void set_caches ();
 
  void
  init_after_cloning (const Channel &other, ObjectCloneType clone_type) override;

  void disconnect_channel ();

  void connect_channel (dsp::PortConnectionsManager &mgr, AudioEngine &engine);
 
  void init_loaded ();

  void handle_recording (long g_frames_start, nframes_t nframes);

  void append_ports (std::vector<Port *> &ports, bool include_plugins);

  void expose_ports_to_backend (AudioEngine &engine);
 
  void set_phase (float phase);
 
  float get_phase () const;
 
  void set_balance_control (float val);

  void add_balance_control (float pan);
 
  float get_balance_control () const;

  void set_track_ptr (ChannelTrack &track);
 
  bool has_output () const { return output_track_uuid_.has_value (); }
 
  Fader &get_post_fader () const { return *fader_; }
  Fader &get_pre_fader () const { return *prefader_; }
 
  auto &get_sends () const { return sends_; }
 
private:
  static constexpr auto kMidiFxKey = "midiFx"sv;
  static constexpr auto kInsertsKey = "inserts"sv;
  static constexpr auto kSendsKey = "sends"sv;
  static constexpr auto kInstrumentKey = "instrument"sv;
  static constexpr auto kPrefaderKey = "prefader"sv;
  static constexpr auto kFaderKey = "fader"sv;
  static constexpr auto kMidiOutKey = "midiOut"sv;
  static constexpr auto kStereoOutLKey = "stereoOutL"sv;
  static constexpr auto kStereoOutRKey = "stereoOutR"sv;
  static constexpr auto kOutputIdKey = "outputId"sv;
  static constexpr auto kTrackIdKey = "trackId"sv;
  static constexpr auto kExtMidiInputsKey = "extMidiIns"sv;
  static constexpr auto kAllMidiInputsKey = "allMidiIns"sv;
  static constexpr auto kMidiChannelsKey = "midiChannels"sv;
  static constexpr auto kAllMidiChannelsKey = "allMidiChannels"sv;
  static constexpr auto kExtStereoLInputsKey = "extStereoLIns"sv;
  static constexpr auto kAllStereoLInputsKey = "allStereoLIns"sv;
  static constexpr auto kExtStereoRInputsKey = "extStereoRIns"sv;
  static constexpr auto kAllStereoRInputsKey = "allStereoRIns"sv;
  static constexpr auto kWidthKey = "width"sv;
 
  friend void to_json (nlohmann::json &j, const Channel &c)
  {
    j[kMidiFxKey] = c.midi_fx_;
    j[kInsertsKey] = c.inserts_;
    j[kSendsKey] = c.sends_;
    j[kInstrumentKey] = c.instrument_;
    j[kPrefaderKey] = c.prefader_;
    j[kFaderKey] = c.fader_;
    j[kMidiOutKey] = c.midi_out_id_;
    j[kStereoOutLKey] = c.stereo_out_left_id_;
    j[kStereoOutRKey] = c.stereo_out_right_id_;
    j[kOutputIdKey] = c.output_track_uuid_;
    j[kTrackIdKey] = c.track_uuid_;
    if (!c.all_midi_ins_)
      {
        j[kExtMidiInputsKey] = c.ext_midi_ins_;
      }
    j[kAllMidiInputsKey] = c.all_midi_ins_;
    if (!c.all_midi_channels_)
      {
        j[kMidiChannelsKey] = c.midi_channels_;
      }
    j[kAllMidiChannelsKey] = c.all_midi_channels_;
    if (!c.all_stereo_l_ins_)
      {
        j[kExtStereoLInputsKey] = c.ext_stereo_l_ins_;
      }
    j[kAllStereoLInputsKey] = c.all_stereo_l_ins_;
    if (!c.all_stereo_r_ins_)
      {
        j[kExtStereoRInputsKey] = c.ext_stereo_r_ins_;
      }
    j[kAllStereoRInputsKey] = c.all_stereo_r_ins_;
    j[kWidthKey] = c.width_;
  }
  friend void from_json (const nlohmann::json &j, Channel &c);

  void connect_no_prev_no_next (Plugin &pl);

  void connect_no_prev_next (Plugin &pl, Plugin &next_pl);

  void connect_prev_no_next (Plugin &prev_pl, Plugin &pl);

  void connect_prev_next (Plugin &prev_pl, Plugin &pl, Plugin &next_pl);

  void disconnect_no_prev_no_next (Plugin &pl);

  void disconnect_no_prev_next (Plugin &pl, Plugin &next_pl);

  void disconnect_prev_no_next (Plugin &prev_pl, Plugin &pl);

  void disconnect_prev_next (Plugin &prev_pl, Plugin &pl, Plugin &next_pl);

  void connect_plugin_to_prefader (Plugin &pl);

  void disconnect_plugin_from_prefader (Plugin &pl);
 
  void connect_plugins ();

  // void init_stereo_out_ports (bool loading);
 
  void disconnect_plugin_from_strip (PluginSlot slot, Plugin &pl);

  void disconnect_port_hardware_inputs (Port &port);
 
  // void disconnect_port_hardware_inputs (StereoPorts &ports);
 
public:
  TrackRegistry  &track_registry_;
  PortRegistry   &port_registry_;
  PluginRegistry &plugin_registry_;

  std::array<std::optional<PluginUuidReference>, STRIP_SIZE> midi_fx_;

  std::array<std::optional<PluginUuidReference>, STRIP_SIZE> inserts_;

  std::optional<PluginUuidReference> instrument_;

  std::array<std::unique_ptr<ChannelSend>, STRIP_SIZE> sends_;

  std::vector<std::unique_ptr<ExtPort>> ext_midi_ins_;

  bool all_midi_ins_ = true;

  std::vector<std::unique_ptr<ExtPort>> ext_stereo_l_ins_;

  bool all_stereo_l_ins_ = false;

  std::vector<std::unique_ptr<ExtPort>> ext_stereo_r_ins_;

  bool all_stereo_r_ins_ = false;

  std::array<bool, 16> midi_channels_{};

  bool all_midi_channels_ = true;

  Fader * fader_ = nullptr;

  Fader * prefader_ = nullptr;

  std::optional<PortUuidReference> midi_out_id_;
 
  /*
   * Ports for direct (track-to-track) routing with the exception of
   * master, which will route the output to monitor in.
   */
  std::optional<PortUuidReference> stereo_out_left_id_;
  std::optional<PortUuidReference> stereo_out_right_id_;

  // bool has_output_ = false;

  std::optional<TrackUuid> output_track_uuid_;

  std::optional<TrackUuid> track_uuid_;

  int width_ = 0;

  ChannelTrack * track_;
};
 
}; // namespace zrythm::gui