sample_processor.h

// SPDX-FileCopyrightText: © 2019-2025 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#pragma once
 
#include "dsp/fader.h"
#include "dsp/graph.h"
#include "dsp/midi_event.h"
#include "gui/dsp/sample_playback.h"
#include "structure/tracks/tracklist.h"
#include "utils/types.h"
 
#include <moodycamel/lightweightsemaphore.h>
 
class FileDescriptor;
class ChordPreset;
 
namespace zrythm::engine::device_io
{
class AudioEngine;
};
 
#define SAMPLE_PROCESSOR (AUDIO_ENGINE->sample_processor_)
 
namespace zrythm::engine::session
{
class SampleProcessor final : public QObject, public dsp::graph::IProcessable
{
  Q_OBJECT
public:
  using PluginConfiguration = zrythm::plugins::PluginConfiguration;
 
public:
  SampleProcessor () = default;
  SampleProcessor (engine::device_io::AudioEngine * engine);
  Z_DISABLE_COPY_MOVE (SampleProcessor)
  ~SampleProcessor () override;
 
  friend void init_from (
    SampleProcessor       &obj,
    const SampleProcessor &other,
    utils::ObjectCloneType clone_type);
 
  void init_loaded (engine::device_io::AudioEngine * engine);

  void load_instrument_if_empty ();

  void process_block (
    EngineProcessTimeInfo  time_nfo,
    const dsp::ITransport &transport,
    const dsp::TempoMap   &tempo_map) noexcept override;
 
  utils::Utf8String get_node_name () const override
  {
    return u8"Sample Processor";
  }
 
  nframes_t get_single_playback_latency () const override { return 0; }

  void remove_sample_playback (SamplePlayback &sp);

  void queue_sample_from_file (const char * path);

  void queue_file (const FileDescriptor &file);

  void queue_chord_preset (const ChordPreset &chord_pset);

  void stop_file_playback ();
 
private:
  static constexpr auto kFaderKey = "fader"sv;
  friend void           to_json (nlohmann::json &j, const SampleProcessor &sp)
  {
    j[kFaderKey] = sp.fader_;
  }
  friend void from_json (const nlohmann::json &j, SampleProcessor &sp)
  {
    // TODO
    // j.at (kFaderKey).get_to (sp.fader_);
  }
 
  void init_common ();
 
  void queue_file_or_chord_preset (
    const FileDescriptor * file,
    const ChordPreset *    chord_pset);
 
public:
  std::vector<SamplePlayback> current_samples_;

  std::unique_ptr<structure::tracks::Tracklist> tracklist_;

  std::unique_ptr<zrythm::plugins::PluginConfiguration> instrument_setting_;
 
  std::unique_ptr<dsp::MidiEvents> midi_events_;

  std::unique_ptr<dsp::Fader> fader_;

  // Position playhead_;

  // Position file_end_pos_;

  bool roll_ = false;

  engine::device_io::AudioEngine * audio_engine_ = nullptr;

  moodycamel::LightweightSemaphore rebuilding_sem_{ 1 };
};
 
}