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/utf8_string.h"
 
#include <QObject>
 
namespace zrythm::dsp::graph
{
class GraphNode;

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

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

  [[gnu::hot]] virtual nframes_t get_single_playback_latency () const
  {
    return 0;
  }

  virtual void prepare_for_processing (
    const GraphNode *    node,
    units::sample_rate_t sample_rate,
    nframes_t            max_block_length)
  {
  }
 
  [[gnu::hot]] virtual void process_block (
    EngineProcessTimeInfo  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
  {
    return u8"Initial Processor";
  }
};

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

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

  [[gnu::hot]] void process (
    EngineProcessTimeInfo  time_nfo,
    nframes_t              remaining_preroll_frames,
    const dsp::ITransport &transport,
    const dsp::TempoMap   &tempo_map) const;
 
  nframes_t get_single_playback_latency () const
  {
    return processable_.get_single_playback_latency ();
  }

  void set_route_playback_latency (nframes_t dest_latency);
 
  void connect_to (GraphNode &target);

  void set_skip_processing (bool skip) { bypass_ = skip; }
 
  IProcessable &get_processable () { 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 (
    EngineProcessTimeInfo &time_nfo,
    nframes_t              remaining_preroll_frames,
    const dsp::ITransport &transport,
    const dsp::TempoMap   &tempo_map) const;

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

  nframes_t playback_latency_ = 0;
 
  // TODO
  nframes_t capture_latency_ = 0;

  int init_refcount_ = 0;

  nframes_t route_playback_latency_ = 0;
 
  /* 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:
  nframes_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