From d22cb528aab416b31a5ef0e672d155ab97185873 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jean-Micha=C3=ABl=20Celerier?=
 <jean-michael.celerier@kdab.com>
Date: Thu, 11 Apr 2019 12:05:37 +0200
Subject: [PATCH 1/2] Fix linux build

---
 examples/print_devices.cpp             |  4 +-
 include/__audio_buffer.h               |  1 -
 include/audio                          |  3 +
 include/audio_backend/__null_backend.h | 90 +++++++++++++++++++++-----
 4 files changed, 79 insertions(+), 19 deletions(-)

diff --git a/examples/print_devices.cpp b/examples/print_devices.cpp
index 721ed2f..aee5c93 100644
--- a/examples/print_devices.cpp
+++ b/examples/print_devices.cpp
@@ -5,7 +5,7 @@
 
 #include <iostream>
 #include <audio>
-
+#include <cassert>
 using namespace std::experimental;
 
 void print_device_info(const audio_device& d) {
@@ -27,4 +27,4 @@ int main() {
 
   std::cout << "\nOutput devices:\n===============\n";
   print_device_list(get_audio_output_device_list());
-}
\ No newline at end of file
+}
diff --git a/include/__audio_buffer.h b/include/__audio_buffer.h
index 99cb4ed..4354db0 100644
--- a/include/__audio_buffer.h
+++ b/include/__audio_buffer.h
@@ -4,7 +4,6 @@
 // (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
 
 #pragma once
-
 _LIBSTDAUDIO_NAMESPACE_BEGIN
 
 struct audio_buffer_order_interleaved {};
diff --git a/include/audio b/include/audio
index b35f4b3..c34e5e5 100644
--- a/include/audio
+++ b/include/audio
@@ -6,6 +6,9 @@
 #pragma once
 
 #include <optional>
+#include <cassert>
+#include <string_view>
+#include <atomic>
 
 // TODO: this is a temporary measure until std::span becomes available
 #include "cpp/span.hpp"
diff --git a/include/audio_backend/__null_backend.h b/include/audio_backend/__null_backend.h
index b74aa36..347f2cb 100644
--- a/include/audio_backend/__null_backend.h
+++ b/include/audio_backend/__null_backend.h
@@ -4,7 +4,7 @@
 // (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
 
 #pragma once
-
+#include <forward_list>
 _LIBSTDAUDIO_NAMESPACE_BEGIN
 
 template<>
@@ -12,24 +12,82 @@ class audio_basic_device<audio_null_driver_t>
 {
 public:
   audio_basic_device() = delete;
+
+  using sample_rate_t = double;
+  sample_rate_t get_sample_rate() const noexcept { return 0; }
+  bool set_sample_rate(sample_rate_t new_sample_rate) {
+    return false;
+  }
+
+  bool start() { return false; }
+  bool stop() { return false; }
+
+  using buffer_size_t = uint32_t;
+
+  buffer_size_t get_buffer_size_frames() const noexcept
+  {
+      return 0;
+  }
+
+  string_view name() const noexcept {
+      return {};
+  }
+
+  using device_id_t = int;
+  device_id_t device_id() const noexcept {
+    return -1;
+  }
+
+  bool is_input() const noexcept {
+    return false;
+  }
+
+  bool is_output() const noexcept {
+      return false;
+  }
+  int get_num_input_channels() const noexcept {
+    return 0;
+  }
+
+  int get_num_output_channels() const noexcept {
+    return 0;
+  }
+
+  template<typename T>
+  void connect(T) {
+
+  }
+
+  constexpr bool can_connect() const noexcept {
+    return false;
+  }
+
+  constexpr bool can_process() const noexcept {
+    return false;
+  }
+
+  constexpr bool is_running() const noexcept {
+    return false;
+  }
+
+  span<const sample_rate_t> get_supported_sample_rates() const noexcept {
+    return { };
+  }
+
+  span<const buffer_size_t> get_supported_buffer_sizes_frames() const noexcept {
+      return { };
+  }
+
+  bool set_buffer_size_frames(buffer_size_t new_buffer_size) {
+    return false;
+  }
+
 };
 
+using __null_device = audio_basic_device<audio_null_driver_t>;
 template<>
-class audio_basic_device_list<audio_null_driver_t>
+class audio_basic_device_list<audio_null_driver_t> : public forward_list<__null_device>
 {
-private:
-  class iterator {
-  public:
-    auto operator==(const iterator&) const noexcept { return true; }
-    auto operator!=(const iterator&) const noexcept { return false; }
-    auto operator++() -> const iterator& { assert(false); return *this; }
-    auto operator*() -> audio_basic_device<audio_null_driver_t>& { assert(false); }
-  };
-
-public:
-  auto begin() -> iterator { return {}; }
-  auto end() -> iterator { return {}; }
-  auto empty() -> bool { return true; }
 };
 
 template<>
@@ -60,4 +118,4 @@ auto get_audio_output_device_list<audio_null_driver_t>()
   return {};
 }
 
-_LIBSTDAUDIO_NAMESPACE_END
\ No newline at end of file
+_LIBSTDAUDIO_NAMESPACE_END

From 1914f3ab2fe5cdb3868fbbbc9043dd2855356fdf Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jean-Micha=C3=ABl=20Celerier?=
 <jean-michael.celerier@kdab.com>
Date: Sat, 13 Apr 2019 21:35:27 +0200
Subject: [PATCH 2/2] refactor and start working on a pulseaudio backend

---
 .gitignore                                   |   2 +
 CMakeLists.txt                               |  19 +-
 include/__audio_base.h                       |  41 ++
 include/__audio_buffer.h                     |   2 +
 include/__audio_device.h                     |   1 +
 include/__audio_exception.h                  |  13 +
 include/__dynamic_library.h                  |  70 +++
 include/audio                                |  39 +-
 include/audio_backend/__coreaudio_backend.h  |  10 +-
 include/audio_backend/__portaudio_backend.h  | 546 ++++++++----------
 include/audio_backend/__pulseaudio_backend.h | 549 +++++++++++++++++++
 11 files changed, 924 insertions(+), 368 deletions(-)
 create mode 100644 include/__audio_base.h
 create mode 100644 include/__audio_exception.h
 create mode 100644 include/__dynamic_library.h
 create mode 100644 include/audio_backend/__pulseaudio_backend.h

diff --git a/.gitignore b/.gitignore
index 7c9deb6..e91eb42 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,5 @@
 .idea
 cmake-build*
 .DS_Store
+*.user
+build
diff --git a/CMakeLists.txt b/CMakeLists.txt
index a9f1329..5adfc2c 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -7,14 +7,29 @@ cmake_minimum_required(VERSION 3.12)
 project(libstdaudio)
 
 set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror -O0 -fsanitize=undefined")
 if (APPLE)
     set(CMAKE_EXE_LINKER_FLAGS "-framework CoreAudio")
 endif ()
 
+# add the headers to at least one target so that they get
+# parsed as part of the project in some IDEs
+set(headers
+    include/__audio_base.h
+    include/__audio_buffer.h
+    include/__audio_device.h
+    include/__audio_exception.h
+    include/__dynamic_library.h
+    include/audio
+    include/cpp/span.hpp
+    include/audio_backend/__coreaudio_backend.h
+    include/audio_backend/__null_backend.h
+    include/audio_backend/__portaudio_backend.h
+    include/audio_backend/__pulseaudio_backend.h
+    )
 include_directories(include)
 
-add_executable(white_noise examples/white_noise.cpp)
+add_executable(white_noise examples/white_noise.cpp ${headers})
 target_link_libraries(white_noise PRIVATE ${CMAKE_DL_LIBS})
 add_executable(print_devices examples/print_devices.cpp)
 target_link_libraries(print_devices PRIVATE ${CMAKE_DL_LIBS})
