fader.h

// SPDX-FileCopyrightText: © 2019-2022, 2024-2026 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#pragma once
 
#include <cstdint>
 
#include "dsp/audio_port.h"
#include "dsp/midi_port.h"
#include "dsp/parameter.h"
#include "dsp/processor_base.h"
#include "utils/icloneable.h"
#include "utils/types.h"
 
namespace zrythm::dsp
{
class Fader : public QObject, public dsp::ProcessorBase
{
  Q_OBJECT
  Q_PROPERTY (
    MidiFaderMode midiMode READ midiMode WRITE setMidiMode NOTIFY midiModeChanged)
  Q_PROPERTY (zrythm::dsp::ProcessorParameter * gain READ gain CONSTANT)
  Q_PROPERTY (zrythm::dsp::ProcessorParameter * balance READ balance CONSTANT)
  Q_PROPERTY (zrythm::dsp::ProcessorParameter * mute READ mute CONSTANT)
  Q_PROPERTY (zrythm::dsp::ProcessorParameter * solo READ solo CONSTANT)
  Q_PROPERTY (zrythm::dsp::ProcessorParameter * listen READ listen CONSTANT)
  Q_PROPERTY (
    zrythm::dsp::ProcessorParameter * monoToggle READ monoToggle CONSTANT)
  Q_PROPERTY (
    zrythm::dsp::ProcessorParameter * swapPhaseToggle READ swapPhaseToggle
      CONSTANT)
  QML_ELEMENT
  QML_UNCREATABLE ("")
 
  struct FaderProcessingCaches
  {
    dsp::ProcessorParameter *     amp_param_{};
    dsp::ProcessorParameter *     balance_param_{};
    dsp::ProcessorParameter *     mute_param_{};
    dsp::ProcessorParameter *     solo_param_{};
    dsp::ProcessorParameter *     listen_param_{};
    dsp::ProcessorParameter *     mono_compat_enabled_param_{};
    dsp::ProcessorParameter *     swap_phase_param_{};
    std::vector<dsp::AudioPort *> audio_ins_rt_;
    std::vector<dsp::AudioPort *> audio_outs_rt_;
    dsp::MidiPort *               midi_in_rt_{};
    dsp::MidiPort *               midi_out_rt_{};
  };
 
public:
  enum class MidiFaderMode : basic_enum_base_type_t
  {
    MIDI_FADER_MODE_VEL_MULTIPLIER,


    MIDI_FADER_MODE_CC_VOLUME,
  };
  Q_ENUM (MidiFaderMode)
 
public:
  using ShouldBeMutedCallback = std::function<bool (bool fader_solo_status)>;

  using MuteGainCallback = std::function<float ()>;

  using PreProcessAudioCallback = std::function<void (
    std::pair<std::span<float>, std::span<float>> stereo_bufs,
    const EngineProcessTimeInfo                  &time_nfo)>;

  Fader (
    dsp::ProcessorBase::ProcessorBaseDependencies      dependencies,
    dsp::PortType                                      signal_type,
    bool                                               hard_limit_output,
    bool                                               make_params_automatable,
    std::optional<std::function<utils::Utf8String ()>> owner_name_provider,
    ShouldBeMutedCallback                              should_be_muted_cb,
    QObject *                                          parent = nullptr);
 
  // ============================================================================
  // QML Interface
  // ============================================================================
 
  MidiFaderMode midiMode () const { return midi_mode_; }
  void          setMidiMode (MidiFaderMode mode)
  {
    if (midi_mode_ == mode)
      return;
 
    midi_mode_ = mode;
    Q_EMIT midiModeChanged (mode);
  }
  Q_SIGNAL void midiModeChanged (MidiFaderMode mode);
 
