juce_hardware_audio_interface.h

// SPDX-FileCopyrightText: © 2026 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#pragma once
 
#include <memory>
#include <optional>
#include <unordered_map>
 
#include "dsp/hardware_audio_interface.h"
#include "dsp/iaudio_callback.h"
 
#include <juce_audio_devices/juce_audio_devices.h>
 
namespace zrythm::dsp
{

class JuceHardwareAudioInterface : public IHardwareAudioInterface
{
public:
  explicit JuceHardwareAudioInterface (
    std::shared_ptr<juce::AudioDeviceManager> device_manager);
 
  ~JuceHardwareAudioInterface () override;
 
  [[nodiscard]] AudioDeviceInfo get_device_info () const override;
 
  void add_audio_callback (IAudioCallback * callback) override;
  void remove_audio_callback (IAudioCallback * callback) override;

  [[nodiscard]] std::optional<juce::AudioWorkgroup>
  get_device_audio_workgroup () const;

  static std::unique_ptr<IHardwareAudioInterface>
  create (std::shared_ptr<juce::AudioDeviceManager> device_manager);
 
private:
  class JuceCallbackAdapter : public juce::AudioIODeviceCallback
  {
  public:
    explicit JuceCallbackAdapter (IAudioCallback &callback)
        : callback_ (callback)
    {
    }
 
    void audioDeviceIOCallbackWithContext (
      const float * const *                     inputChannelData,
      int                                       numInputChannels,
      float * const *                           outputChannelData,
      int                                       numOutputChannels,
      int                                       numSamples,
      const juce::AudioIODeviceCallbackContext &context) override
    {
      juce::ScopedNoDenormals no_denormals;
      callback_.process_audio (
        { inputChannelData, static_cast<size_t> (numInputChannels) },
        { outputChannelData, static_cast<size_t> (numOutputChannels) },
        units::samples (numSamples));
    }
 
    void audioDeviceAboutToStart (juce::AudioIODevice * device) override;
    void audioDeviceStopped () override;
    void audioDeviceError (const juce::String &errorMessage) override;
 
  private:
    IAudioCallback &callback_;
  };
 
  std::shared_ptr<juce::AudioDeviceManager> device_manager_;

  std::unordered_map<IAudioCallback *, std::unique_ptr<JuceCallbackAdapter>>
    callback_adapters_;
};
 
} // namespace zrythm::dsp