miniaudio_protocol.hpp

#pragma once
#include <ossia/detail/config.hpp>
 
#if __has_include(<miniaudio.h>)
#define OSSIA_ENABLE_MINIAUDIO 1
// The single-header implementation is compiled exactly once, in miniaudio.cpp.
// Every other includer of this header only sees declarations, so there is no
// duplicate-symbol clash when libossia and score-plugin-audio are statically
// linked into the same binary (e.g. wasm).
#if defined(__APPLE__)
#define MA_NO_RUNTIME_LINKING 1
#endif
#define MA_ENABLE_ONLY_SPECIFIC_BACKENDS 1
#if defined(__EMSCRIPTEN__)
#define MA_ENABLE_WEBAUDIO 1
#define MA_ENABLE_AUDIO_WORKLETS 1
// The AudioWorklet thread runs the whole ossia execution tick (every node,
// including deep gfx/ISF exec-node call chains). miniaudio allocates a fixed
// heap buffer for that thread's stack; its 128KB default is far too small and
// a deep tick silently overruns it, corrupting adjacent heap allocations
// (manifesting much later as OOB / null-function crashes on the main thread).
// Give it a desktop-sized stack instead.
#define MA_AUDIO_WORKLETS_THREAD_STACK_SIZE 4194304
#elif defined(_WIN32)
#define MA_ENABLE_WASAPI 1
#else
#define MA_ENABLE_COREAUDIO 1
#define MA_ENABLE_ALSA 1
#endif
#define MA_NO_WAV 1
#define MA_NO_FLAC 1
#define MA_NO_MP3 1
#define MA_NO_RESOURCE_MANAGER 1
#define MA_NO_NODE_GRAPH 1
#define MA_NO_GENERATION 1
#define MA_MAX_CHANNELS 1024
// The audio thread is created with this priority when the rtprio limit
// allows it; the callback raises it otherwise (it asks for the maximum by
// default, which the usual limit of 95 or 98 refuses).
#define MA_PTHREAD_REALTIME_THREAD_PRIORITY 95
// Export the miniaudio API from libossia so consumers (score-plugin-audio)
// link against this one copy instead of compiling their own. OSSIA_EXPORT is
// empty in static builds, dllexport/visibility when building the ossia shared
// lib, and dllimport when compiling against it.
#define MA_API OSSIA_EXPORT
 
#include <ossia/audio/audio_engine.hpp>
#include <ossia/detail/logger.hpp>
#include <ossia/detail/pod_vector.hpp>
#include <ossia/detail/thread.hpp>
 
#include <miniaudio.h>
 
#if defined(__EMSCRIPTEN__)
#include <emscripten/em_asm.h>
#endif
 
#define OSSIA_AUDIO_MINIAUDIO 1
 