  zrythm::dsp::ProcessorParameter * gain () const
  {
    if (amp_id_.has_value ())
      {
        return &get_amp_param ();
      }
    return nullptr;
  }
  zrythm::dsp::ProcessorParameter * balance () const
  {
    if (balance_id_.has_value ())
      {
        return &get_balance_param ();
      }
    return nullptr;
  }
  zrythm::dsp::ProcessorParameter * mute () const
  {
    if (mute_id_.has_value ())
      {
        return &get_mute_param ();
      }
    return nullptr;
  }
  zrythm::dsp::ProcessorParameter * solo () const
  {
    if (solo_id_.has_value ())
      {
        return &get_solo_param ();
      }
    return nullptr;
  }
  zrythm::dsp::ProcessorParameter * listen () const
  {
    if (listen_id_.has_value ())
      {
        return &get_listen_param ();
      }
    return nullptr;
  }
  zrythm::dsp::ProcessorParameter * monoToggle () const
  {
    if (mono_compat_enabled_id_.has_value ())
      {
        return &get_mono_compat_enabled_param ();
      }
    return nullptr;
  }
  zrythm::dsp::ProcessorParameter * swapPhaseToggle () const
  {
    if (swap_phase_id_.has_value ())
      {
        return &get_swap_phase_param ();
      }
    return nullptr;
  }
 
  // ============================================================================

  /**
   * Returns if the fader is muted.
   */
  bool currently_muted () const
  {
    const auto &mute_param = get_mute_param ();
    return mute_param.range ().is_toggled (mute_param.currentValue ());
  }

  /**
   * Returns if the track is soloed.
   */
  [[gnu::hot]] bool currently_soloed () const
  {
    const auto &solo_param = get_solo_param ();
    return solo_param.range ().is_toggled (solo_param.currentValue ());
  }

  /**
   * Returns whether the fader is listened.
   */
  bool currently_listened () const
  {
    const auto &listened_param = get_listen_param ();
    return listened_param.range ().is_toggled (listened_param.currentValue ());
  }

  /**
   * Gets the fader amplitude (not db)
   */
  float get_current_amp () const
  {
    const auto &amp_param = get_amp_param ();
    return amp_param.range ().convertFrom0To1 (amp_param.currentValue ());
  }
 
  std::string db_string_getter () const;
 
  void set_mute_gain_callback (MuteGainCallback cb)
  {
    mute_gain_cb_ = std::move (cb);
  }
 
  void set_preprocess_audio_callback (PreProcessAudioCallback cb)
  {
    preprocess_audio_cb_ = std::move (cb);
  }
 
  // ============================================================================
  // ProcessorBase Interface
  // ============================================================================
 
  void custom_prepare_for_processing (
    const graph::GraphNode * node,
    units::sample_rate_t     sample_rate,
    nframes_t                max_block_length) override;
 
  void custom_release_resources () override;
 
  [[gnu::hot]] void custom_process_block (
    EngineProcessTimeInfo  time_nfo,
    const dsp::ITransport &transport,
    const dsp::TempoMap   &tempo_map) noexcept override;
 
  // ============================================================================
 
  bool is_audio () const { return signal_type_ == dsp::PortType::Audio; }
  bool is_midi () const { return signal_type_ == dsp::PortType::Midi; }
 
  bool hard_limiting_enabled () const { return hard_limit_output_; }
 
  friend void
  init_from (Fader &obj, const Fader &other, utils::ObjectCloneType clone_type);
 