diff --git a/include/__audio_base.h b/include/__audio_base.h
new file mode 100644
index 0000000..4586da1
--- /dev/null
+++ b/include/__audio_base.h
@@ -0,0 +1,41 @@
+#pragma once
+
+#include <optional>
+#include <cassert>
+#include <string_view>
+#include <atomic>
+
+// TODO: this is a temporary measure until std::span becomes available
+#include "cpp/span.hpp"
+using namespace TCB_SPAN_NAMESPACE_NAME;
+
+#define _LIBSTDAUDIO_NAMESPACE std::experimental
+
+#define _LIBSTDAUDIO_NAMESPACE_BEGIN namespace _LIBSTDAUDIO_NAMESPACE {
+#define _LIBSTDAUDIO_NAMESPACE_END }
+
+_LIBSTDAUDIO_NAMESPACE_BEGIN
+
+struct audio_null_driver_t {};
+
+#ifdef __APPLE__
+  struct __coreaudio_driver_t {};
+  using audio_default_driver_t = __coreaudio_driver_t;
+#else
+
+#if __has_include(<pulse/pulseaudio.h>)
+  struct __pulseaudio_driver_t {};
+#endif
+#if __has_include(<portaudio.h>)
+  struct __portaudio_driver_t {};
+#endif
+
+#if __has_include(<pulse/pulseaudio.h>)
+  using audio_default_driver_t = __pulseaudio_driver_t;
+#elif __has_include(<portaudio.h>)
+  using audio_default_driver_t = __portaudio_driver_t;
+#endif
+#endif // __APPLE__
+
+_LIBSTDAUDIO_NAMESPACE_END
+
diff --git a/include/__audio_buffer.h b/include/__audio_buffer.h
index 4354db0..7e6b6d0 100644
--- a/include/__audio_buffer.h
+++ b/include/__audio_buffer.h
@@ -4,6 +4,8 @@
 // (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
 
 #pragma once
+#include <__audio_base.h>
+
 _LIBSTDAUDIO_NAMESPACE_BEGIN
 
 struct audio_buffer_order_interleaved {};
diff --git a/include/__audio_device.h b/include/__audio_device.h
index a45c8f9..7c766ff 100644
--- a/include/__audio_device.h
+++ b/include/__audio_device.h
@@ -4,6 +4,7 @@
 // (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
 
 #pragma once
+#include <__audio_base.h>
 
 _LIBSTDAUDIO_NAMESPACE_BEGIN
 
diff --git a/include/__audio_exception.h b/include/__audio_exception.h
new file mode 100644
index 0000000..c8a90c8
--- /dev/null
+++ b/include/__audio_exception.h
@@ -0,0 +1,13 @@
+#pragma once
+#include <__audio_base.h>
+#include <stdexcept>
+
+_LIBSTDAUDIO_NAMESPACE_BEGIN
+
+struct audio_device_exception : public runtime_error {
+  explicit audio_device_exception(const char* what)
+    : runtime_error(what) {
+  }
+};
+
+_LIBSTDAUDIO_NAMESPACE_END
diff --git a/include/__dynamic_library.h b/include/__dynamic_library.h
new file mode 100644
index 0000000..35323e0
--- /dev/null
+++ b/include/__dynamic_library.h
@@ -0,0 +1,70 @@
+#pragma once
+#include <__audio_base.h>
+
+#if defined(_WIN32)
+#define __STDAUDIO_HAS_DYLIB 1
+#include <windows.h>
+#elif __has_include(<dlfcn.h>)
+#define __STDAUDIO_HAS_DYLIB 1
+#include <dlfcn.h>
+#endif
+
+_LIBSTDAUDIO_NAMESPACE_BEGIN
+#if __STDAUDIO_HAS_DYLIB
+class __dynamic_library
+{
+public:
+  explicit __dynamic_library(const char* const so) /* not noexcept - some DLL constructors can throw */
+  {
+#ifdef _WIN32
+    impl = (void*)LoadLibraryA(so);
+#else
+    impl = dlopen(so, RTLD_LAZY | RTLD_LOCAL | RTLD_NODELETE);
+#endif
+  }
+
+  __dynamic_library(const __dynamic_library&) noexcept = delete;
+  __dynamic_library& operator=(const __dynamic_library&) noexcept = delete;
+  __dynamic_library(__dynamic_library&& other)
+  {
+    impl = other.impl;
+    other.impl = nullptr;
+  }
+
+  __dynamic_library& operator=(__dynamic_library&& other) noexcept
+  {
+    impl = other.impl;
+    other.impl = nullptr;
+    return *this;
+  }
+
+  ~__dynamic_library()
+  {
+    if (impl)
+    {
+#ifdef _WIN32
+      FreeLibrary((HMODULE)impl);
+#else
+      dlclose(impl);
+#endif
+    }
+  }
+
+  template <typename T>
+  T symbol(const char* const sym) const noexcept
+  {
+#ifdef _WIN32
+    return (T)GetProcAddress((HMODULE)impl, sym);
+#else
+    return (T)dlsym(impl, sym);
+#endif
+  }
+
+  operator bool() const { return bool(impl); }
+
+private:
+  void* impl{};
+};
+#endif
+
+_LIBSTDAUDIO_NAMESPACE_END
diff --git a/include/audio b/include/audio
index 274d167..cc890ed 100644
--- a/include/audio
+++ b/include/audio
@@ -4,39 +4,7 @@
 // (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
 
 #pragma once
-
-#include <optional>
-#include <cassert>
-#include <string_view>
-#include <atomic>
-
-// TODO: this is a temporary measure until std::span becomes available
-#include "cpp/span.hpp"
-using namespace TCB_SPAN_NAMESPACE_NAME;
-
-#define _LIBSTDAUDIO_NAMESPACE std::experimental
-
-#define _LIBSTDAUDIO_NAMESPACE_BEGIN namespace _LIBSTDAUDIO_NAMESPACE {
-#define _LIBSTDAUDIO_NAMESPACE_END }
-
-_LIBSTDAUDIO_NAMESPACE_BEGIN
-
-struct audio_null_driver_t {};
-
-#ifdef __APPLE__
-  struct __coreaudio_driver_t {};
-  using audio_default_driver_t = __coreaudio_driver_t;
-#else
-
-#if __has_include(<portaudio.h>)
-  struct __portaudio_driver_t {};
-  using audio_default_driver_t = __portaudio_driver_t;
-#endif
-
-#endif // __APPLE__
-
-_LIBSTDAUDIO_NAMESPACE_END
-
+#include <__audio_base.h>
 #include <__audio_buffer.h>
 #include <__audio_device.h>
 #include <audio_backend/__null_backend.h>
@@ -46,4 +14,7 @@ _LIBSTDAUDIO_NAMESPACE_END
 #endif // __APPLE__
 #if __has_include(<portaudio.h>)
   #include <audio_backend/__portaudio_backend.h>
-#endif // __APPLE__
+#endif
+#if __has_include(<pulse/pulseaudio.h>)
+  #include <audio_backend/__pulseaudio_backend.h>
+#endif
diff --git a/include/audio_backend/__coreaudio_backend.h b/include/audio_backend/__coreaudio_backend.h
index 1ca7f4e..0899972 100644
--- a/include/audio_backend/__coreaudio_backend.h
+++ b/include/audio_backend/__coreaudio_backend.h
@@ -5,6 +5,10 @@
 
 #pragma once
 
+#include <__audio_base.h>
+#include <__audio_device.h>
+#include <__audio_buffer.h>
+#include <__audio_exception.h>
 #include <cctype>
 #include <string>
 #include <iostream>
@@ -72,12 +76,6 @@ class __coreaudio_util {
   }
 };
 
-struct audio_device_exception : public runtime_error {
-  explicit audio_device_exception(const char* what)
-    : runtime_error(what) {
-  }
-};
-
 using __coreaudio_device = audio_basic_device<__coreaudio_driver_t>;
 
 template<>