namespace ossia
{
struct miniaudio_context
{
  ma_context context;
};
 
class miniaudio_engine final : public audio_engine
{
 
public:
  std::vector<const ma_device_info*> devices;
  bool is_duplex(const ma_device_id& card_in, const ma_device_id& card_out)
  {
#if defined(__APPLE__)
    return true;
    std::string_view i = card_in.coreaudio;
    std::string_view o = card_out.coreaudio;
    if(i.length() != o.length() || i.empty() || o.empty())
      return false;
    if(i.substr(0, i.size() - 1) == o.substr(0, o.size() - 1))
      return true;
 
#endif
    return memcmp(&card_in, &card_out, sizeof(ma_device_id)) == 0;
  }
  miniaudio_engine(
      std::shared_ptr<miniaudio_context> ctx, std::string name,
      const ma_device_id& card_in, const ma_device_id& card_out, int inputs, int outputs,
      int rate, int bs, ma_share_mode share = ma_share_mode_shared)
      : m_ctx{std::move(ctx)}
  {
    ma_device_type dtype = ma_device_type_duplex;
    if(inputs == 0)
      dtype = ma_device_type_playback;
    else if(outputs == 0)
      dtype = ma_device_type_capture;
 
    ma_device_config config = ma_device_config_init(dtype);
 
    config.sampleRate = rate;
    config.periodSizeInFrames = bs;
    // As for PortAudio: periods shorter than 2 ms get one more.
    config.periods = int64_t(bs) * 1000 < 2 * int64_t(rate) ? 4 : 3;
    // A zeroed device id means "system default device". Passing NULL as the
    // pDeviceID makes miniaudio open the OS default device and, on backends
    // that support it (WASAPI in particular), automatically follow the OS
    // default output/input when the user changes it while the stream runs.
    auto is_default_id = [](const ma_device_id& id) {
      ma_device_id zero{};
      return memcmp(&id, &zero, sizeof(ma_device_id)) == 0;
    };
 
    if(outputs > 0)
    {
      config.playback.pDeviceID = is_default_id(card_out) ? nullptr : &card_out;
      config.playback.channels = outputs;
      config.playback.format = ma_format_f32;
    }
 
    if(inputs > 0)
    {
      config.capture.pDeviceID = is_default_id(card_in) ? nullptr : &card_in;
      config.capture.channels = inputs;
      config.capture.format = ma_format_f32;
    }
 
    config.dataCallback = callback;
 
    config.performanceProfile = ma_performance_profile_low_latency;
    config.noFixedSizedCallback = false;
    config.noClip = false;
    config.noDisableDenormals = false;
    config.noPreSilencedOutputBuffer = false;
 
    config.pUserData = this;
 
    this->effective_buffer_size = bs;
    this->effective_sample_rate = rate;
    this->effective_inputs = inputs;
    this->effective_outputs = outputs;
 
    ins_data.resize(effective_inputs * bs + 16);
    outs_data.resize(effective_outputs * bs + 16);
    ins.resize(effective_inputs + 2);
    outs.resize(effective_outputs + 2);
 
    // Exclusive access (ALSA "hw:") gives a period of bs frames; shared access
    // goes through the system mixer (ALSA dmix), whose own period is used
    // whatever bs is. A device another program holds can only be shared.
    ma_result res = MA_ERROR;
    for(ma_share_mode mode : {share, ma_share_mode_shared})
    {
      config.playback.shareMode = mode;
      config.capture.shareMode = mode;
      // The performance profile only matters without a period size: no
      // retry with another one.
      res = ma_device_init(&m_ctx->context, &config, &m_stream);
      if(res == MA_SUCCESS)
      {
        m_exclusive = mode == ma_share_mode_exclusive;
        if(mode != share)
          ossia::logger().warn(
              "miniaudio: exclusive access refused, using the device in shared mode");
        break;
      }
      if(mode == ma_share_mode_shared)
        break;
    }
    if(res != MA_SUCCESS)
      throw std::runtime_error(
          std::string("miniaudio: cannot open the device: ") + ma_result_description(res));
 
    if(res = ma_device_start(&m_stream); res != MA_SUCCESS)
    {
      ma_device_uninit(&m_stream);
      throw std::runtime_error(
          std::string("miniaudio: cannot start the device: ")
          + ma_result_description(res));
    }
 
    auto to_client_frames = [rate](ma_uint32 frames, ma_uint32 device_rate) {
      return device_rate > 0 ? int(int64_t(frames) * rate / device_rate) : int(frames);
    };
    if(outputs > 0)
      effective_output_latency = to_client_frames(
          m_stream.playback.internalPeriodSizeInFrames * m_stream.playback.internalPeriods,
          m_stream.playback.internalSampleRate);
    if(inputs > 0)
      effective_input_latency = to_client_frames(
          m_stream.capture.internalPeriodSizeInFrames,
          m_stream.capture.internalSampleRate);
 
#if defined(__EMSCRIPTEN__)
    // A duplex device only reaches the output from inside getUserMedia()'s
    // then(): a page with no microphone, or one whose capture fails for any
    // other reason, plays nothing at all. Connecting an already connected node
    // is a no-op, so doing it here costs nothing and makes playback independent
    // of capture.
    EM_ASM(
        {
          const node = emscriptenGetAudioObject($0);
          const ctx = emscriptenGetAudioObject($1);
          if(node && ctx)
            node.connect(ctx.destination);
        },
        m_stream.webaudio.audioWorklet, m_stream.webaudio.audioContext);
#endif
 
    m_active = true;
  }

