channel.h

// SPDX-FileCopyrightText: © 2018-2022, 2024-2026 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#pragma once
 
#include "dsp/fader.h"
#include "dsp/passthrough_processors.h"
#include "plugins/plugin_group.h"
#include "structure/tracks/channel_send.h"
#include "utils/icloneable.h"
 
namespace zrythm::structure::tracks
{
 
class ChannelMidiPassthroughProcessor final
    : public QObject,
      public dsp::MidiPassthroughProcessor
{
  Q_OBJECT
  QML_ELEMENT
  QML_UNCREATABLE ("")
 
public:
  ChannelMidiPassthroughProcessor (
    dsp::ProcessorBase::ProcessorBaseDependencies dependencies,
    QObject *                                     parent = nullptr);
};
 
class ChannelAudioPassthroughProcessor final
    : public QObject,
      public dsp::StereoPassthroughProcessor
{
  Q_OBJECT
  QML_ELEMENT
  QML_UNCREATABLE ("")
 
public:
  ChannelAudioPassthroughProcessor (
    dsp::ProcessorBase::ProcessorBaseDependencies dependencies,
    QObject *                                     parent = nullptr);
};

class Channel : public QObject
{
  Q_OBJECT
  QML_ELEMENT
  Q_PROPERTY (zrythm::dsp::Fader * fader READ fader CONSTANT)
  Q_PROPERTY (QVariant preFader READ preFader CONSTANT)
  Q_PROPERTY (zrythm::dsp::AudioPort * audioOutPort READ audioOutPort CONSTANT)
  Q_PROPERTY (zrythm::dsp::MidiPort * midiOut READ getMidiOut CONSTANT)
  Q_PROPERTY (zrythm::plugins::PluginGroup * inserts READ inserts CONSTANT)
  Q_PROPERTY (zrythm::plugins::PluginGroup * midiFx READ midiFx CONSTANT)
  Q_PROPERTY (
    zrythm::plugins::PluginGroup * instruments READ instruments CONSTANT)
  QML_UNCREATABLE ("")
 
public:
  using PortType = zrythm::dsp::PortType;
  using Plugin = plugins::Plugin;
  using PluginDescriptor = zrythm::plugins::PluginDescriptor;
  using PluginPtrVariant = plugins::PluginPtrVariant;
  using PluginUuid = Plugin::Uuid;
 
  using NameProvider = std::function<utils::Utf8String ()>;
 
public:
  explicit Channel (
    plugins::PluginRegistry                      &plugin_registry,
    dsp::ProcessorBase::ProcessorBaseDependencies processor_dependencies,
    dsp::PortType                                 signal_type,
    NameProvider                                  name_provider,
    bool                                          hard_limit_fader_output,
    dsp::Fader::ShouldBeMutedCallback             should_be_muted_cb,
    QObject *                                     parent = nullptr);
 
  // ============================================================================
  // QML Interface
  // ============================================================================
 
  dsp::Fader * fader () const { return fader_.get (); }
  QVariant     preFader () const
  {
    return is_midi () ? QVariant::fromValue (midi_prefader_.get ())
                      : QVariant::fromValue (audio_prefader_.get ());
  }
  dsp::AudioPort * audioOutPort () const
  {
    return is_audio ()
             ? std::addressof (audio_postfader_->get_audio_out_port ())
             : nullptr;
  }
  dsp::MidiPort * getMidiOut () const
  {
    return is_midi () ? std::addressof (midi_postfader_->get_midi_out_port (0))
                      : nullptr;
  }
  plugins::PluginGroup * midiFx () const { return midi_fx_.get (); }
  plugins::PluginGroup * inserts () const { return inserts_.get (); }
  plugins::PluginGroup * instruments () const { return instruments_.get (); }
 
  // ============================================================================
 
  bool is_midi () const { return signal_type_ == PortType::Midi; }
  bool is_audio () const { return signal_type_ == PortType::Audio; }

  void get_plugins (std::vector<plugins::PluginPtrVariant> &plugins) const;

  plugins::PluginUuidReference remove_plugin (plugins::Plugin::Uuid id);
 
  friend void init_from (
    Channel               &obj,
    const Channel         &other,
    utils::ObjectCloneType clone_type);
 
  dsp::Fader &get_fader () const { return *fader_; }
  auto       &get_midi_pre_fader () const { return *midi_prefader_; }
  auto       &get_audio_pre_fader () const { return *audio_prefader_; }
  auto       &get_midi_post_fader () const { return *midi_postfader_; }
  auto       &get_audio_post_fader () const { return *audio_postfader_; }
 
  auto &pre_fader_sends () const { return prefader_sends_; }
  auto &post_fader_sends () const { return postfader_sends_; }
 
private:
  static constexpr auto kMidiFxKey = "midiFx"sv;
  static constexpr auto kInstrumentsKey = "instruments"sv;
  static constexpr auto kInsertsKey = "inserts"sv;
  static constexpr auto kPreFaderSendsKey = "preFaderSends"sv;
  static constexpr auto kPostFaderSendsKey = "postFaderSends"sv;
  static constexpr auto kPrefaderProcessorKey = "prefaderProcessor"sv;
  static constexpr auto kFaderKey = "fader"sv;
 
  friend void to_json (nlohmann::json &j, const Channel &c);
  friend void from_json (const nlohmann::json &j, Channel &c);
 
  dsp::ProcessorBase::ProcessorBaseDependencies dependencies () const
  {
    return dependencies_;
  }
 
private:
  dsp::ProcessorBase::ProcessorBaseDependencies dependencies_;
  plugins::PluginRegistry                      &plugin_registry_;
 
  NameProvider name_provider_;
 
  dsp::PortType signal_type_;
 
  bool hard_limit_fader_output_;

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

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

  utils::QObjectUniquePtr<plugins::PluginGroup> inserts_;
 
  std::vector<utils::QObjectUniquePtr<ChannelSend>> prefader_sends_;
  std::vector<utils::QObjectUniquePtr<ChannelSend>> postfader_sends_;

  utils::QObjectUniquePtr<dsp::Fader> fader_;

  utils::QObjectUniquePtr<ChannelMidiPassthroughProcessor>  midi_prefader_;
  utils::QObjectUniquePtr<ChannelAudioPassthroughProcessor> audio_prefader_;

  utils::QObjectUniquePtr<ChannelMidiPassthroughProcessor>  midi_postfader_;
  utils::QObjectUniquePtr<ChannelAudioPassthroughProcessor> audio_postfader_;
};
 
}; // namespace zrythm::structure::tracks