diff --git a/include/audio_backend/__portaudio_backend.h b/include/audio_backend/__portaudio_backend.h
index 5f504b5..69afc91 100644
--- a/include/audio_backend/__portaudio_backend.h
+++ b/include/audio_backend/__portaudio_backend.h
@@ -4,86 +4,20 @@
 // (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
 
 #pragma once
+#include <__audio_base.h>
+#include <__audio_device.h>
+#include <__audio_buffer.h>
+#include <__dynamic_library.h>
+#include <__audio_exception.h>
 #include <forward_list>
 #include <functional>
 #include <cassert>
 #include <portaudio.h>
 
-#if defined(_WIN32)
-#define __STDAUDIO_HAS_DYLIB 1
-#include <windows.h>
-#elif __has_include(<dlfcn.h>)
-#define __STDAUDIO_HAS_DYLIB 1
-#include <dlfcn.h>
-#endif
+// multi-API problem : can't e.g. initialize jack from itself, and also from portaudio
 
-// multi-API problem : can't e.g. intiialize jack from itself, and also from portaudio
-//#include <audio>
 _LIBSTDAUDIO_NAMESPACE_BEGIN
 
-struct audio_device_exception : public runtime_error {
-  explicit audio_device_exception(const char* what)
-    : runtime_error(what) {
-  }
-};
-
-#if __STDAUDIO_HAS_DYLIB
-class __dynamic_library
-{
-public:
-  explicit __dynamic_library(const char* const so) noexcept
-  {
-#ifdef _WIN32
-    impl = (void*)LoadLibraryA(so);
-#else
-    impl = dlopen(so, RTLD_LAZY | RTLD_LOCAL | RTLD_NODELETE);
-#endif
-  }
-
-  __dynamic_library(const __dynamic_library&) noexcept = delete;
-  __dynamic_library& operator=(const __dynamic_library&) noexcept = delete;
-  __dynamic_library(__dynamic_library&& other)
-  {
-    impl = other.impl;
-    other.impl = nullptr;
-  }
-
-  __dynamic_library& operator=(__dynamic_library&& other) noexcept
-  {
-    impl = other.impl;
-    other.impl = nullptr;
-    return *this;
-  }
-
-  ~__dynamic_library()
-  {
-    if (impl)
-    {
-#ifdef _WIN32
-      FreeLibrary((HMODULE)impl);
-#else
-      dlclose(impl);
-#endif
-    }
-  }
-
-  template <typename T>
-  T symbol(const char* const sym) const noexcept
-  {
-#ifdef _WIN32
-    return (T)GetProcAddress((HMODULE)impl, sym);
-#else
-    return (T)dlsym(impl, sym);
-#endif
-  }
-
-  operator bool() const { return bool(impl); }
-
-private:
-  void* impl{};
-};
-#endif
-
 class __portaudio_lib
 {
 public:
@@ -187,316 +121,276 @@ class __portaudio_lib
         get_error_text = &::Pa_GetErrorText;
     }
 #endif
-
 };
 
 using __portaudio_device = audio_basic_device<__portaudio_driver_t>;
