track_processor.h

// SPDX-FileCopyrightText: © 2019-2026 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#pragma once
 
#include "dsp/port.h"
#include "dsp/processor_base.h"
#include "structure/arrangement/arranger_object_all.h"
#include "structure/arrangement/timeline_data_provider.h"
#include "structure/tracks/clip_playback_data_provider.h"
#include "utils/icloneable.h"
#include "utils/mpmc_queue.h"
#include "utils/types.h"
 
#include <farbot/RealtimeObject.hpp>
 
namespace zrythm::structure::tracks
{
class TrackProcessor final : public QObject, public dsp::ProcessorBase
{
  Q_OBJECT
  QML_ELEMENT
  QML_UNCREATABLE ("")
 
  using PortType = dsp::PortType;
  using PortFlow = dsp::PortFlow;
 
  struct TrackProcessorProcessingCaches
  {
    std::vector<dsp::AudioPort *> audio_ins_rt_;
    std::vector<dsp::AudioPort *> audio_outs_rt_;
    dsp::MidiPort *               midi_in_rt_{};
    dsp::MidiPort *               midi_out_rt_{};
    dsp::MidiPort *               piano_roll_rt_{};
    dsp::ProcessorParameter *     mono_param_{};
    dsp::ProcessorParameter *     input_gain_{};
    dsp::ProcessorParameter *     output_gain_{};
    dsp::ProcessorParameter *     monitor_audio_{};
  };
 
public:
  using StereoPortPair = std::pair<std::span<float>, std::span<float>>;
  using ConstStereoPortPair =
    std::pair<std::span<const float>, std::span<const float>>;

  using FillEventsCallback = std::function<void (
    const dsp::ITransport        &transport,
    const EngineProcessTimeInfo  &time_nfo,
    dsp::MidiEventVector *        midi_events,
    std::optional<StereoPortPair> stereo_ports)>;

  using HandleRecordingCallback = std::function<void (
    const EngineProcessTimeInfo       &time_nfo,
    const dsp::MidiEventVector *       midi_events,
    std::optional<ConstStereoPortPair> stereo_ports)>;

  using AppendMidiInputsToOutputsFunc = std::function<void (
    dsp::MidiEventVector        &out_events,
    const dsp::MidiEventVector  &in_events,
    const EngineProcessTimeInfo &time_nfo)>;

  using TransformMidiInputsFunc = std::function<void (dsp::MidiEventVector &)>;

  using EnabledProvider = std::function<bool ()>;
 
  using TrackNameProvider = std::function<utils::Utf8String ()>;
 
  using MidiEventProviderProcessFunc = std::function<void (
    const EngineProcessTimeInfo &time_nfo,
    dsp::MidiEventVector        &output_buffer)>;
 
  enum class ActiveMidiEventProviders : uint8_t
  {
    Timeline = 1 << 0,
    ClipLauncher = 1 << 1,
    PianoRoll = 1 << 2,
    Recording = 1 << 3,
    Custom = 1 << 4,
  };
 
  enum class ActiveAudioProviders : uint8_t
  {
    Timeline = 1 << 0,
    ClipLauncher = 1 << 1,
    Recording = 1 << 2,
    Custom = 1 << 3,
  };

  TrackProcessor (
    const dsp::TempoMap                   &tempo_map,
    PortType                               signal_type,
    TrackNameProvider                      track_name_provider,
    EnabledProvider                        enabled_provider,
    bool                                   generates_midi_events,
    bool                                   has_midi_cc,
    bool                                   is_audio_track,
    ProcessorBaseDependencies              dependencies,
    std::optional<FillEventsCallback>      fill_events_cb = std::nullopt,
    std::optional<TransformMidiInputsFunc> transform_midi_inputs_func =
      std::nullopt,
    std::optional<AppendMidiInputsToOutputsFunc>
              append_midi_inputs_to_outputs_func = std::nullopt,
    QObject * parent = nullptr);
 
  // note: this should eventually be passed from the constructor
  void set_handle_recording_callback (HandleRecordingCallback handle_rec_cb)
  {
    handle_recording_cb_ = std::move (handle_rec_cb);
  }
 
  bool is_audio () const { return is_audio_; }
 
  constexpr bool is_midi () const { return is_midi_; }
 
  utils::Utf8String get_full_designation_for_port (const dsp::Port &port) const;
 
  // ============================================================================
  // ProcessorBase Interface
  // ============================================================================

  void custom_process_block (
    EngineProcessTimeInfo  time_nfo,
    const dsp::ITransport &transport,
    const dsp::TempoMap   &tempo_map) noexcept override;
 
  void custom_prepare_for_processing (
    const dsp::graph::GraphNode * node,
    units::sample_rate_t          sample_rate,
    nframes_t                     max_block_length) override;
 
  void custom_release_resources () override;
 
  // ============================================================================
 
  dsp::AudioPort &get_stereo_in_port () const
  {
    assert (is_audio ());
    return *get_input_ports ().front ().get_object_as<dsp::AudioPort> ();
  }
  dsp::AudioPort &get_stereo_out_port () const
  {
    assert (is_audio ());
    return *get_output_ports ().front ().get_object_as<dsp::AudioPort> ();
  }
 
