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

include/opendaw/core/AudioEngine.h
150 строк4 KB
OpenDAW Developer
feat(v0.4.0): Add Audio Device Backend (ALSA)
21 фев 2026, 02:32
21 фев 2026, 02:328473a58
#pragma once

#include <opendaw/audio/AudioBuffer.h>
#include <opendaw/midi/MidiBuffer.h>
#include <opendaw/audio/AudioProcessor.h>
#include <opendaw/io/AudioDevice.h>
#include <memory>
#include <vector>
#include <functional>
#include <atomic>

namespace opendaw {

/**
 * @brief Конфигурация Audio Engine
 */
struct AudioEngineConfig {
    double sampleRate{48000.0};
    int blockSize{512};
    int numInputChannels{2};
    int numOutputChannels{2};
    bool useDoublePrecision{false};
    int numBuffers{4};
    
    double getLatencyMs() const {
        return (blockSize * numBuffers * 1000.0) / sampleRate;
    }
};

/**
 * @brief Статус аудио-движка
 */
enum class AudioEngineStatus {
    Stopped,
    Playing,
    Recording,
    Error
};

/**
 * @brief Главный аудио-движок OpenDAW
 * 
 * Координирует:
 * - Аудио-граф обработки
 * - MIDI обработку
 * - Плагины
 * - Запись/воспроизведение
 */
class AudioEngine {
public:
    AudioEngine();
    ~AudioEngine();
    
    // Запрет копирования
    AudioEngine(const AudioEngine&) = delete;
    AudioEngine& operator=(const AudioEngine&) = delete;
    
    /**
     * @brief Инициализация движка
     */
    bool initialize();
    
    /**
     * @brief Освобождение ресурсов
     */
    void shutdown();
    
    /**
     * @brief Старт воспроизведения
     */
    bool start();
    
    /**
     * @brief Остановка
     */
    void stop();
    
    /**
     * @brief Проверка статуса
     */
    bool isRunning() const { 
        return status_ == AudioEngineStatus::Playing || 
               status_ == AudioEngineStatus::Recording; 
    }
    AudioEngineStatus getStatus() const { return status_; }
    
    /**
     * @brief Конфигурация
     */
    const AudioEngineConfig& getConfig() const { return config_; }
    double getSampleRate() const { return config_.sampleRate; }
    int getBlockSize() const { return config_.blockSize; }
    double getLatencyMs() const { return config_.getLatencyMs(); }
    
    /**
     * @brief Загрузка CPU (0.0 - 1.0)
     */
    float getCpuLoad() const { return cpuLoad_; }
    
    /**
     * @brief Audio Device
     */
    AudioDevice* getAudioDevice() { return audioDevice_.get(); }
    
    /**
     * @brief Транспорт
     */
    void setPlaying(bool playing);
    bool isPlaying() const { return isPlaying_; }
    
    void setRecording(bool recording);
    bool isRecording() const { return isRecording_; }
    
    void setPlayheadPosition(double beats);
    double getPlayheadPosition() const { return playheadPosition_; }
    
    void setTempo(double bpm);
    double getTempo() const { return tempo_; }
    
    /**
     * @brief Callbacks
     */
    using ErrorCallback = std::function<void(const std::string&)>;
    void setErrorCallback(ErrorCallback cb) { errorCallback_ = std::move(cb); }
    
    using StatusCallback = std::function<void(AudioEngineStatus)>;
    void setStatusCallback(StatusCallback cb) { statusCallback_ = std::move(cb); }
    
private:
    AudioEngineConfig config_;
    
    AudioEngineStatus status_{AudioEngineStatus::Stopped};
    std::atomic<bool> isPlaying_{false};
    std::atomic<bool> isRecording_{false};
    std::atomic<double> playheadPosition_{0.0};
    std::atomic<double> tempo_{120.0};
    std::atomic<float> cpuLoad_{0.0f};
    
    ErrorCallback errorCallback_;
    StatusCallback statusCallback_;
    
    std::unique_ptr<AudioDevice> audioDevice_;
    
    void processBlock(float** output, const float** input, int numSamples, 
                      int numInputChannels, int numOutputChannels);
    void updateCpuLoad();
    void handleError(const std::string& error);
};

} // namespace opendaw