graph_node.h

// SPDX-FileCopyrightText: © 2019-2021, 2024-2025 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
/*
 * This file incorporates work covered by the following copyright and
 * permission notice:
 *
 * ---
 *
 * Copyright (C) 2017, 2019 Robin Gareus <robin@gareus.org>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 *
 * SPDX-License-Identifier: GPL-2.0-or-later
 *
 * ---
 */
 
#pragma once
 
#include "dsp/itransport.h"
#include "dsp/tempo_map.h"
#include "utils/units.h"
 
#include <QObject>
 
namespace zrythm::utils
{
class Utf8String;
}
 
namespace zrythm::dsp::graph
{
class GraphNode;

struct ProcessBlockInfo
{
public:
  void print () const;
 
  static constexpr ProcessBlockInfo from_position_and_nframes (
    units::sample_u64_t transport_position,
    units::sample_u32_t nframes)
  {
    return {
      .transport_position_ = transport_position,
      .buffer_offset_ = units::samples (0),
      .nframes_ = nframes
    };
  }
 
  [[gnu::hot]] constexpr units::sample_u64_t end_position () const noexcept
  {
    return transport_position_ + nframes_;
  }
 
public:
  units::sample_u64_t transport_position_;

  units::sample_u32_t buffer_offset_;

  units::sample_u32_t nframes_;
};

class IProcessable
{
public:
  virtual ~IProcessable () { release_resources (); }

  virtual utils::Utf8String get_node_name () const = 0;

  [[gnu::hot]] virtual units::sample_u32_t get_single_playback_latency () const
  {
    return units::samples (0);
  }

  void prepare_for_processing (
    const GraphNode *    node,
    units::sample_rate_t sample_rate,
    units::sample_u32_t  max_block_length);
 
protected:
  virtual void prepare_for_processing_impl (
    const GraphNode *    node,
    units::sample_rate_t sample_rate,
    units::sample_u32_t  max_block_length)
  {
  }
 
public:
  [[gnu::hot]] virtual void process_block (
    dsp::graph::ProcessBlockInfo time_nfo,
    const dsp::ITransport       &transport,
    const dsp::TempoMap         &tempo_map) noexcept [[clang::nonblocking]] { };

  virtual void release_resources () { }
};
 
class InitialProcessor final : public QObject, public IProcessable
{
  Q_OBJECT
 
public:
  utils::Utf8String get_node_name () const override;
};

class GraphNode
{
public:
  using NodeId = int;
 
  GraphNode (NodeId id, IProcessable &processable);
  GraphNode (const GraphNode &) = delete;
  GraphNode &operator= (const GraphNode &) = delete;
  GraphNode (GraphNode &&) = delete;
  GraphNode &operator= (GraphNode &&) = delete;
  ~GraphNode () noexcept = default;

  std::string print_node_to_str () const;
 
  // For debugging purposes.
  NodeId get_id () const { return node_id_; }

  [[gnu::hot]] void process (
    dsp::graph::ProcessBlockInfo time_nfo,
    units::sample_u64_t          remaining_preroll_frames,
    const dsp::ITransport       &transport,
    const dsp::TempoMap         &tempo_map) const;
 
  units::sample_u32_t get_single_playback_latency () const
  {
    return processable_.get_single_playback_latency ();
  }

  void set_route_playback_latency (units::sample_u32_t dest_latency);
 
  void connect_to (GraphNode &target);

  void set_skip_processing (bool skip) { bypass_ = skip; }
 
  IProcessable       &get_processable () { return processable_; }
  const IProcessable &get_processable () const { return processable_; }

  auto &feeds () const { return childnodes_; }

  auto &depends () const { return parentnodes_; }
 
  bool remove_feed (const GraphNode &feed);
  bool remove_depend (const GraphNode &depend);
 
private:
  void add_feeds (GraphNode &dest);
  void add_depends (GraphNode &src);

  [[gnu::hot]] void compensate_latency (
    dsp::graph::ProcessBlockInfo &time_nfo,
    units::sample_u32_t           remaining_preroll_frames,
    const dsp::ITransport        &transport,
    const dsp::TempoMap          &tempo_map) const;

  [[gnu::hot]] void process_chunks_after_splitting_at_loop_points (
    dsp::graph::ProcessBlockInfo &time_nfo,
    const dsp::ITransport        &transport,
    const dsp::TempoMap          &tempo_map) const;
 
public:
  std::atomic<int> refcount_ = 0;

  units::sample_u32_t playback_latency_;
 
  // TODO
  units::sample_u32_t capture_latency_;

  int init_refcount_{};

  units::sample_u32_t route_playback_latency_;
 
  /* For debugging. These are set by
   * GraphNodeCollection.set_initial_and_terminal_nodes(). */
  bool terminal_{ false };
  bool initial_{ false };
 
private:
  NodeId node_id_ = 0;

  std::vector<std::reference_wrapper<GraphNode>> parentnodes_;

  std::vector<std::reference_wrapper<GraphNode>> childnodes_;
 
  IProcessable &processable_;

  bool bypass_ = false;
};

class GraphNodeCollection
{
public:
  units::sample_u32_t get_max_route_playback_latency () const;

  void update_latencies ();

  void set_initial_and_terminal_nodes ();

  void finalize_nodes () { set_initial_and_terminal_nodes (); }
 
  GraphNode * find_node_for_processable (const IProcessable &processable) const;
 
public:
  std::vector<std::unique_ptr<GraphNode>> graph_nodes_;

  std::vector<std::reference_wrapper<GraphNode>> trigger_nodes_;

  std::vector<std::reference_wrapper<GraphNode>> terminal_nodes_;
 
  std::unique_ptr<InitialProcessor> initial_processor_;
};
 
} // namespace zrythm::dsp::graph