hardware_processor.h

// SPDX-FileCopyrightText: © 2020-2022, 2024-2025 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#pragma once
 
#include "engine/device_io/ext_port.h"
#include "gui/dsp/audio_port.h"
#include "gui/dsp/midi_port.h"
#include "utils/icloneable.h"
 
#define HW_IN_PROCESSOR (AUDIO_ENGINE->hw_in_processor_)
#define HW_OUT_PROCESSOR (AUDIO_ENGINE->hw_out_processor_)
 
namespace zrythm::engine::device_io
{
class HardwareProcessor final
    : public ICloneable<HardwareProcessor>,
      public dsp::graph::IProcessable
{
public:
  using PortFlow = zrythm::dsp::PortFlow;
 
public:
  // Rule of 0
  HardwareProcessor () = default;
 
  HardwareProcessor (bool input, AudioEngine * engine);
 
  void init_loaded (AudioEngine * engine);
 
  bool is_in_active_project () const;

  void rescan_ext_ports ();

  ExtPort * find_ext_port (const utils::Utf8String &id);

  template <typename T = Port> T * find_port (const utils::Utf8String &id);

  void setup ();

  void activate (bool activate);

  void process (nframes_t nframes);
 
  utils::Utf8String get_node_name () const override;

  void
  init_after_cloning (const HardwareProcessor &other, ObjectCloneType clone_type)
    override;
 
private:
  static constexpr auto kIsInputKey = "isInput"sv;
  static constexpr auto kExtAudioPortsKey = "extAudioPorts"sv;
  static constexpr auto kExtMidiPortsKey = "extMidiPorts"sv;
  static constexpr auto kAudioPortsKey = "audioPorts"sv;
  static constexpr auto kMidiPortsKey = "midiPorts"sv;
  friend void           to_json (nlohmann::json &j, const HardwareProcessor &p)
  {
    j = nlohmann::json{
      { kIsInputKey,       p.is_input_        },
      { kExtAudioPortsKey, p.ext_audio_ports_ },
      { kExtMidiPortsKey,  p.ext_midi_ports_  },
      { kAudioPortsKey,    p.audio_ports_     },
      { kMidiPortsKey,     p.midi_ports_      },
    };
  }
  friend void from_json (const nlohmann::json &j, HardwareProcessor &p);
 
  template <typename T>
  std::unique_ptr<T>
  create_port_for_ext_port (const ExtPort &ext_port, PortFlow flow);
 
public:
  bool is_input_ = false;

  std::vector<utils::Utf8String> selected_midi_ports_;
  std::vector<utils::Utf8String> selected_audio_ports_;

  std::vector<std::unique_ptr<ExtPort>> ext_audio_ports_;
  std::vector<std::unique_ptr<ExtPort>> ext_midi_ports_;

  std::vector<std::unique_ptr<AudioPort>> audio_ports_;
  std::vector<std::unique_ptr<MidiPort>>  midi_ports_;

  bool setup_ = false;

  bool activated_ = false;
 
  quint64 rescan_timeout_id_ = 0;

  AudioEngine * engine_ = nullptr;
};
 
extern template std::unique_ptr<MidiPort>
HardwareProcessor::create_port_for_ext_port (const ExtPort &, PortFlow);
extern template std::unique_ptr<AudioPort>
HardwareProcessor::create_port_for_ext_port (const ExtPort &, PortFlow);
extern template Port *
HardwareProcessor::find_port (const utils::Utf8String &);
}