  dsp::ProcessorParameter &get_mono_param () const
  {
    return *std::get<dsp::ProcessorParameter *> (
      dependencies ().param_registry_.find_by_id_or_throw (*mono_id_));
  }
  dsp::ProcessorParameter &get_input_gain_param () const
  {
    return *std::get<dsp::ProcessorParameter *> (
      dependencies ().param_registry_.find_by_id_or_throw (*input_gain_id_));
  }
  dsp::ProcessorParameter &get_output_gain_param () const
  {
    return *std::get<dsp::ProcessorParameter *> (
      dependencies ().param_registry_.find_by_id_or_throw (*output_gain_id_));
  }
  dsp::ProcessorParameter &get_monitor_audio_param () const
  {
    return *std::get<dsp::ProcessorParameter *> (
      dependencies ().param_registry_.find_by_id_or_throw (*monitor_audio_id_));
  }

  dsp::ProcessorParameter &
  get_midi_cc_param (midi_byte_t channel, midi_byte_t control_no)
  {
    assert (has_midi_cc_);
    return *std::get<dsp::ProcessorParameter *> (
      dependencies ().param_registry_.find_by_id_or_throw (
        midi_cc_caches_->midi_cc_ids_.at ((channel * 128) + control_no)));
  }

  dsp::MidiPort &get_midi_in_port () const
  {
    assert (is_midi ());
    return *get_input_ports ().front ().get_object_as<dsp::MidiPort> ();
  }

  dsp::MidiPort &get_midi_out_port () const
  {
    assert (is_midi ());
    return *get_output_ports ().front ().get_object_as<dsp::MidiPort> ();
  }

  dsp::MidiPort &get_piano_roll_port () const
  {
    return *get_input_ports ().at (1).get_object_as<dsp::MidiPort> ();
  }
 
  auto &timeline_audio_data_provider ()
  {
    return *timeline_audio_data_provider_;
  }
  auto &timeline_midi_data_provider () { return *timeline_midi_data_provider_; }
 
  auto &clip_playback_data_provider () { return *clip_playback_data_provider_; }

  void set_midi_providers_active (
    ActiveMidiEventProviders event_providers,
    bool                     active);

  void
  set_audio_providers_active (ActiveAudioProviders audio_providers, bool active);

  void
  set_custom_midi_event_provider (MidiEventProviderProcessFunc process_func);

  void fill_midi_events (
    const EngineProcessTimeInfo &time_nfo,
    const dsp::ITransport       &transport,
    dsp::MidiEventVector        &midi_events);

  void fill_audio_events (
    const EngineProcessTimeInfo &time_nfo,
    const dsp::ITransport       &transport,
    StereoPortPair               stereo_ports);
 
private:
  friend void to_json (nlohmann::json &j, const TrackProcessor &tp);
  friend void from_json (const nlohmann::json &j, TrackProcessor &tp);
 
  friend void init_from (
    TrackProcessor        &obj,
    const TrackProcessor  &other,
    utils::ObjectCloneType clone_type);

  void handle_recording (
    const EngineProcessTimeInfo &time_nfo,
    const dsp::ITransport       &transport);

  [[gnu::hot]] void add_events_from_midi_cc_control_ports (
    dsp::MidiEventVector &events,
    nframes_t             local_offset);

  void set_param_id_caches ();
 
// TODO
#if 0
  void set_midi_mappings ();
#endif
 
private:
  const bool is_midi_;
  const bool is_audio_;
  const bool has_piano_roll_port_;
  const bool has_midi_cc_;
 
  const EnabledProvider   enabled_provider_;
  const TrackNameProvider track_name_provider_;
 
  std::optional<FillEventsCallback>      fill_events_cb_;
  std::optional<HandleRecordingCallback> handle_recording_cb_;
  AppendMidiInputsToOutputsFunc          append_midi_inputs_to_outputs_func_;
  std::optional<TransformMidiInputsFunc> transform_midi_inputs_func_;

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

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

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

  std::optional<dsp::ProcessorParameter::Uuid> monitor_audio_id_;
 
#if 0
  std::unique_ptr<engine::session::MidiMappings> cc_mappings_;
#endif

  struct MidiCcCaches
  {
    std::array<dsp::ProcessorParameter::Uuid, 16_zu * 128> midi_cc_ids_;
 
    using SixteenPortUuidArray = std::array<dsp::ProcessorParameter::Uuid, 16>;

    SixteenPortUuidArray pitch_bend_ids_;

    SixteenPortUuidArray poly_key_pressure_ids_;

    SixteenPortUuidArray channel_pressure_ids_;

    MPMCQueue<dsp::ProcessorParameter *> updated_midi_automatable_ports_;
  };
 
  std::unique_ptr<MidiCcCaches> midi_cc_caches_;
 
  // Processing caches
  std::unique_ptr<TrackProcessorProcessingCaches> processing_caches_;

  std::unique_ptr<arrangement::MidiTimelineDataProvider>
    timeline_midi_data_provider_;

  std::unique_ptr<arrangement::AudioTimelineDataProvider>
    timeline_audio_data_provider_;
 
  std::unique_ptr<ClipPlaybackDataProvider> clip_playback_data_provider_;
 
  // TODO: piano roll, recording data providers
 
  farbot::RealtimeObject<
    std::optional<MidiEventProviderProcessFunc>,
    farbot::RealtimeObjectOptions::nonRealtimeMutatable>
    custom_midi_event_provider_;
 
  std::atomic<ActiveMidiEventProviders> active_midi_event_providers_;
  std::atomic<ActiveAudioProviders>     active_audio_providers_;
 
  static_assert (decltype (active_midi_event_providers_)::is_always_lock_free);
};
}
 
ENUM_ENABLE_BITSET (
  zrythm::structure::tracks::TrackProcessor::ActiveMidiEventProviders);