track_processor.h

// SPDX-FileCopyrightText: © 2019-2026 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#pragma once
 
#include <memory>
 
#include "dsp/port.h"
#include "dsp/processor_base.h"
#include "utils/icloneable.h"
 
namespace zrythm::structure::arrangement
{
class MidiTimelineDataProvider;
class AudioTimelineDataProvider;
}
 
namespace zrythm::structure::tracks
{
class ClipPlaybackDataProvider;

class TrackProcessor final : public QObject, public dsp::ProcessorBase
{
  Q_OBJECT
  QML_ELEMENT
  QML_UNCREATABLE ("")
  Q_DISABLE_COPY_MOVE (TrackProcessor)
 
public:
  using StereoPortPair = std::pair<std::span<float>, std::span<float>>;
  using ConstStereoPortPair =
    std::pair<std::span<const float>, std::span<const float>>;
  static constexpr auto midi_in_symbol =
    std::string_view ("track_processor_midi_in");

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

  using RecordingCallbackRT = std::function<void (
    units::sample_t                                timeline_position,
    const dsp::ITransport                         &transport,
    std::optional<std::span<const dsp::MidiEvent>> midi_events,
    std::optional<ConstStereoPortPair>             stereo_ports,
    units::sample_u32_t                            nframes)>;

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

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

  using EnabledProvider = std::function<bool ()>;
 
  using TrackNameProvider = std::function<utils::Utf8String ()>;
 
  enum class Capabilities : uint8_t
  {
    PianoRoll = 1 << 0,
    AudioTrack = 1 << 1,
    Recording = 1 << 2,
  };
 
  enum class MonitorMode : uint8_t
  {
    Off,
    On,
    Auto,
  };
 
  using MidiEventProviderProcessFunc = std::function<void (
    const dsp::graph::ProcessBlockInfo &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,
    dsp::PortType                          signal_type,
    TrackNameProvider                      track_name_provider,
    EnabledProvider                        enabled_provider,
    Capabilities                           capabilities,
    utils::IObjectRegistry                &registry,
    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,
    RecordingCallbackRT recording_cb =
      [] (
        units::sample_t,
        const dsp::ITransport &,
        std::optional<std::span<const dsp::MidiEvent>>,
        std::optional<ConstStereoPortPair>,
        units::sample_u32_t) { },
    QObject * parent = nullptr);
  ~TrackProcessor () override;
 
  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 (
    dsp::graph::ProcessBlockInfo 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,
    units::sample_u32_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;
  dsp::ProcessorParameter &get_input_gain_param () const;
  dsp::ProcessorParameter &get_output_gain_param () const;
  dsp::ProcessorParameter &get_monitor_audio_param () const;
  dsp::ProcessorParameter &get_recording_param () const;
 
  bool is_recording_armed () const;
  bool is_recording_armed_rt () const noexcept [[clang::nonblocking]];
  void set_recording_armed (bool armed);

  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;

  dsp::MidiPort &get_hw_midi_in_port () const;
 
  arrangement::AudioTimelineDataProvider &timeline_audio_data_provider ();
  arrangement::MidiTimelineDataProvider  &timeline_midi_data_provider ();
 
  ClipPlaybackDataProvider &clip_playback_data_provider ();

  void set_hw_midi_channel (int channel);

  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 dsp::graph::ProcessBlockInfo &time_nfo,
    const dsp::ITransport              &transport,
    dsp::MidiEventVector               &midi_events);

  void fill_audio_events (
    const dsp::graph::ProcessBlockInfo &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 set_param_id_caches ();
 
private:
  const bool         is_midi_;
  const bool         is_audio_;
  const Capabilities capabilities_;
 
  const EnabledProvider   enabled_provider_;
  const TrackNameProvider track_name_provider_;
 
  struct Impl;
  std::unique_ptr<Impl> impl_;
};
}
 
ENUM_ENABLE_BITSET (
  zrythm::structure::tracks::TrackProcessor::ActiveMidiEventProviders);
ENUM_ENABLE_BITSET (zrythm::structure::tracks::TrackProcessor::Capabilities);