  dsp::ProcessorParameter &get_amp_param () const
  {
    return *std::get<dsp::ProcessorParameter *> (
      dependencies ().param_registry_.find_by_id_or_throw (*amp_id_));
  }
  dsp::ProcessorParameter &get_balance_param () const
  {
    return *std::get<dsp::ProcessorParameter *> (
      dependencies ().param_registry_.find_by_id_or_throw (*balance_id_));
  }
  dsp::ProcessorParameter &get_mute_param () const
  {
    return *std::get<dsp::ProcessorParameter *> (
      dependencies ().param_registry_.find_by_id_or_throw (*mute_id_));
  }
  dsp::ProcessorParameter &get_solo_param () const
  {
    return *std::get<dsp::ProcessorParameter *> (
      dependencies ().param_registry_.find_by_id_or_throw (*solo_id_));
  }
  dsp::ProcessorParameter &get_listen_param () const
  {
    return *std::get<dsp::ProcessorParameter *> (
      dependencies ().param_registry_.find_by_id_or_throw (*listen_id_));
  }
  dsp::ProcessorParameter &get_mono_compat_enabled_param () const
  {
    return *std::get<dsp::ProcessorParameter *> (
      dependencies ().param_registry_.find_by_id_or_throw (
        *mono_compat_enabled_id_));
  }
  dsp::ProcessorParameter &get_swap_phase_param () const
  {
    return *std::get<dsp::ProcessorParameter *> (
      dependencies ().param_registry_.find_by_id_or_throw (*swap_phase_id_));
  }
  dsp::AudioPort &get_stereo_in_port () const
  {
    if (!is_audio ())
      {
        throw std::runtime_error ("Not an audio fader");
      }
    return *get_input_ports ().at (0).get_object_as<dsp::AudioPort> ();
  }
  dsp::AudioPort &get_stereo_out_port () const
  {
    if (!is_audio ())
      {
        throw std::runtime_error ("Not an audio fader");
      }
    return *get_output_ports ().at (0).get_object_as<dsp::AudioPort> ();
  }
  dsp::MidiPort &get_midi_in_port () const
  {
    return *get_input_ports ().front ().get_object_as<dsp::MidiPort> ();
  }
  dsp::MidiPort &get_midi_out_port () const
  {
    return *get_output_ports ().front ().get_object_as<dsp::MidiPort> ();
  }
 
  auto currently_soloed_rt () const noexcept [[clang::nonblocking]]
  {
    return processing_caches_->solo_param_->range ().is_toggled (
      processing_caches_->solo_param_->currentValue ());
  };
 
  bool currently_listened_rt () const noexcept [[clang::nonblocking]]
  {
    const auto &listened_param = processing_caches_->listen_param_;
    return listened_param->range ().is_toggled (listened_param->currentValue ());
  }
 
private:
  static constexpr auto kMidiModeKey = "midiMode"sv;
  friend void           to_json (nlohmann::json &j, const Fader &fader);
  friend void           from_json (const nlohmann::json &j, Fader &fader);

  void init_param_caches ();

  float calculate_target_gain_rt () const;
 
  bool effectively_muted () const
  {
    return currently_muted () || should_be_muted_cb_ (currently_soloed ());
  }
 
  bool effectively_muted_rt () const
  {
    const auto currently_muted_rt = [this] () {
      return processing_caches_->mute_param_->range ().is_toggled (
        processing_caches_->mute_param_->currentValue ());
    };
 
    return currently_muted_rt () || should_be_muted_cb_ (currently_soloed_rt ());
  }
 
private:
  dsp::PortType signal_type_;
 
  bool hard_limit_output_{};

  float last_cc_volume_ = 0.f;

  std::optional<dsp::ProcessorParameter::Uuid> amp_id_;

  std::optional<dsp::ProcessorParameter::Uuid> balance_id_;

  std::optional<dsp::ProcessorParameter::Uuid> mute_id_;

  std::optional<dsp::ProcessorParameter::Uuid> solo_id_;

  std::optional<dsp::ProcessorParameter::Uuid> listen_id_;

  std::optional<dsp::ProcessorParameter::Uuid> mono_compat_enabled_id_;

  std::optional<dsp::ProcessorParameter::Uuid> swap_phase_id_;

  MidiFaderMode midi_mode_{ MidiFaderMode::MIDI_FADER_MODE_VEL_MULTIPLIER };

  juce::SmoothedValue<float> current_gain_{ 0.f };
 
  ShouldBeMutedCallback should_be_muted_cb_;
 
  std::optional<PreProcessAudioCallback> preprocess_audio_cb_;
 
  MuteGainCallback mute_gain_cb_ = [] () { return 0.f; };
 
  // Processor caches
  std::unique_ptr<FaderProcessingCaches> processing_caches_;
};
}