-// How to handle stuff like MME or pulseaudio where you can mix and match sound cards ?
-template<>
-class audio_basic_device<__portaudio_driver_t>
-{
-    const PaDeviceInfo& m_info;
-    const int m_index;
-public:
-    audio_basic_device(const PaDeviceInfo& info, PaDeviceIndex device):
-        m_info{info}
-      , m_index{device}
-    {
-        if(__portaudio_lib::instance().initialize() != paNoError) {
-            throw std::runtime_error("Cannot initialize portaudio device");
-        }
-
-        m_in.device = m_index;
-        m_in.channelCount = info.maxInputChannels;
-        m_in.sampleFormat = paFloat32; // Let's make that configurable later.
-        m_in.suggestedLatency = 1024. / info.defaultSampleRate;
-        m_in.hostApiSpecificStreamInfo = nullptr;
+// How to handle stuff like MME or pulseaudio where you can mix and match sound
+// cards ?
+template <> class audio_basic_device<__portaudio_driver_t> {
+  const PaDeviceInfo &m_info;
+  const int m_index;
 
-        m_out.device = m_index;
-        m_out.channelCount = info.maxOutputChannels;
-        m_out.sampleFormat = paFloat32; // Let's make that configurable later.
-        m_out.suggestedLatency = 1024. / info.defaultSampleRate;
-        m_out.hostApiSpecificStreamInfo = nullptr;
-
-        m_sampleRate = m_info.defaultSampleRate;
-        m_frames = std::max(m_info.defaultHighInputLatency, m_info.defaultHighOutputLatency) * m_sampleRate;
+public:
+  audio_basic_device(const PaDeviceInfo &info, PaDeviceIndex device)
+      : m_info{info}, m_index{device} {
+    if (__portaudio_lib::instance().initialize() != paNoError) {
+      throw std::runtime_error("Cannot initialize portaudio device");
     }
 
-    audio_basic_device(const audio_basic_device& other) : audio_basic_device(other.m_info, other.m_index)
-    {
+    m_in.device = m_index;
+    m_in.channelCount = info.maxInputChannels;
+    m_in.sampleFormat = paFloat32; // Let's make that configurable later.
+    m_in.suggestedLatency = 1024. / info.defaultSampleRate;
+    m_in.hostApiSpecificStreamInfo = nullptr;
+
+    m_out.device = m_index;
+    m_out.channelCount = info.maxOutputChannels;
+    m_out.sampleFormat = paFloat32; // Let's make that configurable later.
+    m_out.suggestedLatency = 1024. / info.defaultSampleRate;
+    m_out.hostApiSpecificStreamInfo = nullptr;
+
+    m_sampleRate = m_info.defaultSampleRate;
+    m_frames = std::max(m_info.defaultHighInputLatency,
+                        m_info.defaultHighOutputLatency) *
+               m_sampleRate;
+  }
 
-    }
-    audio_basic_device(audio_basic_device&& other) : audio_basic_device(other.m_info, other.m_index)
-    {
+  audio_basic_device(const audio_basic_device &other) = delete;
+  audio_basic_device(audio_basic_device &&other)
+      : audio_basic_device(other.m_info, other.m_index) {}
 
-    }
+  audio_basic_device &operator=(const audio_basic_device &) = delete;
+  audio_basic_device &operator=(audio_basic_device &&) = delete;
+  ~audio_basic_device() { __portaudio_lib::instance().terminate(); }
 
-    audio_basic_device& operator=(const audio_basic_device&) = delete;
-    audio_basic_device& operator=(audio_basic_device&&) = delete;
-    ~audio_basic_device()
-    {
-        __portaudio_lib::instance().terminate();
-    }
+  using sample_rate_t = double;
 
-    using sample_rate_t = double;
+  sample_rate_t get_sample_rate() const noexcept { return m_sampleRate; }
 
-    sample_rate_t get_sample_rate() const noexcept
-    {
-        return m_sampleRate;
-    }
+  bool set_sample_rate(sample_rate_t new_sample_rate) {
+    const bool was_running = is_running();
+    if (was_running)
+      stop();
+    m_sampleRate = new_sample_rate;
 
-    bool set_sample_rate(sample_rate_t new_sample_rate) {
-        const bool was_running = is_running();
-        if(was_running)
-            stop();
-        m_sampleRate = new_sample_rate;
+    if (was_running)
+      start();
+    return true;
+  }
 
-        if(was_running)
-            start();
-        return true;
+  bool start() {
+    if (is_running())
+      return false;
+
+    m_stream = nullptr;
+
+    PaStreamParameters *actualInput{};
+    if (m_in.device != paNoDevice && m_in.channelCount > 0)
+      actualInput = &m_in;
+
+    PaStreamParameters *actualOutput{};
+    if (m_out.device != paNoDevice && m_out.channelCount > 0)
+      actualOutput = &m_out;
+
+    // Another thing with portaudio is that you don't know the
+    // actual buffer size until it's running - and even then it's only an
+    // estimation
+    // - on some platforms it can vary per-tick
+    auto &pa = __portaudio_lib::instance();
+    auto err = pa.open_stream(&m_stream, actualInput, actualOutput,
+                              m_sampleRate, m_frames, paNoFlag, callback, this);
+    if (err != paNoError) {
+      //  std::cerr << pa.get_error_text(err) << "\n";
+      return false;
+    }
+    err = pa.start_stream(m_stream);
+    if (err != paNoError) {
+      pa.close_stream(m_stream);
+      m_stream = nullptr;
+      //  std::cerr << pa.get_error_text(err) << "\n";
+      return false;
     }
 
-    bool start() {
-        if(is_running())
-            return false;
-
-        m_stream = nullptr;
-
-        PaStreamParameters* actualInput{};
-        if (m_in.device != paNoDevice && m_in.channelCount > 0)
-          actualInput = &m_in;
-
-        PaStreamParameters* actualOutput{};
-        if (m_out.device != paNoDevice && m_out.channelCount > 0)
-          actualOutput = &m_out;
-
-        // Another thing with portaudio is that you don't know the
-        // actual buffer size until it's running - and even then it's only an estimation
-        // - on some platforms it can vary per-tick
-        auto& pa = __portaudio_lib::instance();
-        auto err = pa.open_stream(&m_stream, actualInput, actualOutput, m_sampleRate, m_frames, paNoFlag, callback, this);
-        if(err != paNoError) {
-            //  std::cerr << pa.get_error_text(err) << "\n";
-            return false;
-        }
-        err = pa.start_stream(m_stream);
-        if(err != paNoError)
-        {
-            pa.close_stream(m_stream);
-            m_stream = nullptr;
-            //  std::cerr << pa.get_error_text(err) << "\n";
-            return false;
-        }
+    return true;
+  }
 
-        return true;
+  bool stop() {
+    if (!is_running()) {
+      return false;
     }
+    auto &pa = __portaudio_lib::instance();
+    auto err = pa.stop_stream(m_stream);
+    if (err != paNoError)
+      return false;
 
-    bool stop()
-    {
-        if(!is_running())
-        {
-            return false;
-        }
-        auto& pa = __portaudio_lib::instance();
-        auto err = pa.stop_stream(m_stream);
-        if(err != paNoError)
-            return false;
+    err = pa.close_stream(m_stream);
+    if (err != paNoError)
+      return false;
 
-        err = pa.close_stream(m_stream);
-        if(err != paNoError)
-            return false;
+    m_stream = nullptr;
+    return true;
+  }
 
-        m_stream = nullptr;
-        return true;
-    }
+  using buffer_size_t = uint32_t;
 
-    using buffer_size_t = uint32_t;
+  buffer_size_t get_buffer_size_frames() const noexcept { return m_frames; }
 
-    buffer_size_t get_buffer_size_frames() const noexcept
-    {
-        return m_frames;
-    }
+  string_view name() const noexcept { return m_info.name; }
 
-    string_view name() const noexcept {
-        return m_info.name;
-    }
+  using device_id_t = int;
+  device_id_t device_id() const noexcept { return -1; }
 
-    using device_id_t = int;
-    device_id_t device_id() const noexcept {
-        return -1;
-    }
+  bool is_input() const noexcept { return m_in.channelCount > 0; }
 
-    bool is_input() const noexcept {
-        return m_in.channelCount > 0;
-    }
+  bool is_output() const noexcept { return m_out.channelCount > 0; }
 
-    bool is_output() const noexcept {
-        return m_out.channelCount > 0;
-    }
+  int get_num_input_channels() const noexcept { return m_in.channelCount; }
 
-    int get_num_input_channels() const noexcept {
-        return m_in.channelCount;
-    }
+  int get_num_output_channels() const noexcept { return m_out.channelCount; }
 
-    int get_num_output_channels() const noexcept {
-        return m_out.channelCount;
-    }
+  template <typename T> void connect(T t) {
+    // in my experience, it is sometimes necessary to swap callbacks at
+    // run-time. that's doable with some atomic operations.
+    if (is_running())
+      throw audio_device_exception("cannot connect to running audio_device");
 
-    template<typename T>
-    void connect(T t) {
-        // in my experience, it is sometimes necessary to swap callbacks at run-time.
-        // that's doable with some atomic operations.
-        if (is_running())
-          throw audio_device_exception("cannot connect to running audio_device");
+    m_callback = move(t);
+  }
 
-        m_callback = move(t);
-    }
+  constexpr bool can_connect() const noexcept { return true; }
 
-    constexpr bool can_connect() const noexcept {
-        return true;
-    }
+  constexpr bool can_process() const noexcept { return false; }
 
-    constexpr bool can_process() const noexcept {
-        return false;
-    }
+  bool is_running() const noexcept {
+    auto &pa = __portaudio_lib::instance();
+    return m_stream && pa.is_stream_active(m_stream);
+  }
 
-    bool is_running() const noexcept {
-        auto& pa = __portaudio_lib::instance();
-        return m_stream && pa.is_stream_active(m_stream);
-    }
+  // Problem for this : depending on the API, it's a pair <sample rate, buffer
+  // size> which is supported.
+  span<const sample_rate_t> get_supported_sample_rates() const noexcept {
+    static constexpr std::array<sample_rate_t, 2> srs{44100., 48000.};
+    return {srs.data(), srs.size()};
+  }
 
-    // Problem for this : depending on the API, it's a pair <sample rate, buffer size> which is supported.
-    span<const sample_rate_t> get_supported_sample_rates() const noexcept {
-        static constexpr std::array<sample_rate_t, 2> srs{44100., 48000.};
-        return {srs.data(), srs.size()};
-    }
+  span<const buffer_size_t> get_supported_buffer_sizes_frames() const noexcept {
+    static constexpr std::array<buffer_size_t, 7> bs{
+        paFramesPerBufferUnspecified, 32, 64, 128, 256, 512, 1024};
+    return {bs.data(), bs.size()};
+  }
 
-    span<const buffer_size_t> get_supported_buffer_sizes_frames() const noexcept {
-        static constexpr std::array<buffer_size_t, 7> bs{ paFramesPerBufferUnspecified, 32, 64, 128, 256, 512, 1024 };
-        return {bs.data(), bs.size()};
-    }
+  bool set_buffer_size_frames(buffer_size_t new_buffer_size) {
+    const bool was_running = is_running();
+    if (was_running)
+      stop();
 
-    bool set_buffer_size_frames(buffer_size_t new_buffer_size) {
-        const bool was_running = is_running();
-        if(was_running)
-            stop();
+    m_frames = new_buffer_size;
 
-        m_frames = new_buffer_size;
+    if (was_running)
+      start();
+    return true;
+  }
 
-        if(was_running)
-            start();
-        return true;
-    }
 private:
-    double m_sampleRate{};
-    buffer_size_t m_frames{};
-    PaStreamParameters m_in{};
-    PaStreamParameters m_out{};
-    PaStream* m_stream{};
-
-    using __portaudio_callback_t = function<void(__portaudio_device&, audio_device_buffers&)>;
-    __portaudio_callback_t m_callback;
-
-    static int callback(
-            const void* input, void* output, unsigned long nframes,
-            const PaStreamCallbackTimeInfo* timeInfo,
-            PaStreamCallbackFlags statusFlags, void* userData)
-    {
-        auto& self = *static_cast<audio_basic_device*>(userData);
-        if(self.m_callback)
-        {
-            audio_device_buffers bufs;
-            // Right now most efficient way I know of doing conversions is using FFMPEG's libsamplerate.
-            // How would that fit in ?
-            using buffer_t = audio_basic_buffer<float, std::experimental::audio_buffer_order_interleaved>;
-            if(input)
-            {
-                // needs a const_cast here :x
-                buffer_t inb((float*) input, nframes * self.get_num_input_channels(), self.get_num_input_channels());
-                bufs.__input_buffer = inb;
-            }
-
-            if(output)
-            {
-                buffer_t outb((float*) output, nframes * self.get_num_output_channels(), self.get_num_output_channels());
-                bufs.__output_buffer = outb;
-            }
-
-            self.m_callback(self, bufs);
-            auto out = (float*) output;
-        }
-        return paNoError;
+  double m_sampleRate{};
+  buffer_size_t m_frames{};
+  PaStreamParameters m_in{};
+  PaStreamParameters m_out{};
+  PaStream *m_stream{};
+
+  using __portaudio_callback_t =
+      function<void(__portaudio_device &, audio_device_buffers &)>;
+  __portaudio_callback_t m_callback;
+
+  static int callback(const void *input, void *output, unsigned long nframes,
+                      const PaStreamCallbackTimeInfo *timeInfo,
+                      PaStreamCallbackFlags statusFlags, void *userData) {
+    auto &self = *static_cast<audio_basic_device *>(userData);
+    if (self.m_callback) {
+      audio_device_buffers bufs;
+      // Right now most efficient way I know of doing conversions is using
+      // FFMPEG's libsamplerate. How would that fit in ?
+      using buffer_t =
+          audio_basic_buffer<float,
+                             std::experimental::audio_buffer_order_interleaved>;
+      if (input) {
+        // needs a const_cast here :x
+        buffer_t inb((float *)input, nframes * self.get_num_input_channels(),
+                     self.get_num_input_channels());
+        bufs.__input_buffer = inb;
+      }
+
+      if (output) {
+        buffer_t outb((float *)output, nframes * self.get_num_output_channels(),
+                      self.get_num_output_channels());
+        bufs.__output_buffer = outb;
+      }
+
+      self.m_callback(self, bufs);
     }
-
+    return paNoError;
+  }
 };
 
-template<>
-class audio_basic_device_list<__portaudio_driver_t> : public forward_list<__portaudio_device>
-{
-    const __portaudio_lib& library;
-    __portaudio_lib::scoped_init_context context;
-public:
-    audio_basic_device_list(bool init_inputs, bool init_outputs)
-        : library{__portaudio_lib::instance()}
-        , context{library}
-    {
-        for (PaDeviceIndex i = 0, n = library.get_device_count(); i < n; i++)
-        {
-            try {
-                auto dev = library.get_device_info(i);
-                if(!dev)
-                    continue;
-                if((init_inputs && dev->maxInputChannels > 0) || (init_outputs && dev->maxOutputChannels > 0))
-                    this->emplace_front(*dev, i);
-            } catch(...) {
-            }
-        }
+template <>
+class audio_basic_device_list<__portaudio_driver_t>
+    : public forward_list<__portaudio_device> {
+  const __portaudio_lib &library;
+  __portaudio_lib::scoped_init_context context;
 
+public:
+  audio_basic_device_list(bool init_inputs, bool init_outputs)
+      : library{__portaudio_lib::instance()}, context{library} {
+    for (PaDeviceIndex i = 0, n = library.get_device_count(); i < n; i++) {
+      try {
+        auto dev = library.get_device_info(i);
+        if (!dev)
+          continue;
+        if ((init_inputs && dev->maxInputChannels > 0) ||
+            (init_outputs && dev->maxOutputChannels > 0))
+          this->emplace_front(*dev, i);
+      } catch (...) {
+      }
     }
+  }
 };
 
-template<>
+template <>
 auto get_default_audio_input_device<__portaudio_driver_t>()
-  -> optional<audio_basic_device<__portaudio_driver_t>>
-{
-    auto& pa = __portaudio_lib::instance();
-    auto context = pa.scoped_init();
-    auto idx = pa.get_default_input();
-    auto dev = pa.get_device_info(idx);
-    if(dev)
-    {
-        return audio_basic_device<__portaudio_driver_t>{*dev, idx};
-    }
-    return {};
+    -> optional<audio_basic_device<__portaudio_driver_t>> {
+  auto &pa = __portaudio_lib::instance();
+  auto context = pa.scoped_init();
+  auto idx = pa.get_default_input();
+  auto dev = pa.get_device_info(idx);
+  if (dev) {
+    return audio_basic_device<__portaudio_driver_t>{*dev, idx};
+  }
+  return {};
 }
 
-template<>
+template <>
 auto get_default_audio_output_device<__portaudio_driver_t>()
-  -> optional<audio_basic_device<__portaudio_driver_t>>
-{
-    auto& pa = __portaudio_lib::instance();
-    auto context = pa.scoped_init();
-    auto idx = pa.get_default_output();
-    auto dev = pa.get_device_info(idx);
-    if(dev)
-    {
-        return audio_basic_device<__portaudio_driver_t>{*dev, idx};
-    }
-    return {};
+    -> optional<audio_basic_device<__portaudio_driver_t>> {
+  auto &pa = __portaudio_lib::instance();
+  auto context = pa.scoped_init();
+  auto idx = pa.get_default_output();
+  auto dev = pa.get_device_info(idx);
+  if (dev) {
+    return audio_basic_device<__portaudio_driver_t>{*dev, idx};
+  }
+  return {};
 }
 
-template<>
+template <>
 auto get_audio_input_device_list<__portaudio_driver_t>()
- -> audio_basic_device_list<__portaudio_driver_t>
-{
-    return audio_basic_device_list<__portaudio_driver_t>{true, false};
+    -> audio_basic_device_list<__portaudio_driver_t> {
+  return audio_basic_device_list<__portaudio_driver_t>{true, false};
 }
 
-template<>
+template <>
 auto get_audio_output_device_list<__portaudio_driver_t>()
- -> audio_basic_device_list<__portaudio_driver_t>
-{
-    return audio_basic_device_list<__portaudio_driver_t>{false, true};
+    -> audio_basic_device_list<__portaudio_driver_t> {
+  return audio_basic_device_list<__portaudio_driver_t>{false, true};
 }
 
 _LIBSTDAUDIO_NAMESPACE_END
diff --git a/include/audio_backend/__pulseaudio_backend.h b/include/audio_backend/__pulseaudio_backend.h
new file mode 100644
index 0000000..d946713
--- /dev/null
+++ b/include/audio_backend/__pulseaudio_backend.h
@@ -0,0 +1,549 @@
+// libstdaudio
+// Copyright (c) 2019 - Jean-Michaël Celerier
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
+
+#pragma once
+#include <__audio_base.h>
+#include <__audio_device.h>
+#include <__audio_buffer.h>
+#include <__dynamic_library.h>
+#include <__audio_exception.h>
+#include <forward_list>
+#include <functional>
+#include <string>
+#include <thread>
+#include <chrono>
+#include <cassert>
+#include <iostream>
+#include <pulse/pulseaudio.h>
+
+_LIBSTDAUDIO_NAMESPACE_BEGIN
+
+class __pulseaudio_lib
+{
+public:
+    decltype(&::pa_threaded_mainloop_new) pa_threaded_mainloop_new{};
+    decltype(&::pa_threaded_mainloop_free) pa_threaded_mainloop_free{};
+    decltype(&::pa_threaded_mainloop_get_api) pa_threaded_mainloop_get_api{};
+    decltype(&::pa_context_new) pa_context_new{};
+    decltype(&::pa_context_ref) pa_context_ref{};
+    decltype(&::pa_context_unref) pa_context_unref{};
+    decltype(&::pa_context_set_state_callback) pa_context_set_state_callback{};
+    decltype(&::pa_threaded_mainloop_lock) pa_threaded_mainloop_lock{};
+    decltype(&::pa_threaded_mainloop_unlock) pa_threaded_mainloop_unlock{};
+    decltype(&::pa_threaded_mainloop_start) pa_threaded_mainloop_start{};
+    decltype(&::pa_threaded_mainloop_stop) pa_threaded_mainloop_stop{};
+    decltype(&::pa_context_connect) pa_context_connect{};
+    decltype(&::pa_context_get_state) pa_context_get_state{};
+    decltype(&::pa_threaded_mainloop_wait) pa_threaded_mainloop_wait{};
+    decltype(&::pa_channel_map_init_stereo) pa_channel_map_init_stereo{};
+    decltype(&::pa_stream_new) pa_stream_new{};
+    decltype(&::pa_stream_new_with_proplist) pa_stream_new_with_proplist{};
+    decltype(&::pa_stream_ref) pa_stream_ref{};
+    decltype(&::pa_stream_unref) pa_stream_unref{};
+    decltype(&::pa_stream_get_state) pa_stream_get_state{};
+    decltype(&::pa_stream_set_state_callback) pa_stream_set_state_callback{};
+    decltype(&::pa_stream_set_write_callback) pa_stream_set_write_callback{};
+    decltype(&::pa_stream_set_read_callback) pa_stream_set_read_callback{};
+    decltype(&::pa_stream_set_overflow_callback) pa_stream_set_overflow_callback{};
+    decltype(&::pa_stream_connect_playback) pa_stream_connect_playback{};
+    decltype(&::pa_stream_cork) pa_stream_cork{};
+    decltype(&::pa_stream_is_corked) pa_stream_is_corked{};
+    decltype(&::pa_threaded_mainloop_signal) pa_threaded_mainloop_signal{};
+    decltype(&::pa_stream_begin_write) pa_stream_begin_write{};
+    decltype(&::pa_stream_write) pa_stream_write{};
+    decltype(&::pa_stream_set_name) pa_stream_set_name{};
+
+    static const __pulseaudio_lib& instance() {
+        static const __pulseaudio_lib self;
+        return self;
+    }
+
+private:
+#if __STDAUDIO_HAS_DYLIB
+    __dynamic_library library;
+
+    __pulseaudio_lib()
+        :library("libpulse.so")
+    {
+        // in terms of regex:
+        // decltype\(&::([a-z_]+)\) [a-z_]+{};
+        // \1 = library.symbol<decltype(&::\1)>("\1");
+
+        // we need reflection T_T
+        pa_threaded_mainloop_new = library.symbol<decltype(&::pa_threaded_mainloop_new)>("pa_threaded_mainloop_new");
+        pa_threaded_mainloop_free = library.symbol<decltype(&::pa_threaded_mainloop_free)>("pa_threaded_mainloop_free");
+        pa_threaded_mainloop_get_api = library.symbol<decltype(&::pa_threaded_mainloop_get_api)>("pa_threaded_mainloop_get_api");
+        pa_threaded_mainloop_lock = library.symbol<decltype(&::pa_threaded_mainloop_lock)>("pa_threaded_mainloop_lock");
+        pa_threaded_mainloop_unlock = library.symbol<decltype(&::pa_threaded_mainloop_lock)>("pa_threaded_mainloop_unlock");
+        pa_threaded_mainloop_start = library.symbol<decltype(&::pa_threaded_mainloop_start)>("pa_threaded_mainloop_start");
+        pa_threaded_mainloop_stop = library.symbol<decltype(&::pa_threaded_mainloop_stop)>("pa_threaded_mainloop_stop");
+        pa_threaded_mainloop_signal = library.symbol<decltype(&::pa_threaded_mainloop_signal)>("pa_threaded_mainloop_signal");
+        pa_context_new = library.symbol<decltype(&::pa_context_new)>("pa_context_new");
+        pa_context_ref = library.symbol<decltype(&::pa_context_ref)>("pa_context_ref");
+        pa_context_unref = library.symbol<decltype(&::pa_context_unref)>("pa_context_unref");
+        pa_context_set_state_callback = library.symbol<decltype(&::pa_context_set_state_callback)>("pa_context_set_state_callback");
+        pa_context_connect = library.symbol<decltype(&::pa_context_connect)>("pa_context_connect");
+        pa_context_get_state = library.symbol<decltype(&::pa_context_get_state)>("pa_context_get_state");
+        pa_threaded_mainloop_wait = library.symbol<decltype(&::pa_threaded_mainloop_wait)>("pa_threaded_mainloop_wait");
+        pa_channel_map_init_stereo = library.symbol<decltype(&::pa_channel_map_init_stereo)>("pa_channel_map_init_stereo");
+        pa_stream_new = library.symbol<decltype(&::pa_stream_new)>("pa_stream_new");
+        pa_stream_new_with_proplist = library.symbol<decltype(&::pa_stream_new_with_proplist)>("pa_stream_new_with_proplist");
+        pa_stream_ref = library.symbol<decltype(&::pa_stream_ref)>("pa_stream_ref");
+        pa_stream_unref = library.symbol<decltype(&::pa_stream_unref)>("pa_stream_unref");
+        pa_stream_get_state = library.symbol<decltype(&::pa_stream_get_state)>("pa_stream_get_state");
+        pa_stream_set_state_callback = library.symbol<decltype(&::pa_stream_set_state_callback)>("pa_stream_set_state_callback");
+        pa_stream_set_write_callback = library.symbol<decltype(&::pa_stream_set_write_callback)>("pa_stream_set_write_callback");
+        pa_stream_set_read_callback = library.symbol<decltype(&::pa_stream_set_read_callback)>("pa_stream_set_read_callback");
+        pa_stream_set_overflow_callback = library.symbol<decltype(&::pa_stream_set_overflow_callback)>("pa_stream_set_overflow_callback");
+        pa_stream_connect_playback = library.symbol<decltype(&::pa_stream_connect_playback)>("pa_stream_connect_playback");
+        pa_stream_cork = library.symbol<decltype(&::pa_stream_cork)>("pa_stream_cork");
+        pa_stream_is_corked = library.symbol<decltype(&::pa_stream_is_corked)>("pa_stream_is_corked");
+        pa_stream_begin_write = library.symbol<decltype(&::pa_stream_begin_write)>("pa_stream_begin_write");
+        pa_stream_write = library.symbol<decltype(&::pa_stream_write)>("pa_stream_write");
+        pa_stream_set_name = library.symbol<decltype(&::pa_stream_set_name)>("pa_stream_set_name");
+
+
+        // in terms of regex:
+        // decltype\(&::([a-z_]+)\) [a-z_]+{};
+        // assert(\1);
+        assert(pa_threaded_mainloop_new);
+        assert(pa_threaded_mainloop_free);
+        assert(pa_threaded_mainloop_get_api);
+        assert(pa_threaded_mainloop_lock);
+        assert(pa_threaded_mainloop_unlock);
+        assert(pa_threaded_mainloop_start);
+        assert(pa_threaded_mainloop_stop);
+        assert(pa_threaded_mainloop_signal);
+        assert(pa_context_new);
+        assert(pa_context_ref);
+        assert(pa_context_unref);
+        assert(pa_context_set_state_callback);
+        assert(pa_context_connect);
+        assert(pa_context_get_state);
+        assert(pa_threaded_mainloop_wait);
+        assert(pa_channel_map_init_stereo);
+        assert(pa_stream_new);
+        assert(pa_stream_new_with_proplist);
+        assert(pa_stream_ref);
+        assert(pa_stream_unref);
+        assert(pa_stream_get_state);
+        assert(pa_stream_set_state_callback);
+        assert(pa_stream_set_write_callback);
+        assert(pa_stream_set_read_callback);
+        assert(pa_stream_set_overflow_callback);
+        assert(pa_stream_connect_playback);
+        assert(pa_stream_cork);
+        assert(pa_stream_is_corked);
+        assert(pa_stream_begin_write);
+        assert(pa_stream_write);
+        assert(pa_stream_set_name);
+    }
+#else
+    __pulseaudio_lib()
+    {
+        // in terms of regex:
+        // decltype\(&::([a-z_]+)\) [a-z_]+{};
+        // \1 = &::\1;
+
+        pa_threaded_mainloop_new = &::pa_threaded_mainloop_new;
+        pa_threaded_mainloop_free = &::pa_threaded_mainloop_free;
+        pa_threaded_mainloop_get_api = &::pa_threaded_mainloop_get_api;
+        pa_threaded_mainloop_lock = &::pa_threaded_mainloop_lock;
+        pa_threaded_mainloop_unlock = &::pa_threaded_mainloop_unlock;
+        pa_threaded_mainloop_start = &::pa_threaded_mainloop_start;
+        pa_threaded_mainloop_stop = &::pa_threaded_mainloop_stop;
+        pa_threaded_mainloop_signal = &::pa_threaded_mainloop_signal;
+        pa_context_new = &::pa_context_new;
+        pa_context_ref = &::pa_context_ref;
+        pa_context_unref = &::pa_context_unref;
+        pa_context_connect = &::pa_context_connect;
+        pa_context_get_state = &::pa_context_get_state;
+        pa_context_set_state_callback = &::pa_context_set_state_callback;
+        pa_threaded_mainloop_wait = &::pa_threaded_mainloop_wait;
+        pa_channel_map_init_stereo = &::pa_channel_map_init_stereo;
+        pa_stream_new = &::pa_stream_new;
+        pa_stream_new_with_proplist = &::pa_stream_new_with_proplist;
+        pa_stream_ref = &::pa_stream_ref;
+        pa_stream_unref = &::pa_stream_unref;
+        pa_stream_get_state = &::pa_stream_get_state;
+        pa_stream_set_state_callback = &::pa_stream_set_state_callback;
+        pa_stream_set_write_callback = &::pa_stream_set_write_callback;
+        pa_stream_set_read_callback = &::pa_stream_set_read_callback;
+        pa_stream_set_overflow_callback = &::pa_stream_set_overflow_callback;
+        pa_stream_connect_playback = &::pa_stream_connect_playback;
+        pa_stream_cork = &::pa_stream_cork;
+        pa_stream_is_corked = &::pa_stream_is_corked;
+        pa_stream_begin_write = &::pa_stream_begin_write;
+        pa_stream_write = &::pa_stream_write;
+        pa_stream_set_name = &::pa_stream_set_name;
+    }
+#endif
+};
+
+using __pulseaudio_device = audio_basic_device<__pulseaudio_driver_t>;
+// How to handle stuff like MME or pulseaudio where you can mix and match sound
+// cards ?
+template <> class audio_basic_device<__pulseaudio_driver_t> {
+public:
+  audio_basic_device() noexcept {
+    m_sampleRate = 44100;
+    m_frames = 512;
+    m_name = "My app";
+  }
+
+  audio_basic_device(const audio_basic_device &other) = delete;
+  audio_basic_device(audio_basic_device &&other) noexcept
+      : m_sampleRate(other.m_sampleRate), m_frames(other.m_frames),
+        m_mainloop(other.m_mainloop), m_api(other.m_api),
+        m_context(other.m_context), m_stream(other.m_stream),
+        m_callback(std::move(other.m_callback)) {
+    other.m_mainloop = nullptr;
+    other.m_api = nullptr;
+    other.m_context = nullptr;
+    other.m_stream = nullptr;
+  }
+
+  audio_basic_device &operator=(const audio_basic_device &) = delete;
+  audio_basic_device &operator=(audio_basic_device &&) = delete;
+  ~audio_basic_device() { stop(); }
+
+  using sample_rate_t = double;
+
+  sample_rate_t get_sample_rate() const noexcept { return m_sampleRate; }
+
+  bool set_sample_rate(sample_rate_t new_sample_rate) {
+    const bool was_running = is_running();
+    if (was_running)
+      stop();
+    m_sampleRate = new_sample_rate;
+
+    if (was_running)
+      start();
+    return true;
+  }
+
+  bool start() {
+    if (is_running())
+      return false;
+
+    const auto &pa = __pulseaudio_lib::instance();
+
+    m_mainloop = pa.pa_threaded_mainloop_new();
+    if (!m_mainloop) {
+      // let's switch to Either or Outcome shall we :-)
+      throw audio_device_exception("Cannot initialize pulseaudio main loop");
+    }
+
+    m_api = pa.pa_threaded_mainloop_get_api(m_mainloop);
+    if (!m_api) {
+      throw audio_device_exception("Cannot initialize pulseaudio mainloop API");
+    }
+
+    // both for pulseaudio, and for JACK, instead of requesting a device,
+    // you declare your app as being a device which will be a piece of the
+    // audio graph - so there should be an API to set its name in that graph.
+    m_context = pa.pa_context_new(m_api, m_name.data());
+    if (!m_context) {
+      throw audio_device_exception("Cannot initialize pulseaudio context");
+    }
+
+    auto context_callback = [](pa_context *, void *mainloop) {
+      auto &pa = __pulseaudio_lib::instance();
+      pa.pa_threaded_mainloop_signal((pa_threaded_mainloop *)mainloop, 0);
+    };
+    pa.pa_context_set_state_callback(m_context, context_callback, m_mainloop);
+
+    pa.pa_threaded_mainloop_lock(m_mainloop);
+
+    if (auto err = pa.pa_threaded_mainloop_start(m_mainloop); err != 0) {
+      throw audio_device_exception("Cannot start pulseaudio main loop");
+    }
+    if (auto err = pa.pa_context_connect(m_context, nullptr,
+                                         PA_CONTEXT_NOAUTOSPAWN, nullptr);
+        err != 0) {
+      throw audio_device_exception("Cannot conntext the pulseaudio context");
+    }
+
+    // Wait until everything is ready - completely arbitrary timeout, maybe this
+    // should be settable
+    static const constexpr auto default_timeout = 3s;
+    {
+      auto t0 = chrono::steady_clock::now();
+      bool timeout = false;
+      while ((timeout = (chrono::steady_clock::now() - t0 < default_timeout))) {
+        switch (pa.pa_context_get_state(m_context)) {
+        case PA_CONTEXT_CONNECTING:
+        case PA_CONTEXT_AUTHORIZING:
+        case PA_CONTEXT_SETTING_NAME:
+          pa.pa_threaded_mainloop_wait(m_mainloop);
+          continue;
+
+        case PA_CONTEXT_READY:
+          break;
+
+        case PA_CONTEXT_FAILED:
+        case PA_CONTEXT_TERMINATED:
+        default:
+          throw audio_device_exception("Invalid context state");
+        }
+      }
+
+      if (timeout) {
+        throw audio_device_exception("Context creation timeout");
+      }
+    }
+
+
+    /// Everything from the beginning of start() to this point should
+    /// actually go in a context object which is not part of the device.
+    /// (A bit like Pa_Initialize() / Pa_Terminate() for portaudio)
+
+    pa_sample_spec sample_specifications;
+    sample_specifications.format = PA_SAMPLE_FLOAT32LE;
+
+    // for pulseaudio, samplerate is an uint
+    sample_specifications.rate = m_sampleRate;
+
+    // in pulse and JACK we ask how many channels we want ; in addition to Jack,
+    // pulse does intelligent resampling / upmixing / downmixing
+    sample_specifications.channels = 2;
+
+    pa_channel_map map;
+    pa.pa_channel_map_init_stereo(&map);
+
+    m_stream =
+        pa.pa_stream_new(m_context, "My stream", &sample_specifications, &map);
+    if (!m_stream) {
+      throw audio_device_exception("Cannot initialize pulseaudio stream");
+    }
+
+    const auto stream_cb = [](pa_stream *s, void *mainloop) {
+      auto &pa = __pulseaudio_lib::instance();
+      pa.pa_threaded_mainloop_signal((pa_threaded_mainloop *)mainloop, 0);
+    };
+    pa.pa_stream_set_state_callback(m_stream, stream_cb, m_mainloop);
+    pa.pa_stream_set_write_callback(m_stream, output_callback, this);
+
+    // Don't set values here, instead the server will provide what it judges to
+    // be the best.
+    pa_buffer_attr buffer_attr;
+    buffer_attr.maxlength = m_frames * sizeof(float) * get_num_output_channels();
+    buffer_attr.tlength = m_frames * sizeof(float) * get_num_output_channels();
+    buffer_attr.prebuf = (uint32_t)-1;
+    buffer_attr.minreq = 0;
+
+    const auto stream_flags = static_cast<pa_stream_flags_t>(
+        PA_STREAM_START_CORKED | PA_STREAM_INTERPOLATE_TIMING | PA_STREAM_NOT_MONOTONIC |
+        PA_STREAM_AUTO_TIMING_UPDATE | PA_STREAM_ADJUST_LATENCY);
+
+    // Connect stream to the default audio output sink
+    if (auto err = pa.pa_stream_connect_playback(
+            m_stream, nullptr, &buffer_attr, stream_flags, nullptr, nullptr);
+        err != 0) {
+      throw audio_device_exception("Cannot start pulseaudio stream");
+    }
+
+    {
+      auto t0 = chrono::steady_clock::now();
+      bool timeout = false;
+      while ((timeout = (chrono::steady_clock::now() - t0 < default_timeout))) {
+        switch (pa.pa_stream_get_state(m_stream)) {
+        case PA_STREAM_CREATING:
+          pa.pa_threaded_mainloop_wait(m_mainloop);
+          break;
+        case PA_STREAM_READY:
+          break;
+        default:
+          throw audio_device_exception("Invalid stream state");
+        }
+      }
+
+      if (timeout) {
+        throw audio_device_exception("Stream creation timeout");
+      }
+    }
+
+    pa.pa_threaded_mainloop_unlock(m_mainloop);
+
+    // cork means pausing, cork = 0 means resuming
+    pa.pa_stream_cork(m_stream, 0, success_cb, this);
+
+    return true;
+  }
+
+  bool stop() {
+    if (!is_running()) {
+      return false;
+    }
+
+    auto &pa = __pulseaudio_lib::instance();
+    pa.pa_stream_unref(m_stream);
+    m_stream = nullptr;
+    pa.pa_context_unref(m_context);
+    m_context = nullptr;
+    pa.pa_threaded_mainloop_free(m_mainloop);
+    m_mainloop = nullptr;
+    m_api = nullptr;
+    m_stream = nullptr;
+    return true;
+  }
+
+  using buffer_size_t = uint32_t;
+
+  buffer_size_t get_buffer_size_frames() const noexcept { return m_frames; }
+
+  string_view name() const noexcept { return m_name; }
+
+  using device_id_t = int;
+  device_id_t device_id() const noexcept { return -1; }
+
+  bool is_input() const noexcept { return true; }
+
+  bool is_output() const noexcept { return true; }
+
+  int get_num_input_channels() const noexcept { return 0; }
+
+  int get_num_output_channels() const noexcept { return 2; }
+
+  template <typename T> void connect(T t) {
+    // in my experience, it is sometimes necessary to swap callbacks at
+    // run-time. that's doable with some atomic operations.
+    if (is_running())
+      throw audio_device_exception("cannot connect to running audio_device");
+
+    m_callback = move(t);
+  }
+
+  constexpr bool can_connect() const noexcept { return true; }
+
+  constexpr bool can_process() const noexcept { return false; }
+
+  bool is_running() const noexcept {
+    auto &pa = __pulseaudio_lib::instance();
+    return m_stream && pa.pa_stream_is_corked(m_stream);
+  }
+
+  // you can put whatever samplerate you want with pulseaudio.
+  span<const sample_rate_t> get_supported_sample_rates() const noexcept {
+    static constexpr std::array<sample_rate_t, 2> srs{44100., 48000.};
+    return {srs.data(), srs.size()};
+  }
+
+  //  you can put whatever buffersize you want with pulseaudio (and it won't generally be respected anyways)
+  span<const buffer_size_t> get_supported_buffer_sizes_frames() const noexcept {
+    static constexpr std::array<buffer_size_t, 6> bs{32,  64,  128,
+                                                     256, 512, 1024};
+    return {bs.data(), bs.size()};
+  }
+
+  bool set_buffer_size_frames(buffer_size_t new_buffer_size) {
+    const bool was_running = is_running();
+    if (was_running)
+      stop();
+
+    m_frames = new_buffer_size;
+
+    if (was_running)
+      start();
+    return true;
+  }
+
+private:
+  static void output_callback(pa_stream *stream, size_t requested_bytes,
+                              void *userdata) {
+    auto &pa = __pulseaudio_lib::instance();
+    auto &self = *static_cast<audio_basic_device *>(userdata);
+    float *buffer = nullptr;
+    size_t bytes_to_fill = requested_bytes;
+
+    do {
+      if (auto res = pa.pa_stream_begin_write(stream, (void **)&buffer,
+                                              &bytes_to_fill);
+          res != 0) {
+        // we're in huge trouble
+        return;
+      }
+
+      const auto size =
+          bytes_to_fill / (sizeof(float) * self.get_num_output_channels());
+      {
+        if (self.m_callback) {
+          audio_device_buffers bufs;
+          // Pulseaudio entirely separates input and playback
+          // so to have a full duplex callback, it needs to be buffered instead
+          using buffer_t = audio_basic_buffer<
+              float, std::experimental::audio_buffer_order_interleaved>;
+
+          buffer_t outb((float *)buffer, size * self.get_num_output_channels(),
+                        self.get_num_output_channels());
+          bufs.__output_buffer = outb;
+
+          self.m_callback(self, bufs);
+        }
+      }
+
+      if (auto res = pa.pa_stream_write(stream, buffer, bytes_to_fill, nullptr,
+                                        0LL, PA_SEEK_RELATIVE);
+          res != 0) {
+        // we're in huge trouble
+        return;
+      }
+
+      requested_bytes -= bytes_to_fill;
+      bytes_to_fill = requested_bytes;
+    } while (requested_bytes > 0);
+  }
+
+  static void success_cb(pa_stream *, int, void *) {}
+
+  std::string m_name;
+  double m_sampleRate{};
+  buffer_size_t m_frames{};
+
+  pa_threaded_mainloop *m_mainloop{};
+  pa_mainloop_api *m_api{};
+  pa_context *m_context{};
+  pa_stream *m_stream{};
+
+  using __pulseaudio_callback_t =
+      function<void(__pulseaudio_device &, audio_device_buffers &)>;
+  __pulseaudio_callback_t m_callback;
+};
+
+template<>
+class audio_basic_device_list<__pulseaudio_driver_t> : public forward_list<__pulseaudio_device>
+{
+public:
+    audio_basic_device_list()
+    {
+        this->emplace_front(__pulseaudio_device{});
+    }
+};
+
+template <>
+auto get_default_audio_input_device<__pulseaudio_driver_t>()
+    -> optional<audio_basic_device<__pulseaudio_driver_t>> {
+  return __pulseaudio_device{};
+}
+
+template <>
+auto get_default_audio_output_device<__pulseaudio_driver_t>()
+    -> optional<audio_basic_device<__pulseaudio_driver_t>> {
+  return __pulseaudio_device{};
+}
+
+template <>
+auto get_audio_input_device_list<__pulseaudio_driver_t>()
+    -> audio_basic_device_list<__pulseaudio_driver_t> {
+  return {};
+}
+
+template <>
+auto get_audio_output_device_list<__pulseaudio_driver_t>()
+    -> audio_basic_device_list<__pulseaudio_driver_t> {
+  return {};
+}
+
+_LIBSTDAUDIO_NAMESPACE_END