include/opendaw/core/AudioGraph.h - develop - reds/OpenDAW

include/opendaw/core/AudioGraph.h
236 строк6 KB
OpenDAW Developer
feat(v1.0.0-phase1): Add AudioGraph foundation
21 фев 2026, 08:49
21 фев 2026, 08:492a0b0b6
#pragma once

#include <opendaw/audio/AudioBuffer.h>
#include <opendaw/midi/MidiBuffer.h>
#include <opendaw/plugin/Plugin.h>
#include <vector>
#include <memory>
#include <string>

namespace opendaw {

/**
 * @brief Тип дорожки
 */
enum class TrackType {
    Audio,      ///< Аудио дорожка
    Midi,       ///< MIDI дорожка
    Bus,        ///< Шина (группа)
    Master      ///< Мастер шина
};

/**
 * @brief Базовый класс узла в аудио-графе
 */
class AudioNode {
public:
    virtual ~AudioNode() = default;
    
    /**
     * @brief Подготовка к обработке
     */
    virtual void prepare(double sampleRate, int blockSize) = 0;
    
    /**
     * @brief Обработка аудио
     */
    virtual void process(AudioBuffer<float>& audio, MidiBuffer& midi) = 0;
    
    /**
     * @brief Сброс состояния
     */
    virtual void reset() = 0;
    
    /**
     * @brief Название узла
     */
    virtual std::string getName() const = 0;
    
    /**
     * @brief Количество входов
     */
    virtual int getNumInputs() const { return 2; }
    
    /**
     * @brief Количество выходов
     */
    virtual int getNumOutputs() const { return 2; }
    
    /**
     * @brief Задержка в сэмплах
     */
    virtual int getLatencySamples() const { return 0; }
    
    /**
     * @brief Узел активен?
     */
    virtual bool isActive() const { return active_; }
    
    /**
     * @brief Установить активность
     */
    void setActive(bool active) { active_ = active; }
    
protected:
    bool active_{true};
    double sampleRate_{48000.0};
    int blockSize_{512};
};

/**
 * @brief Дорожка (Track) в аудио-графе
 */
class Track : public AudioNode {
public:
    Track(const std::string& name, TrackType type);
    ~Track() override = default;
    
    // AudioNode interface
    void prepare(double sampleRate, int blockSize) override;
    void process(AudioBuffer<float>& audio, MidiBuffer& midi) override;
    void reset() override;
    std::string getName() const override { return name_; }
    
    /**
     * @brief Добавить плагин на дорожку
     */
    void addPlugin(std::unique_ptr<Plugin> plugin);
    
    /**
     * @brief Удалить плагин по индексу
     */
    void removePlugin(int index);
    
    /**
     * @brief Количество плагинов
     */
    int getNumPlugins() const { return static_cast<int>(plugins_.size()); }
    
    /**
     * @brief Получить плагин по индексу
     */
    Plugin* getPlugin(int index);
    
    /**
     * @brief Тип дорожки
     */
    TrackType getType() const { return type_; }
    
    /**
     * @brief Установить громкость (0-1)
     */
    void setVolume(float volume) { volume_ = volume; }
    float getVolume() const { return volume_; }
    
    /**
     * @brief Установить панораму (-1 to 1)
     */
    void setPan(float pan) { pan_ = pan; }
    float getPan() const { return pan_; }
    
    /**
     * @brief Mute
     */
    void setMuted(bool muted) { muted_ = muted; }
    bool isMuted() const { return muted_; }
    
    /**
     * @brief Solo
     */
    void setSolo(bool solo) { solo_ = solo; }
    bool isSolo() const { return solo_; }
    
private:
    std::string name_;
    TrackType type_;
    std::vector<std::unique_ptr<Plugin>> plugins_;
    
    float volume_{1.0f};
    float pan_{0.0f};
    bool muted_{false};
    bool solo_{false};
    
    AudioBuffer<float> tempBuffer_;
};

/**
 * @brief Аудио-граф (сигнальный поток)
 * 
 * Обрабатывает дорожки в правильном порядке:
 * 1. MIDI дорожки (генерируют аудио)
 * 2. Audio дорожки (обрабатывают аудио)
 * 3. Bus дорожки (группируют)
 * 4. Master (финальная обработка)
 */
class AudioGraph {
public:
    AudioGraph();
    ~AudioGraph() = default;
    
    /**
     * @brief Подготовка к обработке
     */
    void prepare(double sampleRate, int blockSize);
    
    /**
     * @brief Обработка всего графа
     */
    void process(AudioBuffer<float>& audio, MidiBuffer& midi);
    
    /**
     * @brief Сброс всех узлов
     */
    void reset();
    
    /**
     * @brief Добавить дорожку
     */
    Track* addTrack(const std::string& name, TrackType type);
    
    /**
     * @brief Удалить дорожку по индексу
     */
    void removeTrack(int index);
    
    /**
     * @brief Получить дорожку по индексу
     */
    Track* getTrack(int index);
    const Track* getTrack(int index) const;
    
    /**
     * @brief Количество дорожек
     */
    int getNumTracks() const { return static_cast<int>(tracks_.size()); }
    
    /**
     * @brief Получить мастер дорожку
     */
    Track* getMaster() { return master_.get(); }
    
    /**
     * @brief Общая задержка графа
     */
    int getTotalLatencySamples() const;
    
    /**
     * @brief Частота дискретизации
     */
    double getSampleRate() const { return sampleRate_; }
    
    /**
     * @brief Размер буфера
     */
    int getBlockSize() const { return blockSize_; }
    
private:
    std::vector<std::unique_ptr<Track>> tracks_;
    std::unique_ptr<Track> master_;
    
    double sampleRate_{48000.0};
    int blockSize_{512};
    
    AudioBuffer<float> outputBuffer_;
};

} // namespace opendaw