  bool exclusive() const noexcept { return m_exclusive; }
 
  bool running() const override
  {
    return m_active && ma_device_get_state(&m_stream) == ma_device_state_started;
  }
 
  bool failed() const noexcept override
  {
    return m_active && !stop_processing
           && ma_device_get_state(&m_stream) == ma_device_state_stopped;
  }
 
  void stop() override
  {
    audio_engine::stop();
 
    if(m_active)
    {
      ma_device_stop(&m_stream);
      ma_device_uninit(&m_stream);
    }
    m_active = false;
  }
 
  ~miniaudio_engine() override { stop(); }
 
private:
  static void
  callback(ma_device* pDevice, void* output, const void* input, ma_uint32 nframes)
  {
#if !defined(__EMSCRIPTEN__)
    [[maybe_unused]]
    static const thread_local auto _
        = [] {
      ossia::set_thread_name("ossia audio 0");
      ossia::set_thread_pinned(thread_type::Audio, 0);
#if defined(__linux__)
      ossia::set_current_thread_realtime(95, true, false);
#endif
      return 0;
    }();
#endif
 
    auto& self = *static_cast<miniaudio_engine*>(pDevice->pUserData);
    self.tick_start();
 
    if(self.stop_processing)
    {
      self.tick_clear();
      return;
    }
 
    auto ins = self.ins.data();
    auto ins_data = self.ins_data.data();
    for(int i = 0; i < self.effective_inputs; i++)
      ins[i] = ins_data + i * nframes;
 
    const float* in_samples = static_cast<const float*>(input);
    for(int c = 0; c < self.effective_inputs; c++)
      for(ma_uint32 f = 0; f < nframes; f++)
        ins[c][f] = in_samples[f * self.effective_inputs + c];
 
    auto outs = self.outs.data();
    auto outs_data = self.outs_data.data();
    std::memset(outs_data, 0, sizeof(float) * self.effective_outputs * nframes);
    for(int i = 0; i < self.effective_outputs; i++)
      outs[i] = outs_data + i * nframes;
 
#if defined(__EMSCRIPTEN__)
    // On WASM audio worklets, std::chrono::steady_clock is unavailable.
    // Use the sample count to derive time instead.
    self.m_frames_elapsed += nframes;
    double nsecs = (double)self.m_frames_elapsed / self.effective_sample_rate;
#else
    if(!self.m_start)
      self.m_start = std::chrono::steady_clock::now();
    auto now = std::chrono::steady_clock::now();
    auto nsecs
        = std::chrono::duration_cast<std::chrono::nanoseconds>(now - *self.m_start)
              .count()
          / 1e9;
#endif
 
    ossia::audio_tick_state ts{(float* const*)ins,     outs,    self.effective_inputs,
                               self.effective_outputs, nframes, nsecs};
    if(self.audio_tick)
      self.audio_tick(ts);
 
    self.tick_end();
 
    float* out_samples = static_cast<float*>(output);
    for(int c = 0; c < self.effective_outputs; c++)
      for(ma_uint32 f = 0; f < nframes; f++)
        out_samples[f * self.effective_outputs + c] = outs[c][f];
  }
 
  std::shared_ptr<miniaudio_context> m_ctx;
  ma_device m_stream;
#if defined(__EMSCRIPTEN__)
  uint64_t m_frames_elapsed{};
#else
  std::optional<std::chrono::steady_clock::time_point> m_start;
#endif
 
  ossia::float_vector ins_data;
  ossia::pod_vector<float*> ins;
  ossia::float_vector outs_data;
  ossia::pod_vector<float*> outs;
 
  bool m_active{};
  bool m_exclusive{};
};
}
 
#endif
// #endif