sdl_protocol.hpp

#pragma once
#include <ossia/detail/config.hpp>
 
#if defined(OSSIA_ENABLE_SDL)
#if __has_include(<SDL2/SDL_audio.h>)
#include <SDL2/SDL_config.h>
#if !defined(SDL_AUDIO_DISABLED)
#include <ossia/audio/audio_engine.hpp>
#include <ossia/detail/pod_vector.hpp>
#include <ossia/detail/thread.hpp>
 
#include <SDL2/SDL.h>
#include <SDL2/SDL_audio.h>
 
#define OSSIA_AUDIO_SDL 1
 
namespace ossia
{
class sdl_protocol final : public audio_engine
{
  static constexpr int inputs = 0;
  static constexpr int outputs = 2;
 
public:
  sdl_protocol(int rate, int bs)
  {
    SDL_Init(SDL_INIT_AUDIO);
    m_desired.freq = rate;
    m_desired.format = AUDIO_F32SYS;
    m_desired.channels = outputs;
    m_desired.samples = bs;
    m_desired.callback = SDLCallback;
    m_desired.userdata = this;
 
    m_deviceId = SDL_OpenAudioDevice(nullptr, 0, &m_desired, &m_obtained, 0);
 
    if(m_deviceId < 2)
    {
      using namespace std::literals;
      throw std::runtime_error("SDL: Couldn't open audio: "s + SDL_GetError());
    }
 
    this->effective_sample_rate = m_obtained.freq;
    this->effective_buffer_size = m_obtained.samples;
    this->effective_inputs = 0;
    this->effective_outputs = m_obtained.channels;
 
    // Preallocate so that the audio thread does not have to: this only ever
    // gets resized if SDL changes the callback buffer size under our feet.
    m_channels.resize(m_obtained.channels);
    m_scratch.resize(std::size_t(m_obtained.samples) * m_obtained.channels);
 
    SDL_PauseAudioDevice(m_deviceId, 0);
    m_activated = true;
  }
 
  ~sdl_protocol() override { stop(); }
 
  bool running() const override
  {
    return m_activated && SDL_GetAudioDeviceStatus(m_deviceId) == SDL_AUDIO_PLAYING;
  }
 
  void stop() override
  {
    audio_engine::stop();
    if(m_activated)
    {
      SDL_CloseAudioDevice(m_deviceId);
      m_activated = false;
    }
    // Not SDL_Quit(): other parts of ossia (joystick, gamecontroller, sensors,
    // haptics) may be using SDL at the same time.
    SDL_QuitSubSystem(SDL_INIT_AUDIO);
  }
 
private:
  static void SDLCallback(void* userData, Uint8* data, int bytes)
  {
    [[maybe_unused]]
    static const thread_local auto _
        = [] {
      ossia::set_thread_name("ossia audio 0");
      ossia::set_thread_pinned(thread_type::Audio, 0);
      return 0;
    }();
 
    auto& self = *static_cast<sdl_protocol*>(userData);
    self.tick_start();
    if(!self.m_start)
      self.m_start = std::chrono::steady_clock::now();
 
    auto audio_out = reinterpret_cast<float*>(data);
    const int out_chan = self.m_obtained.channels;
    assert(out_chan > 0);
 
    // Note: the amount of data asked for here is *not* guaranteed to match the
    // SDL_AudioSpec we got when opening the device. SDL keeps its own copy of
    // that spec and backends are free to rewrite it while the stream runs: on
    // Windows, WASAPI resizes the callback buffer to the device period every
    // time the device is reset (default device changed, format changed in the
    // control panel, endpoint invalidated...), see UpdateAudioStream() in
    // SDL_wasapi.c. Our m_obtained is a stale copy at that point, so the byte
    // count we are given is the only thing we can trust.
    const int frames = bytes / int(sizeof(float) * out_chan);
 
    if(self.stop_processing || frames <= 0)
    {
      self.tick_clear();
      memset(data, 0, bytes);
      return;
    }
 
    {
      const std::size_t samples = std::size_t(frames) * out_chan;
      if(self.m_scratch.size() < samples)
        self.m_scratch.resize(samples);
 
      float* const float_data = self.m_scratch.data();
      memset(float_data, 0, sizeof(float) * samples);
 
      float** const float_output = self.m_channels.data();
      for(int c = 0; c < out_chan; c++)
      {
        float_output[c] = float_data + c * frames;
      }
 
      // if one day there's input... samples[j++] / 32768.;
 
      auto now = std::chrono::steady_clock::now();
      auto nsecs
          = std::chrono::duration_cast<std::chrono::nanoseconds>(now - *self.m_start)
                .count()
            / 1e9;
 
      ossia::audio_tick_state ts{nullptr,  float_output,     0,
                                 out_chan, (uint64_t)frames, nsecs};
      self.audio_tick(ts);
 
      for(int j = 0; j < frames; j++)
        for(int c = 0; c < out_chan; c++)
          *audio_out++ = float_output[c][j];
 
      // Zero the trailing partial frame if SDL asked for a size which is not a
      // multiple of the frame size
      const int written = int(sizeof(float) * samples);
      if(written < bytes)
        memset(data + written, 0, bytes - written);
 
      self.tick_end();
      self.m_total_frames += frames;
    }
  }
 
  SDL_AudioDeviceID m_deviceId{};
  SDL_AudioSpec m_desired, m_obtained;
  ossia::float_vector m_scratch;
  ossia::pod_vector<float*> m_channels;
  uint64_t m_total_frames{};
  std::optional<std::chrono::steady_clock::time_point> m_start;
  bool m_activated{};
};
}
 
#endif
#endif
#endif